Files
VCCPlusOSS/platforms/macos/Tests/StartupTests.swift
T

718 lines
48 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import AppKit
final class StartupTests: XCTestCase {
func testIdentityStartsIndependentlyOfLegacySettingsAndMedia() throws {
let root = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
defer { try? FileManager.default.removeItem(at: root) }
let current = root.appendingPathComponent(AppIdentity.bundleID, isDirectory: true)
let legacy = root.appendingPathComponent("org.vcc.mac", isDirectory: true)
let profiles = ProfileStore(directory: legacy.appendingPathComponent("Profiles"))
try profiles.save(ConfigurationProfile(name: "Legacy profile"))
let disk = legacy.appendingPathComponent("Saved disk.dsk"), bytes = Data([0x42, 0x99])
try bytes.write(to: disk)
XCTAssertEqual(AppIdentity.supportDirectory(in: root), current)
XCTAssertTrue(try ProfileStore(directory: current.appendingPathComponent("Profiles")).load().isEmpty)
XCTAssertEqual(try Data(contentsOf: disk), bytes)
XCTAssertEqual(try profiles.load().first?.name, "Legacy profile")
XCTAssertFalse(FileManager.default.fileExists(atPath: current.path))
}
struct Fixture {
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCStartup-" + UUID().uuidString)
var kit: StarterKit { .init(directory: root.appendingPathComponent("Kit")) }
var support: URL { root.appendingPathComponent("Support") }
var disks: DiskAssignmentStore { .init(url: support.appendingPathComponent("DiskAssignments.json")) }
var startup: StartupStore { .init(directory: support, kit: kit) }
init() throws {
try FileManager.default.createDirectory(at: kit.directory, withIntermediateDirectories: true)
var rom = Data(repeating: 0x12, count: 32768)
rom[0] = 0x20; rom[1] = 0xfe; rom[32766] = 0x80; rom[32767] = 0
try rom.write(to: kit.directory.appendingPathComponent("coco3.rom"))
try Data(repeating: 0, count: 8192).write(to: kit.directory.appendingPathComponent("disk11.rom"))
try Data(repeating: 0, count: 161280).write(to: kit.directory.appendingPathComponent("Hello World.dsk"))
try Data([0x55,0x55,0x3c]).write(to: kit.directory.appendingPathComponent("Hello World.cas"))
try Data(repeating: 0, count: 8192).write(to: kit.directory.appendingPathComponent("rgbdos.rom"))
try Data(repeating: 0x12, count: 8192).write(to: kit.directory.appendingPathComponent("sdcdos.rom"))
try Data(repeating: 0x31, count: 161280).write(to: kit.directory.appendingPathComponent("Hello Hard Disk.dsk"))
try Data(repeating: 0xff, count: 161280).write(to: kit.directory.appendingPathComponent("Blank Disk.dsk"))
let resources = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent().appendingPathComponent("Resources/StarterMedia")
try FileManager.default.copyItem(at: resources.appendingPathComponent("Blank OS9 Header.bin"), to: kit.directory.appendingPathComponent("Blank OS9 Header.bin"))
try Data(repeating: 0, count: 256).write(to: kit.directory.appendingPathComponent("NitrOS-9 L2 V3.3.0.vhd"))
}
func remove() { try? FileManager.default.removeItem(at: root) }
}
@MainActor func testBundledSpeechROMsAreCopiedRememberedAndDoNotChangeStartupSlot() async throws {
let f = try Fixture(); defer { f.remove() }
var pic = Data(repeating: 0, count: 4096)
pic[0] = 0xb3; pic[1] = 0xe0; pic[2] = 0xfd; pic[4094] = 0xf0
try pic.write(to: f.kit.directory.appendingPathComponent("pic-7040-510.bin"))
try Data(repeating: 0, count: 2048).write(to: f.kit.directory.appendingPathComponent("sp0256-al2.bin"))
let suite = "VCCSpeechStartup-" + UUID().uuidString, defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
func create() -> MachineModel {
MachineModel(diskStore: f.disks, displayDefaults: defaults,
inputStore: .init(url: f.support.appendingPathComponent("Input.json")), startupStore: f.startup)
}
func settled(_ model: MachineModel) async throws {
for _ in 0..<1000 { if !model.busy && !model.diskSaving { return }; try await Task.sleep(nanoseconds: 10_000_000) }
XCTFail("Speech startup timed out")
}
var model = create(); try await settled(model)
model.assignCartridge(.speechSound, slot: 2); try await settled(model)
let assignment = model.cartridgeAssignments.slots[2]
XCTAssertNotNil(assignment.url); XCTAssertNotNil(assignment.speechROMURL)
XCTAssertEqual(try Data(contentsOf: XCTUnwrap(assignment.url)), pic)
XCTAssertTrue(assignment.url!.path.hasPrefix(f.support.path))
XCTAssertEqual(model.cartridgeAssignments.physicalSlot, 4); XCTAssertTrue(model.disks[0].mounted); XCTAssertTrue(model.tapeMounted)
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
model.assignCartridge(.speechSound, slot: 1); try await settled(model)
XCTAssertEqual(model.cartridgeAssignments.slots[1], assignment)
await withCheckedContinuation { done in model.shutdown { done.resume() } }
try FileManager.default.removeItem(at: f.kit.directory.appendingPathComponent("pic-7040-510.bin"))
try FileManager.default.removeItem(at: f.kit.directory.appendingPathComponent("sp0256-al2.bin"))
model = create(); try await settled(model)
XCTAssertEqual(model.cartridgeAssignments.slots[1], assignment)
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
@MainActor func testBundledOrchestraDefaultSoundOnlyAndImmutableROMRecovery() async throws {
let f = try Fixture(); defer { f.remove() }
let bundled = f.kit.directory.appendingPathComponent("orch90.rom")
let data = Data(repeating: 0x12, count: 8192); try data.write(to: bundled)
let suite = "VCCOrchestraStartup-" + UUID().uuidString, defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
func create() -> MachineModel {
MachineModel(diskStore: f.disks, displayDefaults: defaults,
inputStore: .init(url: f.support.appendingPathComponent("Input.json")), startupStore: f.startup)
}
func settled(_ model: MachineModel) async throws {
for _ in 0..<1000 { if !model.busy && !model.diskSaving { return }; try await Task.sleep(nanoseconds: 10_000_000) }
XCTFail("Bundled cartridge operation timed out")
}
var model = create(); try await settled(model)
model.assignCartridge(.orchestra90, slot: 1); try await settled(model)
let cached = try XCTUnwrap(model.cartridgeAssignments.slots[1].url)
XCTAssertEqual(try Data(contentsOf: cached), data); XCTAssertTrue(cached.path.hasPrefix(f.support.path))
XCTAssertEqual(model.cartridgeAssignments.physicalSlot, 4, "Selecting sound hardware must not change the boot slot")
model.assignCartridge(.orchestra90, slot: 1, useBundledROM: false); try await settled(model)
XCTAssertNil(model.cartridgeAssignments.slots[1].url)
model.assignCartridge(.orchestra90, slot: 2); try await settled(model)
XCTAssertNil(model.cartridgeAssignments.slots[2].url, "Moving sound-only hardware must not reattach a bundled ROM")
await withCheckedContinuation { done in model.shutdown { done.resume() } }
model = create(); try await settled(model)
XCTAssertNil(model.cartridgeAssignments.slots[2].url, "Explicit sound-only choice survives relaunch")
model.assignCartridge(.empty, slot: 2); try await settled(model)
try Data([1,2,3]).write(to: cached)
model.assignCartridge(.orchestra90, slot: 1); try await settled(model)
XCTAssertNotNil(model.fileError); XCTAssertEqual(model.cartridgeAssignments.slots[1].kind, .empty)
XCTAssertEqual(try Data(contentsOf: cached), Data([1,2,3]), "Never overwrite a changed cached ROM")
try FileManager.default.removeItem(at: cached)
model.assignCartridge(.orchestra90, slot: 1); try await settled(model)
XCTAssertEqual(model.cartridgeAssignments.slots[1].url, cached); XCTAssertNil(model.fileError)
XCTAssertTrue(model.disks[0].mounted); XCTAssertTrue(model.tapeMounted)
await withCheckedContinuation { done in model.shutdown { done.resume() } }
try FileManager.default.removeItem(at: bundled)
model = create(); try await settled(model)
XCTAssertEqual(model.cartridgeAssignments.slots[1].url, cached)
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty, "An app move or removed bundled resource must not break the retained copy")
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
func testSDCSystemProfileSeedsCompleteCardAndPreservesUserChanges() throws {
let f = try Fixture(); defer { f.remove() }
let profile = try f.startup.systemProfile(.cocoSDC)
let slot = try XCTUnwrap(profile.media.cartridges?.slots[4])
let folder = try XCTUnwrap(slot.sdcFolderURL)
XCTAssertEqual(profile.media.cartridges?.physicalSlot, 4)
XCTAssertEqual(slot.kind, .sdc); XCTAssertEqual(slot.sdcReadOnly, false)
XCTAssertNil(profile.media.rom); XCTAssertNil(profile.cassette)
XCTAssertTrue(profile.media.drives.allSatisfy { $0 == nil })
XCTAssertTrue(profile.media.hardDisks!.drives.allSatisfy { $0 == nil })
XCTAssertEqual(try Data(contentsOf: folder.appendingPathComponent("HELLO.DSK")),
try Data(contentsOf: f.kit.directory.appendingPathComponent("Hello World.dsk")))
XCTAssertEqual(try String(contentsOf: folder.appendingPathComponent("startup.cfg"), encoding: .utf8), "0=HELLO.DSK\n")
XCTAssertTrue(FileManager.default.isWritableFile(atPath: folder.path))
let changed = Data(repeating: 0x42, count: 161280)
try changed.write(to: folder.appendingPathComponent("HELLO.DSK"))
try Data("0=OTHER.DSK\n".utf8).write(to: folder.appendingPathComponent("startup.cfg"))
let again = try f.startup.systemProfile(.cocoSDC)
XCTAssertEqual(again.media.cartridges?.slots[4].sdcFolderURL, folder)
XCTAssertEqual(try Data(contentsOf: folder.appendingPathComponent("HELLO.DSK")), changed)
XCTAssertEqual(try String(contentsOf: folder.appendingPathComponent("startup.cfg"), encoding: .utf8), "0=OTHER.DSK\n")
let fresh = try f.startup.systemProfile(.cocoSDC, freshMedia: true)
let clean = try XCTUnwrap(fresh.media.cartridges?.slots[4].sdcFolderURL)
XCTAssertNotEqual(clean, folder)
XCTAssertEqual(try String(contentsOf: clean.appendingPathComponent("startup.cfg"), encoding: .utf8), "0=HELLO.DSK\n")
XCTAssertNotEqual(try Data(contentsOf: clean.appendingPathComponent("HELLO.DSK")), changed)
try FileManager.default.removeItem(at: folder.appendingPathComponent("HELLO.DSK"))
try FileManager.default.removeItem(at: folder.appendingPathComponent("startup.cfg"))
_ = try f.startup.systemProfile(.cocoSDC)
XCTAssertFalse(FileManager.default.fileExists(atPath: folder.appendingPathComponent("HELLO.DSK").path))
XCTAssertFalse(FileManager.default.fileExists(atPath: folder.appendingPathComponent("startup.cfg").path))
_ = try f.startup.appDefaults()
XCTAssertTrue(FileManager.default.fileExists(atPath: folder.path), "Restore Defaults keeps the user's card")
XCTAssertEqual(try Data(contentsOf: f.kit.directory.appendingPathComponent("Hello World.dsk")), Data(repeating: 0, count: 161280))
try FileManager.default.removeItem(at: f.kit.directory.appendingPathComponent("sdcdos.rom"))
XCTAssertNotNil(f.startup.unavailableReason(for: .cocoSDC))
XCTAssertNil(f.startup.unavailableReason(for: .diskBasic))
}
@MainActor func testSDCSystemProfileMountAndGuidanceSurviveRelaunchAndPersonalCopy() async throws {
let f = try Fixture(); defer { f.remove() }
let suite = "VCCSDCStartup-" + UUID().uuidString, defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
var remembered: URL?
for launch in 0..<2 {
let model = MachineModel(diskStore: f.disks, displayDefaults: defaults,
inputStore: .init(url: f.support.appendingPathComponent("Input.json")), startupStore: f.startup)
try await waitForStartup(model)
if launch == 0 {
let loaded = await model.loadSystemProfile(.cocoSDC); XCTAssertTrue(loaded)
remembered = model.cartridgeAssignments.slots[4].sdcFolderURL
}
XCTAssertEqual(model.usageProfile, .cocoSDC)
XCTAssertEqual(model.state, .running); XCTAssertFalse(model.sdcReadOnly)
XCTAssertFalse(model.diskConnected); XCTAssertFalse(model.hardDiskConnected)
XCTAssertFalse(model.tapeMounted); XCTAssertNil(model.sdcError)
XCTAssertEqual(model.cartridgeAssignments.slots[4].sdcFolderURL, remembered)
XCTAssertEqual(model.sdcDriveNames[0], "/HELLO.DSK")
if launch == 1 {
var personal = try await model.captureProfile(name: "My card")
personal.machine.use6309 = true
await model.loadProfile(personal)
XCTAssertEqual(model.usageProfile, .cocoSDC)
XCTAssertEqual(model.sdcDriveNames[0], "/HELLO.DSK")
let unknown = f.root.appendingPathComponent("sdcdos.rom")
try Data(repeating: 0x12, count: 8192).write(to: unknown)
personal.media.cartridges!.slots[4].url = unknown
await model.loadProfile(personal)
XCTAssertNil(model.usageProfile, "A matching filename does not establish firmware identity")
}
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}
func testFirstInstallCopiesWritableMediaAndStableROMs() throws {
let f = try Fixture(); defer { f.remove() }
let boot = try XCTUnwrap(f.startup.prepare(diskStore: f.disks))
let disks = try f.disks.load()
XCTAssertTrue(disks.cartridges!.multiPak); XCTAssertEqual(disks.cartridges!.physicalSlot,4)
XCTAssertEqual(disks.cartridges!.slots.map(\.kind),[.empty,.empty,.empty,.empty,.floppy])
XCTAssertNotNil(disks.drives[0]); XCTAssertTrue(disks.drives.dropFirst().allSatisfy { $0 == nil })
XCTAssertFalse(disks.drives[0]!.writeProtected); XCTAssertFalse(disks.drives[0]!.temporary)
XCTAssertTrue(FileManager.default.isWritableFile(atPath: disks.drives[0]!.url.path))
XCTAssertTrue(boot.systemROM!.path.hasPrefix(f.support.path)); XCTAssertTrue(boot.cassette!.path.hasPrefix(f.support.path))
// Moving/updating/removing the .app does not invalidate selected file references.
try FileManager.default.removeItem(at: f.kit.directory)
XCTAssertEqual(try f.startup.prepare(diskStore:f.disks),boot)
XCTAssertEqual(try ROMImage.read(boot.systemROM!).count,32768)
}
func testRelaunchPreservesModifiedDiskEjectionAndAlternativeROM() throws {
let f = try Fixture(); defer { f.remove() }
var boot = try XCTUnwrap(f.startup.prepare(diskStore:f.disks))
var disks = try f.disks.load(); let url = disks.drives[0]!.url
var data = try Data(contentsOf:url); data[100] = 0x4d; try data.write(to:url)
let alternative = f.root.appendingPathComponent("Alternative.rom")
try Data(contentsOf:boot.systemROM!).write(to:alternative)
boot.systemROM = alternative; boot.cassette = nil; try f.startup.save(boot)
disks.drives[0] = nil; disks.cartridges = CartridgeAssignments(); try f.disks.save(disks)
XCTAssertEqual(try f.startup.prepare(diskStore:f.disks),boot)
XCTAssertEqual(try f.disks.load(),disks); XCTAssertEqual(try Data(contentsOf:url),data)
try FileManager.default.removeItem(at:url)
_ = try f.startup.prepare(diskStore:f.disks)
XCTAssertFalse(FileManager.default.fileExists(atPath:url.path),"Never recreate a deleted/ejected starter disk on relaunch")
}
func testMigrationRetainsExistingAssignmentsEvenWhenEmpty() throws {
for configured in [false,true] {
let f = try Fixture(); defer { f.remove() }
var disks = DiskAssignments()
if configured { disks.rom=f.root.appendingPathComponent("Missing third party.rom"); disks.cartridges=CartridgeAssignments() }
try f.disks.save(disks)
let selection = try XCTUnwrap(f.startup.prepare(diskStore:f.disks))
XCTAssertEqual(try f.disks.load(),disks); XCTAssertNil(selection.cassette)
XCTAssertFalse(FileManager.default.fileExists(atPath:f.support.appendingPathComponent("Starter Media").path))
}
}
func testCorruptSelectionsAndModifiedROMCacheAreNotOverwritten() throws {
let f = try Fixture(); defer { f.remove() }
let boot = try XCTUnwrap(f.startup.prepare(diskStore:f.disks))
try Data("bad json".utf8).write(to:f.startup.url)
XCTAssertThrowsError(try f.startup.prepare(diskStore:f.disks))
XCTAssertEqual(try Data(contentsOf:f.startup.url),Data("bad json".utf8))
try Data([1,2,3]).write(to:boot.systemROM!)
XCTAssertThrowsError(try f.kit.rom("coco3.rom",in:f.support))
XCTAssertEqual(try Data(contentsOf:boot.systemROM!),Data([1,2,3]))
}
@MainActor func testModelBootsROMWithMountedButStoppedTapeAndRemembersChoices() async throws {
let f = try Fixture(); defer { f.remove() }
let suite = "VCCStartup-" + UUID().uuidString, defaults = UserDefaults(suiteName:suite)!
defer { defaults.removePersistentDomain(forName:suite) }
let model = MachineModel(diskStore:f.disks,displayDefaults:defaults,inputStore:.init(url:f.support.appendingPathComponent("Input.json")),startupStore:f.startup)
func settled() async throws {
for _ in 0..<1000 { if !model.busy { return }; try await Task.sleep(nanoseconds:10_000_000) }
XCTFail("Startup timed out")
}
try await settled()
XCTAssertNil(model.fileError); XCTAssertEqual(model.state,.running)
XCTAssertTrue(model.disks[0].mounted); XCTAssertTrue(model.tapeMounted)
XCTAssertEqual(model.tapeMode,0); XCTAssertEqual(model.tapePosition,0); XCTAssertFalse(model.tapeDirty)
XCTAssertTrue(model.cartridgeAssignments.multiPak); XCTAssertEqual(model.cartridgeAssignments.physicalSlot,4)
model.tapeAction(3); try await settled(); XCTAssertNil(try f.startup.read()!.cassette)
let alternative=f.root.appendingPathComponent("Replacement.rom")
let bytes=try ROMImage.read(model.systemROMURL!);try bytes.write(to:alternative)
model.installROM(bytes,url:alternative);try await settled()
XCTAssertEqual(try f.startup.read()!.systemROM,alternative)
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}
extension StartupTests {
@MainActor private func waitForStartup(_ model: MachineModel) async throws {
for _ in 0..<1000 {
if !model.busy && !model.diskSaving { return }
try await Task.sleep(nanoseconds:10_000_000)
}
throw ProfileFailure.message("Startup did not settle")
}
@MainActor func testUnbundledXcodeBuildRemembersExplicitROMAcrossRelaunch() async throws {
let f = try Fixture(); defer { f.remove() }
let store = StartupStore(directory:f.support,kit:nil)
let suite = "VCCUnbundled-" + UUID().uuidString, defaults = UserDefaults(suiteName:suite)!
defer { defaults.removePersistentDomain(forName:suite) }
let rom = f.kit.directory.appendingPathComponent("coco3.rom")
let bytes = try ROMImage.read(rom)
for launch in 0..<2 {
let model = MachineModel(diskStore:f.disks,displayDefaults:defaults,inputStore:.init(url:f.support.appendingPathComponent("Input.json")),startupStore:store)
try await waitForStartup(model)
if launch == 0 {
XCTAssertEqual(model.state,.empty)
model.installROM(bytes,url:rom); try await waitForStartup(model)
}
XCTAssertFalse(model.hasBundledROMs)
XCTAssertNil(model.fileError); XCTAssertEqual(model.systemROMURL,rom); XCTAssertEqual(model.state,.running)
XCTAssertEqual(try store.read()?.systemROM,rom)
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}
@MainActor func testRestoreAppDefaultsRecoversAdvancedSetupAndPersistsWithoutOverwritingMedia() async throws {
let f = try Fixture(); defer { f.remove() }
let suite = "VCCDefaultRestore-" + UUID().uuidString, defaults = UserDefaults(suiteName:suite)!
defer { defaults.removePersistentDomain(forName:suite) }
let inputStore = InputSettingsStore(url:f.support.appendingPathComponent("Input.json"))
let expected = try f.startup.appDefaults()
let disk = expected.media.drives[0]!.url
var saved = try Data(contentsOf:disk);saved[100] = 0x4d;try saved.write(to:disk)
let profileStore = ProfileStore(directory:f.support.appendingPathComponent("Profiles"))
var custom = expected; custom.name = "My advanced setup"
custom.machine = MachineSettings(use6309:true,ram:3,overclock:4,frameInterval:3,fastForward:true)
custom.videoOutput=2; custom.sound=false; custom.volume=0.1
custom.input.keyboard = .coco;custom.input.right.source = .keyboard;custom.fastCassette=true
custom.media.cartridges!.slots[4].kind = .empty;custom.media.cartridges!.slots[2].kind = .floppy
custom.media.cartridges!.physicalSlot=2
try profileStore.save(custom)
for launch in 0..<2 {
let model = MachineModel(diskStore:f.disks,displayDefaults:defaults,inputStore:inputStore,startupStore:f.startup,
inputControllerReadings: { [] })
try await waitForStartup(model)
if launch == 0 {
await model.loadProfile(custom);XCTAssertNil(model.profileError);XCTAssertTrue(model.settings.use6309)
let restored = await model.restoreAppDefaults();XCTAssertTrue(restored)
}
XCTAssertNil(model.profileError);XCTAssertNil(model.fileError)
XCTAssertEqual(model.settings,MachineSettings());XCTAssertEqual(model.state,.running)
XCTAssertEqual(model.videoOutput,.composite);XCTAssertTrue(model.audioEnabled);XCTAssertEqual(model.volume,0.5)
XCTAssertEqual(model.input.settings,.freshDefaults);XCTAssertFalse(model.tapeFast)
XCTAssertEqual(model.cartridgeAssignments,expected.media.cartridges)
XCTAssertTrue(model.disks[0].mounted);XCTAssertFalse(model.disks[0].writeProtected);XCTAssertFalse(model.diskTemporary[0])
XCTAssertTrue(model.disks.dropFirst().allSatisfy { !$0.mounted });XCTAssertFalse(model.hardDiskConnected)
XCTAssertTrue(model.tapeMounted);XCTAssertEqual(model.tapeMode,0);XCTAssertEqual(model.tapePosition,0)
XCTAssertEqual(try f.startup.read()?.systemROM,expected.systemROM)
XCTAssertEqual(try f.disks.load().rom,expected.media.rom)
XCTAssertEqual(try Data(contentsOf:disk),saved)
XCTAssertEqual(try profileStore.load(),[custom])
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}
@MainActor func testBuiltInProfilePreservesInputButPersonalProfileAndExplicitResetApplyTheirChoices() async throws {
let f = try Fixture(); defer { f.remove() }
let suite = "VCCInputProfile-" + UUID().uuidString, defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
let inputStore = InputSettingsStore(url: f.support.appendingPathComponent("Input.json"))
var configured = InputSettings()
configured.right.source = .controller; configured.right.device = "remembered-disconnected"
configured.right.rightStick = true; configured.right.fire1 = 4; configured.right.fire2 = 8
configured.right.deadZone = 0.3; configured.right.interface = .tandy
configured.left.source = .keyboard
try inputStore.save(configured)
let controller = VCCMachineController()
let model = MachineModel(diskStore: f.disks, controller: controller, displayDefaults: defaults, inputStore: inputStore,
startupStore: f.startup, inputControllerReadings: { [] }, restoreMediaOnLaunch: false)
let loaded = await model.loadSystemProfile(.diskBasic)
XCTAssertTrue(loaded); XCTAssertEqual(model.input.settings, configured)
XCTAssertEqual(try inputStore.load(), configured)
let snapshot = await withCheckedContinuation { done in controller.snapshot { done.resume(returning: $0) } }
XCTAssertEqual(Int(snapshot.joystickInputs[0].mode), configured.right.interface.rawValue,
"Preserving settings must also restore their interface to the newly loaded guest")
var personal = try f.startup.appDefaults()
personal.name = "Explicit personal input"; personal.input.right.source = .mouse
personal.input.right.interface = .cocoMax
personal.input.left.source = .keyboard; personal.sound = false
await model.loadProfile(personal)
XCTAssertNil(model.profileError); XCTAssertEqual(model.input.settings, personal.input)
XCTAssertFalse(try inputStore.loadState().automaticRightController)
let inputEpoch = model.input.epoch
model.input.poll() // A neutral sample while paused must not suppress resynchronization.
model.resume(); try await waitForStartup(model)
let resumed = await withCheckedContinuation { done in controller.snapshot { done.resume(returning: $0) } }
XCTAssertEqual(Int(resumed.joystickInputs[0].mode), personal.input.right.interface.rawValue,
"Ordinary resume must apply a profile's unchanged configured interface after paused submissions were ignored")
XCTAssertEqual(resumed.joystickInputs[0].buttons, 0)
XCTAssertEqual(model.input.epoch, inputEpoch, "Machine resynchronization is not a settings edit")
XCTAssertEqual(try inputStore.load(), personal.input)
let reset = await model.restoreAppDefaults()
XCTAssertTrue(reset); XCTAssertEqual(model.input.settings, .freshDefaults)
XCTAssertTrue(try inputStore.loadState().automaticRightController)
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
@MainActor func testDefaultRestoreRefusesUnsavedDiskAndRecording() async throws {
let f = try Fixture(); defer { f.remove() }
let suite = "VCCDefaultGuards-" + UUID().uuidString, defaults = UserDefaults(suiteName:suite)!
defer { defaults.removePersistentDomain(forName:suite) }
let controller=VCCMachineController()
let model = MachineModel(diskStore:f.disks,controller:controller,displayDefaults:defaults,inputStore:.init(url:f.support.appendingPathComponent("Input.json")),startupStore:f.startup)
try await waitForStartup(model)
model.createDisk(1);try await waitForStartup(model)
let startup=try f.startup.read(), assignments=try f.disks.load()
let restored = await model.restoreAppDefaults();XCTAssertFalse(restored)
XCTAssertTrue(model.disks[1].dirty);XCTAssertNotNil(model.profileError);XCTAssertEqual(model.state,.paused)
XCTAssertEqual(try f.startup.read(),startup);XCTAssertEqual(try f.disks.load(),assignments)
await withCheckedContinuation { done in controller.ejectDisk(inDrive:1,discard:true) { _ in done.resume() } }
model.tapeAction(5);try await waitForStartup(model)
let recordingRestored = await model.restoreAppDefaults();XCTAssertFalse(recordingRestored)
XCTAssertEqual(model.tapeMode,2);XCTAssertNotNil(model.profileError)
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}
extension StartupTests {
func testSystemProfilesReuseWorkingMediaAndFreshCopiesKeepOriginals() throws {
let f = try Fixture(); defer { f.remove() }
let disk = try f.startup.systemProfile(.diskBasic)
let hard = try f.startup.systemProfile(.hardDriveBasic)
XCTAssertEqual(disk.name, "Disk BASIC"); XCTAssertEqual(hard.name, "Hard Drive BASIC")
XCTAssertEqual(hard.media.drives, disk.media.drives)
XCTAssertNil(hard.cassette); XCTAssertNotNil(disk.cassette)
XCTAssertEqual(hard.media.cartridges!.slots.map(\.kind), [.empty,.hardDisk,.empty,.empty,.floppy])
XCTAssertEqual(hard.media.cartridges!.physicalSlot, 4)
let hardURL = hard.media.hardDisks!.drives[0]!.url
let original = try Data(contentsOf: hardURL)
let offset = 0x5a000 * 256, volume = 161280
XCTAssertEqual(original.count, 135659520)
XCTAssertEqual(original.prefix(3), Data([5,160,0]))
XCTAssertTrue(original[8192..<offset].allSatisfy { $0 == 0 })
XCTAssertEqual(original[offset..<offset+volume], Data(repeating: 0x31,count:volume))
XCTAssertTrue(original.suffix(255*volume).allSatisfy { $0 == 0xff })
let floppyURL = disk.media.drives[0]!.url
try Data(repeating: 0x67,count:volume).write(to: floppyURL)
let handle = try FileHandle(forWritingTo: hardURL)
try handle.seek(toOffset: UInt64(offset)); try handle.write(contentsOf: Data([0x77]));try handle.close()
let again = try f.startup.systemProfile(.hardDriveBasic)
XCTAssertEqual(again.media, hard.media)
XCTAssertEqual(try Data(contentsOf:hardURL)[offset],0x77)
let fresh = try f.startup.systemProfile(.hardDriveBasic, freshMedia:true)
XCTAssertNotEqual(fresh.media.drives[0]!.url,floppyURL)
XCTAssertEqual(try Data(contentsOf:fresh.media.drives[0]!.url),Data(repeating:0,count:volume))
XCTAssertEqual(try Data(contentsOf:fresh.media.hardDisks!.drives[0]!.url),original)
XCTAssertEqual(try Data(contentsOf:hardURL)[offset],0x77)
XCTAssertEqual(try Data(contentsOf:floppyURL),Data(repeating:0x67,count:volume))
XCTAssertFalse(FileManager.default.fileExists(atPath:f.startup.url.path), "Building a profile never applies it")
var copy = hard; copy.name = "My Hard BASIC"; copy.machine.use6309 = true
let store = ProfileStore(directory:f.support.appendingPathComponent("Profiles"))
try store.save(copy)
XCTAssertFalse(try f.startup.systemProfile(.hardDriveBasic).machine.use6309)
try store.delete(copy.id)
XCTAssertTrue(FileManager.default.fileExists(atPath:hardURL.path))
XCTAssertEqual(try f.startup.appDefaults().media,disk.media)
}
func testUnavailableSystemProfileAndMalformedTemplateLeaveNoPartialHardDisk() throws {
let f = try Fixture(); defer { f.remove() }
let rgb=f.kit.directory.appendingPathComponent("rgbdos.rom")
try FileManager.default.removeItem(at:rgb)
XCTAssertNotNil(f.startup.unavailableReason(for:.hardDriveBasic))
XCTAssertNil(f.startup.unavailableReason(for:.diskBasic))
XCTAssertThrowsError(try f.startup.systemProfile(.hardDriveBasic))
XCTAssertFalse(FileManager.default.fileExists(atPath:f.support.path))
try Data(repeating:0,count:8192).write(to:rgb)
try Data([1]).write(to:f.kit.directory.appendingPathComponent("Blank Disk.dsk"))
XCTAssertThrowsError(try f.startup.systemProfile(.hardDriveBasic))
XCTAssertFalse(FileManager.default.fileExists(atPath:f.support.appendingPathComponent("Starter Media/Hello World.vhd").path))
}
@MainActor func testSystemProfileSwitchAndHardDriveRelaunchPreserveWritableMedia() async throws {
let f = try Fixture(); defer { f.remove() }
let suite="VCCSystemProfiles-"+UUID().uuidString, defaults=UserDefaults(suiteName:suite)!
defer { defaults.removePersistentDomain(forName:suite) }
var hardURL: URL?
for launch in 0..<2 {
let model=MachineModel(diskStore:f.disks,displayDefaults:defaults,inputStore:.init(url:f.support.appendingPathComponent("Input.json")),startupStore:f.startup)
try await waitForStartup(model)
if launch == 0 {
XCTAssertEqual(model.usageProfile, .diskBasic)
XCTAssertEqual(model.guideRequest?.profile, .diskBasic)
let loaded=await model.loadSystemProfile(.hardDriveBasic);XCTAssertTrue(loaded)
XCTAssertEqual(model.profileName,"Hard Drive BASIC")
hardURL = try f.disks.load().hardDisks!.drives[0]!.url
let copied=try await model.makeSystemProfile(.diskBasic,freshMedia:true)
XCTAssertEqual(copied.name,"Disk BASIC")
XCTAssertEqual(model.profileName,"Hard Drive BASIC", "Copying never changes the live machine")
}
XCTAssertEqual(model.usageProfile, .hardDriveBasic)
XCTAssertEqual(model.guideRequest?.profile, .hardDriveBasic)
XCTAssertEqual(model.state,.running);XCTAssertTrue(model.hardDiskConnected)
XCTAssertTrue(model.hardDisks[0].mounted);XCTAssertTrue(model.disks[0].mounted)
XCTAssertFalse(model.tapeMounted);XCTAssertFalse(model.hardTemporary[0]);XCTAssertFalse(model.hardDisks[0].writeProtected)
XCTAssertEqual(try f.disks.load().hardDisks!.drives[0]!.url,hardURL)
if launch == 1 {
let restored=await model.restoreAppDefaults();XCTAssertTrue(restored)
XCTAssertEqual(model.usageProfile, .diskBasic)
XCTAssertEqual(model.profileName,"Disk BASIC");XCTAssertFalse(model.hardDiskConnected)
XCTAssertTrue(model.tapeMounted);XCTAssertEqual(model.state,.running)
XCTAssertTrue(FileManager.default.fileExists(atPath:hardURL!.path))
model.createDisk(1);try await waitForStartup(model)
let rejected=await model.loadSystemProfile(.hardDriveBasic);XCTAssertFalse(rejected)
XCTAssertNil(model.guideRequest, "An unsuccessful switch must not introduce a profile")
XCTAssertEqual(model.profileName,"Disk BASIC");XCTAssertTrue(model.disks[1].dirty)
}
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}
@MainActor func testUsageGuidanceFollowsFirmwareRatherThanProfileOrFileName() async throws {
let f = try Fixture(); defer { f.remove() }
let suite = "VCCUsage-" + UUID().uuidString, defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
let model = MachineModel(diskStore: f.disks, displayDefaults: defaults,
inputStore: .init(url: f.support.appendingPathComponent("Input.json")), startupStore: f.startup)
try await waitForStartup(model)
var personal = try await model.captureProfile(name: "My renamed setup")
personal.machine.use6309 = true
await model.loadProfile(personal)
XCTAssertEqual(model.usageProfile, .diskBasic)
let unknown = f.root.appendingPathComponent("rgbdos.rom")
try Data(repeating: 0x12, count: 8192).write(to: unknown)
personal.name = "Hard Drive BASIC"
personal.media.rom = unknown
await model.loadProfile(personal)
XCTAssertNil(model.usageProfile, "Neither a filename nor a profile name proves which commands a ROM supports")
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
func testNitros9SharesDataDiskAndInitializesOnlyEmptyPartitionWithBackup() throws {
let f = try Fixture(); defer { f.remove() }
let basic = try f.startup.systemProfile(.hardDriveBasic)
let shared = basic.media.hardDisks!.drives[0]!.url
var original = try Data(contentsOf: shared)
original.replaceSubrange(0..<8192, with: Data(repeating: 0, count: 8192)) // prior app's unformatted area
original[0x5a000 * 256 + 123] = 0x71 // existing saved BASIC data
try original.write(to: shared)
let profile = try f.startup.systemProfile(.nitros9)
XCTAssertEqual(profile.bootNitros9, true)
XCTAssertEqual(profile.media.hardDisks!.drives[1]!.url, shared)
XCTAssertEqual(profile.media.drives, basic.media.drives)
XCTAssertNil(profile.cassette)
XCTAssertEqual(try Data(contentsOf: shared), original, "Preparing/copying a profile never modifies a live data disk")
XCTAssertTrue(try f.startup.initializeSharedOS9(for: profile))
let initialized = try Data(contentsOf: shared)
XCTAssertEqual(initialized.prefix(8192), try f.kit.os9Header())
XCTAssertEqual(initialized.dropFirst(8192), original.dropFirst(8192))
let backups = try FileManager.default.contentsOfDirectory(at: shared.deletingLastPathComponent(), includingPropertiesForKeys: nil)
.filter { $0.lastPathComponent.hasPrefix("Before OS9 initialization") }
XCTAssertEqual(backups.count, 1)
XCTAssertEqual(try Data(contentsOf: XCTUnwrap(backups.first)), original)
XCTAssertFalse(try f.startup.initializeSharedOS9(for: profile), "Never reformat an existing filesystem")
var nonempty = original; nonempty[4096] = 7
try nonempty.write(to: shared)
XCTAssertFalse(try f.startup.initializeSharedOS9(for: profile), "Even unrecognized nonzero OS-9 data is preserved")
XCTAssertEqual(try Data(contentsOf: shared), nonempty)
let unrelated = f.root.appendingPathComponent("Unrelated.vhd")
try original.write(to: unrelated)
try FileManager.default.removeItem(at: shared)
try FileManager.default.createSymbolicLink(at: shared, withDestinationURL: unrelated)
XCTAssertFalse(try f.startup.initializeSharedOS9(for: profile), "A replacement symlink never opts another file into formatting")
XCTAssertEqual(try Data(contentsOf: unrelated), original)
let fresh = try f.startup.systemProfile(.nitros9, freshMedia: true)
XCTAssertNotEqual(fresh.media.hardDisks!.drives[1]!.url, shared)
XCTAssertEqual(try Data(contentsOf: fresh.media.hardDisks!.drives[1]!.url).prefix(8192), try f.kit.os9Header())
}
@MainActor func testRememberedMacShellGrantIsLimitedToSelectedSystemDisk() async throws {
let f = try Fixture(); defer { f.remove() }
let suite = "VCCMacShell-" + UUID().uuidString, defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
func open() async throws -> MachineModel {
let model = MachineModel(diskStore: f.disks, displayDefaults: defaults,
inputStore: .init(url: f.support.appendingPathComponent("Input.json")), startupStore: f.startup)
try await waitForStartup(model)
return model
}
func close(_ model: MachineModel) async { await withCheckedContinuation { d in model.shutdown { d.resume() } } }
var model = try await open()
let selected = await model.loadSystemProfile(.nitros9)
XCTAssertTrue(selected); XCTAssertFalse(model.currentSetupHasMacShellPermission)
let url = try XCTUnwrap(model.hardSettings.drives[0]?.url).resolvingSymlinksInPath()
let bytes = try Data(contentsOf: url)
// Seed a prior local consent, without starting a real login shell.
defaults.set(["path": url.path, "sha256": HardDiskFiles.digest(bytes)], forKey: "driveWireNetworking.macShellGrant")
XCTAssertTrue(model.currentSetupHasMacShellPermission)
let clone = try await model.captureProfile(name: SystemProfile.nitros9.name)
await model.loadProfile(clone)
XCTAssertFalse(model.currentSetupHasMacShellPermission, "Imported profile cannot claim an existing disk's grant")
_ = await model.loadSystemProfile(.nitros9)
await close(model)
model = try await open()
XCTAssertTrue(model.currentSetupHasMacShellPermission, "Same locally selected disk on relaunch")
let program = Data([0, 0, 2, 0x20, 0, 0x20, 0xfe, 0xff, 0, 0, 0x20, 0])
let loaded: VCCMachineSnapshot? = await withCheckedContinuation { done in
model.debuggerLoadDevelopmentBinary(program, breakpoints: [0x2000]) { done.resume(returning: $0) }
}
XCTAssertNotNil(loaded)
XCTAssertNil(loaded?.errorMessage)
XCTAssertFalse(model.currentSetupHasMacShellPermission, "Direct execution of an unrelated binary requires its own permission")
await close(model)
try Data(repeating: 0x55, count: bytes.count).write(to: url, options: .atomic)
model = try await open()
XCTAssertTrue(model.hasRememberedMacShellPermission)
XCTAssertFalse(model.currentSetupHasMacShellPermission, "An externally replaced HD0 cannot reuse the original disk's grant")
model.forgetMacShellPermission()
XCTAssertFalse(model.hasRememberedMacShellPermission)
await close(model)
}
@MainActor func testDriveWireAutomaticPresetAndExplicitOverrideAcrossRelaunches() async throws {
let f = try Fixture(); defer { f.remove() }
let suite = "VCCDriveWire-" + UUID().uuidString, defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
func open() async throws -> MachineModel {
let model = MachineModel(diskStore: f.disks, displayDefaults: defaults,
inputStore: .init(url: f.support.appendingPathComponent("Input.json")), startupStore: f.startup)
try await waitForStartup(model)
return model
}
func close(_ model: MachineModel) async {
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
var model = try await open()
XCTAssertFalse(model.driveWireEnabled, "First-launch Disk BASIC")
let selected = await model.loadSystemProfile(.nitros9)
XCTAssertTrue(selected); XCTAssertTrue(model.driveWireEnabled)
await close(model)
model = try await open()
XCTAssertTrue(model.driveWireEnabled, "Restored built-in selection")
XCTAssertNil(defaults.object(forKey: "driveWireNetworking.enabled"), "An automatic default is never stored as an override")
let personal = try await model.captureProfile(name: SystemProfile.nitros9.name)
await model.loadProfile(personal)
XCTAssertNil(model.profileError)
XCTAssertFalse(model.driveWireEnabled, "Matching boot firmware, media and profile name are insufficient")
await close(model)
model = try await open()
XCTAssertFalse(model.driveWireEnabled, "A restored personal profile cannot implicitly enable networking")
_ = await model.loadSystemProfile(.nitros9)
XCTAssertTrue(model.driveWireEnabled)
model.setDriveWireNetworking(false); try await waitForStartup(model)
_ = await model.loadSystemProfile(.nitros9)
XCTAssertFalse(model.driveWireEnabled, "Explicit Off takes precedence on reselection")
await close(model)
model = try await open()
XCTAssertFalse(model.driveWireEnabled, "Explicit Off takes precedence on relaunch")
_ = await model.restoreAppDefaults()
model.setDriveWireNetworking(true); try await waitForStartup(model)
XCTAssertTrue(model.driveWireEnabled, "Networking can be explicitly enabled for other profiles")
await close(model)
model = try await open()
XCTAssertTrue(model.driveWireEnabled, "Explicit On persists independently of the preset")
await close(model)
}
@MainActor func testNitros9BootIntentAndHelpSurvivePersonalCopyAndRelaunch() async throws {
let f = try Fixture(); defer { f.remove() }
let suite = "VCCNitros-" + UUID().uuidString, defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
for launch in 0..<2 {
let model = MachineModel(diskStore: f.disks, displayDefaults: defaults,
inputStore: .init(url: f.support.appendingPathComponent("Input.json")), startupStore: f.startup)
try await waitForStartup(model)
if launch == 0 {
let loaded = await model.loadSystemProfile(.nitros9); XCTAssertTrue(loaded)
let copy = try await model.captureProfile(name: "My OS-9 setup")
XCTAssertEqual(copy.bootNitros9, true)
let encoded = try JSONEncoder().encode(copy)
XCTAssertEqual(try JSONDecoder().decode(ConfigurationProfile.self, from: encoded), copy)
await model.loadProfile(copy)
XCTAssertEqual(model.state, .paused, "Personal profiles retain paused-after-load behavior")
}
XCTAssertEqual(model.usageProfile, .nitros9)
XCTAssertEqual(try f.startup.read()?.bootNitros9, true)
XCTAssertTrue(model.hardDisks[0].mounted && model.hardDisks[1].mounted)
if launch == 1 {
let romURL = try XCTUnwrap(model.systemROMURL)
model.installROM(try Data(contentsOf: romURL), url: romURL)
try await waitForStartup(model)
XCTAssertNil(try f.startup.read()?.bootNitros9, "Manually choosing a system ROM returns to ordinary startup")
let restored = await model.restoreAppDefaults(); XCTAssertTrue(restored)
XCTAssertNil(try f.startup.read()?.bootNitros9)
XCTAssertEqual(model.usageProfile, .diskBasic)
}
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}
}
extension StartupTests {
@MainActor func testMediaOpeningRecordsSuccessAndPreservesUnsavedData() async throws {
_ = NSApplication.shared
let f = try Fixture(); defer { f.remove() }
let suite = "VCCMediaTests-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
defer { defaults.removePersistentDomain(forName: suite) }
let controller = VCCMachineController()
let model = MachineModel(diskStore: f.disks, controller: controller, displayDefaults: defaults,
inputStore: .init(url: f.support.appendingPathComponent("Input.json")), startupStore: f.startup)
try await waitForStartup(model)
let disk = f.kit.directory.appendingPathComponent("Hello World.dsk")
let opening = try XCTUnwrap(model.loadMedia(disk, destination: .floppy(1)))
await opening.value; try await waitForStartup(model)
XCTAssertEqual(model.diskAssignments.drives[1]?.url, disk)
XCTAssertEqual(model.recentMedia.entries.first?.destination, .floppy(1))
XCTAssertEqual(model.state, .running, "Floppy insertion preserves the prior execution state")
let history = model.recentMedia.entries
model.resume(); try await waitForStartup(model)
model.offerMedia(disk, preferred: .cassette)
XCTAssertEqual(model.state, .running, "A mismatched drop must not pause or replace media")
XCTAssertEqual(model.recentMedia.entries, history)
XCTAssertTrue(model.fileError?.contains("does not match") == true)
let missing = f.root.appendingPathComponent("Missing.dsk")
let failedRead = try XCTUnwrap(model.loadMedia(missing, destination: .floppy(0)))
await failedRead.value; try await waitForStartup(model)
XCTAssertEqual(model.recentMedia.entries, history); XCTAssertNotNil(model.fileError)
XCTAssertEqual(model.state, .running, "Read failure must not disturb execution")
model.createDisk(2); try await waitForStartup(model)
XCTAssertTrue(model.disks[2].dirty)
let original = model.diskAssignments.drives[0]?.url
let unsavedDisk = try XCTUnwrap(model.loadMedia(disk, destination: .floppy(0)))
await unsavedDisk.value; try await waitForStartup(model)
XCTAssertTrue(model.disks[2].dirty); XCTAssertEqual(model.diskAssignments.drives[0]?.url, original)
XCTAssertEqual(model.recentMedia.entries, history); XCTAssertNotNil(model.fileError)
await withCheckedContinuation { done in controller.ejectDisk(inDrive: 2, discard: true) { _ in done.resume() } }
model.tapeAction(5); try await waitForStartup(model)
let recording = try XCTUnwrap(model.loadMedia(disk, destination: .floppy(0)))
await recording.value; try await waitForStartup(model)
XCTAssertEqual(model.tapeMode, 2); XCTAssertEqual(model.recentMedia.entries, history)
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
}