Skip to content

Play your own Switch games on iPhone/iPad — one-click macOS app, no terminal. | 把 Switch 游戏装进 iPhone:图形界面一键构建,不用命令行。Bring your own game.

14.4 KB
Raw Blame
import Foundation
import Testing
@testable import ShellHost

@Suite struct EngineLaunchPlanTests {
    /// A game over a temporary framework and app folders. Nothing in `gdir` or the data folder exists until a test adds it.
    struct Rig {
        let box: FrameworkBox
        let fw: URL
        let gdir: URL
        let data: URL
        var game: LaunchableGame

        init(environment: [String: String] = [:], cloud: URL? = nil) throws {
            box = try FrameworkBox()
            fw = try box.makeFramework()
            gdir = box.documents.appendingPathComponent("games/\(Fixtures.orbit)", isDirectory: true)
            data = box.root.appendingPathComponent("data", isDirectory: true)
            try box.makeFolder(data)
            let entry = try #require(GameCatalogue.scan(root: box.frameworks).first)
            game = LaunchableGame(titleID: entry.id, name: entry.title, manifest: try #require(entry.manifest), directory: fw, frameworkURL: fw,
                                  dataURL: data, appFolder: gdir, environment: environment, cloudSavesURL: cloud)
        }
        func plan(envFile: String? = nil) -> EngineLaunchPlan {
            EngineLaunchPlan.make(game: game, appResources: box.resources, documents: box.documents, envFileText: envFile)
        }
    }

    @Test func frameworkBuildEnvironmentReachesTheHostAndDocumentsCanOverrideIt() throws {
        let rig = try Rig()
        try rig.box.write("DM_PROF_TEX_BC_CPU=1\n", to: rig.fw.appendingPathComponent("dm/env.txt"))
        #expect(rig.plan().environment["DM_PROF_TEX_BC_CPU"] == "1")
        #expect(rig.plan().environment["DM_ENV_FILE_KEYS"] == "DM_PROF_TEX_BC_CPU")
        #expect(rig.plan(envFile: "DM_PROF_TEX_BC_CPU=0\n").environment["DM_PROF_TEX_BC_CPU"] == "0")
        try rig.box.write("DM_PROF_TEX_BC_CPU=0\n", to: rig.gdir.appendingPathComponent("env.txt"))
        #expect(rig.plan().environment["DM_PROF_TEX_BC_CPU"] == "0")
        let another = try Rig()
        #expect(another.plan().environment["DM_PROF_TEX_BC_CPU"] == nil)
    }

    @Test func defaultsPointIntoTheFramework() throws {
        let rig = try Rig()
        let env = rig.plan().environment
        #expect(env["DM_PROFILE"] == rig.fw.path + "/profile.tsv")
        #expect(env["DM_NVN_SHMAP"] == rig.fw.path + "/dm/shader_map.tsv")
        #expect(env["DM_MSL_DIR"] == rig.fw.path + "/msl")
        #expect(env["DM_PSO_BUNDLE"] == nil && env["DM_AOC_DIR"] == nil && env["DM_ROMFS"] == nil && env["DM_SAVE_SYNC"] == nil)
        #expect(env["DM_SAVE"] == rig.gdir.path + "/save" && env["DM_TEMP"] == rig.gdir.path + "/temp")
        #expect(env["DM_CHEATS"] == rig.gdir.path + "/cheats")
        #expect(env["DM_FONT_DIR"] == rig.box.resources.path + "/dm/font")
        #expect(env["DM_LAUNCHER"] == "0")
        #expect(env["DM_ENV_FILE_KEYS"] == "")
    }

    @Test func perGameFilesWinWhenPresent() throws {
        let rig = try Rig()
        try rig.box.write("x", to: rig.gdir.appendingPathComponent("profile.tsv"))
        try rig.box.makeFolder(rig.gdir.appendingPathComponent("msl"))
        try rig.box.makeFolder(rig.gdir.appendingPathComponent("pso"))
        try rig.box.makeFolder(rig.fw.appendingPathComponent("pso"))
        let env = rig.plan().environment
        #expect(env["DM_PROFILE"] == rig.gdir.path + "/profile.tsv")
        #expect(env["DM_MSL_DIR"] == rig.gdir.path + "/msl")
        #expect(env["DM_PSO_BUNDLE"] == rig.gdir.path + "/pso")
    }

    @Test func psoFallsBackToTheFramework() throws {
        let rig = try Rig()
        try rig.box.makeFolder(rig.fw.appendingPathComponent("pso"))
        #expect(rig.plan().environment["DM_PSO_BUNDLE"] == rig.fw.path + "/pso")
    }

