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,290 @@
|
||||
// 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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user