// SPDX-License-Identifier: GPL-3.0-or-later import XCTest import AppKit private actor HardSaveGate { private var continuation: CheckedContinuation? private(set) var started = false func wait() async { started = true; await withCheckedContinuation { continuation = $0 } } func open() { continuation?.resume(); continuation = nil } } final class HardDiskTests: XCTestCase { private struct Fixture { let folder: URL, image: URL, second: URL, store: DiskAssignmentStore let original = Data(repeating: 0x11, count: 4096) init(temporary: Bool = false, protected: Bool = false) throws { folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true) image = folder.appendingPathComponent("Hard disk é.VHD"); second = folder.appendingPathComponent("Second.os9") store = DiskAssignmentStore(url: folder.appendingPathComponent("settings.json")) try original.write(to: image); try Data(repeating: 0x22, count: 8192).write(to: second) var settings = DiskAssignments(); var layout = CartridgeAssignments(); var disks = HardDiskAssignments() layout.multiPak = true; layout.mpiConfigured = true; layout.slots[1].kind = .hardDisk disks.drives[0] = .init(url: image, writeProtected: protected, temporary: temporary) disks.drives[1] = .init(url: second, writeProtected: true) settings.cartridges = layout; settings.hardDisks = disks; try store.save(settings) } func remove() { try? FileManager.default.removeItem(at: folder) } } @MainActor private func until(_ condition: () -> Bool) async throws { for _ in 0..<1000 { if condition() { return }; try await Task.sleep(nanoseconds: 10_000_000) } XCTFail("Hard disk operation timed out"); 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 { c in model.shutdown { c.resume() } } } @MainActor private func step(_ action: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot { await withCheckedContinuation { c in action { c.resume(returning: $0) } } } private func writerROM(_ value: UInt8 = 0x5a) -> Data { let code: [UInt8] = [0x8e,2,0,0x86,value,0xa7,0x80,0x8c,3,0,0x26,0xf9, 0x86,2,0xb7,0xff,0x84,0x86,0,0xb7,0xff,0x85,0xb7,0xff,0x82, 0x86,1,0xb7,0xff,0x83,0x86,2,0xb7,0xff,0x83,0x20,0xfe] var rom = Data(repeating: 0, count: 32768); rom.replaceSubrange(0.. 15 } await withCheckedContinuation { c in model.prepareToQuit { c.resume() } } XCTAssertEqual(try Data(contentsOf: f.image), f.original) XCTAssertEqual(model.hardDisks[0].dirty, mode == 1) XCTAssertEqual(model.needsMediaAttention, mode == 1) if mode == 1 { model.setHardTemporary(0, false); try await settled(model) await withCheckedContinuation { c in model.prepareToQuit { c.resume() } } XCTAssertFalse(model.unsavedMedia); XCTAssertEqual(try Data(contentsOf: f.image).first, 0x5a) } } } catch { await close(model); throw error } await close(model) } } } @MainActor func testPersistenceMissingMediaCreationAndSettings() async throws { let f = try Fixture(temporary: true); defer { f.remove() } let model = MachineModel(diskStore: f.store) do { try await settled(model); XCTAssertTrue(model.hardDiskConnected); XCTAssertTrue(model.hardTemporary[0]) model.setHardClock(enabled: false, readOnly: false); try await settled(model) XCTAssertFalse(try XCTUnwrap(f.store.load().hardDisks).clockEnabled) } catch { await close(model); throw error }; await close(model) try FileManager.default.moveItem(at: f.image, to: f.folder.appendingPathComponent("held.vhd")) let restored = MachineModel(diskStore: f.store) do { try await settled(restored); XCTAssertNotNil(restored.hardRestoreErrors[0]); XCTAssertTrue(restored.hardDisks[1].mounted) XCTAssertFalse(restored.hardSettings.clockEnabled); XCTAssertFalse(restored.hardSettings.clockReadOnly) try FileManager.default.moveItem(at: f.folder.appendingPathComponent("held.vhd"), to: f.image) restored.retryHardDisks(); try await settled(restored) XCTAssertTrue(restored.hardRestoreErrors.isEmpty); XCTAssertTrue(restored.hardDisks[0].mounted) restored.ejectHardDisk(0); try await settled(restored) restored.createHardDisk(0, sizeKiB: 8); try await settled(restored); XCTAssertTrue(restored.hardDisks[0].dirty) let exported = f.folder.appendingPathComponent("New image.VHD") restored.exportHardDisk(0, to: exported); try await settled(restored) XCTAssertFalse(restored.hardDisks[0].dirty); XCTAssertEqual(try Data(contentsOf: exported).count,8192) XCTAssertEqual(try f.store.load().hardDisks?.drives[0]?.url, exported) restored.setMultiPak(false); try await settled(restored) XCTAssertFalse(restored.hardDiskConnected); XCTAssertTrue(restored.hardDisks[0].mounted) } catch { await close(restored); throw error }; await close(restored) let reopened = MachineModel(diskStore: f.store) try await settled(reopened); XCTAssertEqual(reopened.hardDisks[0].byteCount,8192); XCTAssertFalse(reopened.hardDiskConnected) await close(reopened) var invalid = try f.store.load(); invalid.hardDisks?.drives.removeLast(); XCTAssertThrowsError(try f.store.save(invalid)) invalid = try f.store.load(); invalid.cartridges?.slots[2].kind = .hardDisk; XCTAssertThrowsError(try f.store.save(invalid)) } @MainActor func testExternalEditFailurePausesAndCanRetry() 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: 4096); try external.write(to: f.image) await run(controller) try await until { model.hardSaveErrors[0] != nil && !model.diskSaving } XCTAssertEqual(model.state,.paused); XCTAssertTrue(model.hardDisks[0].dirty) XCTAssertTrue(model.needsMediaAttention) XCTAssertEqual(try Data(contentsOf: f.image),external) await withCheckedContinuation { c in model.prepareToQuit { c.resume() } }; XCTAssertTrue(model.unsavedMedia) try f.original.write(to: f.image); model.retryHardSave(0) try await until { !model.hardDisks[0].dirty && !model.diskSaving } XCTAssertTrue(model.hardSaveErrors.isEmpty) } catch { await close(model); throw error }; await close(model) } @MainActor func testQuitDrainsPendingSaveWithoutLosingNewerSectors() async throws { let f = try Fixture(); defer { f.remove() } let gate = HardSaveGate(); let controller = VCCMachineController() let model = MachineModel(diskStore: f.store, controller: controller, automaticHardDiskWriter: { patches, length, url, expected in if !(await gate.started) { await gate.wait() } return try HardDiskFiles.saveAutomatically(patches, length: length, to: url, expected: expected) }) do { try await settled(model); await run(controller) for _ in 0..<1000 { if await gate.started { break }; try await Task.sleep(nanoseconds: 10_000_000) } let started = await gate.started; XCTAssertTrue(started); XCTAssertTrue(model.diskSaving) XCTAssertTrue(model.unsavedMedia); XCTAssertFalse(model.needsMediaAttention) await run(controller,value:0x6b) for _ in 0..<20 { _ = await step(controller.snapshot); try await Task.sleep(nanoseconds: 5_000_000) } var quitReady = false; model.prepareToQuit { quitReady = true } try await Task.sleep(nanoseconds: 50_000_000); XCTAssertFalse(quitReady) await gate.open(); try await until { quitReady } XCTAssertFalse(model.unsavedMedia); XCTAssertEqual(try Data(contentsOf: f.image).prefix(256),Data(repeating:0x6b,count:256)) } catch { await gate.open(); await close(model); throw error }; await close(model) } @MainActor func testOldSaveAcknowledgementCannotClearReplacementImage() async { let c = VCCMachineController() _ = await step { c.createHardDisk(inDrive: 0, size: 1024, completion: $0) } let (saved, _): (VCCHardDiskSave?,VCCMachineSnapshot) = await withCheckedContinuation { done in c.captureHardDisk(inDrive: 0, full: true) { done.resume(returning:($0,$1)) } } _ = await step { c.hardDiskAction(1, drive:0, completion:$0) } _ = await step { c.createHardDisk(inDrive:0,size:1024,completion:$0) } let result = await step { c.acknowledgeHardDisk(inDrive:0,token:saved!.token,name:nil,completion:$0) } XCTAssertTrue(result.hardDisks[0].dirty); _ = await step(c.shutdown) } } /// Full-image snapshots must retain the selected filesystem, including when a /// Finder promise is fulfilled after a different volume was selected. final class DiskEditorVolumeStoreTests: XCTestCase { private func fixture(_ name: String) throws -> Data { try Data(contentsOf: URL(fileURLWithPath: #filePath).deletingLastPathComponent() .appendingPathComponent("Fixtures/DiskEditor/\(name).dsk")) } func testNumberedVolumesSwitchMergeRollbackAndSnapshotReader() async throws { let first = try fixture("DECB") let opaque = Data(repeating: 0xA5, count: first.count) let tail = Data(repeating: 0x5A, count: 256) let original = first + opaque + first + tail let store = try DiskImageEditorStore(data: original) let initial = try await store.contents(at: "") XCTAssertEqual(initial.volumes.count, 2) XCTAssertTrue(initial.volumes[1].name.contains("2"), "Skipped slots retain their disk number") let secondID = initial.volumes[1].id let selected = try await store.selectVolume(secondID) XCTAssertEqual(selected.bytes, original) let changed = try await store.change(.rename("README.TXT", "SECOND.TXT"), path: "") XCTAssertEqual(changed.bytes.prefix(first.count * 2), original.prefix(first.count * 2)) XCTAssertEqual(changed.bytes.suffix(256), tail) XCTAssertTrue(changed.entries.contains { $0.name == "SECOND.TXT" }) let frozen = try DiskImageEditorStore(data: changed.bytes, selectedVolumeID: secondID) let frozenBytes = try await frozen.read("SECOND.TXT") XCTAssertFalse(frozenBytes.isEmpty) let switched = try await store.selectVolume(initial.volumeID) XCTAssertTrue(switched.entries.contains { $0.name == "README.TXT" }) XCTAssertFalse(switched.entries.contains { $0.name == "SECOND.TXT" }) let readAfterSwitch = try await frozen.read("SECOND.TXT") XCTAssertEqual(readAfterSwitch, frozenBytes) let restored = try await store.restore(original, path: "") XCTAssertEqual(restored.bytes, original) let secondRestored = try await store.selectVolume(secondID) XCTAssertTrue(secondRestored.entries.contains { $0.name == "README.TXT" }) do { _ = try await store.selectVolume("decb:999:161280"); XCTFail("Foreign volume must be refused") } catch { } let afterRefusal = try await store.contents(at: "") XCTAssertEqual(afterRefusal.volumeID, secondID) XCTAssertEqual(afterRefusal.bytes, original) } func testCombinedOS9AndHDBEditsPreserveOtherFilesystemAndOpaqueTail() async throws { let os9 = try fixture("OS9"), decb = try fixture("DECB") let tail = Data(repeating: 0xA7, count: 512) let original = os9 + decb + tail let store = try DiskImageEditorStore(data: original) let initial = try await store.contents(at: "") XCTAssertEqual(initial.format, "os9"); XCTAssertEqual(initial.volumes.count, 2) let folder = try await store.change(.folder("DOCS"), path: "") XCTAssertEqual(folder.bytes.suffix(decb.count + tail.count), decb + tail) _ = try await store.selectVolume(initial.volumes[1].id) let renamed = try await store.change(.rename("README.TXT", "HD.TXT"), path: "") XCTAssertEqual(renamed.bytes.prefix(os9.count), folder.bytes.prefix(os9.count)) XCTAssertEqual(renamed.bytes.suffix(tail.count), tail) let returned = try await store.selectVolume(initial.volumeID) XCTAssertTrue(returned.entries.contains { $0.name == "DOCS" }) let restored = try await store.restore(original, path: "") XCTAssertEqual(restored.bytes, original) XCTAssertFalse(restored.entries.contains { $0.name == "DOCS" }) } } @MainActor private final class VolumePromiseTestHost: DiskEditorHost { 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 { try await Task.detached { try DiskEditorIO.write(data, to: url, protecting: [sourceURL].compactMap { $0 }, allowEmpty: true, replacing: expected, requireNew: requireNew) }.value } func savePromisedDiskEditorExport(_ data: Data, to url: URL, protecting sourceURL: URL?) async throws { try await Task.detached { try DiskEditorIO.write(data, to: url, protecting: [sourceURL].compactMap { $0 }, allowEmpty: true, requireNew: true, coordinated: false) }.value } 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 } } extension DiskEditorVolumeStoreTests { @MainActor func testFinderPromiseKeepsSelectedVolumeWithIdenticalFileNames() async throws { let folder = FileManager.default.temporaryDirectory.appendingPathComponent("VCCVolumePromise-" + UUID().uuidString) try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: false) defer { try? FileManager.default.removeItem(at: folder) } let decb = try fixture("DECB"), second = folder.appendingPathComponent("second.dsk") try decb.write(to: second) let payload = Data("SECOND VOLUME ONLY\r".utf8) try VCCDiskImageEditorBackend.importData(payload, named: "README.TXT", directory: "", imageURL: second, fileType: 3, ascii: true, replace: true) let bytes = decb + (try Data(contentsOf: second)) let store = try DiskImageEditorStore(data: bytes) let initial = try await store.contents(at: "") let selected = try await store.selectVolume(initial.volumes[1].id) let entry = try XCTUnwrap(selected.entries.first { $0.name == "README.TXT" }) let host = VolumePromiseTestHost() let provider = DiskEditorFilePromise.make(bytes: selected.bytes, entry: entry, machine: host, sourceURL: nil, volumeID: selected.volumeID) _ = try await store.selectVolume(initial.volumeID) _ = try await store.change(.rename("README.TXT", "FIRST.TXT"), path: "") let destination = folder.appendingPathComponent("README.TXT") let error: Error? = await withCheckedContinuation { continuation in provider.delegate!.filePromiseProvider(provider, writePromiseTo: destination) { continuation.resume(returning: $0) } } XCTAssertNil(error) XCTAssertEqual(try Data(contentsOf: destination), payload) } }