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,256 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-or-later
|
||||
import XCTest
|
||||
import SwiftUI
|
||||
import AppKit
|
||||
|
||||
private actor SaveGate {
|
||||
private var release: CheckedContinuation<Void, Never>?
|
||||
private(set) var started = false
|
||||
func wait() async { started = true; await withCheckedContinuation { release = $0 } }
|
||||
func open() { release?.resume(); release = nil }
|
||||
}
|
||||
|
||||
final class DiskAutosaveTests: XCTestCase {
|
||||
private struct Fixture {
|
||||
let folder: URL, disk: URL, store: DiskAssignmentStore
|
||||
let original = Data(repeating: 0, count: 161280)
|
||||
init(temporary: Bool = false, protected: Bool = false) throws {
|
||||
folder = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
|
||||
disk = folder.appendingPathComponent("Autosave é.DSK")
|
||||
try original.write(to: disk)
|
||||
let rom = folder.appendingPathComponent("authored.rom")
|
||||
try Data(repeating: 0, count: 8192).write(to: rom)
|
||||
store = DiskAssignmentStore(url: folder.appendingPathComponent("settings.json"))
|
||||
var settings = DiskAssignments(); settings.rom = rom
|
||||
settings.drives[0] = .init(url: disk, writeProtected: protected, temporary: temporary)
|
||||
try store.save(settings)
|
||||
}
|
||||
func remove() { try? FileManager.default.removeItem(at: folder) }
|
||||
}
|
||||
// Authored code shared by both CPU engines: fill sector 1, commit, then loop.
|
||||
private func writerROM(_ value: UInt8 = 0x5a, repeating: Bool = false) -> Data {
|
||||
var program: [UInt8] = [0x86,0x29,0xb7,0xff,0x40,0x86,1,0xb7,0xff,0x4a,
|
||||
0x86,0xa0,0xb7,0xff,0x48,0x8e,1,0,0x86,value,
|
||||
0xb7,0xff,0x4b,0x30,0x1f,0x26,0xf9,0xb7,0xff,0x4b,0x20,0xfe]
|
||||
if repeating {
|
||||
program.removeLast(2)
|
||||
// Idle between writes so the controller can capture complete sectors.
|
||||
program += [0x8e,0x40,0x00,0x30,0x1f,0x26,0xfc]
|
||||
let back = UInt8(bitPattern: Int8(-(program.count + 2)))
|
||||
program += [0x20, back]
|
||||
}
|
||||
var rom = Data(repeating: 0, count: 32768); rom.replaceSubrange(0..<program.count, with: program)
|
||||
rom[32766] = 0x80; return rom
|
||||
}
|
||||
@MainActor private func step(_ action: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
|
||||
await withCheckedContinuation { continuation in action { continuation.resume(returning: $0) } }
|
||||
}
|
||||
@MainActor private func until(_ condition: () -> Bool) async throws {
|
||||
for _ in 0..<500 {
|
||||
if condition() { return }
|
||||
try await Task.sleep(nanoseconds: 20_000_000)
|
||||
}
|
||||
XCTFail("Timed out waiting for disk saving")
|
||||
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 { continuation in model.shutdown { continuation.resume() } }
|
||||
}
|
||||
@MainActor private func runWriter(_ controller: VCCMachineController, use6309: Bool = false, value: UInt8 = 0x5a) async {
|
||||
let s = await step { controller.loadROM(writerROM(value), use6309: use6309, completion: $0) }
|
||||
XCTAssertNil(s.errorMessage)
|
||||
_ = await step(controller.resume)
|
||||
}
|
||||
func testAutomaticFileWriteRejectsConflictsMissingAndReadOnlyFiles() throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
let changed = Data(repeating: 0x5a, count: 161280)
|
||||
try DiskFiles.saveAutomatically(changed, to: f.disk, expected: f.original)
|
||||
XCTAssertEqual(try Data(contentsOf: f.disk), changed)
|
||||
XCTAssertThrowsError(try DiskFiles.saveAutomatically(f.original, to: f.disk, expected: f.original))
|
||||
XCTAssertEqual(try Data(contentsOf: f.disk), changed)
|
||||
try FileManager.default.setAttributes([.posixPermissions: 0o444], ofItemAtPath: f.disk.path)
|
||||
XCTAssertThrowsError(try DiskFiles.saveAutomatically(f.original, to: f.disk, expected: changed))
|
||||
XCTAssertEqual(try Data(contentsOf: f.disk), changed)
|
||||
try FileManager.default.removeItem(at: f.disk)
|
||||
XCTAssertThrowsError(try DiskFiles.saveAutomatically(changed, to: f.disk, expected: changed))
|
||||
XCTAssertFalse(FileManager.default.fileExists(atPath: f.disk.path))
|
||||
let target = f.folder.appendingPathComponent("image-without-extension")
|
||||
try f.original.write(to: target)
|
||||
try FileManager.default.createSymbolicLink(at: f.disk, withDestinationURL: target)
|
||||
try DiskFiles.saveAutomatically(changed, to: f.disk.resolvingSymlinksInPath(), expected: f.original)
|
||||
XCTAssertEqual(try Data(contentsOf: target), changed)
|
||||
XCTAssertEqual(try FileManager.default.destinationOfSymbolicLink(atPath: f.disk.path), target.path)
|
||||
}
|
||||
func testOlderSettingsDefaultToAutomaticSaving() throws {
|
||||
let f = try Fixture(temporary: true); defer { f.remove() }
|
||||
var json = try XCTUnwrap(JSONSerialization.jsonObject(with: Data(contentsOf: f.store.url)) as? [String: Any])
|
||||
var drives = try XCTUnwrap(json["drives"] as? [Any])
|
||||
var first = try XCTUnwrap(drives[0] as? [String: Any]); first.removeValue(forKey: "temporary")
|
||||
drives[0] = first; json["drives"] = drives
|
||||
try JSONSerialization.data(withJSONObject: json).write(to: f.store.url)
|
||||
XCTAssertFalse(try XCTUnwrap(f.store.load().drives[0]).temporary)
|
||||
}
|
||||
@MainActor func testGuestWritesSaveWithoutPausingOnBothCPUs() async throws {
|
||||
for (cpu, mpi) in [(false, false), (true, false), (false, true), (true, true)] {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
if mpi {
|
||||
var settings = try f.store.load(); var layout = CartridgeAssignments()
|
||||
layout.multiPak = true; layout.mpiConfigured = true; layout.slots[4].kind = .floppy
|
||||
settings.cartridges = layout; try f.store.save(settings)
|
||||
}
|
||||
let controller = VCCMachineController(); let model = MachineModel(diskStore: f.store, controller: controller)
|
||||
do {
|
||||
try await settled(model); await runWriter(controller, use6309: cpu)
|
||||
try await until { (try? Data(contentsOf: f.disk).first) == 0x5a && !model.diskSaving && !model.disks[0].dirty }
|
||||
XCTAssertEqual(model.state, .running); XCTAssertTrue(model.diskSaveErrors.isEmpty)
|
||||
let bytes = try Data(contentsOf: f.disk)
|
||||
XCTAssertEqual(bytes.prefix(256), Data(repeating: 0x5a, count: 256))
|
||||
XCTAssertEqual(bytes.dropFirst(256), f.original.dropFirst(256))
|
||||
} catch { await close(model); throw error }
|
||||
await close(model)
|
||||
let reopened = MachineModel(diskStore: f.store)
|
||||
try await settled(reopened); XCTAssertTrue(reopened.disks[0].mounted); XCTAssertFalse(reopened.disks[0].dirty)
|
||||
await close(reopened)
|
||||
}
|
||||
}
|
||||
@MainActor func testTemporaryModeAndProtectionKeepSourceUnchanged() async throws {
|
||||
for protected in [false, true] {
|
||||
let f = try Fixture(temporary: !protected, protected: protected); defer { f.remove() }
|
||||
let controller = VCCMachineController(); let model = MachineModel(diskStore: f.store, controller: controller)
|
||||
do {
|
||||
try await settled(model); XCTAssertEqual(model.diskTemporary[0], !protected)
|
||||
await runWriter(controller)
|
||||
try await until { model.frames > 20 }
|
||||
await withCheckedContinuation { continuation in model.prepareToQuit { continuation.resume() } }
|
||||
XCTAssertEqual(try Data(contentsOf: f.disk), f.original)
|
||||
XCTAssertEqual(model.disks[0].dirty, !protected)
|
||||
XCTAssertEqual(model.unsavedMedia, !protected)
|
||||
XCTAssertEqual(model.needsMediaAttention, !protected, "Temporary changes must still need attention")
|
||||
if !protected {
|
||||
model.setDiskTemporary(0, false); try await settled(model)
|
||||
XCTAssertFalse(try XCTUnwrap(f.store.load().drives[0]).temporary)
|
||||
await withCheckedContinuation { continuation in model.prepareToQuit { continuation.resume() } }
|
||||
XCTAssertFalse(model.unsavedMedia); XCTAssertEqual(try Data(contentsOf: f.disk).first, 0x5a)
|
||||
}
|
||||
} catch { await close(model); throw error }
|
||||
await close(model)
|
||||
}
|
||||
}
|
||||
@MainActor func testExternalEditPausesAndRetainsChangesUntilRetry() 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: 161280); try external.write(to: f.disk)
|
||||
await runWriter(controller)
|
||||
try await until { model.diskSaveErrors[0] != nil && !model.diskSaving }
|
||||
XCTAssertEqual(model.state, .paused); XCTAssertTrue(model.disks[0].dirty)
|
||||
XCTAssertTrue(model.needsMediaAttention, "Real autosave failures must remain visible")
|
||||
XCTAssertEqual(try Data(contentsOf: f.disk), external)
|
||||
await withCheckedContinuation { continuation in model.prepareToQuit { continuation.resume() } }
|
||||
XCTAssertTrue(model.unsavedMedia); XCTAssertEqual(try Data(contentsOf: f.disk), external)
|
||||
try f.original.write(to: f.disk)
|
||||
model.retryDiskSave(0)
|
||||
try await until { !model.diskSaving && !model.disks[0].dirty }
|
||||
XCTAssertTrue(model.diskSaveErrors.isEmpty); XCTAssertEqual(try Data(contentsOf: f.disk).first, 0x5a)
|
||||
XCTAssertFalse(model.needsMediaAttention)
|
||||
} catch { await close(model); throw error }
|
||||
await close(model)
|
||||
}
|
||||
@MainActor func testRepeatedWritesKeepAttentionAndNativeDisplayStable() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
var assignments = try f.store.load()
|
||||
var layout = CartridgeAssignments(); layout.multiPak = true; layout.mpiConfigured = true
|
||||
layout.slots[4].kind = .floppy; assignments.cartridges = layout; try f.store.save(assignments)
|
||||
let suite = "VCCRepeatedWrites-" + UUID().uuidString
|
||||
let defaults = UserDefaults(suiteName: suite)!
|
||||
defer { defaults.removePersistentDomain(forName: suite) }
|
||||
let controller = VCCMachineController(), gate = SaveGate()
|
||||
let model = MachineModel(diskStore: f.store, controller: controller, displayDefaults: defaults,
|
||||
inputStore: .init(url: f.folder.appendingPathComponent("input.json")),
|
||||
automaticDiskWriter: { data, url, expected in
|
||||
if !(await gate.started) { await gate.wait() }
|
||||
try DiskFiles.saveAutomatically(data, to: url, expected: expected)
|
||||
})
|
||||
let presentation = PresentationSettings(defaults: defaults)
|
||||
let host = NSHostingView(rootView: MachineView(machine: model, presentation: presentation, showManualHome: {}))
|
||||
let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 1100, height: 820),
|
||||
styleMask: [.titled, .resizable], backing: .buffered, defer: false)
|
||||
window.isReleasedWhenClosed = false; window.contentView = host
|
||||
defer { window.close() }
|
||||
func display(_ view: NSView) -> KeyboardDisplay? {
|
||||
if let result = view as? KeyboardDisplay { return result }
|
||||
return view.subviews.lazy.compactMap { display($0) }.first
|
||||
}
|
||||
do {
|
||||
try await settled(model)
|
||||
XCTAssertFalse(model.hardware.custom, "System checks must use the illustrated layout, not its conventional fallback")
|
||||
_ = await step { controller.loadROM(writerROM(repeating: true), use6309: false, completion: $0) }
|
||||
for mode in [PresentationSettings.Mode.display, .system] {
|
||||
presentation.mode = mode
|
||||
try await Task.sleep(nanoseconds: 100_000_000); host.layoutSubtreeIfNeeded()
|
||||
let screen = try XCTUnwrap(display(host))
|
||||
let original = screen.convert(screen.bounds, to: host)
|
||||
_ = await step(controller.resume)
|
||||
for _ in 0..<500 { if await gate.started { break }; try await Task.sleep(nanoseconds: 10_000_000) }
|
||||
let started = await gate.started; XCTAssertTrue(started)
|
||||
let before = await step(controller.snapshot)
|
||||
for _ in 0..<30 {
|
||||
model.poll(); try await Task.sleep(nanoseconds: 20_000_000)
|
||||
host.layoutSubtreeIfNeeded()
|
||||
XCTAssertTrue(model.unsavedMedia, "Quit protection must include pending host writes")
|
||||
XCTAssertFalse(model.needsMediaAttention, "Normal repeated saves must not toggle a warning row")
|
||||
XCTAssertEqual(screen.convert(screen.bounds, to: host), original, "Disk activity must not resize the live display")
|
||||
}
|
||||
let after = await step(controller.snapshot)
|
||||
XCTAssertGreaterThan(after.frames, before.frames)
|
||||
XCTAssertGreaterThan(after.disks[0].writeEvents, before.disks[0].writeEvents)
|
||||
XCTAssertEqual(after.generation, before.generation)
|
||||
_ = await step(controller.pause)
|
||||
}
|
||||
await gate.open()
|
||||
await withCheckedContinuation { done in model.prepareToQuit { done.resume() } }
|
||||
XCTAssertFalse(model.unsavedMedia); XCTAssertFalse(model.needsMediaAttention)
|
||||
XCTAssertEqual(try Data(contentsOf: f.disk).prefix(256), Data(repeating: 0x5a, count: 256))
|
||||
} catch { await gate.open(); await close(model); throw error }
|
||||
await close(model)
|
||||
}
|
||||
@MainActor func testQuitWaitsForPendingSaveAndFlushesNewerGuestWrites() async throws {
|
||||
let f = try Fixture(); defer { f.remove() }
|
||||
let controller = VCCMachineController(); let gate = SaveGate()
|
||||
let model = MachineModel(diskStore: f.store, controller: controller, automaticDiskWriter: { data, url, expected in
|
||||
if !(await gate.started) { await gate.wait() }
|
||||
try DiskFiles.saveAutomatically(data, to: url, expected: expected)
|
||||
})
|
||||
do {
|
||||
try await settled(model); await runWriter(controller)
|
||||
for _ in 0..<500 {
|
||||
if await gate.started { break }
|
||||
try await Task.sleep(nanoseconds: 20_000_000)
|
||||
}
|
||||
let started = await gate.started; XCTAssertTrue(started); XCTAssertTrue(model.diskSaving)
|
||||
XCTAssertEqual(try Data(contentsOf: f.disk), f.original)
|
||||
// Write a newer version while the first snapshot's host write waits.
|
||||
await runWriter(controller, value: 0x6b)
|
||||
let start = await step(controller.snapshot)
|
||||
for _ in 0..<100 {
|
||||
let s = await step(controller.snapshot)
|
||||
if s.frames > start.frames + 2 { break }
|
||||
try await Task.sleep(nanoseconds: 20_000_000)
|
||||
}
|
||||
var quitReady = false
|
||||
model.prepareToQuit { quitReady = true }
|
||||
try await Task.sleep(nanoseconds: 50_000_000)
|
||||
XCTAssertFalse(quitReady, "Quit must wait for outstanding file I/O")
|
||||
await gate.open()
|
||||
try await until { quitReady }
|
||||
XCTAssertFalse(model.unsavedMedia); XCTAssertEqual(model.state, .paused)
|
||||
XCTAssertEqual(try Data(contentsOf: f.disk).prefix(256), Data(repeating: 0x6b, count: 256))
|
||||
} catch { await gate.open(); await close(model); throw error }
|
||||
await close(model)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user