Files
VCCPlusOSS/platforms/macos/Tests/MCPDebuggerInspectionTests.swift
Brian Holman 5534005799 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.
2026-11-17 08:42:27 -07:00

204 lines
14 KiB
Swift

// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import AppKit
@MainActor
final class MCPDebuggerInspectionTests: XCTestCase {
private let resources = URL(fileURLWithPath: #filePath).deletingLastPathComponent()
.deletingLastPathComponent().appendingPathComponent("LocalResources")
private func command(_ operation: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot {
await withCheckedContinuation { c in operation { c.resume(returning: $0) } }
}
func testMemoryIsFrozenScopedBoundedAndCPUSpecific() async throws {
for enhanced in [false, true] {
let controller = VCCMachineController()
_ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) }
_ = await command { controller.loadDiagnostic(use6309: enhanced, completion: $0) }
_ = await command { controller.debuggerWriteMemory(address: 0x4000, data: Data([0xa5, 0x5a]), completion: $0) }
let capture: VCCDebuggerSnapshot = await withCheckedContinuation { c in
controller.debuggerSnapshot(address: 0, followPC: true, memoryAddress: 0x4000) { c.resume(returning: $0) }
}
let snapshot = try MCPDebuggerInspection(runID: "run", capture: capture, scope: [:], sourceStop: nil,
watches: [], watchStatus: "unavailable", ranges: [0x4000..<0x4002, 0xff00..<0xff01])
let regs = try XCTUnwrap(snapshot.fields["registers"] as? [String: Int])
XCTAssertEqual(regs["pc"], Int(capture.machine.programCounter))
XCTAssertEqual(regs["e"] != nil, enhanced)
func read(_ address: Any, _ count: Any, run: String = "run", id: String? = nil) throws -> [Int]? {
try snapshot.reply(tool: "read_debug_memory", arguments: ["address": address, "count": count,
"run_id": run, "snapshot_id": id ?? snapshot.id])["bytes"] as? [Int]
}
_ = await command { controller.debuggerWriteMemory(address: 0x4000, data: Data([0x55]), completion: $0) }
XCTAssertEqual(try read(0x4000, 2), [0xa5, 0x5a])
for address in [0, 0x3fff, 0x4001, 0xfeff, 0xff00, 0xffff] { XCTAssertThrowsError(try read(address, 2)) }
for count: Any in [0, -1, 257, true, 1.5] { XCTAssertThrowsError(try read(0x4000, count)) }
XCTAssertThrowsError(try read(0x4000, 1, run: "other"))
XCTAssertThrowsError(try read(0x4000, 1, id: "other"))
XCTAssertThrowsError(try snapshot.reply(tool: "get_debug_snapshot", arguments: ["run_id": "run", "expression": "PEEK(0)"]))
_ = await command(controller.shutdown)
}
}
#if DEBUG
private func machine(at directory: URL, enhanced: Bool) async throws -> MachineModel {
_ = NSApplication.shared
let roms = resources.appendingPathComponent("ROMs")
try XCTSkipUnless(["coco3.rom", "disk11.rom"].allSatisfy { FileManager.default.fileExists(atPath: roms.appendingPathComponent($0).path) },
"Requires the licensed local BASIC ROMs.")
let suite = "MCPDebugTests-" + UUID().uuidString
let defaults = try XCTUnwrap(UserDefaults(suiteName: suite))
addTeardownBlock { UserDefaults.standard.removePersistentDomain(forName: suite) }
let machine = MachineModel(diskStore: .init(url: directory.appendingPathComponent("disks.json")), displayDefaults: defaults,
inputStore: .init(url: directory.appendingPathComponent("input.json")))
let end = ContinuousClock.now.advanced(by: .seconds(5))
while machine.busy && ContinuousClock.now < end { try await Task.sleep(for: .milliseconds(20)) }
try await MCPBASICRun.bootFixture(machine, romDirectory: roms, use6309: enhanced)
return machine
}
private func directory() throws -> URL {
let root = FileManager.default.temporaryDirectory.appendingPathComponent("MCPDebugger-" + UUID().uuidString)
try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true)
addTeardownBlock { try? FileManager.default.removeItem(at: root) }
return root
}
func testBASICSourceStopWatchMemoryAndEditedDocumentRejection() async throws {
let root = try directory()
let machine = try await machine(at: root, enhanced: false)
defer { machine.shutdown() }
let model = BASICDevelopmentModel(machine: machine, directory: root, initialSource: "10 A=7\n20 PRINT A\n30 END")
model.toggleBreakpoint(20)
model.watchEntry = "A"; model.addWatch()
let host = MCPBASICRun()
await host.start(model: model, bothChoices: false, isCurrent: { true })
let id = try XCTUnwrap(host.runID, host.status)
var result: [String: Any] = [:]
let deadline = ContinuousClock.now.advanced(by: .seconds(3))
repeat {
result = await host.handle(tool: "get_debug_snapshot", arguments: ["run_id": id], model: model)
if result["result"] != nil { break }
try await Task.sleep(for: .milliseconds(25))
} while ContinuousClock.now < deadline
let snapshot = try XCTUnwrap(result["result"] as? [String: Any], String(describing: result))
XCTAssertEqual((snapshot["source_stop"] as? [String: Int])?["line"], 20)
let watches = try XCTUnwrap(snapshot["watches"] as? [[String: String]])
XCTAssertEqual(watches.first?["value"], "7")
let ranges = try XCTUnwrap(snapshot["memory_ranges"] as? [[String: Int]])
let args: [String: Any] = ["run_id": id, "snapshot_id": try XCTUnwrap(snapshot["snapshot_id"] as? String),
"address": try XCTUnwrap(ranges.first?["address"]), "count": 4]
let read = await host.handle(tool: "read_debug_memory", arguments: args, model: model)
XCTAssertEqual(((read["result"] as? [String: Any])?["bytes"] as? [Int])?.suffix(2), [0, 10])
model.source = "10 END"
let stale = await host.handle(tool: "read_debug_memory", arguments: args, model: model)
XCTAssertNotNil(stale["error"])
}
func testOrdinaryCMOCStopsAtMainWithCompiledWatchAndNoDisk() async throws {
let root = try directory(), toolchain = vccQualificationToolchain(resources.appendingPathComponent("ToolchainBundle"))
try XCTSkipUnless(FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path),
"Requires the local staged toolchain.")
let machine = try await machine(at: root, enhanced: true)
defer { machine.shutdown() }
let model = CMOCDevelopmentModel(machine: machine, toolchain: toolchain, buildRoot: root.appendingPathComponent("Builds"),
recoveryRoot: root.appendingPathComponent("Recovery"))
let project = try CMOCProject.create(at: root.appendingPathComponent("C"))
let file = "#include <cmoc.h>\nunsigned int total = 37;\nint main(void)\n{\n total += 5;\n printf(\"RESULT %u\\n\", total);\n return 0;\n}\n"
let artifact = try await model.service.build(project: project, overlays: ["main.c": file], action: .build, configuration: "Debug")
var saved: MCPDebuggerInspection?
let receipt = try await MCPCMOCGuest.runOrdinary(model: model, build: artifact, play: true, isCurrent: { true }) { capture, info, point in
saved = try MCPCMOCGuest.inspection(runID: "native", revision: 2, projectID: "project", build: artifact, capture: capture,
info: info, point: point, watches: ["total", "*((int*) 0xff00)"], sharedPaths: ["main.c"])
}
let snapshot = try XCTUnwrap(saved)
XCTAssertEqual(snapshot.fields["processor"] as? String, "HD6309")
XCTAssertEqual(receipt["artifact_id"] as? String, artifact.id.uuidString)
XCTAssertEqual((snapshot.fields["source_stop"] as? [String: Any])?["path"] as? String, "main.c")
let watches = try XCTUnwrap(snapshot.fields["watches"] as? [[String: String]])
XCTAssertEqual(watches.first?["value"], "37")
XCTAssertNotNil(watches.last?["unavailable"])
XCTAssertFalse(snapshot.machine.disks.contains { $0.mounted })
XCTAssertEqual(receipt["status"] as? String, "continued_from_main")
let deadline = ContinuousClock.now.advanced(by: .seconds(6))
var end = await machine.mcpMachineSnapshot()
while !end.assistantCompiledReturned && ContinuousClock.now < deadline {
try await Task.sleep(for: .milliseconds(30))
end = await machine.mcpMachineSnapshot()
}
XCTAssertTrue(end.assistantCompiledReturned)
XCTAssertTrue(MCPDebuggerInspection.sameProgram(end, snapshot.machine))
let io = MCPCompiledRunIO(machine: machine, runID: "native", expected: snapshot.machine, assembly: false)
let text = try await io.finalScreenText()
XCTAssertTrue(text?.contains("RESULT 42") == true, text ?? "Missing final screen")
do {
_ = try await io.reply("send_keys", arguments: ["run_id": "native", "request_id": "late", "keys": "1"])
XCTFail("A key after program return must not reach the BASIC prompt.")
} catch { XCTAssertEqual(error.localizedDescription, "run_finished") }
let inspected = try await MCPCMOCGuest.runOrdinary(model: model, build: artifact, isCurrent: { true }) { _, _, _ in }
let paused = await machine.mcpMachineSnapshot()
XCTAssertEqual(inspected["status"] as? String, "paused")
XCTAssertEqual(paused.state, .paused)
XCTAssertNotEqual(paused.debuggerProgramRevision, snapshot.machine.debuggerProgramRevision)
}
func testHelloDiskKeepsCapturedInspectionAfterContinueAndEject() async throws {
let root = try directory(), toolchain = vccQualificationToolchain(resources.appendingPathComponent("ToolchainBundle"))
try XCTSkipUnless(FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path),
"Requires the local staged toolchain.")
let machine = try await machine(at: root, enhanced: false)
defer { machine.shutdown() }
let model = CMOCDevelopmentModel(machine: machine, toolchain: toolchain, buildRoot: root.appendingPathComponent("Builds"),
recoveryRoot: root.appendingPathComponent("Recovery"))
let template = resources.deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent()
.appendingPathComponent("examples/cmoc/HelloDisk")
let project = try CMOCProject.createHelloDisk(at: root.appendingPathComponent("Disk"), templateDirectory: template)
let artifact = try await model.service.build(project: project, overlays: [:], action: .disk, configuration: "Debug")
var saved: MCPDebuggerInspection?
let receipt = try await MCPCMOCGuest.run(model: model, build: artifact, isCurrent: { true }) { capture, info, point in
saved = try MCPCMOCGuest.inspection(runID: "disk", revision: 1, projectID: "shared", build: artifact, capture: capture,
info: info, point: point, watches: [], sharedPaths: Set(MCPCMOCProject.diskPaths))
}
let snapshot = try XCTUnwrap(saved), now = await machine.mcpMachineSnapshot()
XCTAssertTrue((receipt["screen"] as? String)?.contains("DISK RESULT: 0") == true)
XCTAssertFalse(now.disks.contains { $0.mounted })
XCTAssertTrue(MCPDebuggerInspection.sameProgram(now, snapshot.machine))
XCTAssertEqual((snapshot.fields["source_stop"] as? [String: Any])?["address"] as? Int,
(receipt["source_stop"] as? [String: Any])?["address"] as? Int)
}
#endif
}
extension MCPDebuggerInspectionTests {
func testOwnedCallContextIdentityRejectsSameClockGuestChanges() throws {
let base: [String: Any] = ["boot": 1, "field_clock": 2, "machine_frame": 3, "cycles": 4, "generation": 5,
"pc": 0x3100, "registers": ["PC": 0x3100, "S": 0x7000, "U": 0x7100],
"processor": "MC6809", "execution_mode": "not_applicable", "md_register": NSNull(),
"mapping_fingerprint": "mapping-1", "program_revision": 1, "physical_pages": ["3": 56],
"logical_memory": Data(repeating: 0, count: 65536).base64EncodedString(),
"available": Data(repeating: 1, count: 65536).base64EncodedString()]
let expected = try XCTUnwrap(MCPCMOC.ownedCaptureFingerprint(base))
for (key, value): (String, Any) in [
("boot", 2), ("field_clock", 3), ("machine_frame", 4), ("cycles", 5), ("generation", 6),
("pc", 0x3101), ("registers", ["PC": 0x3100, "S": 0x7002, "U": 0x7100]),
("processor", "HD6309"), ("execution_mode", "native"), ("md_register", 1),
("mapping_fingerprint", "mapping-2"), ("program_revision", 2), ("physical_pages", ["3": 57]),
("residency_fingerprint", "changed-owner"),
("logical_memory", Data(repeating: 1, count: 65536).base64EncodedString()),
("available", Data(repeating: 0, count: 65536).base64EncodedString())] {
var changed = base; changed[key] = value
XCTAssertNotEqual(MCPCMOC.ownedCaptureFingerprint(changed), expected, key)
}
var budgetOnly = base; budgetOnly["remaining_field_budget"] = 7; budgetOnly["remaining_requests"] = 9
XCTAssertEqual(MCPCMOC.ownedCaptureFingerprint(budgetOnly), expected,
"Read-request bookkeeping is independent of immutable guest identity")
for key in base.keys where key != "md_register" {
var missing = base; missing.removeValue(forKey: key)
XCTAssertNil(MCPCMOC.ownedCaptureFingerprint(missing), key)
}
var reordered = [String: Any]()
for key in base.keys.sorted().reversed() { reordered[key] = base[key] }
XCTAssertEqual(MCPCMOC.ownedCaptureFingerprint(reordered), expected)
}
}