// 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..