Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,675 @@
|
||||
// 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)
|
||||
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,InputSettings());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 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() } }
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user