// SPDX-License-Identifier: GPL-3.0-or-later import XCTest final class CMOCDevelopmentTests: XCTestCase { @MainActor private func command(_ operation: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot { await withCheckedContinuation { continuation in operation { continuation.resume(returning: $0) } } } @MainActor private func capture(_ controller: VCCMachineController, memory: UInt16 = 0x4000) async -> VCCDebuggerSnapshot { await withCheckedContinuation { continuation in controller.debuggerSnapshot(address: 0x4100, followPC: true, memoryAddress: memory) { continuation.resume(returning: $0) } } } private func binary(address: UInt16 = 0x4100, entry: UInt16 = 0x4100, bytes: [UInt8] = [0x86, 0x2A, 0xB7, 0x40, 0x00, 0x4C, 0xB7, 0x40, 0x01, 0x20, 0xFE]) -> Data { Data([0, UInt8(bytes.count >> 8), UInt8(bytes.count & 255), UInt8(address >> 8), UInt8(address & 255)] + bytes + [255, 0, 0, UInt8(entry >> 8), UInt8(entry & 255)]) } @MainActor private func waitForStop(_ controller: VCCMachineController) async -> VCCMachineSnapshot { var result = await command(controller.snapshot) for _ in 0..<200 where result.state == .running { try? await Task.sleep(nanoseconds: 10_000_000) result = await command(controller.snapshot) } XCTAssertEqual(result.state, .paused) return result } @MainActor func testDevelopmentLoadArmsEntryAndLaterBreakpointsAtomicallyOnBothCPUs() async { for use6309 in [false, true] { let controller = VCCMachineController() _ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) } _ = await command { controller.loadDiagnostic(use6309: use6309, completion: $0) } _ = await command { controller.debuggerWriteMemory(address: 0x4000, data: Data([0xA5, 0x5A]), completion: $0) } _ = await command { controller.debuggerConfigureBreakpoints([0x4500], disabled: [0x4100, 0x4501], completion: $0) } let before = await capture(controller) let loaded = await command { controller.debuggerLoadBinary(binary(), breakpoint: 0x4100, completion: $0) } XCTAssertNil(loaded.errorMessage) let entry = await waitForStop(controller) let entryDetail = await capture(controller) XCTAssertEqual(entry.programCounter, 0x4100) XCTAssertEqual(entry.cycles, before.machine.cycles, "Entry breakpoint must stop before the very first instruction") XCTAssertEqual(entry.generation, before.machine.generation, "Loading a build must preserve the machine session") XCTAssertEqual(entryDetail.memory.prefix(2), Data([0xA5, 0x5A])) XCTAssertEqual(Set(entryDetail.breakpoints.map(\.uint16Value)), Set([UInt16(0x4100), 0x4500])) XCTAssertEqual(entryDetail.disabledBreakpoints, [0x4501], "Arming a disabled breakpoint must retain unrelated disabled addresses") _ = await command { controller.debuggerConfigureBreakpoints([0x4500], disabled: [0x4501], completion: $0) } let loadedAgain = await command { controller.debuggerLoadBinary(binary(), breakpoint: 0x4105, completion: $0) } XCTAssertNil(loadedAgain.errorMessage) let later = await waitForStop(controller) let laterDetail = await capture(controller) XCTAssertEqual(later.programCounter, 0x4105) XCTAssertGreaterThan(later.cycles, entry.cycles) XCTAssertEqual(laterDetail.memory.prefix(2), Data([0x2A, 0x5A]), "Only instructions before the selected breakpoint should execute") XCTAssertEqual(Set(laterDetail.breakpoints.map(\.uint16Value)), Set([UInt16(0x4105), 0x4500])) XCTAssertEqual(laterDetail.disabledBreakpoints, [0x4501]) _ = await command(controller.shutdown) } } @MainActor func testDevelopmentLoadRejectsInvalidImagesWithoutMutatingMachineOrBreakpoints() async { for use6309 in [false, true] { let controller = VCCMachineController() _ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) } _ = await command { controller.loadDiagnostic(use6309: use6309, completion: $0) } _ = await command { controller.debuggerConfigureBreakpoints([0x4500], disabled: [0x4501], completion: $0) } let before = await capture(controller) let beforeProgram = await capture(controller, memory: 0x4100) let invalid: [(Data, UInt16)] = [ (Data(binary().dropLast(5)) + binary(address: 0xFF00, entry: 0x4100), 0x4100), (Data([0, 0, 5, 0x41, 0, 0x86]), 0x4100), (binary(), 0x4200), (binary(entry: 0x4200), 0x4100), (binary(address: 0xFF00, entry: 0xFF00), 0xFF00), (binary(address: 0x8000, entry: 0x8000), 0x8000) ] for (image, breakpoint) in invalid { let result = await command { controller.debuggerLoadBinary(image, breakpoint: breakpoint, completion: $0) } XCTAssertNotNil(result.errorMessage) let after = await capture(controller) XCTAssertEqual(after.machine.state, .paused) XCTAssertEqual(after.machine.programCounter, before.machine.programCounter) XCTAssertEqual(after.machine.cycles, before.machine.cycles) XCTAssertEqual(after.machine.generation, before.machine.generation) XCTAssertEqual(after.machine.debuggerProgramRevision, before.machine.debuggerProgramRevision) XCTAssertEqual(after.machine.debuggerMappingFingerprint, before.machine.debuggerMappingFingerprint) XCTAssertEqual(after.memory, before.memory) XCTAssertEqual(after.breakpoints, before.breakpoints) XCTAssertEqual(after.disabledBreakpoints, before.disabledBreakpoints) let afterProgram = await capture(controller, memory: 0x4100) XCTAssertEqual(afterProgram.memory, beforeProgram.memory) } _ = await command(controller.shutdown) } } @MainActor func testDevelopmentBreakpointOwnershipAndProgramRevision() async { for use6309 in [false, true] { let controller = VCCMachineController() _ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) } _ = await command { controller.loadDiagnostic(use6309: use6309, completion: $0) } _ = await command { controller.debuggerConfigureBreakpoints([0x4500], disabled: [0x4100, 0x4501], completion: $0) } let before = await capture(controller) _ = await command { controller.debuggerLoadBinary(binary(), breakpoint: 0x4100, completion: $0) } let first = await waitForStop(controller) XCTAssertGreaterThan(first.debuggerProgramRevision, before.machine.debuggerProgramRevision) XCTAssertEqual(first.debuggerMappingFingerprint, before.machine.debuggerMappingFingerprint) _ = await command(controller.debuggerStep) let stepped = await capture(controller) XCTAssertEqual(stepped.machine.debuggerProgramRevision, first.debuggerProgramRevision, "Execution must not invalidate its own source provenance") _ = await command { controller.debuggerLoadBinary(binary(), breakpoint: 0x4105, completion: $0) } _ = await waitForStop(controller) let second = await capture(controller) XCTAssertEqual(Set(second.breakpoints.map(\.uint16Value)), Set([UInt16(0x4105), 0x4500])) XCTAssertEqual(Set(second.disabledBreakpoints.map(\.uint16Value)), Set([UInt16(0x4100), 0x4501]), "Moving the development breakpoint must restore a user's disabled breakpoint") _ = await command { controller.debuggerLoadBinary(binary(), breakpoint: 0x4106, completion: $0) } _ = await waitForStop(controller) let third = await capture(controller) XCTAssertEqual(Set(third.breakpoints.map(\.uint16Value)), Set([UInt16(0x4106), 0x4500]), "An obsolete development breakpoint must not stop the new build") _ = await command { controller.debuggerWriteMemory(address: 0x4000, data: Data([0x55]), completion: $0) } let edited = await capture(controller) XCTAssertGreaterThan(edited.machine.debuggerProgramRevision, third.machine.debuggerProgramRevision) _ = await command { controller.debuggerConfigureBreakpoints([0x4100, 0x4500], disabled: [0x4501], completion: $0) } _ = await command { controller.debuggerLoadBinary(binary(), breakpoint: 0x4100, completion: $0) } _ = await waitForStop(controller) _ = await command { controller.debuggerLoadBinary(binary(), breakpoint: 0x4105, completion: $0) } _ = await waitForStop(controller) let existing = await capture(controller) XCTAssertEqual(Set(existing.breakpoints.map(\.uint16Value)), Set([UInt16(0x4100), 0x4105, 0x4500]), "The feature must not claim or remove a preexisting enabled breakpoint") _ = await command(controller.shutdown) } } @MainActor func testCompiledEditedProgramStopsAtVerifiedCLineOnBothCPUs() async throws { let resources = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent().appendingPathComponent("LocalResources") let toolchain = vccQualificationToolchain(resources.appendingPathComponent("ToolchainBundle")) let romURL = resources.appendingPathComponent("ROMs/coco3.rom") try XCTSkipUnless(FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path) && FileManager.default.fileExists(atPath: romURL.path), "Local licensed CoCo ROM and staged toolchain are required") let folder = FileManager.default.temporaryDirectory.appendingPathComponent("CMOCExecutionTests-\(UUID().uuidString)") try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: false) defer { try? FileManager.default.removeItem(at: folder) } let project = try CMOCProject.create(at: folder.appendingPathComponent("Project")) let source = CMOCProject.starterSource.replacingOccurrences(of: "What planet do you live on?", with: "Which planet is yours?") let artifact = try await CMOCBuildService(toolchain: toolchain, buildRoot: folder.appendingPathComponent("Builds")).build(project: project, source: source) let mapping = try CMOCSourceMap.parse(source: artifact.sourceData, sourceName: artifact.sourceURL.path, listing: Data(contentsOf: artifact.listingURL), object: Data(contentsOf: artifact.objectURL), objectName: "main.o", linkMap: Data(contentsOf: artifact.mapURL), binary: artifact.binaryData) let promptLine = try XCTUnwrap(source.components(separatedBy: "\n").firstIndex { $0.contains("Which planet is yours?") }) + 1 let instruction = try XCTUnwrap(mapping.instructions.first { $0.sourceLine == promptLine }) let rom = try Data(contentsOf: romURL) for use6309 in [false, true] { let controller = VCCMachineController() _ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) } let loaded = await command { controller.loadROM(rom, use6309: use6309, completion: $0) } XCTAssertNil(loaded.errorMessage) _ = await command(controller.resume) try await Task.sleep(nanoseconds: 1_500_000_000) _ = await command(controller.pause) let before = await capture(controller) let result = await command { controller.debuggerLoadBinary(artifact.binaryData, breakpoint: instruction.address, completion: $0) } XCTAssertNil(result.errorMessage) let stopped = await waitForStop(controller) let snapshot = await capture(controller) XCTAssertEqual(stopped.programCounter, instruction.address) XCTAssertEqual(mapping.line(at: stopped.programCounter), promptLine) XCTAssertEqual(snapshot.instructions.first?.address, instruction.address) XCTAssertEqual(snapshot.instructions.first?.bytes, Data(instruction.bytes), "The live machine must contain the exact relocated instruction verified by the C map") XCTAssertEqual(stopped.generation, before.machine.generation) XCTAssertGreaterThan(stopped.cycles, before.machine.cycles) _ = await command(controller.shutdown) } } @MainActor func testBundledDiskAPIWritesClosesReopensAndReadsAnIsolatedFloppyOnBothCPUs() async throws { try await checkDiskAPIRoundTrip(standalone: false) } @MainActor func testStandaloneDiskAPIReadsAndWritesWithBASICBankedOutOnBothCPUs() async throws { try await checkDiskAPIRoundTrip(standalone: true) } @MainActor private func checkDiskAPIRoundTrip(standalone: Bool) async throws { let mac = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() let resources = mac.appendingPathComponent("LocalResources") let toolchain = vccQualificationToolchain(resources.appendingPathComponent("ToolchainBundle")) let romURL = resources.appendingPathComponent("ROMs/coco3.rom") let diskROMURL = resources.appendingPathComponent("ROMs/disk11.rom") try XCTSkipUnless(FileManager.default.fileExists(atPath: toolchain.appendingPathComponent("share/cmoc/lib/libdecbfile.a").path) && FileManager.default.fileExists(atPath: romURL.path) && FileManager.default.fileExists(atPath: diskROMURL.path), "The local ROMs and bundled DECB file library are required") let folder = FileManager.default.temporaryDirectory.appendingPathComponent("CMOCDiskAPITests-\(UUID().uuidString)") try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: false) defer { try? FileManager.default.removeItem(at: folder) } let project = try CMOCProject.create(at: folder.appendingPathComponent("Project")) // Authored fixture: use the public file API through the running Disk // BASIC ROM. No host-side disk writer substitutes for guest file I/O. var source = """ #include #include DECBDrive drives[1]; DECBFile file; byte written[256], readBack[256]; byte testResult; byte roundTrip(void) { word i; if (decb_init(drives, 1) != DECB_OK) return 1; if (decb_registerDrive(0) != DECB_OK) return 2; if (decb_createSectorFile(&file, 0, "ROUND.DAT", DECB_TYPE_BASIC_DATA, DECB_FORMAT_BINARY) != DECB_OK) return 3; for (i = 0; i < 256; ++i) written[i] = (byte) (i ^ 0x5A); if (decb_writeSector(&file, written, 0) != DECB_OK) return 4; decb_setNumBytesUsedInLastSector(&file, 256); if (decb_closeSectorFile(&file) != DECB_OK) return 5; if (decb_openSectorFile(&file, 0, "ROUND.DAT") != DECB_OK) return 6; if (decb_readSector(&file, readBack, 0) != DECB_OK) return 7; if (memcmp(written, readBack, 256) != 0) return 8; if (decb_closeSectorFile(&file) != DECB_OK) return 9; return DECB_OK; } int main(void) { initCoCoSupport(); setHighSpeed(FALSE); testResult = roundTrip(); if (decb_shutdown() != DECB_OK) testResult = 10; printf("DISK ROUND TRIP RESULT: %u\\n", testResult); return testResult; } """ if standalone { try XCTSkipUnless(FileManager.default.fileExists(atPath: toolchain.appendingPathComponent("share/cmoc/lib/libdskcon-standalone.a").path), "Stage the separately supplied standalone disk driver") var makefile = try String(contentsOf: project.makefileURL) makefile = makefile.replacingOccurrences(of: "LIBS ?= -ldecbfile", with: "LIBS ?= -ldecbfile -ldskcon-standalone") try makefile.write(to: project.makefileURL, atomically: true, encoding: .utf8) source = source.replacingOccurrences(of: "#include ", with: """ #include #include interrupt asm void diskIRQ(void) { asm { _dskcon_irqService IMPORT ldb $FF03 bpl @done ldb $FF02 lbsr _dskcon_irqService @done } } """) source = source.replacingOccurrences(of: "if (decb_registerDrive(0) != DECB_OK) return 2;", with: """ if (*(volatile word *)0xC004 != 0x5A5A) return 11; decb_setDskConAddresses(dskcon_processSector, (DECBDskConVariables *)&DCOPC); if (decb_registerDrive(0) != DECB_OK) return 2; """) source = source.replacingOccurrences(of: "testResult = roundTrip();", with: """ disableInterrupts(); asm("CLR", "$FFDF"); *(volatile word *)0xC004 = 0x5A5A; { byte *irq = *(byte **)0xFFF8; *irq = 0x7E; *(word *)(irq + 1) = (word)diskIRQ; } dskcon_init(dskcon_nmiService); enableInterrupts(); testResult = roundTrip(); """) } let line = try XCTUnwrap(source.components(separatedBy: "\n").firstIndex { $0.contains("printf(") }) + 1 let artifact = try await CMOCBuildService(toolchain: toolchain, buildRoot: folder.appendingPathComponent("Builds")).build(project: project, source: source) let mapData = try Data(contentsOf: artifact.mapURL) let mapping = try CMOCSourceMap.parse(source: artifact.sourceData, sourceName: artifact.sourceURL.path, listing: Data(contentsOf: artifact.listingURL), object: Data(contentsOf: artifact.objectURL), objectName: "main.o", linkMap: mapData, binary: artifact.binaryData) let instruction = try XCTUnwrap(mapping.instructions.first { $0.sourceLine == line }) let symbol = try XCTUnwrap(String(decoding: mapData, as: UTF8.self).components(separatedBy: "\n") .first { $0.hasPrefix("Symbol: _testResult (main.o) = ") }) let resultAddress = try XCTUnwrap(UInt16(try XCTUnwrap(symbol.split(separator: " ").last), radix: 16)) let rom = try Data(contentsOf: romURL), diskROM = try Data(contentsOf: diskROMURL) let blankURL = mac.appendingPathComponent("Resources/StarterMedia/Blank Disk.dsk") let blank = try Data(contentsOf: blankURL) for use6309 in [false, true] { let localDisk = folder.appendingPathComponent(use6309 ? "6309.dsk" : "6809.dsk") try blank.write(to: localDisk) let controller = VCCMachineController() _ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) } let configured = await command { controller.loadDiskROM(diskROM, name: "Disk BASIC", completion: $0) } XCTAssertNil(configured.errorMessage) let layout = await command { controller.configureCartridges([2,0,0,0,2], roms: Array(repeating: Data(), count: 5), names: Array(repeating: "", count: 5), multiPak: true, physicalSlot: 4, completion: $0) } XCTAssertNil(layout.errorMessage) let mounted = await command { controller.mountDisk(blank, drive: 0, name: localDisk.lastPathComponent, readOnly: false, completion: $0) } XCTAssertNil(mounted.errorMessage) _ = await command { controller.loadROM(rom, use6309: use6309, completion: $0) } _ = await command(controller.resume) try await Task.sleep(nanoseconds: 1_500_000_000) _ = await command(controller.pause) let loaded = await command { controller.debuggerLoadBinary(artifact.binaryData, breakpoint: instruction.address, completion: $0) } XCTAssertNil(loaded.errorMessage) var stopped = loaded for _ in 0..<1000 where stopped.state == .running { try await Task.sleep(nanoseconds: 10_000_000) stopped = await command(controller.snapshot) } XCTAssertEqual(stopped.state, .paused) XCTAssertEqual(stopped.programCounter, instruction.address) let snapshot = await capture(controller, memory: resultAddress) XCTAssertEqual(snapshot.memory.first, 0, "Nonzero value identifies the failing guest disk API step") XCTAssertEqual(snapshot.instructions.first?.bytes, Data(instruction.bytes)) XCTAssertGreaterThan(stopped.disks[0].readEvents, 0) XCTAssertGreaterThan(stopped.disks[0].writeEvents, 0) let exported: Data? = await withCheckedContinuation { continuation in controller.exportDisk(inDrive: 0) { bytes, _, _ in continuation.resume(returning: bytes) } } XCTAssertNotNil(exported) if let exported { XCTAssertNotEqual(exported, blank) XCTAssertNotNil(exported.range(of: Data("ROUND DAT".utf8)), "The file must have a real DECB directory entry") try exported.write(to: localDisk) } _ = await command(controller.shutdown) } XCTAssertEqual(try Data(contentsOf: blankURL), blank, "The repository's starter disk must remain pristine") } @MainActor func testCallerSelectionPreservesExecutionAndResetsOnStepOrStaleSource() async throws { let mac = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() let staged = vccQualificationToolchain(mac.appendingPathComponent("LocalResources/ToolchainBundle")) let bundled = Bundle.main.resourceURL!.appendingPathComponent("Toolchain") let toolchain = vccQualificationToolchain(FileManager.default.isExecutableFile(atPath: bundled.appendingPathComponent("bin/cmoc").path) ? bundled : staged) let romURL = mac.appendingPathComponent("LocalResources/ROMs/coco3.rom") try XCTSkipUnless(FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path) && FileManager.default.fileExists(atPath: romURL.path), "Stage the local compiler and CoCo ROM") let root = FileManager.default.temporaryDirectory.appendingPathComponent("CMOCCallerSelection-\(UUID().uuidString)") try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) let suite = "CMOCCallerSelection.\(UUID().uuidString)" let defaults = UserDefaults(suiteName: suite)! defer { defaults.removePersistentDomain(forName: suite); try? FileManager.default.removeItem(at: root) } let pageGlobals = (0..<40).map { String(format: "unsigned int page%02d;", $0) }.joined(separator: "\n") let source = """ #include unsigned int score; unsigned int grid[12][40]; struct Info { unsigned int marker; unsigned int samples[2]; }; \(pageGlobals) unsigned int recurse(unsigned int n) { unsigned int local = n + 10; unsigned int items[40]; struct Info info; items[0] = n + 20; items[35] = n + 55; info.marker = n + 30; if (n == 0) { score = local; /* LEAF_STOP */ return local; /* NEXT_LEAF_LINE */ } local += recurse(n - 1); /* CALLER_SITE */ return local; } int main(void) { score = recurse(2); for (;;) ++score; return 0; } """ let lines = source.components(separatedBy: "\n") let leafLine = try XCTUnwrap(lines.firstIndex { $0.contains("LEAF_STOP") }) + 1 let nextLine = try XCTUnwrap(lines.firstIndex { $0.contains("NEXT_LEAF_LINE") }) + 1 let callerLine = try XCTUnwrap(lines.firstIndex { $0.contains("CALLER_SITE") }) + 1 let project = try CMOCProject.create(at: root.appendingPathComponent("Project")) try Data(source.utf8).write(to: project.sourceURL) let machine = MachineModel(diskStore: .init(url: root.appendingPathComponent("disks.json")), displayDefaults: defaults, inputStore: .init(url: root.appendingPathComponent("input.json"))) let model = CMOCDevelopmentModel(machine: machine, toolchain: toolchain, defaults: defaults) func snapshot() async throws -> VCCDebuggerSnapshot { let result: VCCDebuggerSnapshot? = await withCheckedContinuation { continuation in machine.readDebugger(address: 0, followPC: true, memoryAddress: 0) { continuation.resume(returning: $0) } } return try XCTUnwrap(result) } func nodes(_ listing: CMOCVariableTreeListing) -> [CMOCWatchEvaluator.TreeNode] { listing.rows.compactMap { row in if case .node(let node) = row.content { return node }; return nil } } let itemsPath = CMOCWatchEvaluator.TreePath(root: .variable("items")) let infoPath = CMOCWatchEvaluator.TreePath(root: .variable("info")) func expandedValues(offset: Int = 0) -> [CMOCWatchEvaluator.TreeNode] { nodes(model.variableTree(watches: false, expanded: [itemsPath, infoPath], offsets: [itemsPath: offset], rootOffset: 0)) } do { try model.adopt(project) model.build() for _ in 0..<3000 where model.building { try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertFalse(model.building) XCTAssertNil(model.message) XCTAssertTrue(model.buildMatchesEditor, model.log) for _ in 0..<500 where machine.busy { try await Task.sleep(nanoseconds: 10_000_000) } machine.installROM(try Data(contentsOf: romURL), url: romURL) for _ in 0..<500 where machine.busy { try await Task.sleep(nanoseconds: 10_000_000) } try await Task.sleep(nanoseconds: 1_500_000_000) model.breakpointLine = leafLine XCTAssertTrue(model.canRun) model.run() for _ in 0..<1000 where model.currentLine != leafLine || model.callStack == nil { model.refresh(); try await Task.sleep(nanoseconds: 10_000_000) } let stack = try XCTUnwrap(model.callStack, model.message ?? model.execution) XCTAssertEqual(stack.frames.map(\.functionName), ["recurse", "recurse", "recurse", "main"], stack.termination) XCTAssertEqual(model.watchValue("n")?.value, "0") XCTAssertEqual(model.watchValue("local")?.value, "10") let initialInspection = try XCTUnwrap(model.variableInspectionIdentity) XCTAssertEqual(expandedValues().first { $0.path == itemsPath.appending(.index(0)) }?.value, "20") XCTAssertEqual(expandedValues(offset: 32).first { $0.path == itemsPath.appending(.index(35)) }?.value, "55") XCTAssertEqual(expandedValues().first { $0.path == infoPath.appending(.member("marker")) }?.value, "30") let firstPage = model.variableTree(watches: false, expanded: [], offsets: [:], rootOffset: 0) let secondPage = model.variableTree(watches: false, expanded: [], offsets: [:], rootOffset: 32) XCTAssertGreaterThan(firstPage.rootCount, 32) XCTAssertEqual(nodes(firstPage).count, 32) XCTAssertEqual(secondPage.rootOffset, 32) XCTAssertTrue(Set(nodes(firstPage).map(\.path)).isDisjoint(with: nodes(secondPage).map(\.path))) let gridPath = CMOCWatchEvaluator.TreePath(root: .variable("grid")) let expandedGrid = Set([gridPath] + (0..<12).map { gridPath.appending(.index($0)) }) let bounded = model.variableTree(watches: false, expanded: expandedGrid, offsets: [:], rootOffset: 0) XCTAssertLessThanOrEqual(bounded.rows.count, 256) XCTAssertTrue(bounded.rows.contains { $0.id == .limit }, "Broad trees must report the visible-row limit") model.watchExpression = "items"; model.addWatch() let watchPath = CMOCWatchEvaluator.TreePath(root: .watch("items")) let executionPC = model.pc, executionLine = model.currentLine let navigation = model.navigationRequest let before = try await snapshot() model.selectFrame(1) XCTAssertEqual(model.selectedFrameIndex, 1) XCTAssertNotEqual(model.variableInspectionIdentity, initialInspection) let callerInspection = model.variableInspectionIdentity XCTAssertEqual(expandedValues().first { $0.path == itemsPath.appending(.index(0)) }?.value, "21") XCTAssertEqual(expandedValues().first { $0.path == infoPath.appending(.member("marker")) }?.value, "31") let callerWatch = model.variableTree(watches: true, expanded: [watchPath], offsets: [:], rootOffset: 0) XCTAssertEqual(nodes(callerWatch).first { $0.path == watchPath.appending(.index(0)) }?.value, "21") XCTAssertTrue(model.inspectingCaller) XCTAssertEqual(model.navigationLine, callerLine) XCTAssertNotEqual(model.navigationRequest, navigation) XCTAssertEqual(model.selectedFile, "main.c") XCTAssertEqual(model.watchValue("n")?.value, "1") XCTAssertEqual(model.visibleVariables.first { $0.name == "local" }?.value, "11") XCTAssertEqual(model.pc, executionPC, "Source navigation must not replace the paused execution PC") XCTAssertEqual(model.currentLine, executionLine) let after = try await snapshot() XCTAssertEqual(after.machine.programCounter, before.machine.programCounter) XCTAssertEqual(after.machine.cycles, before.machine.cycles) XCTAssertEqual(after.registers, before.registers) XCTAssertEqual(after.logicalMemory, before.logicalMemory) let callerNavigation = model.navigationRequest for _ in 0..<6 { model.refresh(); try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertEqual(model.selectedFrameIndex, 1, "Polling the same stop must preserve caller selection") XCTAssertEqual(model.navigationRequest, callerNavigation, "Polling must not snap navigation back to frame zero") XCTAssertEqual(model.watchValue("local")?.value, "11") XCTAssertEqual(model.variableInspectionIdentity, callerInspection, "Same-stop refresh must not collapse the variable tree") XCTAssertEqual(expandedValues().first { $0.path == itemsPath.appending(.index(0)) }?.value, "21") model.source += "\n/* edited source invalidates frame provenance */" XCTAssertNil(model.callStack) XCTAssertNil(model.inspectionFrame) XCTAssertNil(model.watchValue("local")) XCTAssertNil(model.variableInspectionIdentity) XCTAssertTrue(model.variableTree(watches: false, expanded: [itemsPath], offsets: [:], rootOffset: 0).rows.isEmpty) XCTAssertTrue(model.variableTree(watches: true, expanded: [watchPath], offsets: [:], rootOffset: 0).rows.isEmpty) XCTAssertFalse(model.canStepC) model.source = source XCTAssertTrue(model.canStepC) model.stepSource(.over) for _ in 0..<1000 where model.currentLine != nextLine || model.commanding || model.callStack == nil { model.refresh(); try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertEqual(model.currentLine, nextLine, model.message ?? model.execution) XCTAssertNotEqual(model.pc, executionPC) XCTAssertEqual(model.selectedFrameIndex, 0, "Execution invalidates the selected caller context") XCTAssertFalse(model.inspectingCaller) XCTAssertNotEqual(model.variableInspectionIdentity, initialInspection) XCTAssertNotEqual(model.variableInspectionIdentity, callerInspection) XCTAssertEqual(expandedValues().first { $0.path == itemsPath.appending(.index(0)) }?.value, "20") XCTAssertEqual(model.watchValue("n")?.value, "0", "Step must control the innermost frame, not the selected caller") XCTAssertEqual(model.watchValue("local")?.value, "10") await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } catch { model.cancelBuild() await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } throw error } } @MainActor func testDefaultHelloDiskLaunchRunsWithoutImplicitBreakpointAndHonorsExplicitStops() async throws { let mac = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() let resources = mac.appendingPathComponent("LocalResources") let tools = vccQualificationToolchain(resources.appendingPathComponent("ToolchainBundle")) let rom = resources.appendingPathComponent("ROMs/coco3.rom"), diskROM = resources.appendingPathComponent("ROMs/disk11.rom") try XCTSkipUnless(FileManager.default.isExecutableFile(atPath: tools.appendingPathComponent("bin/cmoc").path) && FileManager.default.fileExists(atPath: rom.path) && FileManager.default.fileExists(atPath: diskROM.path), "Stage local tools and ROMs") let root = FileManager.default.temporaryDirectory.appendingPathComponent("CMOCNormalLaunch-" + UUID().uuidString) try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) let suite = "CMOCNormalLaunch." + UUID().uuidString // Use an isolated preferences domain and writable media directory. let testDefaults = UserDefaults(suiteName: suite)! defer { testDefaults.removePersistentDomain(forName: suite); try? FileManager.default.removeItem(at: root) } let machine = MachineModel(diskStore: .init(url: root.appendingPathComponent("disks.json")), displayDefaults: testDefaults, inputStore: .init(url: root.appendingPathComponent("input.json"))) let model = CMOCDevelopmentModel(machine: machine, toolchain: tools, defaults: testDefaults) func detail() async throws -> VCCDebuggerSnapshot { let value: VCCDebuggerSnapshot? = await withCheckedContinuation { continuation in machine.readDebugger(address: 0, followPC: true, memoryAddress: 0) { continuation.resume(returning: $0) } } return try XCTUnwrap(value) } func idle() async throws { for _ in 0..<1000 where machine.busy || model.commanding || machine.diskSaving { try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertFalse(machine.busy); XCTAssertFalse(model.commanding) } func screen(_ detail: VCCDebuggerSnapshot) -> String { // Standard 32-column BASIC text cells, read without touching the clipboard. String(bytes: detail.logicalMemory[0x400..<0x600].map { cell in let code = cell & 0x3f return code < 32 ? code + 64 : code }, encoding: .ascii) ?? "" } func bootReady() async throws { if machine.state == .paused { machine.resume(); try await idle() } for _ in 0..<500 { let value = try await detail() if screen(value).contains("OK") { let frame = value.machine.frames for _ in 0..<500 { try await Task.sleep(nanoseconds: 20_000_000) if try await detail().machine.frames >= frame + 30 { return } } break } try await Task.sleep(nanoseconds: 20_000_000) } let failed = try await detail() throw CMOCBuildError.message("Disk BASIC not ready: state=\(failed.machine.state.rawValue) frames=\(failed.machine.frames) screen=\(screen(failed))") } func completed() async throws { var text = "" for _ in 0..<1500 { let snapshot = try await detail(); text = screen(snapshot) if text.contains("GENERATED WORD COUNT: 5") && machine.pasteRemaining == 0 { break } if !model.commanding && snapshot.machine.state == .paused { XCTFail("Normal launch stopped at an unrequested breakpoint"); break } try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertTrue(text.contains("DISK RESULT: 0"), text) XCTAssertTrue(text.contains("GENERATED WORD COUNT: 5"), text) XCTAssertEqual(machine.state, .running, model.message ?? model.execution) } do { let template = mac.deletingLastPathComponent().deletingLastPathComponent().appendingPathComponent("examples/cmoc/HelloDisk") try model.adopt(CMOCProject.createHelloDisk(at: root.appendingPathComponent("Hello Disk"), templateDirectory: template)) model.build() for _ in 0..<3000 where model.building { try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertTrue(model.buildMatchesEditor, model.log) XCTAssertTrue(model.breakpoints.isEmpty) XCTAssertTrue(model.resolvedBreakpointAddresses.isEmpty) XCTAssertNotNil(model.breakpointAddress) XCTAssertEqual(model.runToBreakpointAddresses, [try XCTUnwrap(model.breakpointAddress)]) try await idle() machine.selectDiskROM(diskROM); try await idle() machine.installROM(try Data(contentsOf: rom), url: rom); try await idle() try await bootReady() XCTAssertTrue(machine.diskEnabled) XCTAssertTrue(model.canLaunch, model.message ?? model.execution) model.launchDisk(commands: ["DOS"]) try await idle(); try await completed() // Reboot to a clean prompt, then prove explicit source breakpoints still work. machine.reset(); try await idle(); try await bootReady() model.toggleBreakpoint(13) XCTAssertFalse(model.resolvedBreakpointAddresses.isEmpty) model.launchDisk(commands: ["DOS"]) try await idle() for _ in 0..<1500 where model.currentLine != 13 { model.refresh(); try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertEqual(model.currentLine, 13, model.message ?? model.execution) XCTAssertEqual(machine.state, .paused) model.toggleBreakpoint(13); try await idle() XCTAssertTrue(model.resolvedBreakpointAddresses.isEmpty) machine.reset(); try await idle(); try await bootReady() XCTAssertTrue(model.canLaunch, model.message ?? model.execution) model.launchDisk(commands: ["DOS"]) try await idle(); try await completed() XCTAssertNil(model.currentLine) // The same default program also quickloads without a selected-line stop. machine.reset(); try await idle(); try await bootReady() model.launchQuickload(); try await idle(); try await completed() XCTAssertNil(model.currentLine) await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } catch { model.cancelBuild() await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } throw error } } @MainActor func testRealBuildMappingBecomesStaleWhenEditorChanges() async throws { let bundled = Bundle.main.resourceURL!.appendingPathComponent("Toolchain") let staged = vccQualificationToolchain(URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() .appendingPathComponent("LocalResources/ToolchainBundle")) let toolchain = vccQualificationToolchain(FileManager.default.isExecutableFile(atPath: bundled.appendingPathComponent("bin/cmoc").path) ? bundled : staged) try XCTSkipUnless(FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path), "This integration check requires the bundled development toolchain") let folder = FileManager.default.temporaryDirectory.appendingPathComponent("CMOCDevelopmentTests-\(UUID().uuidString)") try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true) let suite = "CMOCDevelopmentTests.\(UUID().uuidString)" let defaults = UserDefaults(suiteName: suite)! defer { defaults.removePersistentDomain(forName: suite); try? FileManager.default.removeItem(at: folder) } let machine = MachineModel(diskStore: .init(url: folder.appendingPathComponent("disks.json")), displayDefaults: defaults, inputStore: .init(url: folder.appendingPathComponent("input.json"))) let model = CMOCDevelopmentModel(machine: machine, toolchain: toolchain) do { try model.adopt(CMOCProject.create(at: folder.appendingPathComponent("Project"))) model.build() for _ in 0..<3000 where model.building { try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertFalse(model.building) XCTAssertNil(model.message) XCTAssertTrue(model.buildMatchesEditor, model.log) XCTAssertNotNil(model.breakpointAddress) if let artifact = model.artifact { defer { try? FileManager.default.removeItem(at: artifact.directory) } let compiled = model.source model.source += "\n/* edit after building */\n" XCTAssertFalse(model.buildMatchesEditor) XCTAssertNil(model.breakpointAddress, "An old address must never masquerade as a mapping for edited source") XCTAssertFalse(model.canRun) model.source = compiled XCTAssertTrue(model.buildMatchesEditor) let romURL = staged.deletingLastPathComponent().appendingPathComponent("ROMs/coco3.rom") if FileManager.default.fileExists(atPath: romURL.path) { for _ in 0..<500 where machine.busy { try await Task.sleep(nanoseconds: 10_000_000) } machine.installROM(try Data(contentsOf: romURL), url: romURL) for _ in 0..<500 where machine.busy { try await Task.sleep(nanoseconds: 10_000_000) } try await Task.sleep(nanoseconds: 1_500_000_000) model.breakpointLine = 9 XCTAssertTrue(model.canRun) model.run() for _ in 0..<500 where model.currentLine != 9 { model.refresh(); try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertEqual(model.currentLine, 9, model.message ?? model.execution) XCTAssertEqual(model.pc, model.breakpointAddress) XCTAssertTrue(model.loadedMatchesEditor) XCTAssertTrue(model.canStepC) XCTAssertTrue(model.canInspectC, model.variableStatus) model.watchExpression = "1 + 2"; model.addWatch() XCTAssertEqual(model.watchValue("1 + 2")?.value, "3") model.source += "\n/* stale debug source */" XCTAssertFalse(model.canStepC) XCTAssertFalse(model.canInspectC) XCTAssertNil(model.watchValue("1 + 2"), "Stale sources must hide even previously captured values") model.source = compiled await withCheckedContinuation { continuation in machine.debuggerWriteMemory(address: 0x4000, data: Data([0x55])) { continuation.resume() } } for _ in 0..<100 where model.loadedMatchesEditor { model.refresh(); try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertFalse(model.loadedMatchesEditor, "A debugger memory edit must invalidate loaded source provenance") XCTAssertFalse(model.canStepC); XCTAssertFalse(model.canInspectC) XCTAssertNil(model.watchValue("1 + 2")) XCTAssertNil(model.currentLine) model.run() for _ in 0..<500 where model.currentLine != 9 { model.refresh(); try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertEqual(model.currentLine, 9) machine.reset() for _ in 0..<100 where model.loadedMatchesEditor { model.refresh(); try await Task.sleep(nanoseconds: 10_000_000) } XCTAssertFalse(model.loadedMatchesEditor, "A machine reset must detach the previous C execution session") XCTAssertNil(model.currentLine) } } await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } catch { model.cancelBuild() await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } throw error } } } final class CMOCWorkspaceDocumentTests: XCTestCase { @MainActor func testTabsSaveAllOutsideConflictAndRestoration() async throws { let root = FileManager.default.temporaryDirectory.appendingPathComponent("CMOCWorkspaceDocs-\(UUID().uuidString)") let defaultsName = "CMOCWorkspaceDocs.\(UUID().uuidString)" let defaults = UserDefaults(suiteName: defaultsName)! defer { defaults.removePersistentDomain(forName: defaultsName); try? FileManager.default.removeItem(at: root) } try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) let project = try CMOCProject.create(at: root.appendingPathComponent("Project")) try Data("#define ANSWER 42\n".utf8).write(to: project.directory.appendingPathComponent("shared.h")) let machine = MachineModel(diskStore: .init(url: root.appendingPathComponent("disks.json")), displayDefaults: defaults, inputStore: .init(url: root.appendingPathComponent("input.json"))) let model = CMOCDevelopmentModel(machine: machine, defaults: defaults) try model.adopt(project) model.source += "\n/* unsaved main */" let main = model.source model.openFile("shared.h"); model.source = "#define ANSWER 43\n" model.openFile("main.c") XCTAssertEqual(model.source, main) XCTAssertTrue(model.unsaved) XCTAssertTrue(model.save()) XCTAssertEqual(try project.readText(relativePath: "shared.h"), "#define ANSWER 43\n") model.openFile("shared.h"); model.source = "#define ANSWER 44\n" try Data("#define ANSWER 99\n".utf8).write(to: project.directory.appendingPathComponent("shared.h")) model.checkExternalFiles() XCTAssertTrue(model.documents.first { $0.id == "shared.h" }!.conflict) XCTAssertFalse(model.save()) XCTAssertEqual(try project.readText(relativePath: "shared.h"), "#define ANSWER 99\n", "Outside edits must survive Save All") XCTAssertEqual(model.source, "#define ANSWER 44\n", "Editor edits remain recoverable") let restored = CMOCDevelopmentModel(machine: machine, defaults: defaults) restored.restoreWorkspace() XCTAssertEqual(restored.documents.map(\.id), ["main.c", "shared.h"]) XCTAssertEqual(restored.selectedFile, "shared.h") XCTAssertEqual(restored.source, "#define ANSWER 99\n", "Restoration reads disk without executing Make") await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } @MainActor func testSettingsGenerationProtectsCustomChangesAndKeepsBackup() async throws { let root = FileManager.default.temporaryDirectory.appendingPathComponent("CMOCWorkspaceSettings-\(UUID().uuidString)") let defaultsName = "CMOCWorkspaceSettings.\(UUID().uuidString)" let defaults = UserDefaults(suiteName: defaultsName)! defer { defaults.removePersistentDomain(forName: defaultsName); try? FileManager.default.removeItem(at: root) } try FileManager.default.createDirectory(at: root, withIntermediateDirectories: true) let project = try CMOCProject.create(at: root.appendingPathComponent("Project")) let original = try project.readText(relativePath: "Makefile") let machine = MachineModel(diskStore: .init(url: root.appendingPathComponent("disks.json")), displayDefaults: defaults, inputStore: .init(url: root.appendingPathComponent("input.json"))) let model = CMOCDevelopmentModel(machine: machine, defaults: defaults) try model.adopt(project) var settings = CMOCMakefileSettings(); settings.executable = "hello.bin" var configuration = project.configuration; configuration.makefileSettings = settings; configuration.binary = "hello.bin" let generated = try settings.generateMakefile() let hash = CMOCProject.sha256(Data(original.utf8)) try Data((original + "\n# outside edit\n").utf8).write(to: project.makefileURL) XCTAssertThrowsError(try model.applyProjectSettings(configuration, makefile: generated, expectedMakefileHash: hash, expectedConfigHash: nil)) XCTAssertFalse(FileManager.default.fileExists(atPath: project.directory.appendingPathComponent(CMOCProject.configurationFilename).path)) try Data(original.utf8).write(to: project.makefileURL) try model.applyProjectSettings(configuration, makefile: generated, expectedMakefileHash: hash, expectedConfigHash: nil) XCTAssertEqual(try String(contentsOf: project.makefileURL), generated) let backups = try FileManager.default.contentsOfDirectory(at: project.directory.appendingPathComponent(".vccplus-build/Makefile Backups"), includingPropertiesForKeys: nil) XCTAssertEqual(backups.count, 1) XCTAssertEqual(try String(contentsOf: backups[0]), original) XCTAssertEqual(try CMOCProject.open(at: project.directory).configuration.binary, "hello.bin") await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } } } @MainActor func testClickableDiagnosticRetainsNestedFileIdentity() { let diagnostics = CMOCDevelopmentModel.parseDiagnostics("src/one/helper.c:17: error: missing value\n/private/tmp/build/src/two/helper.c:9:4: warning: unused\nmake: failed", directory: URL(fileURLWithPath: "/private/tmp/build")) XCTAssertEqual(diagnostics.map(\.file), ["src/one/helper.c", "src/two/helper.c"]) XCTAssertEqual(diagnostics.map(\.line), [17, 9]) } }