    @Test(arguments: [false, true]) func sharedEnvCanDisableADiscoveredPipelineArchive(perGameArchive: Bool) throws {
        let rig = try Rig()
        try rig.box.makeFolder(rig.fw.appendingPathComponent("pso"))
        if perGameArchive { try rig.box.makeFolder(rig.gdir.appendingPathComponent("pso")) }
        let env = rig.plan(envFile: "DM_PSO_BUNDLE=off\n").environment
        #expect(env["DM_PSO_BUNDLE"] == "off")
        #expect(env["DM_ENV_FILE_KEYS"] == "DM_PSO_BUNDLE")
    }

    @Test func gameArchiveOverrideWinsOverSharedFileAndStaysWithItsGame() throws {
        let rig = try Rig()
        try rig.box.makeFolder(rig.fw.appendingPathComponent("pso"))
        try rig.box.write("DM_PSO_BUNDLE=off\n", to: rig.gdir.appendingPathComponent("env.txt"))
        let env = rig.plan(envFile: "DM_PSO_BUNDLE=/shared/archive\n").environment
        #expect(env["DM_PSO_BUNDLE"] == "off")
        #expect(env["DM_ENV_FILE_KEYS"] == "DM_PSO_BUNDLE")
        var other = rig.game
        other.appFolder = rig.box.documents.appendingPathComponent("games/0100000000000000")
        let otherPlan = EngineLaunchPlan.make(game: other, appResources: rig.box.resources, documents: rig.box.documents, envFileText: nil)
        #expect(otherPlan.environment["DM_PSO_BUNDLE"] == rig.fw.path + "/pso")
        #expect(otherPlan.environment["DM_ENV_FILE_KEYS"] == "")
    }

    @Test func explicitLaunchArchiveWinsOverEnvFilesAndDiscoveredArchives() throws {
        let rig = try Rig(environment: ["DM_PSO_BUNDLE": "/launch/archive"])
        try rig.box.makeFolder(rig.fw.appendingPathComponent("pso"))
        try rig.box.write("DM_PSO_BUNDLE=off\n", to: rig.gdir.appendingPathComponent("env.txt"))
        let env = rig.plan(envFile: "DM_PSO_BUNDLE=/shared/archive\n").environment
        #expect(env["DM_PSO_BUNDLE"] == "/launch/archive")
        #expect(env["DM_ENV_FILE_KEYS"] == "")
    }

    @Test func romfsImageIsMatchedCaseInsensitively() throws {
        let rig = try Rig()
        try rig.box.write("x", to: rig.data.appendingPathComponent("Romfs.IMG"))
        try rig.box.write("", to: rig.data.appendingPathComponent("fixture.marker"))
        let found = try #require(rig.plan().environment["DM_ROMFS"])
        #expect(found.lowercased() == rig.data.path.lowercased() + "/romfs.img", "the image wins over the marker in the same folder")
    }

    @Test func emptyImageFallsThroughToTheTree() throws {
        let rig = try Rig()
        try rig.box.write("", to: rig.data.appendingPathComponent("romfs.img"))
        try rig.box.write("", to: rig.data.appendingPathComponent("romfs/fixture.marker"))
        #expect(rig.plan().environment["DM_ROMFS"] == rig.data.path + "/romfs")
    }

    @Test func dataFolderItselfWithTheMarker() throws {
        let rig = try Rig()
        #expect(rig.plan().environment["DM_ROMFS"] == nil)
        try rig.box.write("", to: rig.data.appendingPathComponent("fixture.marker"))
        #expect(rig.plan().environment["DM_ROMFS"] == rig.data.path)
    }

    @Test func aocFromDataThenFromTheAppFolder() throws {
        let rig = try Rig()
        try rig.box.makeFolder(rig.gdir.appendingPathComponent("aoc"))
        #expect(rig.plan().environment["DM_AOC_DIR"] == rig.gdir.path + "/aoc")
        try rig.box.makeFolder(rig.data.appendingPathComponent("aoc"))
        #expect(rig.plan().environment["DM_AOC_DIR"] == rig.data.path + "/aoc")
    }

    @Test func settingsAndCloudFolderAreSet() throws {
        let cloud = URL(fileURLWithPath: "/tmp/cloud-saves/", isDirectory: true)
        let rig = try Rig(environment: ["DM_LANG": "de", "DM_SHOW_FPS": "1"], cloud: cloud)
        let env = rig.plan().environment
        #expect(env["DM_LANG"] == "de" && env["DM_SHOW_FPS"] == "1")
        #expect(env["DM_SAVE_SYNC"] == "/tmp/cloud-saves")
    }

