Files
VCCPlusOSS/platforms/macos/Tests/DiskEditorSafetyTests.swift

933 lines
69 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import AppKit
final class DiskEditorSafetyTests: XCTestCase {
private let original = Data(repeating: 0, count: 161280)
@MainActor private func step(_ operation: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
await withCheckedContinuation { continuation in operation { continuation.resume(returning: $0) } }
}
@MainActor private func capture(_ controller: VCCMachineController) async -> (VCCDiskEditCapture?, VCCMachineSnapshot) {
await withCheckedContinuation { continuation in
controller.beginDiskEditor(inDrive: 0) { continuation.resume(returning: ($0, $1)) }
}
}
@MainActor private func prepare(_ controller: VCCMachineController, _ token: UInt64, _ data: Data) async -> (Bool, VCCMachineSnapshot) {
await withCheckedContinuation { continuation in
controller.prepareDiskEditor(token: token, data: data) { continuation.resume(returning: ($0, $1)) }
}
}
@MainActor private func commit(_ controller: VCCMachineController, _ token: UInt64, confirmed: Bool, saved: Bool) async -> (Bool, VCCMachineSnapshot) {
await withCheckedContinuation { continuation in
controller.commitDiskEditor(token: token, restartConfirmed: confirmed, sourceSaved: saved) { continuation.resume(returning: ($0, $1)) }
}
}
@MainActor private func setup(_ controller: VCCMachineController, cpu: Bool, readOnly: Bool = false) async {
let diagnostic = await step { controller.loadDiagnostic(use6309: cpu, completion: $0) }
XCTAssertNil(diagnostic.errorMessage)
let rom = await step { controller.loadDiskROM(Data(repeating: 0, count: 8192), name: "authored.rom", completion: $0) }
XCTAssertNil(rom.errorMessage)
let mount = await step { controller.mountDisk(original, drive: 0, name: "fixture.dsk", readOnly: readOnly, completion: $0) }
XCTAssertNil(mount.errorMessage)
}
@MainActor func testLeaseBlocksExecutionAndMediaOnBothCPUsAndCancelRetainsBytes() async throws {
for cpu in [false, true] {
let controller = VCCMachineController()
await setup(controller, cpu: cpu)
_ = await step(controller.resume)
let (optional, locked) = await capture(controller)
let edit = try XCTUnwrap(optional)
XCTAssertTrue(locked.diskEditorLocked); XCTAssertEqual(locked.state, .paused)
XCTAssertEqual(edit.data, original)
let refused = [
await step(controller.resume), await step(controller.reset), await step(controller.debuggerStep),
await step { controller.ejectDisk(inDrive: 0, discard: true, completion: $0) },
await step { controller.mountDisk(original, drive: 0, name: "other.dsk", readOnly: false, completion: $0) },
await step { controller.loadDiagnostic(use6309: !cpu, completion: $0) }
]
for result in refused {
XCTAssertNotNil(result.errorMessage); XCTAssertTrue(result.diskEditorLocked)
XCTAssertEqual(result.generation, locked.generation); XCTAssertEqual(result.frames, locked.frames)
XCTAssertEqual(result.state, .paused)
}
var edited = original; edited[1000] = 0x5a
let (valid, _) = await prepare(controller, edit.token, edited); XCTAssertTrue(valid)
let cancelled = await step { controller.cancelDiskEditor(token: edit.token, completion: $0) }
XCTAssertNil(cancelled.errorMessage); XCTAssertFalse(cancelled.diskEditorLocked)
let (next, _) = await capture(controller)
XCTAssertEqual(next?.data, original, "Private changes must not reach the mounted disk on Cancel")
let stale = await step { controller.cancelDiskEditor(token: edit.token, completion: $0) }
XCTAssertNotNil(stale.errorMessage); XCTAssertTrue(stale.diskEditorLocked)
_ = await step { controller.cancelDiskEditor(token: next!.token, completion: $0) }
let resumed = await step(controller.resume); XCTAssertNil(resumed.errorMessage)
_ = await step(controller.shutdown)
}
}
@MainActor func testValidationProtectionRestartAndDirtySemanticsOnBothCPUs() async throws {
for cpu in [false, true] {
let controller = VCCMachineController(); await setup(controller, cpu: cpu)
let (optional, before) = await capture(controller); let edit = try XCTUnwrap(optional)
let invalid = await prepare(controller, edit.token, Data(repeating: 0, count: 184320))
XCTAssertFalse(invalid.0); XCTAssertNotNil(invalid.1.errorMessage)
var bytes = original; bytes[1000] = 0xa5
let valid = await prepare(controller, edit.token, bytes); XCTAssertTrue(valid.0)
let unconfirmed = await commit(controller, edit.token, confirmed: false, saved: false)
XCTAssertFalse(unconfirmed.0); XCTAssertEqual(unconfirmed.1.generation, before.generation)
let applied = await commit(controller, edit.token, confirmed: true, saved: false)
XCTAssertTrue(applied.0); XCTAssertNil(applied.1.errorMessage)
XCTAssertFalse(applied.1.diskEditorLocked); XCTAssertTrue(applied.1.disks[0].dirty)
XCTAssertGreaterThan(applied.1.generation, before.generation); XCTAssertEqual(applied.1.state, .paused)
let (current, _) = await capture(controller); XCTAssertEqual(current?.data, bytes)
_ = await step { controller.cancelDiskEditor(token: current!.token, completion: $0) }
_ = await step(controller.shutdown)
let readOnly = VCCMachineController(); await setup(readOnly, cpu: cpu, readOnly: true)
let (protected, _) = await capture(readOnly); XCTAssertFalse(protected!.canApply)
let refusal = await prepare(readOnly, protected!.token, bytes)
XCTAssertFalse(refusal.0); XCTAssertNotNil(refusal.1.errorMessage)
_ = await step { readOnly.cancelDiskEditor(token: protected!.token, completion: $0) }
_ = await step(readOnly.shutdown)
}
}
@MainActor func testHardDiskLeasesAndRestartApplyRetainOtherMediaOnBothCPUs() async throws {
for cpu in [false, true] {
for drive in 0..<2 {
let controller = VCCMachineController(); await setup(controller, cpu: cpu)
let disk = Data(repeating: UInt8(0x20 + drive), count: 20 * 1024 * 1024)
let other = Data(repeating: 0x71, count: 1024)
_ = await step { controller.mountHardDisk(disk, drive: drive, name: "authored.vhd", readOnly: false, completion: $0) }
_ = await step { controller.mountHardDisk(other, drive: 1 - drive, name: "other.vhd", readOnly: false, completion: $0) }
_ = await step(controller.resume)
let (optional, before): (VCCDiskEditCapture?, VCCMachineSnapshot) = await withCheckedContinuation { continuation in
controller.beginHardDiskEditor(inDrive: drive) { continuation.resume(returning: ($0, $1)) }
}
let edit = try XCTUnwrap(optional)
XCTAssertEqual(edit.data, disk); XCTAssertTrue(edit.canApply)
XCTAssertTrue(before.diskEditorLocked); XCTAssertEqual(before.state, .paused)
for result in [await step(controller.resume), await step(controller.reset),
await step { controller.hardDiskAction(1, drive: drive, completion: $0) },
await step { controller.mountHardDisk(other, drive: 1 - drive, name: "replacement.vhd", readOnly: false, completion: $0) },
await step { controller.ejectDisk(inDrive: 0, discard: true, completion: $0) }] {
XCTAssertNotNil(result.errorMessage); XCTAssertTrue(result.diskEditorLocked)
XCTAssertEqual(result.generation, before.generation)
}
var edited = disk; edited[edited.count - 1] = 0x5a
let invalid = await prepare(controller, edit.token, edited.dropLast(256))
XCTAssertFalse(invalid.0)
let valid = await prepare(controller, edit.token, edited); XCTAssertTrue(valid.0)
let declined = await commit(controller, edit.token, confirmed: false, saved: false)
XCTAssertFalse(declined.0); XCTAssertEqual(declined.1.generation, before.generation)
let applied = await commit(controller, edit.token, confirmed: true, saved: false)
XCTAssertTrue(applied.0); XCTAssertFalse(applied.1.diskEditorLocked)
XCTAssertTrue(applied.1.hardDisks[drive].dirty); XCTAssertTrue(applied.1.disks[0].mounted)
XCTAssertTrue(applied.1.hardDisks[1 - drive].mounted)
XCTAssertGreaterThan(applied.1.generation, before.generation); XCTAssertEqual(applied.1.state, .paused)
let (check, _): (VCCDiskEditCapture?, VCCMachineSnapshot) = await withCheckedContinuation { continuation in
controller.beginHardDiskEditor(inDrive: drive) { continuation.resume(returning: ($0, $1)) }
}
XCTAssertEqual(check?.data, edited)
let stale = await prepare(controller, edit.token, disk); XCTAssertFalse(stale.0)
_ = await step { controller.cancelDiskEditor(token: check!.token, completion: $0) }
let (preserved, _): (VCCDiskEditCapture?, VCCMachineSnapshot) = await withCheckedContinuation { continuation in
controller.beginHardDiskEditor(inDrive: 1 - drive) { continuation.resume(returning: ($0, $1)) }
}
XCTAssertEqual(preserved?.data, other)
_ = await step { controller.cancelDiskEditor(token: preserved!.token, completion: $0) }
_ = await step(controller.shutdown)
}
}
}
@MainActor func testHardDiskEditorReadOnlyAndOtherDirtyMediaAreRefused() async throws {
let controller = VCCMachineController(); await setup(controller, cpu: false)
let data = Data(repeating: 0, count: 4096)
_ = await step { controller.mountHardDisk(data, drive: 0, name: "protected.vhd", readOnly: true, completion: $0) }
let (optional, _): (VCCDiskEditCapture?, VCCMachineSnapshot) = await withCheckedContinuation { continuation in
controller.beginHardDiskEditor(inDrive: 0) { continuation.resume(returning: ($0, $1)) }
}
let edit = try XCTUnwrap(optional); XCTAssertFalse(edit.canApply)
let refused = await prepare(controller, edit.token, data); XCTAssertFalse(refused.0)
_ = await step { controller.cancelDiskEditor(token: edit.token, completion: $0) }
_ = await step { controller.hardDiskAction(1, drive: 0, completion: $0) }
_ = await step { controller.mountHardDisk(data, drive: 0, name: "writable.vhd", readOnly: false, completion: $0) }
_ = await step { controller.createHardDisk(inDrive: 1, size: 4096, completion: $0) }
let (second, _): (VCCDiskEditCapture?, VCCMachineSnapshot) = await withCheckedContinuation { continuation in
controller.beginHardDiskEditor(inDrive: 0) { continuation.resume(returning: ($0, $1)) }
}
let dirtyRefusal = await prepare(controller, second!.token, data)
XCTAssertFalse(dirtyRefusal.0); XCTAssertTrue(dirtyRefusal.1.diskEditorLocked)
_ = await step { controller.cancelDiskEditor(token: second!.token, completion: $0) }
_ = await step(controller.shutdown)
}
@MainActor func testHardDiskModelTemporaryAutomaticExternalChangeAndAliases() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let disk = folder.appendingPathComponent("authored.vhd"), alias = folder.appendingPathComponent("alias.dsk")
let rom = folder.appendingPathComponent("authored.rom")
let data = Data(repeating: 0x11, count: 161280)
try data.write(to: disk); try FileManager.default.linkItem(at: disk, to: alias)
try Data(repeating: 0, count: 8192).write(to: rom)
let store = DiskAssignmentStore(url: folder.appendingPathComponent("settings.json"))
var settings = DiskAssignments(), hard = HardDiskAssignments()
settings.rom = rom; settings.drives[0] = .init(url: alias, writeProtected: false, temporary: true)
hard.drives[0] = .init(url: disk, writeProtected: false, temporary: true); settings.hardDisks = hard
try store.save(settings)
let conflictedModel = MachineModel(diskStore: store)
for _ in 0..<500 { if !conflictedModel.busy && !conflictedModel.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
XCTAssertEqual(conflictedModel.mountedHardDiskEditorDrive(for: alias), 0)
let conflicted = try await conflictedModel.beginHardDiskEditor(inDrive: 0)
XCTAssertFalse(conflicted.canApply)
try await conflictedModel.cancelDiskEditor(conflicted)
await withCheckedContinuation { continuation in conflictedModel.shutdown { continuation.resume() } }
settings.drives[0] = nil; try store.save(settings)
let model = MachineModel(diskStore: store)
for _ in 0..<500 { if !model.busy && !model.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
let temporary = try await model.beginHardDiskEditor(inDrive: 0)
XCTAssertTrue(temporary.hardDisk); XCTAssertTrue(temporary.canApply)
var edited = data; edited[1000] = 0x4a
try await model.applyDiskEditor(temporary, data: edited, restartConfirmed: true)
XCTAssertEqual(try Data(contentsOf: disk), data); XCTAssertTrue(model.hardDisks[0].dirty)
XCTAssertTrue(model.hardTemporary[0])
let current = try await model.beginHardDiskEditor(inDrive: 0)
XCTAssertEqual(current.data, edited); try await model.cancelDiskEditor(current)
model.setHardTemporary(0, false)
for _ in 0..<500 {
if !model.busy && !model.diskSaving && !model.hardDisks[0].dirty { break }
try await Task.sleep(nanoseconds: 20_000_000)
}
XCTAssertFalse(model.hardDisks[0].dirty)
XCTAssertEqual(try Data(contentsOf: disk), edited, "Later automatic saving retains editor sector changes")
await withCheckedContinuation { continuation in model.shutdown { continuation.resume() } }
try data.write(to: disk, options: .atomic)
hard.drives[0] = .init(url: disk, writeProtected: false, temporary: false); settings.hardDisks = hard; try store.save(settings)
let automatic = MachineModel(diskStore: store)
for _ in 0..<500 { if !automatic.busy && !automatic.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
let session = try await automatic.beginHardDiskEditor(inDrive: 0)
var external = data; external[1001] = 0x7e; try external.write(to: disk, options: .atomic)
do { try await automatic.applyDiskEditor(session, data: edited, restartConfirmed: true); XCTFail("External bytes must survive") }
catch { XCTAssertTrue(automatic.diskEditorLocked) }
XCTAssertEqual(try Data(contentsOf: disk), external)
try await automatic.cancelDiskEditor(session)
let changed = try await automatic.beginHardDiskEditor(inDrive: 0); XCTAssertFalse(changed.canApply)
try await automatic.cancelDiskEditor(changed)
try data.write(to: disk, options: .atomic)
let fresh = try await automatic.beginHardDiskEditor(inDrive: 0)
try await automatic.applyDiskEditor(fresh, data: edited, restartConfirmed: true)
XCTAssertEqual(try Data(contentsOf: disk), edited); XCTAssertFalse(automatic.hardDisks[0].dirty)
let check = try await automatic.beginHardDiskEditor(inDrive: 0)
XCTAssertEqual(check.data, edited); try await automatic.cancelDiskEditor(check)
await withCheckedContinuation { continuation in automatic.shutdown { continuation.resume() } }
}
@MainActor func testModelHardLinkConflictTemporaryApplyAndExternalChange() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let disk = folder.appendingPathComponent("fixture.dsk"), alias = folder.appendingPathComponent("alias.dsk")
let rom = folder.appendingPathComponent("authored.rom")
try original.write(to: disk); try Data(repeating: 0, count: 8192).write(to: rom)
try FileManager.default.linkItem(at: disk, to: alias)
let store = DiskAssignmentStore(url: folder.appendingPathComponent("settings.json"))
var assignments = DiskAssignments(); assignments.rom = rom
assignments.drives[0] = .init(url: disk, writeProtected: false, temporary: true)
assignments.drives[1] = .init(url: alias, writeProtected: false, temporary: true)
try store.save(assignments)
let controller = VCCMachineController(); let model = MachineModel(diskStore: store, controller: controller)
for _ in 0..<500 { if !model.busy && !model.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
XCTAssertFalse(model.busy); XCTAssertEqual(model.mountedEditorDrive(for: alias), 0)
let conflicted = try await model.beginDiskEditor(inDrive: 0)
XCTAssertFalse(conflicted.canApply); XCTAssertNotNil(conflicted.applyRestriction)
try await model.cancelDiskEditor(conflicted)
XCTAssertEqual(try Data(contentsOf: disk), original)
await withCheckedContinuation { continuation in model.shutdown { continuation.resume() } }
assignments.drives[1] = nil; try store.save(assignments)
let second = MachineModel(diskStore: store)
for _ in 0..<500 { if !second.busy && !second.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
let editable = try await second.beginDiskEditor(inDrive: 0); XCTAssertTrue(editable.canApply)
var edited = original; edited[1000] = 0x6b
try await second.applyDiskEditor(editable, data: edited, restartConfirmed: true)
XCTAssertEqual(try Data(contentsOf: disk), original)
XCTAssertTrue(second.disks[0].dirty); XCTAssertTrue(second.diskTemporary[0])
let check = try await second.beginDiskEditor(inDrive: 0); XCTAssertEqual(check.data, edited)
try await second.cancelDiskEditor(check)
// A changed host source becomes copy-only; its bytes must never be overwritten.
var external = original; external[1001] = 0x7c; try external.write(to: disk, options: .atomic)
let changed = try await second.beginDiskEditor(inDrive: 0); XCTAssertFalse(changed.canApply)
try await second.cancelDiskEditor(changed)
XCTAssertEqual(try Data(contentsOf: disk), external)
await withCheckedContinuation { continuation in second.shutdown { continuation.resume() } }
}
@MainActor func testAutomaticApplyUsesAtomicSourceCheckAndLeavesCleanMountedBytes() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let disk = folder.appendingPathComponent("fixture.dsk"), rom = folder.appendingPathComponent("authored.rom")
try original.write(to: disk); try Data(repeating: 0, count: 8192).write(to: rom)
let store = DiskAssignmentStore(url: folder.appendingPathComponent("settings.json"))
var assignments = DiskAssignments(); assignments.rom = rom
assignments.drives[0] = .init(url: disk, writeProtected: false, temporary: false); try store.save(assignments)
let model = MachineModel(diskStore: store)
for _ in 0..<500 { if !model.busy && !model.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
let session = try await model.beginDiskEditor(inDrive: 0)
var edited = original; edited[1000] = 0x45
var external = original; external[1001] = 0x7e; try external.write(to: disk, options: .atomic)
do { try await model.applyDiskEditor(session, data: edited, restartConfirmed: true); XCTFail("External edits must be preserved") }
catch { XCTAssertTrue(model.diskEditorLocked) }
XCTAssertEqual(try Data(contentsOf: disk), external)
try await model.cancelDiskEditor(session)
try original.write(to: disk, options: .atomic)
let fresh = try await model.beginDiskEditor(inDrive: 0)
XCTAssertEqual(fresh.data, original, "A failed host write cannot replace mounted bytes")
try await model.applyDiskEditor(fresh, data: edited, restartConfirmed: true)
XCTAssertEqual(try Data(contentsOf: disk), edited); XCTAssertFalse(model.disks[0].dirty)
XCTAssertFalse(model.diskEditorLocked)
let current = try await model.beginDiskEditor(inDrive: 0); XCTAssertEqual(current.data, edited)
try await model.cancelDiskEditor(current)
await withCheckedContinuation { continuation in model.shutdown { continuation.resume() } }
}
@MainActor func testFinderInsertionExecutionChoicesOnBothCPUs() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let disk = folder.appendingPathComponent("insert.dsk"), rom = folder.appendingPathComponent("authored.rom")
try original.write(to: disk); try Data(repeating: 0, count: 8192).write(to: rom)
for cpu in [false, true] {
let store = DiskAssignmentStore(url: folder.appendingPathComponent(UUID().uuidString + ".json"))
var assignments = DiskAssignments(); assignments.rom = rom; try store.save(assignments)
let controller = VCCMachineController(); let model = MachineModel(diskStore: store, controller: controller)
for _ in 0..<500 { if !model.busy && !model.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
_ = await step { controller.loadDiagnostic(use6309: cpu, completion: $0) }
for execution in DiskInsertionExecution.allCases {
for running in [false, true] {
let initial = await step(running ? controller.resume : controller.pause)
try await model.insertDiskFromMedia(disk, drive: 2, execution: execution)
let after = await step(controller.snapshot)
let shouldRun = execution == .run || (execution == .keepCurrentState && running)
XCTAssertEqual(after.state, shouldRun ? .running : .paused)
XCTAssertEqual(after.generation, initial.generation, "Insertion must not boot or reset the guest")
XCTAssertTrue(after.disks[2].mounted); XCTAssertEqual(after.disks[2].name, disk.lastPathComponent)
XCTAssertEqual(model.diskAssignments.drives[2]?.url, disk)
XCTAssertEqual(try Data(contentsOf: disk), original)
}
}
let invalid = folder.appendingPathComponent("missing.dsk")
let beforeInvalid = await step(controller.resume)
do { try await model.insertDiskFromMedia(invalid, drive: 2, execution: .pause, reset: .coldRestart); XCTFail("An unavailable disk must fail preflight before resetting") }
catch { }
let afterInvalid = await step(controller.snapshot)
XCTAssertEqual(afterInvalid.state, .running); XCTAssertEqual(afterInvalid.generation, beforeInvalid.generation)
XCTAssertEqual(model.diskAssignments.drives[2]?.url, disk)
_ = await step(controller.pause)
_ = await step { controller.createDisk(inDrive: 3, completion: $0) }
let beforeRefusal = await step(controller.resume)
do { try await model.insertDiskFromMedia(disk, drive: 2, execution: .run, reset: .coldRestart); XCTFail("Unsaved unrelated media must block replacement and reset") }
catch { }
let refused = await step(controller.snapshot)
XCTAssertEqual(refused.state, .paused); XCTAssertTrue(refused.disks[3].dirty)
XCTAssertEqual(refused.generation, beforeRefusal.generation)
XCTAssertEqual(model.diskAssignments.drives[2]?.url, disk)
await withCheckedContinuation { continuation in model.shutdown { continuation.resume() } }
}
}
@MainActor func testFinderInsertionResetChoicesProtectRAMAndRespectExecutionOnBothCPUs() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let disk = folder.appendingPathComponent("insert.dsk"), invalid = folder.appendingPathComponent("malformed.dsk")
let rom = folder.appendingPathComponent("authored.rom")
try original.write(to: disk); try Data([1, 2, 3]).write(to: invalid)
try Data(repeating: 0, count: 8192).write(to: rom)
for cpu in [false, true] {
let store = DiskAssignmentStore(url: folder.appendingPathComponent(UUID().uuidString + ".json"))
var assignments = DiskAssignments(); assignments.rom = rom; try store.save(assignments)
let controller = VCCMachineController(); let model = MachineModel(diskStore: store, controller: controller)
for _ in 0..<500 { if !model.busy && !model.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
_ = await step { controller.loadDiagnostic(use6309: cpu, completion: $0) }
// A marker in ordinary guest RAM distinguishes retained RAM from a
// cold restart without depending on private ROM initialization.
func marker() async -> Data {
let memory: VCCDebugMemoryCapture = await withCheckedContinuation { continuation in
controller.debuggerMemory(address: 0x6000, count: 2, physical: false, logicalAddress: 0x6000,
os9: false, decode: false) { continuation.resume(returning: $0) }
}
return memory.bytes
}
let beforeInvalid = await step { controller.debuggerWriteMemory(address: 0x6000, data: Data([0xa5, 0x5a]), completion: $0) }
for reset in [DiskInsertionReset.softReset, .coldRestart] {
do { try await model.insertDiskFromMedia(invalid, drive: 2, execution: .pause, reset: reset); XCTFail("Malformed images must fail before reset") }
catch { }
let afterInvalid = await step(controller.snapshot)
XCTAssertEqual(afterInvalid.generation, beforeInvalid.generation)
XCTAssertFalse(afterInvalid.disks[2].mounted)
let bytes = await marker(); XCTAssertEqual(bytes, Data([0xa5, 0x5a]))
}
for reset in [DiskInsertionReset.softReset, .coldRestart] {
for execution in DiskInsertionExecution.allCases {
for running in [false, true] {
_ = await step(controller.pause)
_ = await step { controller.debuggerWriteMemory(address: 0x6000, data: Data([0xa5, 0x5a]), completion: $0) }
let initial = await step(running ? controller.resume : controller.pause)
try await model.insertDiskFromMedia(disk, drive: 2, execution: execution, reset: reset)
let after = await step(controller.snapshot)
let shouldRun = execution == .run || (execution == .keepCurrentState && running)
XCTAssertEqual(after.state, shouldRun ? .running : .paused)
XCTAssertEqual(after.generation, initial.generation + 1, "Exactly the selected reset precedes insertion")
XCTAssertTrue(after.disks[2].mounted); XCTAssertEqual(after.disks[2].name, disk.lastPathComponent)
XCTAssertEqual(model.diskAssignments.drives[2]?.url, disk)
_ = await step(controller.pause)
let bytes = await marker()
if reset == .softReset { XCTAssertEqual(bytes, Data([0xa5, 0x5a])) }
else { XCTAssertNotEqual(bytes, Data([0xa5, 0x5a])) }
}
}
}
XCTAssertEqual(try Data(contentsOf: disk), original)
await withCheckedContinuation { continuation in model.shutdown { continuation.resume() } }
}
}
@MainActor func testEditorExportsProtectAssignedAliasesAndExternalChanges() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let disk = folder.appendingPathComponent("fixture.dsk"), alias = folder.appendingPathComponent("alias.dsk")
let rom = folder.appendingPathComponent("authored.rom"), export = folder.appendingPathComponent("export.txt")
try original.write(to: disk); try FileManager.default.linkItem(at: disk, to: alias)
try Data(repeating: 0, count: 8192).write(to: rom)
let store = DiskAssignmentStore(url: folder.appendingPathComponent("settings.json"))
var assignments = DiskAssignments(); assignments.rom = rom
assignments.drives[0] = .init(url: disk, writeProtected: false, temporary: true); try store.save(assignments)
let model = MachineModel(diskStore: store)
for _ in 0..<500 { if !model.busy && !model.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
XCTAssertTrue(model.diskEditorSourceIsAssigned(alias))
XCTAssertFalse(model.diskEditorSourceIsAssigned(export))
let session = try await model.beginDiskEditor(inDrive: 0)
do { try await model.saveDiskEditorExport(Data([1]), to: alias, protecting: nil); XCTFail("A mounted hard-link alias is protected") } catch { }
XCTAssertEqual(try Data(contentsOf: disk), original)
try await model.saveDiskEditorExport(Data(), to: export, protecting: disk, requireNew: true)
XCTAssertEqual(try Data(contentsOf: export), Data(), "Empty files must export without dropping the edit lease")
do { try await model.saveDiskEditorExport(Data([2]), to: export, protecting: disk, requireNew: true); XCTFail("A Finder promise cannot overwrite a later file") } catch { }
try Data([3]).write(to: export)
do { try await model.saveDiskEditorExport(Data([4]), to: export, protecting: disk, replacing: Data()); XCTFail("Changed export destination must be preserved") } catch { }
XCTAssertEqual(try Data(contentsOf: export), Data([3]))
XCTAssertTrue(model.diskEditorLocked); XCTAssertFalse(model.busy)
try await model.cancelDiskEditor(session)
var edited = original; edited[1000] = 0x71
do { try await model.saveOfflineDiskEditor(edited, to: alias, replacing: original); XCTFail("Offline save cannot replace a mounted alias") } catch { }
XCTAssertEqual(try Data(contentsOf: disk), original)
await withCheckedContinuation { continuation in model.shutdown { continuation.resume() } }
}
@MainActor func testNativeDiskOpenChoicesRetainOS9HardDiskDestinations() {
let floppy = DiskMediaOpenOptions(preferred: nil)
XCTAssertEqual(floppy.action.itemTitles, ["Edit Disk Image", "Insert into Floppy Drive"])
XCTAssertFalse(floppy.drive.isEnabled); XCTAssertFalse(floppy.execution.isEnabled)
XCTAssertFalse(floppy.reset.isEnabled)
XCTAssertEqual(floppy.reset.itemTitles, ["No Reset", "Soft Reset", "Cold Restart"])
XCTAssertEqual(floppy.reset.indexOfSelectedItem, 0)
floppy.action.selectItem(at: 1); floppy.update()
XCTAssertEqual(floppy.drive.itemTitles, ["FD0", "FD1", "FD2", "FD3"])
XCTAssertTrue(floppy.execution.isEnabled)
XCTAssertTrue(floppy.reset.isEnabled)
let os9 = DiskMediaOpenOptions(preferred: .hardDisk(1), supportsHardDisk: true)
XCTAssertEqual(os9.action.itemTitles, ["Edit Disk Image", "Insert into Floppy Drive", "Insert into Hard Disk"])
XCTAssertEqual(os9.action.indexOfSelectedItem, 2)
XCTAssertEqual(os9.drive.itemTitles, ["HD0", "HD1"]); XCTAssertEqual(os9.drive.indexOfSelectedItem, 1)
XCTAssertTrue(os9.drive.isEnabled); XCTAssertFalse(os9.execution.isEnabled)
XCTAssertFalse(os9.reset.isEnabled)
os9.action.selectItem(at: 1); os9.update()
os9.drive.selectItem(at: 3)
XCTAssertEqual(os9.drive.itemTitles, ["FD0", "FD1", "FD2", "FD3"]); XCTAssertTrue(os9.execution.isEnabled)
os9.action.selectItem(at: 2); os9.update()
XCTAssertEqual(os9.drive.indexOfSelectedItem, 1); XCTAssertFalse(os9.execution.isEnabled)
os9.action.selectItem(at: 1); os9.update()
XCTAssertEqual(os9.drive.indexOfSelectedItem, 3)
os9.action.selectItem(at: 0); os9.update()
XCTAssertFalse(os9.drive.isEnabled); XCTAssertFalse(os9.execution.isEnabled)
XCTAssertFalse(os9.reset.isEnabled)
}
@MainActor func testOS9ImportReplacementRecognizesDifferentFilenameCase() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/OS9.dsk")
let original = try Data(contentsOf: fixture)
let store = try DiskImageEditorStore(data: original)
let contents = try await store.contents(at: "")
let machine = MachineModel(diskStore: DiskAssignmentStore(url: folder.appendingPathComponent("settings.json")))
for _ in 0..<500 { if !machine.busy && !machine.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
let editor = DiskImageEditorModel(store: store, machine: machine, session: nil, sourceURL: nil,
name: "OS9.dsk", original: original, contents: contents, sourceReadOnly: false)
let host = folder.appendingPathComponent("readme.txt")
let replacement = Data("Case-varied replacement preserves one existing OS-9 entry.\r".utf8)
try replacement.write(to: host)
let needsReplacement = editor.importNeedsReplacement([host])
XCTAssertTrue(needsReplacement, "The native replacement confirmation must recognize OS-9 filename casing")
XCTAssertFalse(editor.importNeedsReplacement([folder.appendingPathComponent("NEW.TXT")]))
let after = try await store.change(.importFiles([host], type: 3, ascii: true, replace: needsReplacement), path: "")
XCTAssertEqual(after.entries.count, contents.entries.count)
let result = try await store.read("README.TXT"); XCTAssertEqual(result, replacement)
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
@MainActor func testSaveEditedCopyRejectsNewAndChangedDestinationConflicts() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/DECB.dsk")
let original = try Data(contentsOf: fixture)
let store = try DiskImageEditorStore(data: original)
let contents = try await store.contents(at: "")
let machine = MachineModel(diskStore: DiskAssignmentStore(url: folder.appendingPathComponent("settings.json")))
for _ in 0..<500 { if !machine.busy && !machine.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
let editor = DiskImageEditorModel(store: store, machine: machine, session: nil, sourceURL: fixture,
name: "DECB.dsk", original: original, contents: contents, sourceReadOnly: false)
let destination = folder.appendingPathComponent("Edited.dsk")
let unrelated = Data("A file appeared after choosing the destination.".utf8)
try unrelated.write(to: destination)
do { try await editor.saveCopy(to: destination, replacing: nil); XCTFail("A new copy cannot overwrite a file that appeared later") } catch { }
XCTAssertEqual(try Data(contentsOf: destination), unrelated)
let changed = Data("The previously approved copy changed.".utf8)
try changed.write(to: destination)
do { try await editor.saveCopy(to: destination, replacing: unrelated); XCTFail("An externally changed destination must be preserved") } catch { }
XCTAssertEqual(try Data(contentsOf: destination), changed)
try await editor.saveCopy(to: destination, replacing: changed)
XCTAssertEqual(try Data(contentsOf: destination), contents.bytes)
XCTAssertEqual(try Data(contentsOf: fixture), original)
let newDestination = folder.appendingPathComponent("New Edited.dsk")
try await editor.saveCopy(to: newDestination, replacing: nil)
XCTAssertEqual(try Data(contentsOf: newDestination), contents.bytes)
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
@MainActor func testDiskFilePromiseFactoryRetainsDelegateWithoutSubclass() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let source = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/OS9.dsk")
let bytes = try Data(contentsOf: source), store = try DiskImageEditorStore(data: bytes)
let initialContents = try await store.contents(at: "")
let entry = try XCTUnwrap(initialContents.entries.first)
let machine = MachineModel(diskStore: DiskAssignmentStore(url: folder.appendingPathComponent("settings.json")))
for _ in 0..<500 { if !machine.busy && !machine.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
var provider: NSFilePromiseProvider?
weak var delegate: AnyObject?
autoreleasepool {
provider = DiskEditorFilePromise.make(bytes: bytes, entry: entry, machine: machine, sourceURL: source)
delegate = provider?.userInfo as AnyObject?
}
XCTAssertNotNil(delegate, "The ordinary provider must strongly retain its weak delegate through userInfo")
XCTAssertEqual(ObjectIdentifier(type(of: try XCTUnwrap(provider))), ObjectIdentifier(NSFilePromiseProvider.self))
XCTAssertTrue((provider?.delegate as AnyObject?) === delegate)
XCTAssertEqual(provider?.delegate?.filePromiseProvider(try XCTUnwrap(provider), fileNameForType: provider!.fileType), "README.TXT")
autoreleasepool { provider = nil }
XCTAssertNil(delegate, "The delegate must not form a retain cycle with its provider")
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
@MainActor func testDiskTablePasteboardPromiseExportsImmutableOS9BytesAfterFolderCreation() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/OS9.dsk")
let original = try Data(contentsOf: fixture), source = folder.appendingPathComponent("original.dsk")
try original.write(to: source)
let store = try DiskImageEditorStore(data: original)
let contents = try await store.change(.folder("DOCS"), path: "")
let machine = MachineModel(diskStore: DiskAssignmentStore(url: folder.appendingPathComponent("settings.json")))
for _ in 0..<500 { if !machine.busy && !machine.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
let editor = DiskImageEditorModel(store: store, machine: machine, session: nil, sourceURL: source,
name: "original.dsk", original: original, contents: contents, sourceReadOnly: false)
let coordinator = DiskEditorFileTable.Coordinator(editor), table = NSTableView()
coordinator.rows = contents.entries
let fileRow = try XCTUnwrap(coordinator.rows.firstIndex { $0.name == "README.TXT" })
let folderRow = try XCTUnwrap(coordinator.rows.firstIndex { $0.name == "DOCS" })
XCTAssertNil(coordinator.tableView(table, pasteboardWriterForRow: folderRow))
XCTAssertNil(coordinator.tableView(table, pasteboardWriterForRow: -1))
let provider = try XCTUnwrap(coordinator.tableView(table, pasteboardWriterForRow: fileRow) as? NSFilePromiseProvider)
weak var retainedDelegate = provider.userInfo as AnyObject?
let pasteboard = NSPasteboard.withUniqueName()
defer { pasteboard.clearContents(); pasteboard.releaseGlobally() }
XCTAssertTrue(pasteboard.writeObjects([provider]))
XCTAssertFalse(provider.writableTypes(for: pasteboard).isEmpty)
XCTAssertFalse(try XCTUnwrap(pasteboard.pasteboardItems).isEmpty)
// The working image can change after dragging. The promised bytes must
// still belong to the original dragged snapshot, independent of the UI.
let changed = try await store.change(.delete([coordinator.rows[fileRow]]), path: "")
XCTAssertFalse(changed.entries.contains { $0.name == "README.TXT" })
XCTAssertNotNil(retainedDelegate, "The provider must keep its snapshot delegate alive after serialization and subsequent edits")
let destination = folder.appendingPathComponent("Finder Drop", isDirectory: true)
try FileManager.default.createDirectory(at: destination, withIntermediateDirectories: false)
let exported = destination.appendingPathComponent("README.TXT")
let completed = expectation(description: "File promise fulfilled")
let delegate = try XCTUnwrap(provider.delegate)
// NSFilePromiseReceiver requires a genuine AppKit drag session. Exercise
// serialization above and the real asynchronous writer here; Finder's
// receiving side remains a separate desktop integration check.
delegate.filePromiseProvider(provider, writePromiseTo: exported) { error in
XCTAssertNil(error); completed.fulfill()
}
await fulfillment(of: [completed], timeout: 10)
XCTAssertEqual(try Data(contentsOf: exported), Data("VCC Plus authored Disk Image Editor fixture.\rDECB and OS-9 round trips preserve exact file bytes.\r".utf8))
XCTAssertEqual(try Data(contentsOf: source), original)
XCTAssertEqual(try Data(contentsOf: fixture), original)
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
@MainActor func testDiskFilePromiseRefusesSourceAliasesAndExistingDestinations() async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/OS9.dsk")
let original = try Data(contentsOf: fixture), source = folder.appendingPathComponent("original.dsk")
try original.write(to: source)
let alias = folder.appendingPathComponent("alias.dsk")
try FileManager.default.linkItem(at: source, to: alias)
let store = try DiskImageEditorStore(data: original)
let initialContents = try await store.contents(at: "")
let entry = try XCTUnwrap(initialContents.entries.first)
let machine = MachineModel(diskStore: DiskAssignmentStore(url: folder.appendingPathComponent("settings.json")))
for _ in 0..<500 { if !machine.busy && !machine.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
let provider = DiskEditorFilePromise.make(bytes: original, entry: entry, machine: machine, sourceURL: source)
let delegate = try XCTUnwrap(provider.delegate)
for destination in [source, alias] {
let error: Error? = await withCheckedContinuation { continuation in
delegate.filePromiseProvider(provider, writePromiseTo: destination) { continuation.resume(returning: $0) }
}
XCTAssertNotNil(error)
XCTAssertEqual(try Data(contentsOf: destination), original)
}
let destination = folder.appendingPathComponent("README.TXT"), unrelated = Data("Keep this later file.".utf8)
try unrelated.write(to: destination)
let error: Error? = await withCheckedContinuation { continuation in
delegate.filePromiseProvider(provider, writePromiseTo: destination) { continuation.resume(returning: $0) }
}
XCTAssertNotNil(error)
XCTAssertEqual(try Data(contentsOf: destination), unrelated)
XCTAssertEqual(try Data(contentsOf: source), original)
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
@MainActor private func finishMoveEditorWork(_ editor: DiskImageEditorModel) async throws {
for _ in 0..<500 {
if !editor.busy { return }
try await Task.sleep(nanoseconds: 10_000_000)
}
XCTFail("The disk editor did not finish its operation")
throw ProfileFailure.message("Disk editor test operation timed out")
}
@MainActor private func withMoveEditor(_ operation: @MainActor (MachineModel, DiskImageEditorModel, DiskImageEditorStore, URL) async throws -> Void) async throws {
let folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
defer { try? FileManager.default.removeItem(at: folder) }
let fixture = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/OS9.dsk")
let bytes = try Data(contentsOf: fixture), source = folder.appendingPathComponent("source.dsk")
try bytes.write(to: source)
let controller = VCCMachineController()
await setup(controller, cpu: false)
let mounted = await step { controller.mountDisk(bytes, drive: 0, name: "source.dsk", readOnly: false, completion: $0) }
XCTAssertNil(mounted.errorMessage)
let machine = MachineModel(diskStore: DiskAssignmentStore(url: folder.appendingPathComponent("settings.json")), controller: controller)
for _ in 0..<500 { if !machine.busy && !machine.diskSaving { break }; try await Task.sleep(nanoseconds: 20_000_000) }
let store = try DiskImageEditorStore(data: bytes)
let contents = try await store.change(.folder("DEST"), path: "")
let editor = DiskImageEditorModel(store: store, machine: machine, session: nil, sourceURL: source,
name: "source.dsk", original: bytes, contents: contents, sourceReadOnly: false)
let before = await step(controller.snapshot)
do {
try await operation(machine, editor, store, source)
XCTAssertEqual(try Data(contentsOf: source), bytes)
XCTAssertEqual(try Data(contentsOf: fixture), bytes)
let after = await step(controller.snapshot)
XCTAssertEqual(after.generation, before.generation); XCTAssertEqual(after.frames, before.frames)
let (mountedCopy, _) = await capture(controller)
XCTAssertEqual(mountedCopy?.data, bytes, "Private working edits cannot reach the mounted disk")
if let mountedCopy { _ = await step { controller.cancelDiskEditor(token: mountedCopy.token, completion: $0) } }
} catch {
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
throw error
}
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
@MainActor func testMoveModelRejectsForeignEditedUndoneAndNavigatedRequests() async throws {
try await withMoveEditor { machine, editor, store, source in
let originalWorking = editor.contents.bytes
let entry = try XCTUnwrap(editor.contents.entries.first { $0.name == "README.TXT" })
let request = try XCTUnwrap(editor.moveRequest(for: [entry]))
let otherStore = try DiskImageEditorStore(data: originalWorking)
let otherContents = try await otherStore.contents(at: "")
let other = DiskImageEditorModel(store: otherStore, machine: machine, session: nil, sourceURL: source,
name: "Same bytes, separate editor", original: originalWorking, contents: otherContents, sourceReadOnly: false)
XCTAssertFalse(other.moveSourceIsCurrent(request))
other.move(request, to: "DEST")
XCTAssertNotNil(other.error); XCTAssertEqual(other.contents.bytes, originalWorking)
editor.change(.folder("NEW")); try await self.finishMoveEditorWork(editor)
XCTAssertNil(editor.error); XCTAssertFalse(editor.moveSourceIsCurrent(request))
let edited = editor.contents.bytes
editor.move(request, to: "DEST")
XCTAssertNotNil(editor.error); XCTAssertEqual(editor.contents.bytes, edited)
editor.undo(); try await self.finishMoveEditorWork(editor)
XCTAssertNil(editor.error); XCTAssertEqual(editor.contents.bytes, originalWorking)
XCTAssertFalse(editor.moveSourceIsCurrent(request), "Undo must not resurrect an earlier request after an intervening edit")
let fresh = try XCTUnwrap(editor.moveRequest(for: [entry]))
editor.navigate("DEST"); try await self.finishMoveEditorWork(editor)
XCTAssertNil(editor.error); XCTAssertEqual(editor.path, "DEST")
XCTAssertFalse(editor.moveSourceIsCurrent(fresh))
do { _ = try await editor.moveDestination(fresh, path: ""); XCTFail("A request from another displayed source folder must be refused") } catch { }
editor.move(fresh, to: "")
XCTAssertNotNil(editor.error)
let retained = try await store.contents(at: "")
XCTAssertEqual(retained.bytes, originalWorking)
XCTAssertTrue(retained.entries.contains { $0.name == "README.TXT" })
}
}
@MainActor func testMoveModelCollisionStaleDestinationAndSuccessfulUndoRedo() async throws {
try await withMoveEditor { _, editor, store, source in
let host = source.deletingLastPathComponent().appendingPathComponent("SECOND.DAT")
let payload = Data("Second file moves in the same transaction.\r".utf8)
try payload.write(to: host)
editor.change(.importFiles([host], type: 3, ascii: true, replace: false)); try await self.finishMoveEditorWork(editor)
editor.change(.folder("BUSY")); try await self.finishMoveEditorWork(editor)
let collision = source.deletingLastPathComponent().appendingPathComponent("readme.txt")
try Data("Keep the destination's existing file.".utf8).write(to: collision)
_ = try await store.change(.importFiles([collision], type: 3, ascii: true, replace: false), path: "BUSY")
editor.refresh(); try await self.finishMoveEditorWork(editor)
let before = editor.contents.bytes
let files = editor.contents.entries.filter { !$0.directory }
XCTAssertEqual(files.count, 2)
let request = try XCTUnwrap(editor.moveRequest(for: files))
for destination in ["MISSING", "README.TXT", "BUSY"] {
editor.move(request, to: destination); try await self.finishMoveEditorWork(editor)
XCTAssertNotNil(editor.error); XCTAssertEqual(editor.contents.bytes, before)
let current = try await store.contents(at: "")
XCTAssertEqual(current.bytes, before, "An invalid destination or one collision must retain the entire batch")
}
let preview = try await editor.moveDestination(request, path: "DEST")
let changed = try await store.change(.folder("LATE"), path: "DEST")
editor.move(request, to: "DEST", expectedDestination: preview); try await self.finishMoveEditorWork(editor)
XCTAssertNotNil(editor.error)
let stillChanged = try await store.contents(at: "")
XCTAssertEqual(stillChanged.bytes, changed.bytes, "A stale destination preview cannot move either source file")
editor.refresh(); try await self.finishMoveEditorWork(editor)
let latest = editor.contents.bytes
let fresh = try XCTUnwrap(editor.moveRequest(for: editor.contents.entries.filter { !$0.directory }))
let freshDestination = try await editor.moveDestination(fresh, path: "DEST")
editor.move(fresh, to: "DEST", expectedDestination: freshDestination); try await self.finishMoveEditorWork(editor)
XCTAssertNil(editor.error); XCTAssertNotNil(editor.notice)
let moved = editor.contents.bytes
XCTAssertNotEqual(moved, latest)
XCTAssertFalse(editor.contents.entries.contains { !$0.directory })
let readback = try await store.read("DEST/SECOND.DAT"); XCTAssertEqual(readback, payload)
editor.undo(); try await self.finishMoveEditorWork(editor)
XCTAssertNil(editor.error); XCTAssertEqual(editor.contents.bytes, latest)
editor.redo(); try await self.finishMoveEditorWork(editor)
XCTAssertNil(editor.error); XCTAssertEqual(editor.contents.bytes, moved)
let final = try await store.contents(at: "DEST")
XCTAssertEqual(Set(final.entries.map(\.name)), ["LATE", "README.TXT", "SECOND.DAT"])
}
}
@MainActor func testOwnedMovePromiseAdvertisesPayloadBeforePasteboardSerialization() async throws {
try await withMoveEditor { machine, editor, _, source in
let entry = try XCTUnwrap(editor.contents.entries.first { $0.name == "README.TXT" })
let request = try XCTUnwrap(editor.moveRequest(for: [entry]))
let payload = try JSONEncoder().encode(DiskEditorDragPayload(request))
let ownedType = NSPasteboard.PasteboardType("com.brianholman.vccplus.disk-editor-files")
let pasteboard = NSPasteboard.withUniqueName()
defer { pasteboard.clearContents(); pasteboard.releaseGlobally() }
let plain = DiskEditorFilePromise.make(bytes: editor.contents.bytes, entry: entry, machine: machine, sourceURL: source)
// Construct the actual owned subtype, including its designated
// initializer, before any dragging callback could add a type.
let provider = DiskEditorFilePromise.make(bytes: editor.contents.bytes, entry: entry, machine: machine,
sourceURL: source, movePayload: payload)
weak var delegate = provider.userInfo as AnyObject?
let standardTypes = Set(plain.writableTypes(for: pasteboard))
let ownedTypes = Set(provider.writableTypes(for: pasteboard))
XCTAssertFalse(standardTypes.isEmpty)
XCTAssertFalse(standardTypes.contains(ownedType))
XCTAssertTrue(ownedTypes.isSuperset(of: standardTypes), "Local move identity must retain all ordinary file-promise types")
XCTAssertTrue(ownedTypes.contains(ownedType))
XCTAssertEqual(provider.pasteboardPropertyList(forType: ownedType) as? Data, payload)
XCTAssertEqual(provider.writingOptions(forType: ownedType, pasteboard: pasteboard), [])
for type in standardTypes {
XCTAssertEqual(provider.writingOptions(forType: type, pasteboard: pasteboard), plain.writingOptions(forType: type, pasteboard: pasteboard))
}
XCTAssertTrue(pasteboard.writeObjects([provider]))
XCTAssertEqual(pasteboard.data(forType: ownedType), payload)
let serialized = try XCTUnwrap(pasteboard.pasteboardItems?.first)
XCTAssertTrue(Set(serialized.types).isSuperset(of: standardTypes))
XCTAssertEqual(serialized.data(forType: ownedType), payload)
XCTAssertNotNil(delegate, "The payload provider retains its immutable export delegate through userInfo")
XCTAssertTrue((provider.delegate as AnyObject?) === delegate)
XCTAssertEqual(provider.delegate?.filePromiseProvider(provider, fileNameForType: provider.fileType), "README.TXT")
}
}
@MainActor func testConcurrentFilePromisesPreserveExistingDestinationAndCompleteRemainingExports() async throws {
try await withMoveEditor { machine, editor, store, source in
let entry = try XCTUnwrap(editor.contents.entries.first { $0.name == "README.TXT" })
let snapshot = editor.contents.bytes
let count = 25 // 24 new exports plus one existing-destination refusal.
let providers = (0..<count).map { _ in
DiskEditorFilePromise.make(bytes: snapshot, entry: entry, machine: machine, sourceURL: source)
}
let output = source.deletingLastPathComponent().appendingPathComponent("Concurrent Promises", isDirectory: true)
try FileManager.default.createDirectory(at: output, withIntermediateDirectories: false)
let collisionIndex = 7, existing = Data("Preserve this file created before the promise was fulfilled.".utf8)
try existing.write(to: output.appendingPathComponent("export-\(collisionIndex).txt"))
// Every independent drag item owns the original immutable bytes,
// even after the editor's live working image loses that file.
_ = try await store.change(.delete([entry]), path: "")
let completed = expectation(description: "All independent file promises complete")
completed.expectedFulfillmentCount = count
completed.assertForOverFulfill = true
let callers = OperationQueue()
callers.maxConcurrentOperationCount = count
for (index, provider) in providers.enumerated() {
let delegate = try XCTUnwrap(provider.delegate)
let destination = output.appendingPathComponent("export-\(index).txt")
// Submit all delegates independently, as a multi-row drag may
// do. Awaiting each export here would hide busy-guard races.
callers.addOperation {
delegate.filePromiseProvider(provider, writePromiseTo: destination) { error in
if index == collisionIndex { XCTAssertNotNil(error, "A queued promise cannot overwrite an existing file") }
else { XCTAssertNil(error, "Independent promise \(index) must finish without a shared-machine busy refusal") }
completed.fulfill()
}
}
}
await fulfillment(of: [completed], timeout: 20)
let expected = Data("VCC Plus authored Disk Image Editor fixture.\rDECB and OS-9 round trips preserve exact file bytes.\r".utf8)
for index in 0..<count {
XCTAssertEqual(try Data(contentsOf: output.appendingPathComponent("export-\(index).txt")), index == collisionIndex ? existing : expected)
}
XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: output.path).count, count)
// A later job must remain usable even if the collision happened to
// be last in the concurrent arrival order.
let followup = DiskEditorFilePromise.make(bytes: snapshot, entry: entry, machine: machine, sourceURL: source)
let followupDelegate = try XCTUnwrap(followup.delegate)
let followupURL = output.appendingPathComponent("after-failure.txt")
let recovered = expectation(description: "Promise queue remains usable after a failed job")
followupDelegate.filePromiseProvider(followup, writePromiseTo: followupURL) { error in
XCTAssertNil(error); recovered.fulfill()
}
await fulfillment(of: [recovered], timeout: 10)
XCTAssertEqual(try Data(contentsOf: followupURL), expected)
XCTAssertFalse(machine.busy, "The final promised export must release the machine's media guard")
XCTAssertFalse(machine.diskSaving)
withExtendedLifetime(providers) { }
}
}
@MainActor func testCompanionDiskCopyPreservesGuestStateDirtyBytesAndSaveTokenOnBothCPUs() async throws {
for cpu in [false, true] {
let controller = VCCMachineController()
await setup(controller, cpu: cpu)
let (captured, _) = await capture(controller)
let edit = try XCTUnwrap(captured)
var edited = original; edited[1000] = 0x6d
let valid = await prepare(controller, edit.token, edited); XCTAssertTrue(valid.0)
let applied = await commit(controller, edit.token, confirmed: true, saved: false); XCTAssertTrue(applied.0)
let (exported, token, before): (Data?, UInt64, VCCMachineSnapshot) = await withCheckedContinuation { continuation in
controller.exportDisk(inDrive: 0) { continuation.resume(returning: ($0, $1, $2)) }
}
XCTAssertEqual(exported, edited); XCTAssertTrue(before.disks[0].dirty)
let (copied, after): (Data?, VCCMachineSnapshot) = await withCheckedContinuation { continuation in
controller.snapshotDiskCopy(inDrive: 0) { continuation.resume(returning: ($0, $1)) }
}
XCTAssertEqual(copied, edited); XCTAssertTrue(after.disks[0].dirty)
XCTAssertEqual(after.generation, before.generation); XCTAssertEqual(after.frames, before.frames)
XCTAssertEqual(after.state, before.state); XCTAssertFalse(after.diskEditorLocked)
let acknowledged = await step { controller.markDiskSaved(inDrive: 0, token: token, name: "fixture.dsk", completion: $0) }
XCTAssertNil(acknowledged.errorMessage); XCTAssertFalse(acknowledged.disks[0].dirty, "Copy must not consume or replace an existing export token")
let running = await step(controller.resume)
let (liveCopy, live): (Data?, VCCMachineSnapshot) = await withCheckedContinuation { continuation in
controller.snapshotDiskCopy(inDrive: 0) { continuation.resume(returning: ($0, $1)) }
}
XCTAssertEqual(liveCopy, edited); XCTAssertEqual(live.state, .running)
XCTAssertEqual(live.generation, running.generation); XCTAssertFalse(live.diskEditorLocked)
_ = await step(controller.shutdown)
let protected = VCCMachineController(); await setup(protected, cpu: cpu, readOnly: true)
let (readOnlyCopy, protectedState): (Data?, VCCMachineSnapshot) = await withCheckedContinuation { continuation in
protected.snapshotDiskCopy(inDrive: 0) { continuation.resume(returning: ($0, $1)) }
}
XCTAssertEqual(readOnlyCopy, original); XCTAssertNil(protectedState.errorMessage)
XCTAssertFalse(protectedState.disks[0].dirty)
_ = await step(protected.shutdown)
}
}
}
/// The shared editor must use the supplied application's media policy rather
/// than reaching back into the emulator model through a hidden singleton.
@MainActor
private final class CompanionEditorFixtureHost: DiskEditorHost {
struct Export {
let data: Data, destination: URL, source: URL?, expected: Data?
let requireNew: Bool, promised: Bool
}
var exports: [Export] = []
func beginDiskEditor(inDrive drive: Int) async throws -> DiskEditorSession { throw DiskEditorFailure.message("Not mounted") }
func cancelDiskEditor(_ session: DiskEditorSession) async throws { }
func applyDiskEditor(_ session: DiskEditorSession, data: Data, restartConfirmed: Bool) async throws { throw DiskEditorFailure.message("Not mounted") }
func saveDiskEditorExport(_ data: Data, to url: URL, protecting sourceURL: URL?, replacing expected: Data?, requireNew: Bool) async throws {
exports.append(Export(data: data, destination: url, source: sourceURL, expected: expected, requireNew: requireNew, promised: false))
}
func savePromisedDiskEditorExport(_ data: Data, to url: URL, protecting sourceURL: URL?) async throws {
exports.append(Export(data: data, destination: url, source: sourceURL, expected: nil, requireNew: true, promised: true))
}
func saveOfflineDiskEditor(_ data: Data, to url: URL, replacing original: Data) async throws { throw DiskEditorFailure.message("Not mounted") }
func mountedEditorDrive(for url: URL) -> Int? { nil }
func diskEditorSourceIsAssigned(_ url: URL) -> Bool { false }
func diskEditorPresentation(for session: DiskEditorSession?) -> DiskEditorPresentation {
.init(context: "DW2 · Guest stopped", applyHint: "Restart the real CoCo before resuming.",
applyButtonTitle: "Apply to DW2…", applyConfirmationTitle: "Apply the edited image?",
applyConfirmationMessage: "The DriveWire host owns this disk.", applyConfirmationAction: "Apply",
closeNotice: "The DriveWire host remains disconnected.")
}
}
final class SharedDiskEditorHostTests: XCTestCase {
private var fixture: URL {
URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/DiskEditor/OS9.dsk")
}
@MainActor func testSharedEditorSavesThroughHostPolicyWithSourceAndExpectedBytes() async throws {
let original = try Data(contentsOf: fixture)
let store = try DiskImageEditorStore(data: original)
let contents = try await store.change(.folder("DOCS"), path: "")
let host = CompanionEditorFixtureHost()
let editor = DiskImageEditorModel(store: store, machine: host, session: nil, sourceURL: fixture,
name: "OS9.dsk", original: original, contents: contents, sourceReadOnly: false)
XCTAssertEqual(editor.presentation.applyButtonTitle, "Apply to DW2…")
let destination = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString + ".dsk")
let prior = Data("Previously saved image".utf8)
try await editor.saveCopy(to: destination, replacing: prior)
let replaced = try XCTUnwrap(host.exports.first)
XCTAssertEqual(replaced.data, contents.bytes); XCTAssertNotEqual(replaced.data, original)
XCTAssertEqual(replaced.destination, destination); XCTAssertEqual(replaced.source, fixture)
XCTAssertEqual(replaced.expected, prior); XCTAssertFalse(replaced.requireNew); XCTAssertFalse(replaced.promised)
try await editor.saveCopy(to: destination, replacing: nil)
XCTAssertTrue(try XCTUnwrap(host.exports.last).requireNew)
XCTAssertEqual(try Data(contentsOf: fixture), original)
XCTAssertFalse(FileManager.default.fileExists(atPath: destination.path), "Only the supplied host may perform the final write")
}
@MainActor func testSharedFilePromiseExportsItsSnapshotThroughCompanionHost() async throws {
let original = try Data(contentsOf: fixture), store = try DiskImageEditorStore(data: original)
let contents = try await store.contents(at: "")
let entry = try XCTUnwrap(contents.entries.first { $0.name == "README.TXT" })
let expected = try await store.read(entry.path)
let host = CompanionEditorFixtureHost()
let promise = DiskEditorFilePromise.make(bytes: original, entry: entry, machine: host, sourceURL: fixture)
_ = try await store.change(.delete([entry]), path: "")
let destination = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
let done = expectation(description: "Shared promise reached companion host")
try XCTUnwrap(promise.delegate).filePromiseProvider(promise, writePromiseTo: destination) { error in
XCTAssertNil(error); done.fulfill()
}
await fulfillment(of: [done], timeout: 10)
let exported = try XCTUnwrap(host.exports.first)
XCTAssertEqual(exported.data, expected); XCTAssertEqual(exported.source, fixture)
XCTAssertEqual(exported.destination, destination); XCTAssertTrue(exported.promised); XCTAssertTrue(exported.requireNew)
XCTAssertEqual(try Data(contentsOf: fixture), original)
}
}