// SPDX-License-Identifier: GPL-3.0-or-later import XCTest final class DiskPersistenceTests: XCTestCase { func testBASICExportProtectsAssignedFilesAliasesAndSDCFolders() throws { let directory = try temporaryDirectory() defer { try? FileManager.default.removeItem(at: directory) } let original = Data("original mounted media".utf8), replacement = Data("new export".utf8) let mounted = directory.appendingPathComponent("mounted.dsk") try original.write(to: mounted) let hardlink = directory.appendingPathComponent("hardlink.dsk") try FileManager.default.linkItem(at: mounted, to: hardlink) let symlink = directory.appendingPathComponent("symlink.dsk") try FileManager.default.createSymbolicLink(at: symlink, withDestinationURL: mounted) for destination in [mounted, hardlink, symlink] { XCTAssertThrowsError(try DiskFiles.exportBASIC(replacement, to: destination, protecting: [mounted])) } XCTAssertEqual(try Data(contentsOf: mounted), original) let card = directory.appendingPathComponent("card") try FileManager.default.createDirectory(at: card, withIntermediateDirectories: true) let cardFile = card.appendingPathComponent("new.dsk") XCTAssertThrowsError(try DiskFiles.exportBASIC(replacement, to: cardFile, protecting: [card])) XCTAssertFalse(FileManager.default.fileExists(atPath: cardFile.path)) let source = directory.appendingPathComponent("source.bas") try original.write(to: source) XCTAssertThrowsError(try DiskFiles.exportBASIC(replacement, to: source, protecting: [source])) XCTAssertEqual(try Data(contentsOf: source), original) let separate = directory.appendingPathComponent("export.dsk") try DiskFiles.exportBASIC(replacement, to: separate, protecting: [mounted, card, source]) XCTAssertEqual(try Data(contentsOf: separate), replacement) // A separately confirmed, unassigned destination can be replaced. try DiskFiles.exportBASIC(original, to: separate, protecting: [mounted]) XCTAssertEqual(try Data(contentsOf: separate), original) } private func temporaryDirectory() throws -> URL { let url = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString) try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true) return url } private func fixture(_ folder: URL) throws -> DiskAssignments { let rom = folder.appendingPathComponent("Authored disk.rom") try Data(repeating: 0, count: 8192).write(to: rom) var settings = DiskAssignments(); settings.rom = rom for drive in 0..<4 { let url = folder.appendingPathComponent("Disk é \(drive).DSK") try Data(repeating: UInt8(drive), count: 161280).write(to: url) settings.drives[drive] = .init(url: url, writeProtected: drive == 2) } return settings } @MainActor private func settled(_ machine: MachineModel) async throws { for _ in 0..<1000 { if !machine.busy { return } try await Task.sleep(nanoseconds: 10_000_000) } XCTFail("Machine operation did not finish") throw NSError(domain: "TestTimeout", code: 1) } @MainActor private func withMachine(_ store: DiskAssignmentStore, _ body: (MachineModel) async throws -> Void) async throws { let machine = MachineModel(diskStore: store) do { try await settled(machine) try await body(machine) } catch { await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } throw error } await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } @MainActor func testDisplayPreferenceRestoresWithoutGuestReset() async throws { let suite = "VCCDisplayTests-" + UUID().uuidString let defaults = try XCTUnwrap(UserDefaults(suiteName: suite)) defer { defaults.removePersistentDomain(forName: suite) } XCTAssertEqual(DisplayOutput.remembered(in: defaults), .composite) let folder = try temporaryDirectory(); defer { try? FileManager.default.removeItem(at: folder) } let store = DiskAssignmentStore(url: folder.appendingPathComponent("disks.json")) for output in [DisplayOutput.compositeAlternate, .rgb] { let machine = MachineModel(diskStore: store, displayDefaults: defaults) try await settled(machine) XCTAssertEqual(machine.videoOutput, DisplayOutput.remembered(in: defaults)) machine.loadDiagnostic(); try await settled(machine) machine.setVideoOutput(output); try await settled(machine) XCTAssertEqual(machine.state, .paused); XCTAssertEqual(machine.frames, 0) XCTAssertEqual(machine.videoOutput, output) XCTAssertEqual(DisplayOutput.remembered(in: defaults), output) await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } let restored = MachineModel(diskStore: store, displayDefaults: defaults) try await settled(restored); XCTAssertEqual(restored.videoOutput, .rgb) await withCheckedContinuation { continuation in restored.shutdown { continuation.resume() } } defaults.set(99, forKey: DisplayOutput.preferenceKey) XCTAssertEqual(DisplayOutput.remembered(in: defaults), .composite) } func testSettingsRoundTripAndValidation() throws { let folder = try temporaryDirectory(); defer { try? FileManager.default.removeItem(at: folder) } let store = DiskAssignmentStore(url: folder.appendingPathComponent("Preferences/disks.json")) XCTAssertEqual(try store.load(), DiskAssignments()) let settings = try fixture(folder) try store.save(settings) XCTAssertEqual(try DiskAssignmentStore(url: store.url).load(), settings) let original = try Data(contentsOf: store.url) var bad = settings; bad.version = 99 XCTAssertThrowsError(try store.save(bad)) XCTAssertEqual(try Data(contentsOf: store.url), original) for invalid in [Data("broken JSON".utf8), Data(repeating: 32, count: 65537), try JSONEncoder().encode(bad)] { try invalid.write(to: store.url) XCTAssertThrowsError(try store.load()) XCTAssertEqual(try Data(contentsOf: store.url), invalid, "Reading never overwrites invalid preferences") } bad = settings; bad.drives.removeLast() XCTAssertThrowsError(try store.save(bad)) bad = settings; bad.rom = URL(string: "https://example.invalid/rom")! XCTAssertThrowsError(try store.save(bad)) bad = settings; bad.rom = nil XCTAssertThrowsError(try store.save(bad)) try store.save(DiskAssignments()) XCTAssertEqual(try store.load(), DiskAssignments()) } @MainActor func testRelaunchRestoresAllFourDrivesAndProtection() async throws { let folder = try temporaryDirectory(); defer { try? FileManager.default.removeItem(at: folder) } let store = DiskAssignmentStore(url: folder.appendingPathComponent("disks.json")) let settings = try fixture(folder) try FileManager.default.setAttributes([.posixPermissions: 0o444], ofItemAtPath: settings.drives[1]!.url.path) try store.save(settings) for _ in 0..<2 { try await withMachine(store) { machine in XCTAssertEqual(machine.state, .empty, "Restoring disks never starts a CPU or selects a system ROM") XCTAssertTrue(machine.diskEnabled); XCTAssertTrue(machine.diskRestoreErrors.isEmpty) XCTAssertNil(machine.diskSettingsError) for drive in 0..<4 { XCTAssertTrue(machine.disks[drive].mounted); XCTAssertFalse(machine.disks[drive].dirty) XCTAssertEqual(machine.disks[drive].name, settings.drives[drive]!.url.lastPathComponent) } XCTAssertTrue(machine.disks[1].sourceReadOnly); XCTAssertTrue(machine.disks[1].writeProtected) XCTAssertTrue(machine.disks[2].writeProtected); XCTAssertFalse(machine.disks[2].sourceReadOnly) XCTAssertFalse(machine.disks[0].writeProtected) XCTAssertEqual(try store.load(), settings, "Restore does not silently rewrite saved choices") } } } @MainActor func testMissingROMAndPartialDriveRestoreCanRetry() async throws { let folder = try temporaryDirectory(); defer { try? FileManager.default.removeItem(at: folder) } let store = DiskAssignmentStore(url: folder.appendingPathComponent("disks.json")) let settings = try fixture(folder); try store.save(settings) try FileManager.default.removeItem(at: settings.rom!) try FileManager.default.removeItem(at: settings.drives[1]!.url) try Data([1, 2, 3]).write(to: settings.drives[3]!.url) try await withMachine(store) { machine in XCTAssertFalse(machine.diskEnabled); XCTAssertNotNil(machine.diskRestoreErrors[-1]) XCTAssertEqual(try store.load(), settings) try Data(repeating: 0, count: 8192).write(to: settings.rom!) machine.retryRememberedDisks(); try await settled(machine) XCTAssertTrue(machine.diskEnabled); XCTAssertTrue(machine.disks[0].mounted) XCTAssertTrue(machine.disks[2].mounted); XCTAssertFalse(machine.disks[1].mounted) XCTAssertFalse(machine.disks[3].mounted); XCTAssertEqual(machine.diskRestoreErrors.count, 2) // A retry after another file becomes available must not replace dirty media. machine.createDisk(0); try await settled(machine) XCTAssertTrue(machine.disks[0].dirty) try Data(repeating: 1, count: 161280).write(to: settings.drives[1]!.url) machine.retryRememberedDisks(); try await settled(machine) XCTAssertTrue(machine.disks[0].dirty); XCTAssertTrue(machine.disks[1].mounted) XCTAssertEqual(machine.diskRestoreErrors.count, 1) machine.ejectDisk(3); try await settled(machine) XCTAssertNil(try store.load().drives[3]); XCTAssertTrue(machine.diskRestoreErrors.isEmpty) XCTAssertNil(try store.load().drives[0], "An unexported new disk has no remembered file") } } @MainActor func testSuccessfulChangesPersistAndFailedChangesDoNot() async throws { let folder = try temporaryDirectory(); defer { try? FileManager.default.removeItem(at: folder) } let store = DiskAssignmentStore(url: folder.appendingPathComponent("disks.json")) let settings = try fixture(folder) try await withMachine(store) { machine in XCTAssertNil(machine.diskSettingsError, "A first launch with no settings is normal") machine.selectDiskROM(settings.rom!); try await settled(machine) machine.insertDisk(settings.drives[0]!.url, drive: 0); try await settled(machine) machine.protectDisk(0, true); try await settled(machine) let saved = try store.load() XCTAssertEqual(saved.rom, settings.rom); XCTAssertTrue(saved.drives[0]!.writeProtected) let invalid = folder.appendingPathComponent("bad.dsk"); try Data([1]).write(to: invalid) machine.insertDisk(invalid, drive: 0); try await settled(machine) XCTAssertNotNil(machine.error); XCTAssertEqual(try store.load(), saved) machine.selectDiskROM(invalid); try await settled(machine) XCTAssertNotNil(machine.fileError); XCTAssertEqual(try store.load(), saved) machine.createDisk(0); try await settled(machine) XCTAssertNil(try store.load().drives[0]); XCTAssertTrue(machine.disks[0].dirty) machine.exportDisk(0, to: folder.appendingPathComponent("missing/export.dsk")); try await settled(machine) XCTAssertNotNil(machine.fileError); XCTAssertTrue(machine.disks[0].dirty) XCTAssertNil(try store.load().drives[0]) let exported = folder.appendingPathComponent("Export é.DSK") machine.exportDisk(0, to: exported); try await settled(machine) XCTAssertNil(machine.error); XCTAssertNil(machine.fileError); XCTAssertFalse(machine.disks[0].dirty) XCTAssertEqual(try store.load().drives[0]?.url, exported) } try await withMachine(store) { machine in XCTAssertTrue(machine.disks[0].mounted); XCTAssertEqual(machine.disks[0].name, "Export é.DSK") machine.ejectDisk(0); try await settled(machine) XCTAssertNil(try store.load().drives[0]) } try await withMachine(store) { machine in XCTAssertFalse(machine.disks[0].mounted) } } @MainActor func testDamagedSettingsAndSaveFailureAreVisibleAndRecoverable() async throws { let folder = try temporaryDirectory(); defer { try? FileManager.default.removeItem(at: folder) } let store = DiskAssignmentStore(url: folder.appendingPathComponent("disks.json")) let bad = Data("not settings".utf8); try bad.write(to: store.url) let settings = try fixture(folder) try await withMachine(store) { machine in XCTAssertNotNil(machine.diskSettingsError); XCTAssertFalse(machine.diskEnabled) XCTAssertFalse(machine.diskSettingsNeedsSave) XCTAssertEqual(try Data(contentsOf: store.url), bad) // Explicit file selection replaces unreadable preferences. machine.selectDiskROM(settings.rom!); try await settled(machine) XCTAssertNil(machine.diskSettingsError); XCTAssertEqual(try store.load().rom, settings.rom) try FileManager.default.removeItem(at: store.url) try FileManager.default.createDirectory(at: store.url, withIntermediateDirectories: false) machine.insertDisk(settings.drives[0]!.url, drive: 0); try await settled(machine) XCTAssertTrue(machine.disks[0].mounted); XCTAssertNotNil(machine.diskSettingsError) XCTAssertTrue(machine.diskSettingsNeedsSave) try FileManager.default.removeItem(at: store.url) machine.saveDiskAssignments() XCTAssertNil(machine.diskSettingsError); XCTAssertFalse(machine.diskSettingsNeedsSave) XCTAssertEqual(try store.load().drives[0]?.url, settings.drives[0]?.url) } } }