// 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.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 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.. 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() } } } }