Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

@@ -0,0 +1,189 @@
// 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 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)
}
}
}