    @Test func envFileParsing() {
        let text = "# comment\n\n  DM_A=1  \nnoequals\n=novalue\nDM_B=x=y\r\n  # indented comment\nDM_C=\n"
        let pairs = EngineLaunchPlan.parseEnvFile(text)
        #expect(pairs.map(\.key) == ["DM_A", "DM_B", "DM_C"])
        #expect(pairs.map(\.value) == ["1", "x=y", ""])
        #expect(EngineLaunchPlan.parseEnvFile("").isEmpty)
    }

    @Test func envFileNeverOverridesAndListsItsKeys() throws {
        let rig = try Rig(environment: ["DM_LANG": "de"])
        let env = rig.plan(envFile: "DM_LANG=fr\nDM_SAVE=/elsewhere\nDM_LAUNCHER=1\nDM_TRACE=2\nDM_OTHER=3\n").environment
        #expect(env["DM_LANG"] == "de" && env["DM_SAVE"] == rig.gdir.path + "/save" && env["DM_LAUNCHER"] == "0")
        #expect(env["DM_TRACE"] == "2" && env["DM_OTHER"] == "3")
        #expect(env["DM_ENV_FILE_KEYS"] == "DM_TRACE DM_OTHER")
    }

    /// #557: a mod's `DM_ROMFS_OVERLAY` in the shared file reached every game. The game's own file stays with the game.
    @Test func gameEnvFileWinsOverTheSharedOneAndIsReadFromTheGamesFolder() throws {
        let rig = try Rig(environment: ["DM_LANG": "de"])
        try FileManager.default.createDirectory(at: rig.gdir, withIntermediateDirectories: true)
        try "# this game\nDM_ROMFS_OVERLAY=/mods/orbit\nDM_TRACE=9\nDM_LANG=fr\nDM_SAVE=/elsewhere\n".write(to: rig.gdir.appendingPathComponent("env.txt"), atomically: true, encoding: .utf8)
        let env = rig.plan(envFile: "DM_ROMFS_OVERLAY=/mods/other\nDM_TRACE=1\nDM_OTHER=3\n").environment
        #expect(env["DM_ROMFS_OVERLAY"] == "/mods/orbit")
        #expect(env["DM_TRACE"] == "9")
        #expect(env["DM_OTHER"] == "3", "the shared file still applies to what the game's file does not set")
        #expect(env["DM_LANG"] == "de" && env["DM_SAVE"] == rig.gdir.path + "/save", "the launch environment wins over both files")
        #expect(env["DM_ENV_FILE_KEYS"] == "DM_ROMFS_OVERLAY DM_TRACE DM_OTHER")
    }

    @Test func anotherGameDoesNotSeeTheFirstGamesEnvFile() throws {
        let rig = try Rig()
        try FileManager.default.createDirectory(at: rig.gdir, withIntermediateDirectories: true)
        try "DM_ROMFS_OVERLAY=/mods/orbit\n".write(to: rig.gdir.appendingPathComponent("env.txt"), atomically: true, encoding: .utf8)
        var other = rig.game
        other.appFolder = rig.box.documents.appendingPathComponent("games/0100000000000000", isDirectory: true)
        let env = EngineLaunchPlan.make(game: other, appResources: rig.box.resources, documents: rig.box.documents, envFileText: nil).environment
        #expect(env["DM_ROMFS_OVERLAY"] == nil)
        #expect(env["DM_ENV_FILE_KEYS"] == "")
    }

    @Test func withoutAGameEnvFileOnlyTheSharedOneApplies() throws {
        let rig = try Rig()
        let env = rig.plan(envFile: "DM_TRACE=1\n").environment
        #expect(env["DM_TRACE"] == "1" && env["DM_ENV_FILE_KEYS"] == "DM_TRACE")
    }

    // MARK: the game's mods folder (#557)

