// SPDX-License-Identifier: GPL-3.0-or-later import XCTest import SwiftUI import AppKit private actor SaveGate { private var release: CheckedContinuation? private(set) var started = false func wait() async { started = true; await withCheckedContinuation { release = $0 } } func open() { release?.resume(); release = nil } } final class DiskAutosaveTests: XCTestCase { private struct Fixture { let folder: URL, disk: URL, store: DiskAssignmentStore let original = Data(repeating: 0, count: 161280) init(temporary: Bool = false, protected: Bool = false) throws { folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true) disk = folder.appendingPathComponent("Autosave é.DSK") try original.write(to: disk) let rom = folder.appendingPathComponent("authored.rom") try Data(repeating: 0, count: 8192).write(to: rom) store = DiskAssignmentStore(url: folder.appendingPathComponent("settings.json")) var settings = DiskAssignments(); settings.rom = rom settings.drives[0] = .init(url: disk, writeProtected: protected, temporary: temporary) try store.save(settings) } func remove() { try? FileManager.default.removeItem(at: folder) } } // Authored code shared by both CPU engines: fill sector 1, commit, then loop. private func writerROM(_ value: UInt8 = 0x5a, repeating: Bool = false) -> Data { var program: [UInt8] = [0x86,0x29,0xb7,0xff,0x40,0x86,1,0xb7,0xff,0x4a, 0x86,0xa0,0xb7,0xff,0x48,0x8e,1,0,0x86,value, 0xb7,0xff,0x4b,0x30,0x1f,0x26,0xf9,0xb7,0xff,0x4b,0x20,0xfe] if repeating { program.removeLast(2) // Idle between writes so the controller can capture complete sectors. program += [0x8e,0x40,0x00,0x30,0x1f,0x26,0xfc] let back = UInt8(bitPattern: Int8(-(program.count + 2))) program += [0x20, back] } var rom = Data(repeating: 0, count: 32768); rom.replaceSubrange(0.. Void) -> Void) async -> VCCMachineSnapshot { await withCheckedContinuation { continuation in action { continuation.resume(returning: $0) } } } @MainActor private func until(_ condition: () -> Bool) async throws { for _ in 0..<500 { if condition() { return } try await Task.sleep(nanoseconds: 20_000_000) } XCTFail("Timed out waiting for disk saving") throw NSError(domain: "TestTimeout", code: 1) } @MainActor private func settled(_ model: MachineModel) async throws { try await until { !model.busy && !model.diskSaving } } @MainActor private func close(_ model: MachineModel) async { await withCheckedContinuation { continuation in model.shutdown { continuation.resume() } } } @MainActor private func runWriter(_ controller: VCCMachineController, use6309: Bool = false, value: UInt8 = 0x5a) async { let s = await step { controller.loadROM(writerROM(value), use6309: use6309, completion: $0) } XCTAssertNil(s.errorMessage) _ = await step(controller.resume) } func testAutomaticFileWriteRejectsConflictsMissingAndReadOnlyFiles() throws { let f = try Fixture(); defer { f.remove() } let changed = Data(repeating: 0x5a, count: 161280) try DiskFiles.saveAutomatically(changed, to: f.disk, expected: f.original) XCTAssertEqual(try Data(contentsOf: f.disk), changed) XCTAssertThrowsError(try DiskFiles.saveAutomatically(f.original, to: f.disk, expected: f.original)) XCTAssertEqual(try Data(contentsOf: f.disk), changed) try FileManager.default.setAttributes([.posixPermissions: 0o444], ofItemAtPath: f.disk.path) XCTAssertThrowsError(try DiskFiles.saveAutomatically(f.original, to: f.disk, expected: changed)) XCTAssertEqual(try Data(contentsOf: f.disk), changed) try FileManager.default.removeItem(at: f.disk) XCTAssertThrowsError(try DiskFiles.saveAutomatically(changed, to: f.disk, expected: changed)) XCTAssertFalse(FileManager.default.fileExists(atPath: f.disk.path)) let target = f.folder.appendingPathComponent("image-without-extension") try f.original.write(to: target) try FileManager.default.createSymbolicLink(at: f.disk, withDestinationURL: target) try DiskFiles.saveAutomatically(changed, to: f.disk.resolvingSymlinksInPath(), expected: f.original) XCTAssertEqual(try Data(contentsOf: target), changed) XCTAssertEqual(try FileManager.default.destinationOfSymbolicLink(atPath: f.disk.path), target.path) } func testOlderSettingsDefaultToAutomaticSaving() throws { let f = try Fixture(temporary: true); defer { f.remove() } var json = try XCTUnwrap(JSONSerialization.jsonObject(with: Data(contentsOf: f.store.url)) as? [String: Any]) var drives = try XCTUnwrap(json["drives"] as? [Any]) var first = try XCTUnwrap(drives[0] as? [String: Any]); first.removeValue(forKey: "temporary") drives[0] = first; json["drives"] = drives try JSONSerialization.data(withJSONObject: json).write(to: f.store.url) XCTAssertFalse(try XCTUnwrap(f.store.load().drives[0]).temporary) } @MainActor func testGuestWritesSaveWithoutPausingOnBothCPUs() async throws { for (cpu, mpi) in [(false, false), (true, false), (false, true), (true, true)] { let f = try Fixture(); defer { f.remove() } if mpi { var settings = try f.store.load(); var layout = CartridgeAssignments() layout.multiPak = true; layout.mpiConfigured = true; layout.slots[4].kind = .floppy settings.cartridges = layout; try f.store.save(settings) } let controller = VCCMachineController(); let model = MachineModel(diskStore: f.store, controller: controller) do { try await settled(model); await runWriter(controller, use6309: cpu) try await until { (try? Data(contentsOf: f.disk).first) == 0x5a && !model.diskSaving && !model.disks[0].dirty } XCTAssertEqual(model.state, .running); XCTAssertTrue(model.diskSaveErrors.isEmpty) let bytes = try Data(contentsOf: f.disk) XCTAssertEqual(bytes.prefix(256), Data(repeating: 0x5a, count: 256)) XCTAssertEqual(bytes.dropFirst(256), f.original.dropFirst(256)) } catch { await close(model); throw error } await close(model) let reopened = MachineModel(diskStore: f.store) try await settled(reopened); XCTAssertTrue(reopened.disks[0].mounted); XCTAssertFalse(reopened.disks[0].dirty) await close(reopened) } } @MainActor func testTemporaryModeAndProtectionKeepSourceUnchanged() async throws { for protected in [false, true] { let f = try Fixture(temporary: !protected, protected: protected); defer { f.remove() } let controller = VCCMachineController(); let model = MachineModel(diskStore: f.store, controller: controller) do { try await settled(model); XCTAssertEqual(model.diskTemporary[0], !protected) await runWriter(controller) try await until { model.frames > 20 } await withCheckedContinuation { continuation in model.prepareToQuit { continuation.resume() } } XCTAssertEqual(try Data(contentsOf: f.disk), f.original) XCTAssertEqual(model.disks[0].dirty, !protected) XCTAssertEqual(model.unsavedMedia, !protected) XCTAssertEqual(model.needsMediaAttention, !protected, "Temporary changes must still need attention") if !protected { model.setDiskTemporary(0, false); try await settled(model) XCTAssertFalse(try XCTUnwrap(f.store.load().drives[0]).temporary) await withCheckedContinuation { continuation in model.prepareToQuit { continuation.resume() } } XCTAssertFalse(model.unsavedMedia); XCTAssertEqual(try Data(contentsOf: f.disk).first, 0x5a) } } catch { await close(model); throw error } await close(model) } } @MainActor func testExternalEditPausesAndRetainsChangesUntilRetry() async throws { let f = try Fixture(); defer { f.remove() } let controller = VCCMachineController(); let model = MachineModel(diskStore: f.store, controller: controller) do { try await settled(model) let external = Data(repeating: 7, count: 161280); try external.write(to: f.disk) await runWriter(controller) try await until { model.diskSaveErrors[0] != nil && !model.diskSaving } XCTAssertEqual(model.state, .paused); XCTAssertTrue(model.disks[0].dirty) XCTAssertTrue(model.needsMediaAttention, "Real autosave failures must remain visible") XCTAssertEqual(try Data(contentsOf: f.disk), external) await withCheckedContinuation { continuation in model.prepareToQuit { continuation.resume() } } XCTAssertTrue(model.unsavedMedia); XCTAssertEqual(try Data(contentsOf: f.disk), external) try f.original.write(to: f.disk) model.retryDiskSave(0) try await until { !model.diskSaving && !model.disks[0].dirty } XCTAssertTrue(model.diskSaveErrors.isEmpty); XCTAssertEqual(try Data(contentsOf: f.disk).first, 0x5a) XCTAssertFalse(model.needsMediaAttention) } catch { await close(model); throw error } await close(model) } @MainActor func testRepeatedWritesKeepAttentionAndNativeDisplayStable() async throws { let f = try Fixture(); defer { f.remove() } var assignments = try f.store.load() var layout = CartridgeAssignments(); layout.multiPak = true; layout.mpiConfigured = true layout.slots[4].kind = .floppy; assignments.cartridges = layout; try f.store.save(assignments) let suite = "VCCRepeatedWrites-" + UUID().uuidString let defaults = UserDefaults(suiteName: suite)! defer { defaults.removePersistentDomain(forName: suite) } let controller = VCCMachineController(), gate = SaveGate() let model = MachineModel(diskStore: f.store, controller: controller, displayDefaults: defaults, inputStore: .init(url: f.folder.appendingPathComponent("input.json")), automaticDiskWriter: { data, url, expected in if !(await gate.started) { await gate.wait() } try DiskFiles.saveAutomatically(data, to: url, expected: expected) }) let presentation = PresentationSettings(defaults: defaults) let host = NSHostingView(rootView: MachineView(machine: model, presentation: presentation, showManualHome: {})) let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 1100, height: 820), styleMask: [.titled, .resizable], backing: .buffered, defer: false) window.isReleasedWhenClosed = false; window.contentView = host defer { window.close() } func display(_ view: NSView) -> KeyboardDisplay? { if let result = view as? KeyboardDisplay { return result } return view.subviews.lazy.compactMap { display($0) }.first } do { try await settled(model) XCTAssertFalse(model.hardware.custom, "System checks must use the illustrated layout, not its conventional fallback") _ = await step { controller.loadROM(writerROM(repeating: true), use6309: false, completion: $0) } for mode in [PresentationSettings.Mode.display, .system] { presentation.mode = mode try await Task.sleep(nanoseconds: 100_000_000); host.layoutSubtreeIfNeeded() let screen = try XCTUnwrap(display(host)) let original = screen.convert(screen.bounds, to: host) _ = await step(controller.resume) for _ in 0..<500 { if await gate.started { break }; try await Task.sleep(nanoseconds: 10_000_000) } let started = await gate.started; XCTAssertTrue(started) let before = await step(controller.snapshot) for _ in 0..<30 { model.poll(); try await Task.sleep(nanoseconds: 20_000_000) host.layoutSubtreeIfNeeded() XCTAssertTrue(model.unsavedMedia, "Quit protection must include pending host writes") XCTAssertFalse(model.needsMediaAttention, "Normal repeated saves must not toggle a warning row") XCTAssertEqual(screen.convert(screen.bounds, to: host), original, "Disk activity must not resize the live display") } let after = await step(controller.snapshot) XCTAssertGreaterThan(after.frames, before.frames) XCTAssertGreaterThan(after.disks[0].writeEvents, before.disks[0].writeEvents) XCTAssertEqual(after.generation, before.generation) _ = await step(controller.pause) } await gate.open() await withCheckedContinuation { done in model.prepareToQuit { done.resume() } } XCTAssertFalse(model.unsavedMedia); XCTAssertFalse(model.needsMediaAttention) XCTAssertEqual(try Data(contentsOf: f.disk).prefix(256), Data(repeating: 0x5a, count: 256)) } catch { await gate.open(); await close(model); throw error } await close(model) } @MainActor func testQuitWaitsForPendingSaveAndFlushesNewerGuestWrites() async throws { let f = try Fixture(); defer { f.remove() } let controller = VCCMachineController(); let gate = SaveGate() let model = MachineModel(diskStore: f.store, controller: controller, automaticDiskWriter: { data, url, expected in if !(await gate.started) { await gate.wait() } try DiskFiles.saveAutomatically(data, to: url, expected: expected) }) do { try await settled(model); await runWriter(controller) for _ in 0..<500 { if await gate.started { break } try await Task.sleep(nanoseconds: 20_000_000) } let started = await gate.started; XCTAssertTrue(started); XCTAssertTrue(model.diskSaving) XCTAssertEqual(try Data(contentsOf: f.disk), f.original) // Write a newer version while the first snapshot's host write waits. await runWriter(controller, value: 0x6b) let start = await step(controller.snapshot) for _ in 0..<100 { let s = await step(controller.snapshot) if s.frames > start.frames + 2 { break } try await Task.sleep(nanoseconds: 20_000_000) } var quitReady = false model.prepareToQuit { quitReady = true } try await Task.sleep(nanoseconds: 50_000_000) XCTAssertFalse(quitReady, "Quit must wait for outstanding file I/O") await gate.open() try await until { quitReady } XCTAssertFalse(model.unsavedMedia); XCTAssertEqual(model.state, .paused) XCTAssertEqual(try Data(contentsOf: f.disk).prefix(256), Data(repeating: 0x6b, count: 256)) } catch { await gate.open(); await close(model); throw error } await close(model) } }