Files
VCCPlusOSS/platforms/macos/Tests/SoftwareLibraryLaunchPlanTests.swift

253 lines
21 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
final class SoftwareLibraryLaunchPlanTests: XCTestCase {
private var root: URL!
private var working: URL { root.appendingPathComponent("Working") }
private let sha = String(repeating: "a", count: 64)
override func setUpWithError() throws {
root = FileManager.default.temporaryDirectory.appendingPathComponent("LibraryLaunch-" + UUID().uuidString)
try FileManager.default.createDirectory(at: working, withIntermediateDirectories: true)
}
override func tearDownWithError() throws { try? FileManager.default.removeItem(at: root) }
@discardableResult private func file(_ path: String, bytes: Data = Data([1, 2, 3])) throws -> URL {
let url = working.appendingPathComponent(path)
try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true)
try bytes.write(to: url); return url
}
private func receipt(_ paths: [String]) -> SoftwareLibraryInstallationReceipt {
.init(releaseID: "release", packageSHA256: sha, installedAt: Date(), workingDirectory: working, relativeFiles: paths)
}
private func release(media: String = "disk", profile: String = "disk-basic", paths: [(String, String)] = [], command: String? = nil,
extra: [String: LibraryJSON] = [:], status: String = "source-ready") -> SoftwareLibraryRelease {
var configuration: [String: LibraryJSON] = ["profile": .string(profile), "processor": .string("6809"), "ram_kib": .number(2048), "controller_slot": .number(4), "video": .string("composite")]
configuration.merge(extra, uniquingKeysWith: { _, newer in newer })
let setup = SoftwareLibrarySetup(status: status, command: command, instructions: "Mount the supplied media and follow its manual.", configuration: .object(configuration), selectedMembers: .array(paths.map { .object(["target": .string($0.0), "path": .string($0.1), "sha256": .string(sha)]) }), reasons: [], validation: .object([:]))
return .init(id: "release", titleID: "title", name: "Example.zip", category: "Disks/Games", mediaType: media, contentRole: "software", sourceURL: URL(string: "https://colorcomputerarchive.com/Example.zip")!, modifiedAt: nil, modifiedPrecision: nil, modifiedTimezone: nil, packageSHA256: sha, byteSize: 100, languageStatus: "english", metadata: .object(["title": .string("Example")]), setup: setup, assets: [], downloadURLs: [])
}
func testPresentationDistinguishesKnownStartupFromManualOrAmbiguousSetup() {
func automatic(_ item: SoftwareLibraryRelease) -> Bool { SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: item) }
XCTAssertTrue(automatic(release(media: "cartridge", profile: "rom-cartridge", paths: [("cartridge", "GAME.CCC")])))
XCTAssertTrue(automatic(release(paths: [("disk0", "GAME.DSK")], command: "LOADM\"GAME\":EXEC\r", status: "manual-setup")))
XCTAssertTrue(automatic(release(media: "cassette", paths: [("media", "GAME.cas")], command: "CLOADM\rEXEC\r")))
XCTAssertTrue(automatic(release(media: "sdc", profile: "coco-sdc", paths: [("disk0", "GAME.DSK")], command: "RUN\"AUTOEXEC:0\"\r")))
XCTAssertFalse(automatic(release(media: "cartridge", profile: "rom-cartridge", extra: ["launch_method": .string("cartridge-autostart")])))
XCTAssertFalse(automatic(release(media: "cartridge", profile: "rom-cartridge", paths: [("cartridge", "UNKNOWN.bin")])))
XCTAssertFalse(automatic(release(command: "RUN\"GAME\"\r")))
XCTAssertFalse(automatic(release(paths: [("disk0", "GAME.DSK")])))
XCTAssertFalse(automatic(release(paths: [("disk0", "GAME.DSK")], command: "DIR\r")))
XCTAssertFalse(automatic(release(paths: [("disk0", "GAME.DSK")], command: "RUN\rDIR\r")))
XCTAssertFalse(automatic(release(media: "hard-disk", profile: "hard-drive-basic", paths: [("hardDisk0", "GAME.vhd")], command: "DOS\r")))
XCTAssertFalse(automatic(release(paths: [("disk0", "GAME.vhd")], command: "DOS\r")))
}
func testUnconfiguredPersonalROMImportOffersRealCartridgeSetup() async throws {
let selected = root.appendingPathComponent("AUTHORED.ROM"), bytes = Data([0x12,0x39])
try bytes.write(to: selected)
let store = PersonalSoftwareLibraryStore(root: root.appendingPathComponent("PersonalLibrary"))
let draft = try await store.inspect([selected]), entry = try await store.save(draft)
XCTAssertFalse(entry.configured)
let imported = await store.directory(for: entry.id)
let plan = try SoftwareLibraryLaunchPlan.prepare(release: entry.release(in: imported), receipt: entry.receipt(in: imported))
XCTAssertEqual(plan.profile, .romCartridge)
XCTAssertEqual(plan.cartridgeURL?.lastPathComponent, "AUTHORED.ROM")
XCTAssertTrue(plan.commands.isEmpty)
XCTAssertEqual(try Data(contentsOf: selected), bytes)
try plan.validateMedia()
}
func testCartridgeAutostartsWithoutTypingAndHonorsItsStartupSlot() throws {
try file("GAME.ccc")
let plan = try SoftwareLibraryLaunchPlan.prepare(release: release(media: "cartridge", profile: "rom-cartridge", paths: [("cartridge", "GAME.ccc")], extra: ["cartridge_slot": .number(2)]), receipt: receipt(["GAME.ccc"]))
XCTAssertTrue(plan.automaticallyStarts); XCTAssertTrue(plan.commands.isEmpty)
XCTAssertEqual(plan.cartridgeURL?.lastPathComponent, "GAME.ccc"); XCTAssertEqual(plan.controllerSlot, 2)
XCTAssertTrue(plan.floppyURLs.isEmpty); XCTAssertNil(plan.cassetteURL)
try plan.validateMedia()
}
func testOrchestraCartridgeKeepsNativeDeviceAndUnknownDevicesAreNotGenericROMs() throws {
try file("ORCH90.ccc")
let orchestra = release(media: "cartridge", profile: "rom-cartridge", paths: [("cartridge", "ORCH90.ccc")], extra: ["cartridge_device": .string("orchestra90")])
let plan = try SoftwareLibraryLaunchPlan.prepare(release: orchestra, receipt: receipt(["ORCH90.ccc"]))
XCTAssertEqual(plan.cartridgeDevice, .orchestra90)
XCTAssertTrue(plan.automaticallyStarts)
XCTAssertTrue(SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: orchestra))
let plain = try SoftwareLibraryLaunchPlan.prepare(release: release(media: "cartridge", profile: "rom-cartridge", paths: [("cartridge", "ORCH90.ccc")]), receipt: receipt(["ORCH90.ccc"]))
XCTAssertEqual(plain.cartridgeDevice, .rom)
for device: LibraryJSON in [.string("game-master"), .number(5)] {
let unsupported = release(media: "cartridge", profile: "rom-cartridge", paths: [("cartridge", "ORCH90.ccc")], extra: ["cartridge_device": device])
XCTAssertFalse(SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: unsupported))
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: unsupported, receipt: receipt(["ORCH90.ccc"])))
}
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "ORCH90.ccc")], extra: ["cartridge_device": .string("orchestra90")]), receipt: receipt(["ORCH90.ccc"])))
}
func testDiskAppliesRecommendedProcessorRAMAndVideoWithoutDependingOnTestedStatus() throws {
try file("Game/HELLO.DSK")
let plan = try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "Game/HELLO.DSK")], command: "LOADM\"HELLO\":EXEC\\r", extra: ["processor": .string("6309"), "ram_kib": .number(8192), "video": .string("rgb")], status: "manual-setup"), receipt: receipt(["Game/HELLO.DSK"]))
XCTAssertTrue(plan.use6309); XCTAssertEqual(plan.ramIndex, 3); XCTAssertEqual(plan.ramKiB, 8192); XCTAssertEqual(plan.videoOutput, 0)
XCTAssertEqual(plan.floppyURLs[0]?.lastPathComponent, "HELLO.DSK"); XCTAssertEqual(plan.commands, ["LOADM\"HELLO\":EXEC"])
XCTAssertTrue(plan.automaticallyStarts)
}
func testFD502RecipeAndManualSelectionAcceptTrackAndVDKImages() throws {
let paths = ["FLEX.DMK", "Explorer.vdk"]
for path in paths { try file(path) }
let recipe = release(paths: [("disk0", paths[0]), ("disk3", paths[1])], command: "DOS\r")
XCTAssertTrue(SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: recipe))
let plan = try SoftwareLibraryLaunchPlan.prepare(release: recipe, receipt: receipt(paths))
XCTAssertEqual(plan.floppyURLs[0]?.lastPathComponent, paths[0])
XCTAssertEqual(plan.floppyURLs[3]?.lastPathComponent, paths[1])
for path in paths {
let manual = try SoftwareLibraryLaunchPlan.prepare(release: release(status: "manual-setup"), receipt: receipt(paths), selectedMember: path)
XCTAssertEqual(manual.floppyURLs[0]?.lastPathComponent, path)
XCTAssertFalse(manual.automaticallyStarts)
}
XCTAssertFalse(SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: release(media: "sdc", profile: "coco-sdc", paths: [("disk0", paths[0])], command: "DOS\r")))
}
func testCassetteProducesSeparateLoadAndRunStepsForPromptSequencing() throws {
try file("HELLO.cas")
let plan = try SoftwareLibraryLaunchPlan.prepare(release: release(media: "cassette", paths: [("media", "HELLO.cas")], command: "CLOAD\rRUN\r"), receipt: receipt(["HELLO.cas"]))
XCTAssertEqual(plan.commands, ["CLOAD", "RUN"]); XCTAssertTrue(plan.automaticallyStarts)
XCTAssertNotNil(plan.cassetteURL); XCTAssertNil(plan.cartridgeURL)
}
func testSDCPreservesSiblingDisksAndMountsBeforeLoadingProgram() throws {
try file("Double Dragon/DDRAGON1.DSK"); try file("Double Dragon/DDRAGON2.DSK")
let plan = try SoftwareLibraryLaunchPlan.prepare(release: release(media: "sdc", profile: "coco-sdc", paths: [("disk0", "Double Dragon/DDRAGON1.DSK")], command: "RUN\"AUTOEXEC:0\"\\r", extra: ["sd_working_directory": .string("Double Dragon")]), receipt: receipt(["Double Dragon/DDRAGON1.DSK", "Double Dragon/DDRAGON2.DSK"]))
XCTAssertEqual(plan.sdcFolderURL?.lastPathComponent, "Double Dragon")
XCTAssertEqual(plan.sdcInitialImages, [0: "DDRAGON1.DSK"])
XCTAssertEqual(plan.commands, ["DRIVE 0,\"DDRAGON1.DSK\"", "RUN\"AUTOEXEC:0\""])
XCTAssertTrue(plan.floppyURLs.isEmpty); try plan.validateMedia()
}
func testAmbiguousManualMediaRequiresExplicitChoiceAndDoesNotGuessStartupCommand() throws {
try file("ONE.DSK"); try file("TWO.DSK")
let item = release(command: "RUN\"ONE\"\\r", status: "manual-setup")
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: item, receipt: receipt(["ONE.DSK", "TWO.DSK"]))) { error in
guard case SoftwareLibraryLaunchPlan.Failure.needsSelection(let choices) = error else { return XCTFail("Expected a media selection") }
XCTAssertEqual(choices.map(\.path), ["ONE.DSK", "TWO.DSK"])
}
let plan = try SoftwareLibraryLaunchPlan.prepare(release: item, receipt: receipt(["ONE.DSK", "TWO.DSK"]), selectedMember: "TWO.DSK")
XCTAssertEqual(plan.floppyURLs[0]?.lastPathComponent, "TWO.DSK")
XCTAssertFalse(plan.automaticallyStarts); XCTAssertTrue(plan.commands.isEmpty)
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: item, receipt: receipt(["ONE.DSK", "TWO.DSK"]), selectedMember: "../ONE.DSK"))
}
func testSingleManualDiskMountsForGuidanceAndSingleCCCStillAutostarts() throws {
try file("GAME.DSK"); try file("GAME.ccc")
let disk = try SoftwareLibraryLaunchPlan.prepare(release: release(status: "manual-setup"), receipt: receipt(["GAME.DSK"]))
XCTAssertFalse(disk.automaticallyStarts); XCTAssertTrue(disk.commands.isEmpty); XCTAssertNotNil(disk.floppyURLs[0])
let cart = try SoftwareLibraryLaunchPlan.prepare(release: release(media: "cartridge", profile: "rom-cartridge", status: "manual-setup"), receipt: receipt(["GAME.ccc"]))
XCTAssertTrue(cart.automaticallyStarts)
}
func testWorkingSavesAreNotRejectedByOriginalMemberFingerprint() throws {
let media = try file("GAME.DSK")
try Data([9, 8, 7, 6]).write(to: media)
let plan = try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "GAME.DSK")], command: "DOS\\r"), receipt: receipt(["GAME.DSK"]))
XCTAssertTrue(plan.automaticallyStarts); try plan.validateMedia()
XCTAssertEqual(try Data(contentsOf: media), Data([9, 8, 7, 6]))
}
func testUnsafeOrMissingSelectedMediaNeverProducesPlan() throws {
try file("GAME.DSK")
for path in ["../Original/GAME.DSK", "/GAME.DSK", "folder/../GAME.DSK", "GAME.DSK:stream", "absent.DSK"] {
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", path)]), receipt: receipt([path])))
}
let outside = root.appendingPathComponent("outside.DSK"); try Data([8]).write(to: outside)
try FileManager.default.removeItem(at: working.appendingPathComponent("GAME.DSK"))
try FileManager.default.createSymbolicLink(at: working.appendingPathComponent("GAME.DSK"), withDestinationURL: outside)
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "GAME.DSK")]), receipt: receipt(["GAME.DSK"])))
}
func testRevalidationRejectsReplacementLinkAndSDCSiblingLink() throws {
let media = try file("GAME.DSK")
let plan = try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "GAME.DSK")]), receipt: receipt(["GAME.DSK"]))
try FileManager.default.removeItem(at: media)
let outside = root.appendingPathComponent("outside.DSK"); try Data([1]).write(to: outside)
try FileManager.default.createSymbolicLink(at: media, withDestinationURL: outside)
XCTAssertThrowsError(try plan.validateMedia())
try FileManager.default.removeItem(at: media); try file("GAME.DSK")
let sdc = try SoftwareLibraryLaunchPlan.prepare(release: release(media: "sdc", profile: "coco-sdc", paths: [("disk0", "GAME.DSK")]), receipt: receipt(["GAME.DSK"]))
try FileManager.default.createSymbolicLink(at: working.appendingPathComponent("escape"), withDestinationURL: root)
XCTAssertThrowsError(try sdc.validateMedia())
}
func testMalformedRecommendationsAndConflictingTargetsAreRejected() throws {
try file("GAME.DSK")
for extra: [String: LibraryJSON] in [["processor": .string("x86")], ["processor": .number(6809)], ["ram_kib": .number(4096)], ["ram_kib": .string("2048")], ["controller_slot": .number(0)], ["controller_slot": .bool(true)], ["video": .string("shell")]] {
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "GAME.DSK")], extra: extra), receipt: receipt(["GAME.DSK"])))
}
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "GAME.DSK"), ("disk0", "GAME.DSK")]), receipt: receipt(["GAME.DSK"])))
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("execute-host", "GAME.DSK")]), receipt: receipt(["GAME.DSK"])))
let mismatched = SoftwareLibraryInstallationReceipt(releaseID: "other", packageSHA256: sha, installedAt: Date(), workingDirectory: working, relativeFiles: ["GAME.DSK"])
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "GAME.DSK")]), receipt: mismatched))
}
func testUnknownCommandsRemainManualAndBinaryFilesAreNotGuessedAsCartridges() throws {
try file("GAME.DSK"); try file("PROGRAM.bin")
let plan = try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "GAME.DSK")], command: "SYSTEM \"curl example.invalid\"\\r"), receipt: receipt(["GAME.DSK"]))
XCTAssertFalse(plan.automaticallyStarts); XCTAssertTrue(plan.commands.isEmpty)
XCTAssertTrue(plan.manualInstructions.contains("manual entry"))
XCTAssertThrowsError(try SoftwareLibraryLaunchPlan.prepare(release: release(media: "cartridge", profile: "rom-cartridge"), receipt: receipt(["PROGRAM.bin"])))
}
func testDoesNotTypeAnotherLineAfterStartingGuestSoftware() throws {
for command in ["RUN\"GAME\"\rDIR\r", "EXEC\rRUN\r", "DOS\rNEW\r", "LOAD \"BOOT\", R\rEXEC\r"] {
XCTAssertNil(SoftwareLibraryLaunchPlan.decodeCommands(command), command)
}
XCTAssertEqual(SoftwareLibraryLaunchPlan.decodeCommands("RUN\"INTRO\":EXEC\r"), ["RUN\"INTRO\":EXEC"])
XCTAssertEqual(SoftwareLibraryLaunchPlan.decodeCommands("LOADM\"JUNGLE\":EXEC:LOADM\"JUNGLE2\":EXEC\r"), ["LOADM\"JUNGLE\":EXEC:LOADM\"JUNGLE2\":EXEC"])
try file("GAME.DSK")
let plan = try SoftwareLibraryLaunchPlan.prepare(release: release(paths: [("disk0", "GAME.DSK")], command: "RUN\"GAME\"\rDIR\r"), receipt: receipt(["GAME.DSK"]))
XCTAssertFalse(plan.automaticallyStarts)
XCTAssertTrue(plan.commands.isEmpty)
XCTAssertNotNil(plan.floppyURLs[0])
}
func testCommandGrammarHandlesQuotedColonAndRejectsDoubleEscapesAndControls() {
XCTAssertEqual(SoftwareLibraryLaunchPlan.decodeCommands("RUN\"AUTOEXEC:0\"\\r"), ["RUN\"AUTOEXEC:0\""])
XCTAssertEqual(SoftwareLibraryLaunchPlan.decodeCommands("CLOADM\\rEXEC\\r"), ["CLOADM", "EXEC"])
XCTAssertEqual(SoftwareLibraryLaunchPlan.decodeCommands("PCLEAR1:RUN\"FIRE&GAS\"\r"), ["PCLEAR1:RUN\"FIRE&GAS\""])
XCTAssertEqual(SoftwareLibraryLaunchPlan.decodeCommands("LOAD CHR$(42),R\\r"), ["LOAD CHR$(42),R"])
for command in ["RUN\"broken", "RUN\"A\"\u{1b}", "RUN\\\"A\\\"\\r", "RUN\"A\":FORMAT\"B\"", "RUN\"A\\B\"", String(repeating: "RUN\r", count: 20)] {
XCTAssertNil(SoftwareLibraryLaunchPlan.decodeCommands(command), command)
}
}
func testBasicProgramLoadThenRunUsesSeparateKeyboardLines() throws {
for sequence in ["LOAD \"POPSTAR\"\nRUN", "load \"POPSTAR\"\r\nrun", "LOAD\"POPSTAR\"\\rRUN\\r"] {
let commands = try XCTUnwrap(SoftwareLibraryLaunchPlan.decodeCommands(sequence))
XCTAssertEqual(commands.count, 2)
XCTAssertEqual(commands[0].uppercased().replacingOccurrences(of: " ", with: ""), "LOAD\"POPSTAR\"")
XCTAssertEqual(commands[1].uppercased(), "RUN")
}
try file("POPSTAR.DSK")
let item = release(paths: [("disk0", "POPSTAR.DSK")], command: "LOAD \"POPSTAR\"\nRUN", status: "manual-setup")
XCTAssertTrue(SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: item))
let plan = try SoftwareLibraryLaunchPlan.prepare(release: item, receipt: receipt(["POPSTAR.DSK"]))
XCTAssertTrue(plan.automaticallyStarts)
XCTAssertEqual(plan.commands, ["LOAD \"POPSTAR\"", "RUN"])
XCTAssertEqual(plan.floppyURLs[0]?.lastPathComponent, "POPSTAR.DSK")
XCTAssertNil(SoftwareLibraryLaunchPlan.decodeCommands("LOAD \"POPSTAR\":RUN"), "BASIC discards the rest of the LOAD command line")
XCTAssertEqual(SoftwareLibraryLaunchPlan.decodeCommands("LOAD \"POPSTAR\""), ["LOAD \"POPSTAR\""])
XCTAssertFalse(SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: release(paths: [("disk0", "POPSTAR.DSK")], command: "LOAD \"POPSTAR\"")))
XCTAssertNil(SoftwareLibraryLaunchPlan.decodeCommands("LOAD \"POPSTAR\"\nRUN\nDIR"), "No later commands may be typed into a started guest program")
}
@MainActor
func testReviewedPersonalDiskOffersPlayWithoutLoadingCommands() throws {
try file("GAME.DSK")
var entry = PersonalSoftwareEntry(id: UUID(), title: "Reviewed personal disk", files: [
.init(path: "GAME.DSK", kind: "disk", byteSize: 3, sha256: sha, role: "disk0")
])
entry.configured = true
let item = entry.release(in: root)
XCTAssertTrue(SoftwareLibraryLaunchPlan.hasPlayAction(for: item))
XCTAssertFalse(SoftwareLibraryLaunchPlan.hasAutomaticStartup(for: item))
let plan = try SoftwareLibraryLaunchPlan.prepare(release: item, receipt: entry.receipt(in: root))
XCTAssertTrue(plan.offersPlay); XCTAssertFalse(plan.automaticallyStarts)
XCTAssertTrue(plan.commands.isEmpty); XCTAssertNotNil(plan.floppyURLs[0])
let model = SoftwareLibraryModel(state: .init(directory: root.appendingPathComponent("State")))
XCTAssertEqual(model.launchLabel(item, installed: true), "Play…")
XCTAssertEqual(model.launchSymbol(item), "play.fill")
entry.command = "LOAD \"GAME\""
let loadOnly = try SoftwareLibraryLaunchPlan.prepare(release: entry.release(in: root), receipt: entry.receipt(in: root))
XCTAssertTrue(loadOnly.offersPlay); XCTAssertFalse(loadOnly.automaticallyStarts)
XCTAssertEqual(loadOnly.commands, ["LOAD \"GAME\""])
entry.command = "SYSTEM \"curl example.invalid\""
let unsupported = try SoftwareLibraryLaunchPlan.prepare(release: entry.release(in: root), receipt: entry.receipt(in: root))
XCTAssertTrue(unsupported.offersPlay); XCTAssertTrue(unsupported.commands.isEmpty)
entry.configured = false
XCTAssertFalse(SoftwareLibraryLaunchPlan.hasPlayAction(for: entry.release(in: root)))
entry.configured = true; entry.files[0].role = ""
XCTAssertFalse(SoftwareLibraryLaunchPlan.hasPlayAction(for: entry.release(in: root)))
XCTAssertFalse(SoftwareLibraryLaunchPlan.hasPlayAction(for: release(paths: [("disk0", "GAME.DSK")])), "Public catalog labels retain their existing behavior")
}
}