Files
VCCPlusOSS/platforms/macos/Tests/HardDiskTests.swift
T

291 lines
20 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import AppKit
private actor HardSaveGate {
private var continuation: CheckedContinuation<Void, Never>?
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..<code.count, with: code); rom[32766] = 0x80
return rom
}
@MainActor private func run(_ controller: VCCMachineController, cpu: Bool = false, value: UInt8 = 0x5a) async {
let snapshot = await step { controller.loadROM(writerROM(value), use6309: cpu, completion: $0) }
XCTAssertNil(snapshot.errorMessage); _ = await step(controller.resume)
}
func testRawFilesAtomicSectorSavingAndConflictProtection() throws {
let f = try Fixture(); defer { f.remove() }
let original = try HardDiskFiles.readImage(f.image)
XCTAssertEqual(original.digest, HardDiskFiles.digest(f.original))
var patches = Data([1,0,0,0]); patches.append(Data(repeating: 0x5a, count: 256))
let digest = try HardDiskFiles.saveAutomatically(patches, length: 6144, to: f.image, expected: original.digest)
var expected = f.original; expected.replaceSubrange(256..<512, with: Data(repeating: 0x5a, count: 256)); expected.append(Data(repeating: 0, count: 2048))
XCTAssertEqual(try Data(contentsOf: f.image), expected); XCTAssertEqual(digest, HardDiskFiles.digest(expected))
XCTAssertThrowsError(try HardDiskFiles.saveAutomatically(patches, length: 6144, to: f.image, expected: original.digest))
XCTAssertEqual(try Data(contentsOf: f.image), expected)
try FileManager.default.setAttributes([.posixPermissions: 0o444], ofItemAtPath: f.image.path)
XCTAssertTrue(try HardDiskFiles.readImage(f.image).readOnly)
XCTAssertThrowsError(try HardDiskFiles.saveAutomatically(patches, length: 6144, to: f.image, expected: digest))
try FileManager.default.removeItem(at: f.image)
XCTAssertThrowsError(try HardDiskFiles.saveAutomatically(patches, length: 6144, to: f.image, expected: digest))
XCTAssertFalse(FileManager.default.fileExists(atPath: f.image.path))
let target = f.folder.appendingPathComponent("raw-no-extension")
try f.original.write(to: target); try FileManager.default.createSymbolicLink(at: f.image, withDestinationURL: target)
let linked = try HardDiskFiles.readImage(f.image)
_ = try HardDiskFiles.saveAutomatically(patches, length: 4096, to: f.image.resolvingSymlinksInPath(), expected: linked.digest)
XCTAssertEqual(try FileManager.default.destinationOfSymbolicLink(atPath: f.image.path), target.path)
for invalid in [Data(), Data(repeating: 0, count: 257), Data("conectix".utf8) + Data(repeating: 0, count: 504)] {
try invalid.write(to: f.second); XCTAssertThrowsError(try HardDiskFiles.readImage(f.second))
}
var bad = patches; bad[3] = 0xff
let before = try Data(contentsOf: target)
XCTAssertThrowsError(try HardDiskFiles.saveAutomatically(bad, length: 4096, to: target, expected: HardDiskFiles.digest(before)))
XCTAssertEqual(try Data(contentsOf: target), before)
}
@MainActor func testGuestWritesAutomaticTemporaryAndProtectedOnBothCPUs() async throws {
for cpu in [false, true] {
for mode in 0..<3 {
let f = try Fixture(temporary: mode == 1, protected: mode == 2); defer { f.remove() }
let controller = VCCMachineController(); let model = MachineModel(diskStore: f.store, controller: controller)
do {
try await settled(model); await run(controller, cpu: cpu)
if mode == 0 {
try await until { (try? Data(contentsOf: f.image).first) == 0x5a && !model.diskSaving && !model.hardDisks[0].dirty }
XCTAssertEqual(model.state, .running)
XCTAssertEqual(try Data(contentsOf: f.image).dropFirst(256), f.original.dropFirst(256))
} else {
try await until { model.frames > 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)
}
}