Sync VCC Plus 3.7.1 build 67 source
Refresh reviewed MCP output export, four-drive owned playtests, bounded BASIC readiness, and pinned CMOC 0.1.101 source/patches. Preserve independent source-edition identity, empty libraries, notices and privacy boundaries. Validated 74 export/privacy checks, pinned dependency sources, and an independent unsigned universal Release build. A subsequent documentation-only correction removes an excluded qualification link; all build inputs remain identical.
This commit is contained in:
1 parent
4abc194001
commit
5534005799
54 files changed
+2950
-435
No files matched your search
@@ -1829,6 +1829,469 @@ final class MCPPlaytestTests: XCTestCase {
|
||||
catch { XCTAssertTrue(error.localizedDescription.contains("stale_run")) }
|
||||
}
|
||||
|
||||
func testOwnedMultipleDrivesReadBothWriteOnlyHomeAndRetainIndependentlyOnBothProcessors() async throws {
|
||||
let (helper, system, diskROM) = try inputs()
|
||||
for cpu in ["6809", "6309"] {
|
||||
for homeDrive in 0...2 {
|
||||
let dataDrive = homeDrive + 1
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiDrive-" + UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
var home = disk(), data = disk()
|
||||
home.replaceSubrange(0..<4, with: Data("HOME".utf8))
|
||||
data.replaceSubrange(0..<4, with: Data("DATA".utf8))
|
||||
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-drive-\(cpu)-\(homeDrive)", primary: home, world: data)
|
||||
// DSKI$ returns two 128-byte strings per sector. Reserve a
|
||||
// normal BASIC string heap for both disks and the save buffers.
|
||||
let source = "CLEAR2000\n5 H=\(homeDrive):D=\(dataDrive)\n10 IFINKEY$=\"\"THEN10\n20 DSKI$H,0,1,A$,B$:DSKI$D,0,1,C$,E$:PRINTLEFT$(A$,4);\":\";LEFT$(C$,4)\n30 A$=\"SAVE\"+STRING$(124,88):B$=STRING$(128,89):DSKO$H,0,2,A$,B$:DSKI$H,0,2,A$,B$:PRINTLEFT$(A$,4):GOTO10\nRUN\n"
|
||||
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: home,
|
||||
bootCommands: source, projectID: "multi-drive-\(cpu)-\(homeDrive)", revision: 1,
|
||||
artifactID: declaration.proof.artifactID!, cpu: cpu, helperURL: helper,
|
||||
retentionDirectory: root, diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
|
||||
defer { test.invalidate() }
|
||||
_ = try await test.pausePlaytest()
|
||||
func exchange(_ drive: Int, _ id: String?, _ hash: String?, _ requestID: String, protection: Bool? = nil) async throws -> [String: Any] {
|
||||
var request: [String: Any] = ["run_id": test.runID, "request_id": requestID, "action": id == nil ? "eject" : "insert", "drive": drive]
|
||||
if let id { request["media_id"] = id; request["media_sha256"] = hash }
|
||||
if let protection { request["write_protected"] = protection }
|
||||
return try await test.reply("exchange_playtest_media", arguments: request)
|
||||
}
|
||||
let before = try await test.capture()
|
||||
XCTAssertEqual((before["drives"] as? [[String: Any]])?.count, 4)
|
||||
for invalid: Any in [true, 1.5, -1, 4, "1"] {
|
||||
await expectDiskFailure {
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "invalid-drive", "action": "eject", "drive": invalid])
|
||||
}
|
||||
}
|
||||
for invalid: Any in [1, "true"] {
|
||||
await expectDiskFailure {
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "invalid-protection", "action": "insert", "drive": dataDrive,
|
||||
"media_id": declaration.media[1].id, "media_sha256": declaration.media[1].baseSHA256, "write_protected": invalid])
|
||||
}
|
||||
}
|
||||
await expectDiskFailure {
|
||||
_ = try await exchange(dataDrive, declaration.media[0].id, declaration.media[0].baseSHA256, "duplicate-mount")
|
||||
}
|
||||
if homeDrive != 0 {
|
||||
_ = try await exchange(0, nil, nil, "eject-home")
|
||||
_ = try await exchange(homeDrive, declaration.media[0].id, declaration.media[0].baseSHA256, "move-home")
|
||||
}
|
||||
let inserted = try await exchange(dataDrive, declaration.media[1].id, declaration.media[1].baseSHA256, "data", protection: true)
|
||||
let insertedRows = try XCTUnwrap(inserted["drives"] as? [[String: Any]])
|
||||
XCTAssertEqual(insertedRows[dataDrive]["write_protected"] as? Bool, true)
|
||||
XCTAssertEqual(insertedRows[homeDrive]["write_protected"] as? Bool, false)
|
||||
XCTAssertEqual(inserted["field_clock"] as? Int, before["field_clock"] as? Int)
|
||||
XCTAssertEqual(inserted["target_drive"] as? Int, dataDrive)
|
||||
XCTAssertEqual(inserted["media_id"] as? String, homeDrive == 0 ? declaration.media[0].id : nil)
|
||||
let retry = try await exchange(dataDrive, declaration.media[1].id, declaration.media[1].baseSHA256, "data", protection: true)
|
||||
XCTAssertEqual(inserted as NSDictionary, retry as NSDictionary)
|
||||
await expectDiskFailure { _ = try await exchange(homeDrive, declaration.media[1].id, declaration.media[1].baseSHA256, "data", protection: true) }
|
||||
await expectDiskFailure { _ = try await exchange(dataDrive, declaration.media[1].id, declaration.media[1].baseSHA256, "data", protection: false) }
|
||||
_ = try await test.continuePlaytest()
|
||||
_ = try await test.reply("playtest_input", arguments: ["run_id": test.runID, "request_id": "read-and-save", "steps": [["keys": ["r"], "fields": 18], ["keys": [], "fields": 420]]])
|
||||
_ = try await test.pausePlaytest()
|
||||
let saved = try await test.capture()
|
||||
let text = saved["screen_text"] as? String ?? ""
|
||||
XCTAssertTrue(text.contains("HOME:DATA"), text)
|
||||
XCTAssertTrue(text.contains("SAVE"), text)
|
||||
let rows = try XCTUnwrap(saved["drives"] as? [[String: Any]])
|
||||
XCTAssertGreaterThan((rows[homeDrive]["disk_reads"] as? Int) ?? 0, 0)
|
||||
XCTAssertGreaterThan((rows[homeDrive]["disk_writes"] as? Int) ?? 0, 0)
|
||||
XCTAssertGreaterThan((rows[dataDrive]["disk_reads"] as? Int) ?? 0, 0)
|
||||
XCTAssertEqual(rows[dataDrive]["disk_writes"] as? Int, 0)
|
||||
XCTAssertEqual(rows[dataDrive]["disk_sha256"] as? String, CMOCProject.sha256(data))
|
||||
XCTAssertNotEqual(rows[homeDrive]["disk_sha256"] as? String, CMOCProject.sha256(home))
|
||||
let restarted = try await test.reply("restart_playtest", arguments: ["run_id": test.runID, "request_id": "restart-all"])
|
||||
let restartedRows = try XCTUnwrap(restarted["drives"] as? [[String: Any]])
|
||||
for drive in 0..<4 {
|
||||
XCTAssertEqual(restartedRows[drive]["media_id"] as? String, rows[drive]["media_id"] as? String)
|
||||
XCTAssertEqual(restartedRows[drive]["disk_sha256"] as? String, rows[drive]["disk_sha256"] as? String)
|
||||
XCTAssertEqual(restartedRows[drive]["write_protected"] as? Bool, rows[drive]["write_protected"] as? Bool)
|
||||
}
|
||||
let stopArgs: [String: Any] = ["run_id": test.runID, "request_id": "stop"]
|
||||
let stopped = try await test.reply("stop_playtest", arguments: stopArgs)
|
||||
let repeated = try await test.reply("stop_playtest", arguments: stopArgs)
|
||||
XCTAssertEqual(stopped as NSDictionary, repeated as NSDictionary)
|
||||
let retained = try XCTUnwrap(stopped["retained_media"] as? [[String: Any]])
|
||||
XCTAssertEqual(retained.count, 2)
|
||||
XCTAssertEqual(Set(retained.compactMap { $0["retained_disk_id"] as? String }).count, 2)
|
||||
for (index, medium) in declaration.media.enumerated() {
|
||||
let record = try XCTUnwrap(retained.first { $0["media_id"] as? String == medium.id })
|
||||
let id = try XCTUnwrap(record["retained_disk_id"] as? String), hash = try XCTUnwrap(record["disk_sha256"] as? String)
|
||||
let loaded = try await MCPPlaytestDiskStore.load(directory: root, id: id, expectedSHA256: hash,
|
||||
projectKey: declaration.key, artifactDiskSHA256: declaration.proof.artifactDiskSHA256!,
|
||||
mediaKey: medium.key, mediaBaseSHA256: medium.baseSHA256)
|
||||
XCTAssertEqual(loaded.record.provenance.writeProtected, index == 1)
|
||||
if index == 1 { XCTAssertEqual(loaded.data, data) }
|
||||
else { XCTAssertEqual(String(decoding: loaded.data[256..<260], as: UTF8.self), "SAVE") }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testMultiDriveDefaultFD0RetryIdentityAndIndependentEqualByteCopies() async throws {
|
||||
let (helper, system, diskROM) = try inputs()
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiIdentity-" + UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let original = disk(), declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-identity", primary: original, world: original)
|
||||
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: original,
|
||||
bootCommands: "10 GOTO10\nRUN\n", projectID: "multi-identity", revision: 1,
|
||||
artifactID: declaration.proof.artifactID!, helperURL: helper, retentionDirectory: root,
|
||||
diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
|
||||
defer { test.invalidate() }
|
||||
_ = try await test.pausePlaytest()
|
||||
let omitted: [String: Any] = ["run_id": test.runID, "request_id": "default-eject", "action": "eject"]
|
||||
let ejected = try await test.reply("exchange_playtest_media", arguments: omitted)
|
||||
var explicit = omitted; explicit["drive"] = 0
|
||||
let explicitRetry = try await test.reply("exchange_playtest_media", arguments: explicit)
|
||||
XCTAssertEqual(explicitRetry as NSDictionary, ejected as NSDictionary)
|
||||
for drive in 0...1 {
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "insert-\(drive)", "action": "insert", "drive": drive,
|
||||
"media_id": declaration.media[drive].id, "media_sha256": declaration.media[drive].baseSHA256])
|
||||
}
|
||||
let snapshot = try await test.capture()
|
||||
let rows = try XCTUnwrap(snapshot["drives"] as? [[String: Any]])
|
||||
XCTAssertNotEqual(rows[0]["media_id"] as? String, rows[1]["media_id"] as? String)
|
||||
XCTAssertEqual(rows[0]["disk_sha256"] as? String, rows[1]["disk_sha256"] as? String)
|
||||
let stopped = try await test.reply("stop_playtest", arguments: ["run_id": test.runID, "request_id": "stop"])
|
||||
XCTAssertEqual((stopped["retained_media"] as? [[String: Any]])?.count, 2)
|
||||
}
|
||||
|
||||
func testMultiDriveStopDrainsFourLargeDisksWithinTheExistingWireLimit() async throws {
|
||||
let (helper, system, diskROM) = try inputs()
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCFourDriveDrain-" + UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let artifact = UUID().uuidString, project = "four-drive-drain", projectKey = CMOCProject.sha256(Data(project.utf8))
|
||||
let base = disk(), primaryHash = CMOCProject.sha256(base)
|
||||
let media = (0..<4).map { index -> MCPPlaytestMedium in
|
||||
// 80-track single-sided raw images are valid and fit the per-image
|
||||
// budget. Four base64 payloads would exceed the 1 MiB wire bound.
|
||||
var bytes = index == 0 ? base : Data(repeating: UInt8(40 + index), count: 80 * 18 * 256)
|
||||
bytes[0] = UInt8(index)
|
||||
let key = index == 0 ? "primary" : "disk:drive\(index).dsk", hash = CMOCProject.sha256(bytes)
|
||||
let proof = MCPPlaytestDiskStore.Provenance(projectKey: projectKey, artifactID: artifact,
|
||||
artifactDiskSHA256: primaryHash, mediaKey: key, mediaBaseSHA256: hash)
|
||||
return MCPPlaytestMedium(id: MCPPlaytestMedium.identifier(artifactID: artifact, key: key), name: "drive\(index).dsk",
|
||||
key: key, baseSHA256: hash, data: bytes, provenance: proof)
|
||||
}
|
||||
// Keep primary hash and actual bytes identical for artifact binding.
|
||||
let primary = media[0]
|
||||
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: primary.data,
|
||||
bootCommands: "10 GOTO10\nRUN\n", projectID: project, revision: 1, artifactID: artifact,
|
||||
helperURL: helper, retentionDirectory: root, diskProvenance: primary.provenance, media: media, multiDrive: true)
|
||||
defer { test.invalidate() }
|
||||
_ = try await test.pausePlaytest()
|
||||
for drive in 1...3 {
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "drive-\(drive)", "action": "insert", "drive": drive,
|
||||
"media_id": media[drive].id, "media_sha256": media[drive].baseSHA256])
|
||||
}
|
||||
let stopped = try await test.reply("stop_playtest", arguments: ["run_id": test.runID, "request_id": "stop"])
|
||||
let records = try XCTUnwrap(stopped["retained_media"] as? [[String: Any]])
|
||||
XCTAssertEqual(records.count, 4)
|
||||
for medium in media {
|
||||
let record = try XCTUnwrap(records.first { $0["media_id"] as? String == medium.id })
|
||||
XCTAssertEqual(record["disk_sha256"] as? String, medium.baseSHA256)
|
||||
let id = try XCTUnwrap(record["retained_disk_id"] as? String)
|
||||
XCTAssertEqual(try Data(contentsOf: MCPPlaytestDiskStore.diskURL(directory: root, id: id)), medium.data)
|
||||
}
|
||||
}
|
||||
|
||||
func testMultiDriveRetentionCanRetryAfterFrozenWorkerExit() async throws {
|
||||
let (helper, system, diskROM) = try inputs()
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiRetentionRetry-" + UUID().uuidString)
|
||||
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true, attributes: [.posixPermissions: 0o700])
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let blocked = root.appendingPathComponent("retained")
|
||||
try Data("not a folder".utf8).write(to: blocked)
|
||||
let original = disk(); var data = disk(); data[0] = 81
|
||||
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-retention-retry", primary: original, world: data)
|
||||
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: original,
|
||||
bootCommands: "10 PRINT 47\nSAVE\"HOME\"\n", projectID: "multi-retention-retry", revision: 1,
|
||||
artifactID: declaration.proof.artifactID!, helperURL: helper, retentionDirectory: blocked,
|
||||
diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
|
||||
defer { test.invalidate() }
|
||||
_ = try await test.pausePlaytest()
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "data", "action": "insert", "drive": 1,
|
||||
"media_id": declaration.media[1].id, "media_sha256": declaration.media[1].baseSHA256])
|
||||
let before = try await test.capture()
|
||||
let beforeRows = try XCTUnwrap(before["drives"] as? [[String: Any]])
|
||||
let stop: [String: Any] = ["run_id": test.runID, "request_id": "stop"]
|
||||
await expectDiskFailure { _ = try await test.reply("stop_playtest", arguments: stop) }
|
||||
XCTAssertNotNil(test.retentionError)
|
||||
let pending = try await test.capture()
|
||||
XCTAssertEqual(pending["status"] as? String, "retention_pending")
|
||||
try FileManager.default.removeItem(at: blocked)
|
||||
let stopped = try await test.reply("stop_playtest", arguments: stop)
|
||||
XCTAssertNil(test.retentionError)
|
||||
let records = try XCTUnwrap(stopped["retained_media"] as? [[String: Any]])
|
||||
XCTAssertEqual(records.count, 2)
|
||||
for index in 0...1 {
|
||||
let record = try XCTUnwrap(records.first { $0["media_id"] as? String == declaration.media[index].id })
|
||||
XCTAssertEqual(record["disk_sha256"] as? String, beforeRows[index]["disk_sha256"] as? String)
|
||||
}
|
||||
}
|
||||
|
||||
func testOwnedDriveProtectionBlocksGuestWriteAndCanBeChangedWithReview() async throws {
|
||||
let (helper, system, diskROM) = try inputs()
|
||||
for cpu in ["6809", "6309"] {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCOwnedWriteProtect-" + UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let original = disk(), declaration = declaredMedia(artifact: UUID().uuidString, project: "protected-" + cpu, primary: original, world: original)
|
||||
let program = "CLEAR2000\n10 IFINKEY$=\"\"THEN10\n20 A$=STRING$(128,88):B$=STRING$(128,89):DSKO$0,0,2,A$,B$:PRINT\"WROTE HOME\":GOTO10\nRUN\n"
|
||||
let test = try await MCPPlaytest.start(systemROM: system, diskROM: diskROM, disk: original,
|
||||
bootCommands: program, projectID: "protected-" + cpu, revision: 1, artifactID: declaration.proof.artifactID!, cpu: cpu,
|
||||
helperURL: helper, retentionDirectory: root, diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
|
||||
defer { test.invalidate() }
|
||||
_ = try await test.pausePlaytest()
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "protect", "action": "insert",
|
||||
"media_id": declaration.media[0].id, "media_sha256": declaration.media[0].baseSHA256, "write_protected": true])
|
||||
_ = try await test.continuePlaytest()
|
||||
_ = try await test.reply("playtest_input", arguments: ["run_id": test.runID, "request_id": "protected-write",
|
||||
"steps": [["keys": ["r"], "fields": 18], ["keys": [], "fields": 180]]])
|
||||
_ = try await test.pausePlaytest()
|
||||
let refused = try await test.capture()
|
||||
let rows = try XCTUnwrap(refused["drives"] as? [[String: Any]])
|
||||
XCTAssertEqual(rows[0]["disk_sha256"] as? String, declaration.media[0].baseSHA256)
|
||||
XCTAssertEqual(rows[0]["disk_writes"] as? Int, 0)
|
||||
XCTAssertTrue((refused["screen_text"] as? String ?? "").contains("WP ERROR"), refused["screen_text"] as? String ?? "")
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID, "request_id": "unprotect", "action": "insert", "drive": 0,
|
||||
"media_id": declaration.media[0].id, "media_sha256": declaration.media[0].baseSHA256, "write_protected": false])
|
||||
_ = try await test.reply("restart_playtest", arguments: ["run_id": test.runID, "request_id": "restart"])
|
||||
_ = try await test.reply("playtest_input", arguments: ["run_id": test.runID, "request_id": "writable-write",
|
||||
"steps": [["keys": ["r"], "fields": 18], ["keys": [], "fields": 240]]])
|
||||
_ = try await test.pausePlaytest()
|
||||
let written = try await test.capture()
|
||||
let writtenRows = try XCTUnwrap(written["drives"] as? [[String: Any]])
|
||||
XCTAssertGreaterThan(writtenRows[0]["disk_writes"] as? Int ?? 0, 0)
|
||||
XCTAssertNotEqual(writtenRows[0]["disk_sha256"] as? String, declaration.media[0].baseSHA256)
|
||||
XCTAssertTrue((written["screen_text"] as? String ?? "").contains("WROTE HOME"))
|
||||
_ = try await test.reply("stop_playtest", arguments: ["run_id": test.runID, "request_id": "stop"])
|
||||
}
|
||||
}
|
||||
|
||||
func testMultiDriveExchangeChecksSharedControllerAndMalformedDriveBeforeMutation() async throws {
|
||||
let (helper, system, diskROM) = try inputs()
|
||||
for cpu in ["6809", "6309"] {
|
||||
let worker = try MediaWorkerClient(helper); defer { worker.close() }
|
||||
// Real guest selects FD0 and starts a read with motor disabled;
|
||||
// even an otherwise empty FD3 must refuse its own exchange.
|
||||
let commands = try CocoPaste("POKE65344,1:POKE65352,128\n", mode: .text)
|
||||
_ = try await worker.request(["op": "init", "system_rom": system.base64EncodedString(), "disk_rom": diskROM.base64EncodedString(),
|
||||
"disk": disk().base64EncodedString(), "boot_keys": commands.chords.map { NSNumber(value: $0) }, "cpu": cpu, "multi_drive": true])
|
||||
_ = try await worker.request(["op": "pause"])
|
||||
let before = try await worker.request(["op": "media_status"])
|
||||
XCTAssertEqual(before["floppy_busy"] as? Bool, true)
|
||||
for drive: Any in [true, 1.25, -1, 4] {
|
||||
await expectDiskFailure {
|
||||
_ = try await worker.request(["op": "exchange_media", "drive": drive, "expected_media_generation": 0, "expected_disk_sha256": ""])
|
||||
}
|
||||
}
|
||||
do {
|
||||
_ = try await worker.request(["op": "exchange_media", "drive": 3, "expected_media_generation": 0, "expected_disk_sha256": ""])
|
||||
XCTFail("A pending FD0 command must block FD3 replacement")
|
||||
} catch { XCTAssertTrue(error.localizedDescription.contains("playtest_media_busy")) }
|
||||
let after = try await worker.request(["op": "media_status"])
|
||||
XCTAssertEqual(before["drives"] as? NSArray, after["drives"] as? NSArray)
|
||||
for key in ["field_clock", "cycles", "generation", "pc", "boot"] { XCTAssertEqual(before[key] as? NSNumber, after[key] as? NSNumber) }
|
||||
let frozen = try await worker.request(["op": "stop"])
|
||||
XCTAssertEqual(frozen["media_frozen"] as? Bool, true)
|
||||
for drive in 0..<4 { _ = try await worker.request(["op": "export_media", "drive": drive]) }
|
||||
_ = try await worker.request(["op": "finish_stop"])
|
||||
}
|
||||
}
|
||||
|
||||
/// These are bounded negative protocol fixtures, not emulator evidence.
|
||||
/// Actual guest I/O is covered by the independent both-CPU tests above.
|
||||
private func faultingMultiDriveHelper(_ mode: String, root: URL) throws -> URL {
|
||||
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true, attributes: [.posixPermissions: 0o700])
|
||||
let path = root.appendingPathComponent("multi-wire-fixture")
|
||||
let source = """
|
||||
#!/usr/bin/env python3
|
||||
import sys,json,base64,hashlib,os
|
||||
mode=\(String(reflecting: mode))
|
||||
disks=[None]*4; ids=[None]*4; gens=[0]*4; protections=[False]*4; originals=['']*4
|
||||
cpu='6809'; frozen=False; failed_export=False
|
||||
def digest(data): return hashlib.sha256(data).hexdigest() if data else ''
|
||||
def row(drive):
|
||||
data=disks[drive]
|
||||
return {'drive':drive,'label':'FD'+str(drive),'inserted':data is not None,'disk_present':data is not None,
|
||||
'media_id':ids[drive],'disk_original_sha256':originals[drive],'disk_sha256':digest(data),
|
||||
'media_generation':gens[drive],'byte_count':len(data) if data else 0,'disk_dirty':False,
|
||||
'write_protected':protections[drive],'disk_reads':0,'disk_writes':0,'mount_read_bytes':0,'mount_write_bytes':0}
|
||||
def status():
|
||||
first=row(0)
|
||||
return {'cpu':cpu,'processor':'HD6309' if cpu=='6309' else 'MC6809','state':'paused',
|
||||
'media_id':first['media_id'],'disk_present':first['disk_present'],'disk_sha256':first['disk_sha256'],
|
||||
'disk_original_sha256':first['disk_original_sha256'],'media_generation':gens[0],
|
||||
'disk_dirty':False,'floppy_busy':False,'field_clock':0,'cycles':100,'generation':1,'boot':1,'pc':100,
|
||||
'drives':[row(d) for d in range(4)]}
|
||||
for line in sys.stdin:
|
||||
r=json.loads(line); op=r['op']; end=False
|
||||
with open(os.path.join(os.path.dirname(__file__),'trace.jsonl'),'a') as trace: trace.write(json.dumps(r)+'\\n')
|
||||
if op=='init':
|
||||
disks[0]=base64.b64decode(r['disk']); ids[0]=r['media_id']; cpu=r['cpu']; originals[0]=digest(disks[0]); out=status()
|
||||
elif op=='export_media':
|
||||
drive=r['drive']
|
||||
if mode=='partial-stop' and frozen and drive==2 and not os.path.exists(os.path.join(os.path.dirname(__file__),'retry')):
|
||||
print(json.dumps({'error':'fixture_partial_drain'}),flush=True); continue
|
||||
out=status(); out['exported_drive']=row(drive)
|
||||
if disks[drive] is not None: out['disk_base64']=base64.b64encode(disks[drive]).decode()
|
||||
if mode=='wrong-target' and not frozen and drive==1 and not failed_export:
|
||||
out['exported_drive']['media_id']='foreign'; failed_export=True
|
||||
elif op in ('media_status','capture','pause'): out=status()
|
||||
elif op=='exchange_media':
|
||||
drive=r['drive']; old=digest(disks[drive]); ids[drive]=r.get('media_id')
|
||||
disks[drive]=base64.b64decode(r['disk_base64']) if ids[drive] else None
|
||||
protections[drive]=r.get('write_protected',False); originals[drive]=digest(disks[drive]); gens[drive]+=1
|
||||
if mode=='exit-after-commit': os._exit(0)
|
||||
if mode=='mark-after-commit':
|
||||
with open(os.path.join(os.path.dirname(__file__),'committed'),'w') as marker: marker.write('committed')
|
||||
out=status(); out['previous_disk_sha256']=old; out['target_drive']=drive
|
||||
elif op=='stop':
|
||||
frozen=True; out=status(); out['media_frozen']=True
|
||||
elif op=='finish_stop': out=status(); end=True
|
||||
else:
|
||||
print(json.dumps({'error':'unexpected_operation'}),flush=True); continue
|
||||
print(json.dumps({'result':out}),flush=True)
|
||||
if end: break
|
||||
"""
|
||||
try Data(source.utf8).write(to: path)
|
||||
try FileManager.default.setAttributes([.posixPermissions: 0o700], ofItemAtPath: path.path)
|
||||
return path
|
||||
}
|
||||
|
||||
func testMultiDriveLostCommitRetainsAllFrozenCopiesAndMarksOnlyTargetUncertain() async throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiLostReply-" + UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let helper = try faultingMultiDriveHelper("exit-after-commit", root: root)
|
||||
let original = disk(); var data = disk(); data[0] = 93
|
||||
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-lost", primary: original, world: data)
|
||||
let test = try await MCPPlaytest.start(systemROM: Data(repeating: 0, count: 32768), diskROM: Data(repeating: 0, count: 8192), disk: original,
|
||||
bootCommands: "PRINT1\n", projectID: "multi-lost", revision: 1, artifactID: declaration.proof.artifactID!, helperURL: helper,
|
||||
retentionDirectory: root.appendingPathComponent("retained"), diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
|
||||
await expectDiskFailure {
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id": test.runID,"request_id":"lost","action":"insert","drive":1,
|
||||
"media_id":declaration.media[1].id,"media_sha256":declaration.media[1].baseSHA256])
|
||||
}
|
||||
await test.invalidate().value
|
||||
let receipt = try XCTUnwrap(test.finalReceipt)
|
||||
XCTAssertEqual(receipt["media_selection_uncertain"] as? Bool, true)
|
||||
XCTAssertEqual(receipt["uncertain_drives"] as? [Int], [1])
|
||||
let drives = try XCTUnwrap(receipt["drives"] as? [[String: Any]])
|
||||
XCTAssertEqual(drives[0]["media_id"] as? String, declaration.media[0].id)
|
||||
XCTAssertTrue(drives[1]["media_id"] is NSNull)
|
||||
let retained = try XCTUnwrap(receipt["retained_media"] as? [[String: Any]])
|
||||
XCTAssertEqual(retained.count, 2)
|
||||
for medium in declaration.media {
|
||||
let row = try XCTUnwrap(retained.first { $0["media_id"] as? String == medium.id })
|
||||
XCTAssertEqual(row["disk_sha256"] as? String, medium.baseSHA256)
|
||||
}
|
||||
}
|
||||
|
||||
func testMultiDrivePartialDrainRetriesWithoutASecondStopOrRepeatedEarlierExport() async throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiPartialDrain-" + UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let helper = try faultingMultiDriveHelper("partial-stop", root: root)
|
||||
let original = disk(), declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-partial", primary: original, world: original)
|
||||
let test = try await MCPPlaytest.start(systemROM: Data(repeating: 0, count: 32768), diskROM: Data(repeating: 0, count: 8192), disk: original,
|
||||
bootCommands: "PRINT1\n", projectID: "multi-partial", revision: 1, artifactID: declaration.proof.artifactID!, helperURL: helper,
|
||||
retentionDirectory: root.appendingPathComponent("retained"), diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
|
||||
defer { test.invalidate() }
|
||||
let stop: [String: Any] = ["run_id":test.runID,"request_id":"stop"]
|
||||
await expectDiskFailure { _ = try await test.reply("stop_playtest", arguments: stop) }
|
||||
XCTAssertNotNil(test.retentionError)
|
||||
try Data("retry".utf8).write(to: root.appendingPathComponent("retry"))
|
||||
let stopped = try await test.reply("stop_playtest", arguments: stop)
|
||||
XCTAssertEqual(stopped["disk_retained"] as? Bool, true)
|
||||
let trace = try String(contentsOf: root.appendingPathComponent("trace.jsonl"), encoding: .utf8).split(separator:"\n").map {
|
||||
try XCTUnwrap(JSONSerialization.jsonObject(with: Data($0.utf8)) as? [String: Any])
|
||||
}
|
||||
XCTAssertEqual(trace.filter { $0["op"] as? String == "stop" }.count, 1)
|
||||
for drive in 0...1 { XCTAssertEqual(trace.filter { $0["op"] as? String == "export_media" && $0["drive"] as? Int == drive }.count, 1) }
|
||||
XCTAssertEqual(trace.filter { $0["op"] as? String == "export_media" && $0["drive"] as? Int == 2 }.count, 2)
|
||||
}
|
||||
|
||||
func testMultiDriveWrongExportTargetCannotPoisonAnotherMedium() async throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiWrongExport-" + UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let helper = try faultingMultiDriveHelper("wrong-target", root: root)
|
||||
let original = disk(); var data = disk(); data[0] = 95
|
||||
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-wrong", primary: original, world: data)
|
||||
let store = root.appendingPathComponent("retained")
|
||||
let test = try await MCPPlaytest.start(systemROM: Data(repeating: 0, count: 32768), diskROM: Data(repeating: 0, count: 8192), disk: original,
|
||||
bootCommands: "PRINT1\n", projectID: "multi-wrong", revision: 1, artifactID: declaration.proof.artifactID!, helperURL: helper,
|
||||
retentionDirectory: store, diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
|
||||
defer { test.invalidate() }
|
||||
await expectDiskFailure {
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id":test.runID,"request_id":"wrong","action":"insert","drive":1,
|
||||
"media_id":declaration.media[1].id,"media_sha256":declaration.media[1].baseSHA256])
|
||||
}
|
||||
let stopped = try await test.reply("stop_playtest", arguments: ["run_id":test.runID,"request_id":"stop"])
|
||||
let records = try XCTUnwrap(stopped["retained_media"] as? [[String: Any]])
|
||||
for medium in declaration.media {
|
||||
let record = try XCTUnwrap(records.first { $0["media_id"] as? String == medium.id })
|
||||
let id = try XCTUnwrap(record["retained_disk_id"] as? String)
|
||||
XCTAssertEqual(try Data(contentsOf: MCPPlaytestDiskStore.diskURL(directory: store,id:id)), medium.data)
|
||||
}
|
||||
}
|
||||
|
||||
func testMultiDriveRechecksRetainedOutgoingBytesBeforeAnotherReplacement() async throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiRetentionEvidence-" + UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let helper = try faultingMultiDriveHelper("normal", root: root)
|
||||
let original = disk(); var data = disk(); data[0] = 97
|
||||
let declaration = declaredMedia(artifact: UUID().uuidString, project: "multi-retained-evidence", primary: original, world: data)
|
||||
let store = root.appendingPathComponent("retained")
|
||||
let test = try await MCPPlaytest.start(systemROM: Data(repeating: 0, count: 32768), diskROM: Data(repeating: 0, count: 8192), disk: original,
|
||||
bootCommands: "PRINT1\n", projectID: "multi-retained-evidence", revision: 1, artifactID: declaration.proof.artifactID!, helperURL: helper,
|
||||
retentionDirectory: store, diskProvenance: declaration.proof, media: declaration.media, multiDrive: true)
|
||||
defer { test.invalidate() }
|
||||
let eject = try await test.reply("exchange_playtest_media", arguments: ["run_id":test.runID,"request_id":"eject","action":"eject"])
|
||||
let previous = try XCTUnwrap(eject["previous_media"] as? [String: Any])
|
||||
let retained = try XCTUnwrap(previous["retained_disk"] as? [String: Any])
|
||||
let retainedID = try XCTUnwrap(retained["retained_disk_id"] as? String)
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id":test.runID,"request_id":"restore","action":"insert",
|
||||
"media_id":declaration.media[0].id,"media_sha256":declaration.media[0].baseSHA256])
|
||||
let url = try MCPPlaytestDiskStore.diskURL(directory: store,id:retainedID)
|
||||
try data.write(to: url)
|
||||
await expectDiskFailure {
|
||||
_ = try await test.reply("exchange_playtest_media", arguments: ["run_id":test.runID,"request_id":"changed-evidence","action":"insert",
|
||||
"media_id":declaration.media[1].id,"media_sha256":declaration.media[1].baseSHA256])
|
||||
}
|
||||
let unchanged = try await test.capture()
|
||||
XCTAssertEqual(unchanged["media_id"] as? String, declaration.media[0].id)
|
||||
XCTAssertEqual(unchanged["disk_sha256"] as? String, declaration.media[0].baseSHA256)
|
||||
XCTAssertEqual(try Data(contentsOf:url), data, "The failed swap must not silently repair changed retention evidence")
|
||||
try original.write(to:url)
|
||||
_ = try await test.reply("stop_playtest", arguments:["run_id":test.runID,"request_id":"stop"])
|
||||
}
|
||||
|
||||
func testMultiDriveLateAuthorityLossPreservesAcknowledgedTargetReceipt() async throws {
|
||||
let root = FileManager.default.temporaryDirectory.appendingPathComponent("VCCMultiLateAuthority-" + UUID().uuidString)
|
||||
defer { try? FileManager.default.removeItem(at: root) }
|
||||
let helper = try faultingMultiDriveHelper("mark-after-commit", root:root)
|
||||
let original = disk(); var data = disk(); data[0] = 99
|
||||
let declaration = declaredMedia(artifact: UUID().uuidString, project:"multi-late-authority", primary:original,world:data)
|
||||
let test = try await MCPPlaytest.start(systemROM:Data(repeating:0,count:32768),diskROM:Data(repeating:0,count:8192),disk:original,
|
||||
bootCommands:"PRINT1\n",projectID:"multi-late-authority",revision:1,artifactID:declaration.proof.artifactID!,helperURL:helper,
|
||||
retentionDirectory:root.appendingPathComponent("retained"),diskProvenance:declaration.proof,media:declaration.media,multiDrive:true)
|
||||
defer { test.invalidate() }
|
||||
let request: [String:Any] = ["run_id":test.runID,"request_id":"commit","action":"insert","drive":1,"write_protected":true,
|
||||
"media_id":declaration.media[1].id,"media_sha256":declaration.media[1].baseSHA256]
|
||||
do {
|
||||
_ = try await test.reply("exchange_playtest_media",arguments:request,isCurrent:{ !FileManager.default.fileExists(atPath:root.appendingPathComponent("committed").path) })
|
||||
XCTFail("A committed exchange cannot return through expired authority")
|
||||
} catch { XCTAssertTrue(error.localizedDescription.contains("stale_run_after_commit")) }
|
||||
let acknowledged = try await test.reply("exchange_playtest_media",arguments:request)
|
||||
XCTAssertEqual(acknowledged["target_drive"] as? Int,1)
|
||||
let rows = try XCTUnwrap(acknowledged["drives"] as? [[String:Any]])
|
||||
XCTAssertEqual(rows[1]["media_id"] as? String,declaration.media[1].id)
|
||||
XCTAssertEqual(rows[1]["media_generation"] as? Int,1)
|
||||
XCTAssertEqual(rows[1]["write_protected"] as? Bool,true)
|
||||
let stopped = try await test.reply("stop_playtest",arguments:["run_id":test.runID,"request_id":"stop"])
|
||||
let records = try XCTUnwrap(stopped["retained_media"] as? [[String:Any]])
|
||||
XCTAssertEqual(records.first { $0["media_id"] as? String == declaration.media[1].id }?["write_protected"] as? Bool,true)
|
||||
}
|
||||
|
||||
private func declaredMedia(artifact: String, project: String, primary: Data, world: Data)
|
||||
-> (key: String, proof: MCPPlaytestDiskStore.Provenance, media: [MCPPlaytestMedium]) {
|
||||
let key = CMOCProject.sha256(Data(project.utf8)), primaryHash = CMOCProject.sha256(primary)
|
||||
|
||||
Reference in new issue
Block a user