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,391 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import XCTest
|
||||
|
||||
final class CartridgePersistenceTests: XCTestCase {
|
||||
@MainActor func testSpeechSoundTwoROMSelectionProfilesMoveAndRecovery() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
let pic = f.folder.appendingPathComponent("pic.bin"), speech = f.folder.appendingPathComponent("speech.bin")
|
||||
var firmware = Data(repeating: 0, count: 4096)
|
||||
firmware[0] = 0xb3; firmware[1] = 0xe0; firmware[2] = 0xfd; firmware[4094] = 0xf0
|
||||
try firmware.write(to: pic); try Data(repeating: 0, count: 2048).write(to: speech)
|
||||
try await withModel(f.store) { model in
|
||||
model.setMultiPak(true); try await settled(model)
|
||||
model.assignCartridge(.speechSound, slot: 2); try await settled(model)
|
||||
XCTAssertNotNil(model.cartridgeRestoreErrors[2])
|
||||
model.selectSpeechROM(speech, slot: 2, speech: false); try await settled(model)
|
||||
XCTAssertNotNil(model.fileError); XCTAssertNil(model.cartridgeAssignments.slots[2].url)
|
||||
model.selectSpeechROM(pic, slot: 2, speech: false); try await settled(model)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[2].url, pic)
|
||||
XCTAssertNotNil(model.cartridgeRestoreErrors[2])
|
||||
model.selectSpeechROM(speech, slot: 2, speech: true); try await settled(model)
|
||||
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
|
||||
model.assignCartridge(.speechSound, slot: 1); try await settled(model)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[2].kind, .empty)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[1].speechROMURL, speech)
|
||||
var profile = ConfigurationProfile(name: "Speech")
|
||||
profile.media = try f.store.load()
|
||||
let exported = f.folder.appendingPathComponent("speech.vccprofile")
|
||||
try ProfileStore.write(profile, to: exported)
|
||||
let imported = try ProfileStore.read(exported), prepared = try PreparedProfile.read(imported)
|
||||
XCTAssertEqual(prepared.cartridges[1].count, 6144)
|
||||
XCTAssertEqual(prepared.request().kinds[1], 6)
|
||||
XCTAssertTrue(imported.references.contains { $0.key == .speechROM(1) })
|
||||
let duplicate = profile.media.cartridges!.slots[1]
|
||||
profile.media.cartridges?.slots[2] = duplicate
|
||||
XCTAssertThrowsError(try profile.validate())
|
||||
}
|
||||
try FileManager.default.removeItem(at: speech)
|
||||
try await withModel(f.store) { model in
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[1].kind, .speechSound)
|
||||
XCTAssertNotNil(model.cartridgeRestoreErrors[1])
|
||||
var profile = ConfigurationProfile(name: "Missing speech"); profile.media = try f.store.load()
|
||||
XCTAssertThrowsError(try PreparedProfile.read(profile))
|
||||
try Data(repeating: 0, count: 2048).write(to: speech)
|
||||
model.retryRememberedCartridges(); try await settled(model)
|
||||
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
|
||||
XCTAssertEqual(model.cartridgeNames[1], "Speech/Sound Cartridge")
|
||||
}
|
||||
}
|
||||
|
||||
@MainActor func testOrchestraOptionalROMProfilesMovesAndMissingFileRecovery() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
try await withModel(f.store) { model in
|
||||
model.setMultiPak(true); try await settled(model)
|
||||
model.assignCartridge(.orchestra90, slot: 1); try await settled(model)
|
||||
XCTAssertEqual(model.cartridgeNames[1], "Orchestra-90"); XCTAssertFalse(model.hardware.custom)
|
||||
XCTAssertEqual(model.hardware.values["slot1"], "orchestra")
|
||||
XCTAssertNil(model.cartridgeAssignments.slots[1].url)
|
||||
model.selectCartridgeROM(f.second, slot: 1, kind: .orchestra90); try await settled(model)
|
||||
XCTAssertNotNil(model.fileError); XCTAssertNil(model.cartridgeAssignments.slots[1].url)
|
||||
model.selectCartridgeROM(f.rom, slot: 1, kind: .orchestra90); try await settled(model)
|
||||
XCTAssertNil(model.fileError)
|
||||
model.assignCartridge(.orchestra90, slot: 2); try await settled(model)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[1].kind, .empty)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[2].url, f.rom)
|
||||
var profile = ConfigurationProfile(name: "Orchestra")
|
||||
profile.media = try f.store.load()
|
||||
let url = f.folder.appendingPathComponent("orchestra.vccprofile")
|
||||
try ProfileStore.write(profile, to: url)
|
||||
let restored = try ProfileStore.read(url)
|
||||
XCTAssertEqual(restored, profile)
|
||||
let prepared = try PreparedProfile.read(restored).request()
|
||||
XCTAssertEqual(prepared.kinds[2], 5); XCTAssertEqual(prepared.cartridgeROMs[2].count, 8192)
|
||||
XCTAssertTrue(ProfileGuidance(restored).coverage.contains("Multi-Pak"))
|
||||
profile.media.cartridges?.slots[1].kind = .orchestra90
|
||||
XCTAssertThrowsError(try profile.validate())
|
||||
}
|
||||
try FileManager.default.removeItem(at: f.rom)
|
||||
try await withModel(f.store) { model in
|
||||
XCTAssertNotNil(model.cartridgeRestoreErrors[2])
|
||||
XCTAssertEqual(model.cartridgeNames[2], "Orchestra-90", "Missing program ROM leaves sound hardware available")
|
||||
var profile = ConfigurationProfile(name: "Missing"); profile.media = try f.store.load()
|
||||
XCTAssertThrowsError(try PreparedProfile.read(profile), "Profile loading must not silently omit a selected ROM")
|
||||
try Data(repeating: 0x12, count: 8192).write(to: f.rom)
|
||||
model.retryRememberedCartridges(); try await settled(model)
|
||||
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
|
||||
model.setMultiPak(false); try await settled(model)
|
||||
model.assignCartridge(.orchestra90, slot: 0); try await settled(model)
|
||||
XCTAssertNil(model.cartridgeAssignments.slots[0].url)
|
||||
model.setMultiPak(true); try await settled(model)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[2].url, f.rom)
|
||||
model.assignCartridge(.orchestra90, slot: 2); try await settled(model) // Remove ROM only.
|
||||
XCTAssertNil(model.cartridgeAssignments.slots[2].url)
|
||||
}
|
||||
try await withModel(f.store) { model in
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[2].kind, .orchestra90)
|
||||
XCTAssertNil(model.cartridgeAssignments.slots[2].url)
|
||||
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
|
||||
}
|
||||
}
|
||||
@MainActor func testOrchestraBridgePlaysThroughNativeAudioAndRejectsInvalidLayouts() async throws {
|
||||
@MainActor func step(_ action: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
|
||||
await withCheckedContinuation { done in action { done.resume(returning: $0) } }
|
||||
}
|
||||
let c = VCCMachineController()
|
||||
_ = await step { c.setAudioEnabled(true, volume: 0, completion: $0) }
|
||||
_ = await step { c.loadDiagnostic(use6309: false, completion: $0) }
|
||||
let empty = Array(repeating: Data(), count: 5), names = Array(repeating: "", count: 5)
|
||||
var state = await step { c.configureCartridges([0,5,0,0,0], roms: empty, names: names, multiPak: true, physicalSlot: 4, completion: $0) }
|
||||
XCTAssertNil(state.errorMessage); XCTAssertEqual(state.cartridgeNames[1], "Orchestra-90")
|
||||
state = await step { c.configureCartridges([0,5,5,0,0], roms: empty, names: names, multiPak: true, physicalSlot: 4, completion: $0) }
|
||||
XCTAssertNotNil(state.errorMessage); XCTAssertEqual(state.cartridgeKinds[2], 0)
|
||||
var bad = empty; bad[1] = Data(repeating: 0, count: 8193)
|
||||
state = await step { c.configureCartridges([0,5,0,0,0], roms: bad, names: names, multiPak: true, physicalSlot: 4, completion: $0) }
|
||||
XCTAssertNotNil(state.errorMessage)
|
||||
let code: [UInt8] = [0x86,0x40,0xb7,0xff,0x7b,0x8e,1,0,0x30,0x1f,0x26,0xfc,0x88,0x80,0x20,0xf2]
|
||||
let binary = Data([0,0,UInt8(code.count),0x30,0] + code + [0xff,0,0,0x30,0])
|
||||
_ = await step { c.quickLoadBinary(binary, completion: $0) }
|
||||
for _ in 0..<300 {
|
||||
state = await step(c.snapshot)
|
||||
if state.audioConsumed > 4410 || state.errorMessage != nil { break }
|
||||
try await Task.sleep(nanoseconds: 10_000_000)
|
||||
}
|
||||
XCTAssertNil(state.errorMessage); XCTAssertGreaterThan(state.audioConsumed, 4410)
|
||||
XCTAssertGreaterThan(state.audioSignalSamples, 4410)
|
||||
let starts = state.audioStarts, generation = state.generation
|
||||
let muted = await step { c.setAudioEnabled(true, volume: 0, completion: $0) }
|
||||
XCTAssertEqual(muted.audioStarts, starts); XCTAssertEqual(muted.generation, generation)
|
||||
let paused = await step(c.pause)
|
||||
try await Task.sleep(nanoseconds: 100_000_000)
|
||||
state = await step(c.snapshot)
|
||||
XCTAssertEqual(state.frames, paused.frames); XCTAssertEqual(state.audioConsumed, paused.audioConsumed)
|
||||
_ = await step(c.shutdown)
|
||||
}
|
||||
|
||||
@MainActor func testRamDiskAssignmentProfilesAndConventionalFallback() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
try await withModel(f.store) { model in
|
||||
model.setMultiPak(true); try await settled(model)
|
||||
model.assignCartridge(.ramDisk, slot: 1); try await settled(model)
|
||||
XCTAssertEqual(model.cartridgeNames[1], "RAM disk (512 KB)")
|
||||
XCTAssertTrue(model.hardware.custom)
|
||||
XCTAssertEqual(model.hardware.values["slot1"], "empty", "Never show a RAM disk as a hard-disk controller")
|
||||
model.assignCartridge(.ramDisk, slot: 2); try await settled(model)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[1].kind, .empty)
|
||||
var profile = ConfigurationProfile(name: "RAM disk setup")
|
||||
profile.media = try f.store.load()
|
||||
let url = f.folder.appendingPathComponent("ram.vccprofile")
|
||||
try ProfileStore.write(profile, to: url)
|
||||
let restored = try ProfileStore.read(url)
|
||||
XCTAssertEqual(restored.media.cartridges?.slots[2].kind, .ramDisk)
|
||||
XCTAssertTrue(ProfileGuidance(restored).coverage.contains("conventional"))
|
||||
let prepared = try PreparedProfile.read(restored)
|
||||
XCTAssertEqual(prepared.request().kinds[2], 4)
|
||||
var invalid = restored
|
||||
invalid.media.cartridges?.slots[3].kind = .ramDisk
|
||||
XCTAssertThrowsError(try invalid.validate())
|
||||
}
|
||||
try await withModel(f.store) { model in
|
||||
XCTAssertEqual(model.cartridgeNames[2], "RAM disk (512 KB)")
|
||||
XCTAssertTrue(model.hardware.custom)
|
||||
model.assignCartridge(.empty, slot: 2); try await settled(model)
|
||||
XCTAssertFalse(model.hardware.custom)
|
||||
}
|
||||
}
|
||||
|
||||
@MainActor func testRamDiskBridgeRetainsAcrossLayoutChangesButClearsOnDetachAndProfile() async throws {
|
||||
@MainActor func step(_ action: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
|
||||
await withCheckedContinuation { done in action { done.resume(returning: $0) } }
|
||||
}
|
||||
for cpu in [false, true] {
|
||||
let controller = VCCMachineController()
|
||||
_ = await step { controller.setAudioEnabled(false, volume: 0, completion: $0) }
|
||||
_ = await step { controller.loadDiagnostic(use6309: cpu, completion: $0) }
|
||||
func layout(_ kinds: [NSNumber], mpi: Bool = true, slot: Int = 4) async {
|
||||
let state = await step { controller.configureCartridges(kinds,
|
||||
roms: Array(repeating: Data(), count: 5), names: Array(repeating: "", count: 5),
|
||||
multiPak: mpi, physicalSlot: slot, completion: $0) }
|
||||
XCTAssertNil(state.errorMessage)
|
||||
}
|
||||
func run(write: UInt8? = nil, expect: UInt8) async throws {
|
||||
var code: [UInt8] = [0x86,0x30,0xb7,0xff,0x7f] // CTS4, SCS1; ignored in single mode.
|
||||
if let write { code += [0x86,write,0xb7,0xff,0x43] }
|
||||
// Compare the device value, then park at distinct success/failure PCs.
|
||||
code += [0xb6,0xff,0x43,0x81,expect,0x26,2,0x20,0xfe,0x20,0xfe]
|
||||
let binary = Data([0,0,UInt8(code.count),0x30,0] + code + [0xff,0,0,0x30,0])
|
||||
let expectedPC = 0x3000 + code.count - 4
|
||||
var state = await step { controller.quickLoadBinary(binary, completion: $0) }
|
||||
XCTAssertNil(state.errorMessage)
|
||||
for _ in 0..<100 {
|
||||
state = await step(controller.snapshot)
|
||||
if state.programCounter == expectedPC || state.programCounter == expectedPC + 2 { break }
|
||||
try await Task.sleep(nanoseconds: 10_000_000)
|
||||
}
|
||||
XCTAssertEqual(Int(state.programCounter), expectedPC, "Guest observed unexpected RAM disk contents")
|
||||
_ = await step(controller.pause)
|
||||
}
|
||||
await layout([0,4,0,0,0]); try await run(write: 0xa5, expect: 0xa5)
|
||||
_ = await step(controller.reset); try await run(expect: 0xa5)
|
||||
_ = await step(controller.softReset); try await run(expect: 0xa5)
|
||||
await layout([4,4,0,0,0], mpi: false); try await run(expect: 0xa5)
|
||||
await layout([4,0,0,0,0], mpi: false); try await run(expect: 0xa5)
|
||||
await layout([0,0,0,0,0], mpi: false)
|
||||
await layout([4,0,0,0,0], mpi: false); try await run(expect: 0)
|
||||
try await run(write: 0x67, expect: 0x67)
|
||||
let profile = VCCMachineProfile(); profile.sound = false; profile.use6309 = cpu; profile.kinds = [4,0,0,0,0]
|
||||
var rom = Data(repeating: 0x12, count: 32768)
|
||||
rom[0] = 0x20; rom[1] = 0xfe; rom[32766] = 0x80; rom[32767] = 0
|
||||
profile.systemROM = rom
|
||||
let applied: Bool = await withCheckedContinuation { done in
|
||||
controller.applyProfile(profile) { ok, state in XCTAssertNil(state.errorMessage); done.resume(returning: ok) }
|
||||
}
|
||||
XCTAssertTrue(applied); try await run(expect: 0)
|
||||
_ = await step(controller.shutdown)
|
||||
}
|
||||
}
|
||||
private struct Fixture {
|
||||
let folder: URL, rom: URL, second: URL, diskROM: URL, disk: URL, store: DiskAssignmentStore
|
||||
init() throws {
|
||||
folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
|
||||
rom = folder.appendingPathComponent("Cart é.ROM"); second = folder.appendingPathComponent("Second.ccc")
|
||||
diskROM = folder.appendingPathComponent("disk.rom"); disk = folder.appendingPathComponent("disk.DSK")
|
||||
store = DiskAssignmentStore(url: folder.appendingPathComponent("settings.json"))
|
||||
try Data(repeating: 0x12, count: 8192).write(to: rom)
|
||||
try Data(repeating: 0x34, count: 16384).write(to: second)
|
||||
try Data(repeating: 0, count: 8192).write(to: diskROM)
|
||||
try Data(repeating: 0, count: 161280).write(to: disk)
|
||||
}
|
||||
func remove() { try? FileManager.default.removeItem(at: folder) }
|
||||
}
|
||||
@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)
|
||||
}
|
||||
XCTFail("Cartridge operation timed out"); throw NSError(domain: "TestTimeout", code: 1)
|
||||
}
|
||||
@MainActor private func withModel(_ store: DiskAssignmentStore, _ body: (MachineModel) async throws -> Void) async throws {
|
||||
let model = MachineModel(diskStore: store)
|
||||
do { try await settled(model); try await body(model) }
|
||||
catch {
|
||||
await withCheckedContinuation { c in model.shutdown { c.resume() } }; throw error
|
||||
}
|
||||
await withCheckedContinuation { c in model.shutdown { c.resume() } }
|
||||
}
|
||||
func testCartridgeFileAndSettingsValidation() throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
XCTAssertEqual(try DiskFiles.readCartridgeROM(f.rom).count, 8192)
|
||||
for bytes in [Data(), Data(repeating: 0, count: 262145), Data([0x4d,0x5a,0,0])] {
|
||||
try bytes.write(to: f.second); XCTAssertThrowsError(try DiskFiles.readCartridgeROM(f.second))
|
||||
}
|
||||
XCTAssertThrowsError(try DiskFiles.readCartridgeROM(f.disk))
|
||||
var s = DiskAssignments(); s.cartridges = CartridgeAssignments()
|
||||
s.cartridges?.slots[1] = .init(kind: .rom, url: f.rom)
|
||||
try f.store.save(s); XCTAssertEqual(try f.store.load(), s)
|
||||
var invalid = s; invalid.cartridges?.physicalSlot = 0; XCTAssertThrowsError(try f.store.save(invalid))
|
||||
invalid = s; invalid.cartridges?.slots.removeLast(); XCTAssertThrowsError(try f.store.save(invalid))
|
||||
invalid = s; invalid.cartridges?.slots[1].url = nil; XCTAssertThrowsError(try f.store.save(invalid))
|
||||
invalid = s; invalid.cartridges?.slots[2].kind = .floppy; invalid.cartridges?.slots[3].kind = .floppy
|
||||
XCTAssertThrowsError(try f.store.save(invalid)); XCTAssertEqual(try f.store.load(), s)
|
||||
}
|
||||
@MainActor func testModesSlotsAndDiskAssignmentsSurviveRelaunch() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
var old = DiskAssignments(); old.rom = f.diskROM
|
||||
old.drives[0] = .init(url: f.disk, writeProtected: true, temporary: true)
|
||||
try f.store.save(old)
|
||||
try await withModel(f.store) { model in
|
||||
XCTAssertTrue(model.diskConnected); XCTAssertEqual(model.cartridgeAssignments.slots[0].kind, .floppy)
|
||||
model.setMultiPak(true); try await settled(model)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[4].kind, .floppy)
|
||||
XCTAssertTrue(model.diskConnected); XCTAssertTrue(model.disks[0].mounted)
|
||||
model.selectCartridgeROM(f.rom, slot: 1); try await settled(model)
|
||||
model.selectCartridgeROM(f.second, slot: 2); try await settled(model)
|
||||
model.selectPhysicalSlot(2); try await settled(model)
|
||||
XCTAssertEqual(model.romSlot, 2); XCTAssertEqual(model.ioSlot, 2)
|
||||
model.setMultiPak(false); try await settled(model)
|
||||
XCTAssertTrue(model.diskConnected); XCTAssertEqual(model.romSlot, 0)
|
||||
model.selectCartridgeROM(f.second, slot: 0); try await settled(model)
|
||||
XCTAssertFalse(model.diskConnected); XCTAssertTrue(model.disks[0].mounted)
|
||||
XCTAssertTrue(model.disks[0].writeProtected); XCTAssertTrue(model.diskTemporary[0])
|
||||
}
|
||||
try await withModel(f.store) { model in
|
||||
XCTAssertFalse(model.cartridgeAssignments.multiPak); XCTAssertEqual(model.cartridgeNames[0], f.second.lastPathComponent)
|
||||
XCTAssertEqual(model.cartridgeNames[1], f.rom.lastPathComponent)
|
||||
XCTAssertFalse(model.diskConnected); XCTAssertTrue(model.disks[0].mounted)
|
||||
model.setMultiPak(true); try await settled(model)
|
||||
XCTAssertTrue(model.diskConnected); XCTAssertEqual(model.romSlot, 2)
|
||||
model.assignCartridge(.floppy, slot: 3); try await settled(model)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[4].kind, .empty)
|
||||
XCTAssertEqual(model.cartridgeAssignments.slots[3].kind, .floppy)
|
||||
model.assignCartridge(.empty, slot: 1); try await settled(model)
|
||||
}
|
||||
try await withModel(f.store) { model in
|
||||
XCTAssertTrue(model.cartridgeAssignments.multiPak)
|
||||
XCTAssertTrue(model.cartridgeNames[1].isEmpty); XCTAssertEqual(model.cartridgeNames[2], f.second.lastPathComponent)
|
||||
XCTAssertEqual(model.cartridgeNames[3], "Floppy controller"); XCTAssertTrue(model.disks[0].mounted)
|
||||
}
|
||||
}
|
||||
@MainActor func testUnavailableROMRetryPreservesOtherSlotsAndSettings() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
var settings = DiskAssignments(); var layout = CartridgeAssignments()
|
||||
layout.multiPak = true; layout.mpiConfigured = true
|
||||
layout.slots[1] = .init(kind: .rom, url: f.rom); layout.slots[2] = .init(kind: .rom, url: f.second)
|
||||
settings.cartridges = layout; try f.store.save(settings)
|
||||
let saved = try Data(contentsOf: f.store.url); try FileManager.default.removeItem(at: f.rom)
|
||||
try await withModel(f.store) { model in
|
||||
XCTAssertNotNil(model.cartridgeRestoreErrors[1]); XCTAssertTrue(model.cartridgeNames[1].isEmpty)
|
||||
XCTAssertEqual(model.cartridgeNames[2], f.second.lastPathComponent)
|
||||
XCTAssertEqual(try Data(contentsOf: f.store.url), saved)
|
||||
try Data(repeating: 0x12, count: 8192).write(to: f.rom)
|
||||
// A working slot's original file may disappear; retry must retain its owned bytes.
|
||||
try FileManager.default.removeItem(at: f.second)
|
||||
model.retryRememberedCartridges(); try await settled(model)
|
||||
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty)
|
||||
XCTAssertEqual(model.cartridgeNames[1], f.rom.lastPathComponent)
|
||||
XCTAssertEqual(model.cartridgeNames[2], f.second.lastPathComponent)
|
||||
try Data().write(to: f.rom)
|
||||
model.selectCartridgeROM(f.rom, slot: 2); try await settled(model)
|
||||
XCTAssertNotNil(model.fileError); XCTAssertEqual(model.cartridgeNames[2], f.second.lastPathComponent)
|
||||
XCTAssertEqual(try Data(contentsOf: f.store.url), saved)
|
||||
}
|
||||
}
|
||||
@MainActor func testFirstMPIActivationKeepsMissingROMRecoverable() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
var settings = DiskAssignments(); var layout = CartridgeAssignments()
|
||||
layout.slots[0] = .init(kind: .rom, url: f.rom); settings.cartridges = layout
|
||||
try f.store.save(settings); try FileManager.default.removeItem(at: f.rom)
|
||||
try await withModel(f.store) { model in
|
||||
model.setMultiPak(true); try await settled(model)
|
||||
XCTAssertNotNil(model.cartridgeRestoreErrors[4])
|
||||
model.setMultiPak(false); try await settled(model)
|
||||
model.assignCartridge(.empty, slot: 0); try await settled(model)
|
||||
XCTAssertNil(model.cartridgeRestoreErrors[0]); XCTAssertNotNil(model.cartridgeRestoreErrors[4])
|
||||
model.setMultiPak(true); try await settled(model)
|
||||
try Data(repeating: 0x12, count: 8192).write(to: f.rom)
|
||||
model.retryRememberedCartridges(); try await settled(model)
|
||||
XCTAssertTrue(model.cartridgeRestoreErrors.isEmpty); XCTAssertEqual(model.cartridgeNames[4], f.rom.lastPathComponent)
|
||||
}
|
||||
}
|
||||
@MainActor func testDirtyDisksRemainAvailableWhenDisconnected() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
var settings = DiskAssignments(); settings.rom = f.diskROM; try f.store.save(settings)
|
||||
try await withModel(f.store) { model in
|
||||
model.createDisk(0); try await settled(model)
|
||||
XCTAssertTrue(model.disks[0].dirty)
|
||||
model.selectCartridgeROM(f.rom, slot: 0); try await settled(model)
|
||||
XCTAssertFalse(model.diskConnected); XCTAssertTrue(model.disks[0].dirty)
|
||||
model.setMultiPak(true); try await settled(model)
|
||||
model.assignCartridge(.floppy, slot: 1); try await settled(model)
|
||||
XCTAssertTrue(model.diskConnected); XCTAssertTrue(model.disks[0].dirty)
|
||||
await withCheckedContinuation { c in model.prepareToQuit { c.resume() } }
|
||||
XCTAssertTrue(model.unsavedMedia)
|
||||
model.exportDisk(0, to: f.disk); try await settled(model)
|
||||
XCTAssertFalse(model.disks[0].dirty); XCTAssertTrue(model.diskConnected)
|
||||
}
|
||||
}
|
||||
@MainActor func testBridgeRejectsInvalidAndBusyLayoutsWithoutReplacingSlots() async throws {
|
||||
let controller = VCCMachineController()
|
||||
func step(_ action: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
|
||||
await withCheckedContinuation { c in action { c.resume(returning: $0) } }
|
||||
}
|
||||
let diskROM = Data(repeating: 0, count: 8192)
|
||||
_ = await step { controller.loadDiskROM(diskROM, name: "disk", completion: $0) }
|
||||
_ = await step { controller.mountDisk(Data(repeating: 0, count: 161280), drive: 0, name: "test", readOnly: false, completion: $0) }
|
||||
let empty = Array(repeating: Data(), count: 5), names = Array(repeating: "", count: 5)
|
||||
var snapshot = await step { controller.configureCartridges([0,2,0,0,2], roms: empty, names: names, multiPak: true, physicalSlot: 4, completion: $0) }
|
||||
XCTAssertNotNil(snapshot.errorMessage); XCTAssertFalse(snapshot.multiPakEnabled); XCTAssertTrue(snapshot.disks[0].mounted)
|
||||
snapshot = await step { controller.configureCartridges([2,0,0,0,2], roms: empty, names: names, multiPak: true, physicalSlot: 4, completion: $0) }
|
||||
XCTAssertNil(snapshot.errorMessage); XCTAssertTrue(snapshot.multiPakEnabled)
|
||||
// Start a write command and leave its data transfer incomplete.
|
||||
var system = Data(repeating: 0, count: 32768)
|
||||
let code: [UInt8] = [0x86,0x29,0xb7,0xff,0x40,0x86,1,0xb7,0xff,0x4a,0x86,0xa0,0xb7,0xff,0x48,0x20,0xfe]
|
||||
system.replaceSubrange(0..<code.count, with: code); system[32766] = 0x80
|
||||
_ = await step { controller.loadROM(system, use6309: false, completion: $0) }
|
||||
_ = await step(controller.resume)
|
||||
for _ in 0..<100 {
|
||||
snapshot = await step(controller.snapshot)
|
||||
if snapshot.diskBusy { break }
|
||||
try await Task.sleep(nanoseconds: 1_000_000)
|
||||
}
|
||||
XCTAssertTrue(snapshot.diskBusy)
|
||||
_ = await step(controller.pause)
|
||||
snapshot = await step { controller.configureCartridges([2,0,0,0,2], roms: empty, names: names, multiPak: false, physicalSlot: 1, completion: $0) }
|
||||
XCTAssertNotNil(snapshot.errorMessage); XCTAssertTrue(snapshot.multiPakEnabled); XCTAssertEqual(snapshot.physicalSlot, 4)
|
||||
_ = await step(controller.reset)
|
||||
snapshot = await step { controller.configureCartridges([2,0,0,0,2], roms: empty, names: names, multiPak: false, physicalSlot: 1, completion: $0) }
|
||||
XCTAssertNil(snapshot.errorMessage); XCTAssertFalse(snapshot.multiPakEnabled); XCTAssertTrue(snapshot.disks[0].mounted)
|
||||
_ = await step(controller.shutdown)
|
||||
}
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user