Files

258 lines
17 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
final class ProfileTests: XCTestCase {
func testProfileSchemaBoundsAndLocalReferences() throws {
let profile = ConfigurationProfile(name: "Games")
XCTAssertNoThrow(try profile.validate())
var invalid = profile; invalid.version = 2; XCTAssertThrowsError(try invalid.validate())
invalid = profile; invalid.systemROM = URL(string: "https://example.com/rom"); XCTAssertThrowsError(try invalid.validate())
invalid = profile; invalid.machine.ram = 99; XCTAssertThrowsError(try invalid.validate())
invalid = profile; invalid.volume = .nan; XCTAssertThrowsError(try invalid.validate())
invalid = profile; invalid.name = "\n"; XCTAssertThrowsError(try invalid.validate())
}
}
extension ProfileTests {
private struct Fixture {
let folder: URL, suite: String, defaults: UserDefaults
var diskStore: DiskAssignmentStore { .init(url: folder.appendingPathComponent("disk-settings.json")) }
var inputStore: InputSettingsStore { .init(url: folder.appendingPathComponent("input-settings.json")) }
var store: ProfileStore { .init(directory: folder.appendingPathComponent("Profiles")) }
init() throws {
folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
suite = "VCCProfiles-" + UUID().uuidString; defaults = UserDefaults(suiteName: suite)!
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
}
func remove() { defaults.removePersistentDomain(forName: suite); try? FileManager.default.removeItem(at: folder) }
func profile() throws -> ConfigurationProfile {
var p = ConfigurationProfile(name: "CoCo é / Games")
var rom = Data(repeating: 0x12, count: 32768)
rom[0] = 0x20; rom[1] = 0xfe; rom[32766] = 0x80; rom[32767] = 0
p.systemROM = folder.appendingPathComponent("system.rom"); try rom.write(to: p.systemROM!)
p.machine = .init(use6309: true, ram: 3, overclock: 3, frameInterval: 4, fastForward: true)
p.videoOutput = 2; p.sound = false; p.volume = 0.25
p.media.rom = folder.appendingPathComponent("disk.rom"); try Data(repeating: 0, count: 8192).write(to: p.media.rom!)
let floppy = folder.appendingPathComponent("disk é.dsk"); try Data(repeating: 0x5a, count: 161280).write(to: floppy)
p.media.drives[0] = .init(url: floppy, writeProtected: true, temporary: true)
let hard = folder.appendingPathComponent("hard.vhd"); try Data(repeating: 0x31, count: 4096).write(to: hard)
var h = HardDiskAssignments(); h.clockEnabled = false; h.clockReadOnly = false
h.drives[1] = .init(url: hard, writeProtected: true, temporary: true); p.media.hardDisks = h
let cart = folder.appendingPathComponent("game.ccc"); try Data(repeating: 0x42, count: 8192).write(to: cart)
var c = CartridgeAssignments(); c.multiPak = true; c.mpiConfigured = true; c.physicalSlot = 2
c.slots[0] = .init(kind: .rom, url: cart); c.slots[1] = .init(kind: .rom, url: cart)
c.slots[2].kind = .floppy; c.slots[3].kind = .hardDisk; p.media.cartridges = c
p.cassette = folder.appendingPathComponent("tape.cas"); try Data([0x55,0x55,0x3c]).write(to: p.cassette!)
p.fastCassette = true; p.input.keyboard = .coco
p.input.right.source = .controller; p.input.right.device = "remembered disconnected controller"
p.input.left.source = .keyboard
return p
}
}
@MainActor private func step(_ operation: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
await withCheckedContinuation { c in operation { c.resume(returning: $0) } }
}
@MainActor private func apply(_ request: VCCMachineProfile, to controller: VCCMachineController) async -> (Bool, VCCMachineSnapshot) {
await withCheckedContinuation { c in controller.applyProfile(request) { c.resume(returning: ($0, $1)) } }
}
@MainActor private func settled(_ 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("Profile test timed out")
}
@MainActor private func withModel(_ f: Fixture, _ body: (MachineModel, VCCMachineController) async throws -> Void) async throws {
let c = VCCMachineController()
let model = MachineModel(diskStore: f.diskStore, controller: c, displayDefaults: f.defaults, inputStore: f.inputStore)
do { try await settled(model); try await body(model, c) }
catch { await withCheckedContinuation { done in model.shutdown { done.resume() } }; throw error }
await withCheckedContinuation { done in model.shutdown { done.resume() } }
}
func testProfileLibraryRoundTripRenameDeleteAndBoundedImport() throws {
let f = try Fixture(); defer { f.remove() }
var profile = try f.profile(); try f.store.save(profile)
XCTAssertEqual(try f.store.load(), [profile])
XCTAssertEqual(try ProfileStore.read(f.store.file(profile.id)), profile)
let bytes = try Data(contentsOf: f.store.file(profile.id))
XCTAssertLessThan(bytes.count, 10000, "Profile contains references, not disk/ROM payloads")
var duplicate = profile; duplicate.id = UUID(); XCTAssertThrowsError(try f.store.save(duplicate))
profile.name = "Renamed"; try f.store.save(profile); XCTAssertEqual(try f.store.load().first?.name, "Renamed")
let exported = f.folder.appendingPathComponent("share.vccprofile"); try ProfileStore.write(profile, to: exported)
var imported = try ProfileStore.read(exported); imported.id = UUID(); imported.name = "Imported"; try f.store.save(imported)
try f.store.delete(profile.id); XCTAssertEqual(try f.store.load(), [imported])
XCTAssertTrue(FileManager.default.fileExists(atPath: profile.systemROM!.path))
let bad = f.folder.appendingPathComponent("large.vccprofile"); try Data(repeating: 0, count: 65537).write(to: bad)
XCTAssertThrowsError(try ProfileStore.read(bad))
var future = imported; future.version = 99
try JSONEncoder().encode(future).write(to: bad); XCTAssertThrowsError(try ProfileStore.read(bad))
}
func testMissingFilesCanBeRemappedWithoutEmbeddingMedia() throws {
let f = try Fixture(); defer { f.remove() }
var p = try f.profile()
let original = p.systemROM!; let moved = f.folder.appendingPathComponent("Moved system.rom")
try FileManager.default.moveItem(at: original, to: moved)
XCTAssertThrowsError(try PreparedProfile.read(p)) { XCTAssertTrue($0.localizedDescription.contains("System ROM")) }
p.replace(.systemROM, with: moved)
XCTAssertEqual(try PreparedProfile.read(p).systemROM?.count, 32768)
try Data().write(to: p.media.drives[0]!.url)
XCTAssertThrowsError(try PreparedProfile.read(p))
}
@MainActor func testProfileLoadsAllSettingsAndRecapturesAcrossRelaunch() async throws {
let f = try Fixture(); defer { f.remove() }
var profile = try f.profile()
for cpu in [false, true] {
profile.machine.use6309 = cpu; try f.store.save(profile)
try await withModel(f) { model, controller in
await model.loadProfile(profile)
XCTAssertNil(model.profileError); XCTAssertEqual(model.state, .paused); XCTAssertEqual(model.frames, 0)
XCTAssertEqual(model.systemROMURL, profile.systemROM); XCTAssertEqual(model.settings, profile.machine)
XCTAssertEqual(model.videoOutput.rawValue, 2); XCTAssertFalse(model.audioEnabled); XCTAssertEqual(model.volume, 0.25)
XCTAssertTrue(model.diskConnected); XCTAssertTrue(model.hardDiskConnected); XCTAssertEqual(model.romSlot, 2)
XCTAssertTrue(model.disks[0].mounted); XCTAssertTrue(model.disks[0].writeProtected); XCTAssertTrue(model.diskTemporary[0])
XCTAssertTrue(model.hardDisks[1].mounted); XCTAssertTrue(model.hardTemporary[1])
XCTAssertTrue(model.tapeMounted); XCTAssertTrue(model.tapeFast); XCTAssertEqual(model.tapeMode, 0)
XCTAssertEqual(model.input.settings, profile.input)
let recaptured = try await model.captureProfile(name: profile.name, replacing: profile.id)
XCTAssertEqual(recaptured, profile)
let snapshot = await step(controller.snapshot); XCTAssertEqual(snapshot.programCounter, 0x8000)
XCTAssertFalse(snapshot.hardClockEnabled); XCTAssertFalse(snapshot.hardClockReadOnly)
model.resume(); try await settled(model); try await Task.sleep(nanoseconds: 40_000_000)
let running = await step(controller.snapshot); XCTAssertGreaterThan(running.frames, 0)
}
}
let remembered = try f.diskStore.load()
XCTAssertEqual(remembered, profile.media); XCTAssertEqual(try f.inputStore.load(), profile.input)
XCTAssertEqual(MachineSettings.remembered(in: f.defaults), profile.machine)
XCTAssertEqual(try f.store.load(), [profile])
}
@MainActor func testProfileModifiedTracksConfigurationNotPresentationOrTransport() async throws {
let f = try Fixture(); defer { f.remove() }
let profile = try f.profile()
try await withModel(f) { model, controller in
await model.loadProfile(profile); XCTAssertNil(model.profileError)
XCTAssertFalse(model.profileModified)
let presentation = PresentationSettings(defaults: f.defaults)
presentation.mode = .system; presentation.expanded = true
model.tapeAction(1); try await settled(model)
XCTAssertFalse(model.profileModified, "Playing tape and changing views do not modify a setup")
model.volume = 0.7; model.setAudio(model.audioEnabled); try await settled(model)
XCTAssertTrue(model.profileModified)
model.volume = profile.volume; model.setAudio(model.audioEnabled); try await settled(model)
XCTAssertFalse(model.profileModified)
model.createDisk(1); try await settled(model)
XCTAssertTrue(model.profileModified, "New unbacked media must be visible as a setup change")
_ = await step { controller.ejectDisk(inDrive: 1, discard: true, completion: $0) }
}
}
@MainActor func testMalformedMediaRejectsWholeProfileWithoutChangingMachine() async throws {
let f = try Fixture(); defer { f.remove() }
let profile = try f.profile()
try await withModel(f) { model, controller in
await model.loadProfile(profile); XCTAssertNil(model.profileError)
let before = await step(controller.snapshot)
let assignments = try Data(contentsOf: f.diskStore.url)
var bad = profile; bad.machine.ram = 0; bad.name = "Rejected"
bad.media.drives[0]?.url = f.folder.appendingPathComponent("bad.dsk")
try Data([1,2,3]).write(to: bad.media.drives[0]!.url)
await model.loadProfile(bad)
XCTAssertNotNil(model.profileError); XCTAssertEqual(model.profileName, profile.name)
XCTAssertEqual(model.settings, profile.machine); XCTAssertEqual(model.systemROMURL, profile.systemROM)
let after = await step(controller.snapshot)
XCTAssertEqual(after.generation, before.generation); XCTAssertTrue(after.disks[0].mounted)
XCTAssertEqual(try Data(contentsOf: f.diskStore.url), assignments)
XCTAssertEqual(MachineSettings.remembered(in: f.defaults), profile.machine)
}
}
@MainActor func testDirtyDisksAndRecordingBlockProfileSwitchAndSaveRequiresPaths() async throws {
let f = try Fixture(); defer { f.remove() }
let profile = try f.profile()
try await withModel(f) { model, controller in
await model.loadProfile(profile)
model.createDisk(1); try await settled(model)
let before = await step(controller.snapshot)
await model.loadProfile(ConfigurationProfile(name: "Empty"))
XCTAssertNotNil(model.profileError); XCTAssertTrue(model.disks[1].dirty)
let after = await step(controller.snapshot); XCTAssertEqual(after.generation, before.generation)
do { _ = try await model.captureProfile(name: "Unsaved"); XCTFail("New disk has no backing path") } catch { }
_ = await step { controller.ejectDisk(inDrive: 1, discard: true, completion: $0) }
_ = await step { controller.tapeAction(5, completion: $0) }
await model.loadProfile(ConfigurationProfile(name: "Empty"))
XCTAssertNotNil(model.profileError); XCTAssertEqual(model.tapeMode, 2)
XCTAssertEqual(model.profileName, profile.name)
}
}
@MainActor func testBridgeRejectsInvalidSettingsAndPreservesDirtyMedia() async throws {
let f = try Fixture(); defer { f.remove() }
let controller = VCCMachineController()
let request = try PreparedProfile.read(f.profile()).request()
var (applied, snapshot) = await apply(request, to: controller)
XCTAssertTrue(applied); XCTAssertNil(snapshot.errorMessage)
let generation = snapshot.generation
request.ram = 4
(applied, snapshot) = await apply(request, to: controller)
XCTAssertFalse(applied); XCTAssertNotNil(snapshot.errorMessage); XCTAssertEqual(snapshot.generation, generation)
request.ram = 1
_ = await step { controller.createDisk(inDrive: 1, completion: $0) }
(applied, snapshot) = await apply(request, to: controller)
XCTAssertFalse(applied); XCTAssertTrue(snapshot.disks[1].dirty); XCTAssertEqual(snapshot.generation, generation)
_ = await step(controller.shutdown)
}
}
extension ProfileTests {
@MainActor func testLoadingEmptySetupEjectsOldMediaWithoutChangingFiles() async throws {
let f = try Fixture(); defer { f.remove() }
let profile = try f.profile()
let originals = try profile.references.map { try Data(contentsOf: $0.url) }
try await withModel(f) { model, controller in
await model.loadProfile(profile); XCTAssertNil(model.profileError)
let empty = ConfigurationProfile(name: "Bare CoCo")
await model.loadProfile(empty); XCTAssertNil(model.profileError)
XCTAssertEqual(model.state, .empty); XCTAssertNil(model.systemROMURL); XCTAssertEqual(model.profileName, empty.name)
XCTAssertFalse(model.diskEnabled); XCTAssertFalse(model.tapeMounted)
XCTAssertTrue(model.disks.allSatisfy { !$0.mounted }); XCTAssertTrue(model.hardDisks.allSatisfy { !$0.mounted })
XCTAssertTrue(model.cartridgeNames.allSatisfy { $0.isEmpty }); XCTAssertNil(model.pixels)
XCTAssertEqual(model.settings, MachineSettings()); XCTAssertFalse(model.diskConnected); XCTAssertFalse(model.hardDiskConnected)
XCTAssertEqual(try profile.references.map { try Data(contentsOf: $0.url) }, originals)
}
}
// A real guest sector write verifies the profile path drains automatic saves,
// detects external edits, and never silently discards temporary changes.
@MainActor func testProfileSwitchFlushesAutomaticWritesAndBlocksSaveConflicts() async throws {
for mode in 0..<3 { // automatic save, external edit conflict, temporary disk
let f = try Fixture(); defer { f.remove() }
var profile = try f.profile()
var layout = CartridgeAssignments(); layout.slots[0].kind = .floppy
profile.media.cartridges = layout
profile.media.drives[0]?.writeProtected = false; profile.media.drives[0]?.temporary = mode == 2
profile.machine.fastForward = false; profile.machine.overclock = 1
let program: [UInt8] = [0x86,0x29,0xb7,0xff,0x40,0x86,1,0xb7,0xff,0x4a,
0x86,0xa0,0xb7,0xff,0x48,0x8e,1,0,0x86,0x6b,
0xb7,0xff,0x4b,0x30,0x1f,0x26,0xf9,0xb7,0xff,0x4b,0x20,0xfe]
var rom = Data(repeating: 0, count: 32768); rom.replaceSubrange(0..<program.count, with: program); rom[32766] = 0x80
try rom.write(to: profile.systemROM!)
try await withModel(f) { model, controller in
await model.loadProfile(profile); XCTAssertNil(model.profileError)
let file = profile.media.drives[0]!.url
if mode == 1 { try Data(repeating: 0x11, count: 161280).write(to: file) }
_ = await step(controller.resume)
var snapshot = await step(controller.snapshot)
for _ in 0..<100 where !snapshot.disks[0].dirty {
try await Task.sleep(nanoseconds: 1_000_000)
snapshot = await step(controller.snapshot)
}
XCTAssertTrue(snapshot.disks[0].dirty)
await model.loadProfile(ConfigurationProfile(name: "Next"))
let bytes = try Data(contentsOf: file)
if mode == 0 {
XCTAssertNil(model.profileError); XCTAssertEqual(model.profileName, "Next"); XCTAssertEqual(bytes.prefix(256), Data(repeating: 0x6b, count: 256))
} else {
XCTAssertNotNil(model.profileError); XCTAssertEqual(model.profileName, profile.name)
XCTAssertTrue(model.disks[0].dirty); XCTAssertEqual(model.state, .paused)
XCTAssertEqual(bytes, Data(repeating: mode == 1 ? 0x11 : 0x5a, count: 161280))
}
}
}
}
}