Publish VCC Plus OSS source distribution for 3.6.2 build 60
This commit is contained in:
commit
c652a5276d
1192 files changed
+272368
No files matched your search
@@ -0,0 +1,225 @@
|
||||
// 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)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user