    @Test func modsFolderSetsTheOverlayOnlyWhenItExistsAndHoldsAUsableMod() throws {
        let rig = try Rig()
        #expect(rig.plan().environment["DM_ROMFS_OVERLAY"] == nil)
        let mods = rig.gdir.appendingPathComponent("mods")
        try rig.box.makeFolder(mods)
        #expect(rig.plan().environment["DM_ROMFS_OVERLAY"] == nil, "an empty mods folder")
        try rig.box.makeFolder(mods.appendingPathComponent("code/exefs"))
        try rig.box.makeFolder(mods.appendingPathComponent(".hidden/romfs"))
        try rig.box.write("x", to: mods.appendingPathComponent("loose-file.txt"))
        #expect(rig.plan().environment["DM_ROMFS_OVERLAY"] == nil, "code only, hidden and plain files do not count")
        try rig.box.makeFolder(mods.appendingPathComponent("b/romfs"))
        try rig.box.makeFolder(mods.appendingPathComponent("a/atmosphere/contents/\(Fixtures.orbit)/romfs"))
        try rig.box.write("x", to: mods.appendingPathComponent("c/data.bin"))
        let env = rig.plan().environment
        #expect(env["DM_ROMFS_OVERLAY"] == [mods.path + "/a/atmosphere/contents/\(Fixtures.orbit)/romfs", mods.path + "/b/romfs", mods.path + "/c"].joined(separator: ":"))
        #expect(env["DM_ENV_FILE_KEYS"] == "", "the mods folder is not an env file")
    }

    @Test func modsOfOneGameDoNotReachAnother() throws {
        let rig = try Rig()
        try rig.box.makeFolder(rig.gdir.appendingPathComponent("mods/m/romfs"))
        var other = rig.game
        other.appFolder = rig.box.documents.appendingPathComponent("games/0100000000000000", isDirectory: true)
        let env = EngineLaunchPlan.make(game: other, appResources: rig.box.resources, documents: rig.box.documents, envFileText: nil).environment
        #expect(env["DM_ROMFS_OVERLAY"] == nil)
        #expect(rig.plan().environment["DM_ROMFS_OVERLAY"] == rig.gdir.path + "/mods/m/romfs")
    }

    @Test func overlayPrecedenceIsLaunchEnvironmentThenGameEnvFileThenModsThenSharedFile() throws {
        let shared = "DM_ROMFS_OVERLAY=/shared\n"
        // mods beat the shared file
        var rig = try Rig()
        try rig.box.makeFolder(rig.gdir.appendingPathComponent("mods/m/romfs"))
        #expect(rig.plan(envFile: shared).environment["DM_ROMFS_OVERLAY"] == rig.gdir.path + "/mods/m/romfs")
        #expect(rig.plan(envFile: shared).environment["DM_ENV_FILE_KEYS"] == "")
        // the game's env file beats the mods folder
        try rig.box.write("DM_ROMFS_OVERLAY=/own\n", to: rig.gdir.appendingPathComponent("env.txt"))
        #expect(rig.plan(envFile: shared).environment["DM_ROMFS_OVERLAY"] == "/own")
        // the launch environment beats the game's env file
        rig = try Rig(environment: ["DM_ROMFS_OVERLAY": "/launch"])
        try rig.box.makeFolder(rig.gdir.appendingPathComponent("mods/m/romfs"))
        try rig.box.write("DM_ROMFS_OVERLAY=/own\n", to: rig.gdir.appendingPathComponent("env.txt"))
        #expect(rig.plan(envFile: shared).environment["DM_ROMFS_OVERLAY"] == "/launch")
        // without a mods folder the shared file still applies
        let plain = try Rig()
        #expect(plain.plan(envFile: shared).environment["DM_ROMFS_OVERLAY"] == "/shared")
    }

    @Test func argumentsExecutableAndLocations() throws {
        let rig = try Rig()
        let plan = rig.plan()
        #expect(plan.arguments == ["dmhost", rig.fw.path + "/dm", "main", "sdk"])
        #expect(plan.frameworkExecutable.path == rig.fw.path + "/DmGame")
        #expect(plan.imageMarker == "dmgame_image_marker")
        #expect(plan.logURL.path == rig.box.documents.path + "/log.txt")
        #expect(plan.workingDirectory.path == rig.box.documents.path)
        #expect(plan.foldersToCreate.map(\.path) == [rig.gdir.path + "/save", rig.gdir.path + "/temp"])
    }

    @Test func makingThePlanCreatesNothingButCreateFoldersDoes() throws {
        let rig = try Rig()
        let plan = rig.plan()
        #expect(!FileManager.default.fileExists(atPath: rig.gdir.path))
        try plan.createFolders()
        for url in plan.foldersToCreate { #expect(FileManager.default.fileExists(atPath: url.path)) }
        #expect(!FileManager.default.fileExists(atPath: rig.gdir.path + "/cheats"))
        try plan.createFolders()
    }
}