// SPDX-License-Identifier: GPL-3.0-or-later import XCTest import AppKit import SwiftUI /// Explicit test-only input keeps compiler qualification away from normal app staging. /// Xcode forwards TEST_RUNNER_VCC_TEST_TOOLCHAIN_DIR to this environment variable. func vccQualificationToolchain(_ fallback: URL) -> URL { guard let path = ProcessInfo.processInfo.environment["VCC_TEST_TOOLCHAIN_DIR"] else { return fallback } XCTAssertTrue(path.hasPrefix("/"), "Compiler qualification requires an absolute runtime path") let candidate = URL(fileURLWithPath: path, isDirectory: true) XCTAssertTrue(FileManager.default.isExecutableFile(atPath: candidate.appendingPathComponent("bin/cmoc").path), "Explicit compiler qualification input is unavailable; do not silently use another runtime") return candidate } final class CMOCBuildServiceTests: XCTestCase { private var folder: URL! override func setUpWithError() throws { folder = FileManager.default.temporaryDirectory.appendingPathComponent("CMOC tests " + UUID().uuidString) try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true) } override func tearDownWithError() throws { try? FileManager.default.removeItem(at: folder) } private func project() throws -> CMOCProject { try CMOCProject.create(at: folder.appendingPathComponent("My Project")) } private func toolchain(make: String) throws -> URL { let root = folder.appendingPathComponent("Tool Chain") let bin = root.appendingPathComponent("bin") try FileManager.default.createDirectory(at: bin, withIntermediateDirectories: true) for name in ["make", "cmoc", "cpp", "lwasm", "lwlink"] { let url = bin.appendingPathComponent(name) let script = name == "make" ? make : "exit 0\n" try Data(("#!/bin/sh\n" + script).utf8).write(to: url) try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: url.path) } return root } private let successful = """ test "$1" = '--no-print-directory' || exit 71 test "$4" = 'MAKE=make' || exit 72 test -x "$CMOC" || exit 73 printf 'compiler stdout\\n' printf 'compiler stderr\\n' >&2 for ext in bin o s lst map link; do printf 'fixture' > "main.$ext"; done """ func testPublicPlaytestProcessorSelectionIsCanonicalAndDefaultsToMC6809() throws { XCTAssertEqual(try MCPPlaytestProcessor.selected(nil), .mc6809) XCTAssertEqual(try MCPPlaytestProcessor.selected("MC6809").workerCPU, "6809") XCTAssertEqual(try MCPPlaytestProcessor.selected("HD6309").workerCPU, "6309") for invalid: Any in ["6809", "6309", "hd6309", "", NSNull(), true, 9, [], [:]] { XCTAssertThrowsError(try MCPPlaytestProcessor.selected(invalid)) } } @MainActor func testAcceptedPlaytestStartupRemainsPollableAndLaunchesOnlyOnce() async throws { let start = MCPOwnedPlaytestStart(identity: "exact-selection", requestID: "start-once", projectID: "project", revision: 7, artifactID: "artifact", processor: .hd6309) let began = expectation(description: "Preparation reached suspended work") var resume: CheckedContinuation? var launches = 0 start.launch { operation in launches += 1 operation.updatePhase("booting") await withCheckedContinuation { resume = $0; began.fulfill() } return ["run_id": operation.runID, "field_clock": 61, "png_base64": "not-for-metadata"] } let accepted = start.fields XCTAssertEqual(accepted["status"] as? String, "starting") XCTAssertEqual(accepted["requested_processor"] as? String, "HD6309") XCTAssertNil(accepted["execution_mode"], "Preparation cannot claim an observed guest CPU mode") XCTAssertEqual(accepted["run_id"] as? String, start.runID) XCTAssertNotNil(UUID(uuidString: start.runID)) XCTAssertEqual(accepted["poll_tool"] as? String, "get_run") XCTAssertEqual(accepted["busy"] as? Bool, true) await fulfillment(of: [began], timeout: 2) XCTAssertEqual(start.fields["phase"] as? String, "booting") // Retrying an accepted operation cannot dispatch another worker. start.launch { _ in launches += 1; return [:] } XCTAssertEqual(launches, 1) XCTAssertEqual(start.fields["status"] as? String, "starting") try XCTUnwrap(resume).resume() await start.waitForCompletion() XCTAssertEqual(start.fields["status"] as? String, "ready") XCTAssertEqual(start.fields["busy"] as? Bool, false) let receipt = try XCTUnwrap(start.fields["receipt"] as? [String: Any]) XCTAssertEqual(receipt["field_clock"] as? Int, 61) XCTAssertNil(receipt["png_base64"]) XCTAssertNil(start.fields["poll_tool"]) } @MainActor func testPendingPlaytestCancellationCannotBecomeReadyAfterLateCompletion() async throws { let start = MCPOwnedPlaytestStart(identity: "exact-selection", requestID: "cancel-me", projectID: "project", revision: 7, artifactID: "artifact") let began = expectation(description: "Boot is in flight") var resume: CheckedContinuation? var lateCleanup = 0 start.launch { operation in operation.updatePhase("booting") // This fixture intentionally does not cooperate with cancellation // until its external work returns, like a worker initialization. await withCheckedContinuation { resume = $0; began.fulfill() } if !operation.acceptingResult { lateCleanup += 1 } return ["run_id": operation.runID, "field_clock": 61] } await fulfillment(of: [began], timeout: 2) let reserved = start.runID start.cancel(); start.cancel() XCTAssertEqual(start.fields["status"] as? String, "cancelling") XCTAssertEqual(start.fields["busy"] as? Bool, true, "Replacement must wait for late-worker cleanup") XCTAssertEqual(start.fields["run_id"] as? String, reserved) try XCTUnwrap(resume).resume() await start.waitForCompletion() XCTAssertEqual(lateCleanup, 1) XCTAssertEqual(start.fields["status"] as? String, "cancelled") XCTAssertEqual(start.fields["busy"] as? Bool, false) XCTAssertNil(start.fields["receipt"], "A late result must not overwrite cancellation") } @MainActor func testPlaytestStartupCancelledBeforeSchedulingSettlesWithoutEnteringPreparation() async throws { let start = MCPOwnedPlaytestStart(identity: "cancel-before-schedule", requestID: "cancel-before-schedule", projectID: "project", revision: 7, artifactID: "artifact") var preparations = 0 // Capture the previous cleanup before dispatch. A later cleanup that // waits on this start must never become this start's own dependency. let priorCleanup = Task { } start.launch { operation in guard operation.acceptingResult else { throw CancellationError() } await priorCleanup.value guard operation.acceptingResult else { throw CancellationError() } preparations += 1 return [:] } // No suspension has occurred, so the launch task has not begun yet. start.cancel() let retiredCleanup = Task { await start.waitForCompletion() } await retiredCleanup.value XCTAssertEqual(preparations, 0) XCTAssertEqual(start.fields["status"] as? String, "cancelled") XCTAssertEqual(start.fields["busy"] as? Bool, false) } @MainActor func testPlaytestStartupFailureRetainsPhaseAndRedactedReasonForPolling() async throws { let start = MCPOwnedPlaytestStart(identity: "exact-selection", requestID: "will-fail", projectID: "project", revision: 7, artifactID: "artifact", redactionRoots: [folder]) let privatePath = folder.appendingPathComponent("disk.dsk").path start.launch { operation in operation.updatePhase("reading_artifact") throw CMOCBuildError.message("Artifact disk changed: " + privatePath) } await start.waitForCompletion() XCTAssertEqual(start.fields["status"] as? String, "failed") XCTAssertEqual(start.fields["phase"] as? String, "reading_artifact") XCTAssertEqual(start.fields["busy"] as? Bool, false) XCTAssertEqual(start.fields["error"] as? String, "Artifact disk changed: /disk.dsk") XCTAssertNil(start.fields["receipt"]) } func testAssistantBuildsOrdinarySourcesWithOnlyItsOwnRecipe() async throws { let runtime = vccQualificationToolchain(URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() .appendingPathComponent("LocalResources/ToolchainBundle")) guard FileManager.default.isExecutableFile(atPath: runtime.appendingPathComponent("bin/cmoc").path) else { throw XCTSkip("Stage the bundled CMOC tools") } let project = try self.project() let marker = folder.appendingPathComponent("custom-recipe-ran") try Data("$(shell touch '\(marker.path)')\n$(error custom makefile executed)\n".utf8).write(to: project.makefileURL) let service = CMOCBuildService(toolchain: runtime, buildRoot: folder.appendingPathComponent("Artifacts")) let examples = [ ["main.c": CMOCProject.starterSource], ["main.c": "#include \"value.h\"\nint main(void) { return value(); }\n", "include/value.h": "#ifndef VALUE_H\n#define VALUE_H\nint value(void);\n#endif /* VALUE_H */\n", "root.h": "#define BASE 7\n", "src/value.c": "#include \"value.h\"\n#include \"root.h\"\n#define TWICE(n) ((n) * 2)\nint value(void) { return TWICE(BASE); }\n"] ] for inputs in examples { let scope = try MCPCMOCProject(project: project, files: Array(inputs.keys) + ["Makefile", "private.txt"]) XCTAssertFalse(scope.helloDisk) XCTAssertEqual(scope.paths, inputs.keys.sorted()) for (path, source) in inputs { try scope.validate(source, path: path) } let snapshot = try scope.snapshotProject(at: folder.appendingPathComponent(UUID().uuidString), inputs: inputs) let artifact = try await service.build(project: snapshot, overlays: inputs, action: .build) XCTAssertTrue(artifact.hasBinary) XCTAssertFalse(artifact.hasDisk) XCTAssertEqual(artifact.entrySourcePath, "main.c") XCTAssertFalse(FileManager.default.fileExists(atPath: marker.path)) } } func testAssistantSourceDirectivesCannotReachUnsharedFiles() throws { let project = try self.project() let scope = try MCPCMOCProject(project: project, files: ["main.c", "include/defs.h"]) XCTAssertNoThrow(try scope.validate("/* note */ #include \"defs.h\" // local\n#if defined(FLAG)\n#endif\n", path: "main.c")) XCTAssertNoThrow(try scope.validate("#define MIN(a,b) ((a)<(b)?(a):(b))\n", path: "main.c")) for attack in ["/* comment\n*/ #include \"/etc/passwd\"", "#include \"../secret.h\"", "#include SECRET", "#include ", "#pragma asm", "#define JOIN(x,y) x ## y", "/*\n*/ %:include \"/etc/passwd\"", "#inc\\ \nlude \"/etc/passwd\"", "asm { incbin /etc/passwd }", "_CMOC_CONCAT(a,sm) { incbin blah }", "#define __GNUC__ 1", "#line 1 \"host-path\""] { XCTAssertThrowsError(try scope.validate(attack, path: "main.c"), attack) } XCTAssertThrowsError(try MCPCMOCProject(project: project, files: ["main.c", "bad$(touch).c"])) } func testCustomMakeAssistantAcceptsProjectAssemblyWithoutWeakeningOrdinarySourceRules() throws { let project = try self.project() let files = ["main.c", "video.h", "drawing.asm", "Makefile"] let ordinary = try MCPCMOCProject(project: project, files: files) let custom = try MCPCMOCProject(project: project, files: files, customMake: true) let source = """ #include #include "video.h" #if !defined(TERRAIN_BANK) #error Select the terrain bank before building #endif static asm void draw(void) { asm { rts } } """ XCTAssertThrowsError(try ordinary.validate(source, path: "main.c")) XCTAssertNoThrow(try custom.validate(source, path: "main.c")) XCTAssertTrue(custom.paths.contains("drawing.asm")) XCTAssertTrue(custom.paths.contains("Makefile")) XCTAssertThrowsError(try custom.validate("int main;\0", path: "main.c")) } func testRestrictedAssistantDirectiveFailureIdentifiesFileAndLine() throws { let project = try self.project() let scope = try MCPCMOCProject(project: project, files: ["main.c"]) XCTAssertThrowsError(try scope.validate("/* ordinary project */\n\n#pragma asm\n", path: "main.c")) { error in XCTAssertTrue(error.localizedDescription.contains("unsupported_source_directive")) XCTAssertTrue(error.localizedDescription.contains("main.c:3"), error.localizedDescription) } } func testCustomMakeRecipeIdentityBindsDeclaredRecipeAndExecutableHelpersButNotCChanges() { func captured(recipe: String = "build:\n\ttools/generate > main.bin\n", helper: String = "#!/bin/sh\nprintf first\n", source: String = "int main(void) { return 0; }\n", helperMode: Int = 0o755) -> MCPCMOCMakeInputs { MCPCMOCMakeInputs(makefile: "build.recipe", files: [ "build.recipe": Data(recipe.utf8), "tools/generate": Data(helper.utf8), "main.c": Data(source.utf8) ], permissions: ["build.recipe": 0o644, "tools/generate": helperMode, "main.c": 0o644], support: CMOCBuildSupportSnapshot(files: [:], permissions: [:])) } let original = captured() let changedRecipe = captured(recipe: "build:\n\ttools/generate > another.bin\n") let changedHelper = captured(helper: "#!/bin/sh\nprintf second\n") let changedMode = captured(helperMode: 0o744) let changedC = captured(source: "int main(void) { return 42; }\n") XCTAssertNotEqual(original.recipeID, changedRecipe.recipeID, "A configured Makefile may have an arbitrary filename") XCTAssertNotEqual(original.recipeID, changedHelper.recipeID, "An executable helper need not have a script extension") XCTAssertNotEqual(original.recipeID, changedMode.recipeID) XCTAssertEqual(original.recipeID, changedC.recipeID, "Ordinary source changes invalidate the revision without changing recipe consent") XCTAssertNotEqual(original, changedC) } func testCustomMakeSnapshotPreservesGeneratedInputTimestampOrderingAndRefreshesDrafts() throws { let project = try self.project() let source = try project.readSource() let makefile = try project.readText(relativePath: "Makefile") let scope = try MCPCMOCProject(project: project, files: ["main.c", "Makefile", "loader.asm"], customMake: true) let generatedDate = Date(timeIntervalSince1970: 1_000_000_000) let assemblyDate = generatedDate.addingTimeInterval(60) let savedSourceDate = generatedDate.addingTimeInterval(-60) let draft = source + "\n/* editor draft */\n" let snapshot = try scope.snapshotProject(at: folder.appendingPathComponent("Captured Project"), inputs: ["main.c": draft], buildInputs: ["main.c": Data(source.utf8), "Makefile": Data(makefile.utf8), "loader.asm": Data(" rts\n".utf8), "build/loader.raw": Data([0x39])], support: nil, permissions: [:], modificationDates: ["main.c": savedSourceDate, "loader.asm": assemblyDate, "build/loader.raw": generatedDate], overlayPaths: ["main.c"]) func date(_ path: String) throws -> Date { let values = try FileManager.default.attributesOfItem(atPath: snapshot.directory.appendingPathComponent(path).path) return try XCTUnwrap(values[.modificationDate] as? Date) } XCTAssertEqual(try date("build/loader.raw").timeIntervalSince1970, generatedDate.timeIntervalSince1970, accuracy: 0.001) XCTAssertEqual(try date("loader.asm").timeIntervalSince1970, assemblyDate.timeIntervalSince1970, accuracy: 0.001) XCTAssertLessThan(try date("build/loader.raw"), try date("loader.asm"), "Make must see the same dependency ordering in a new snapshot") XCTAssertGreaterThan(try date("main.c"), assemblyDate, "An editor overlay must not inherit an old saved-file timestamp") XCTAssertEqual(try snapshot.readSource(), draft) XCTAssertEqual(try project.readSource(), source) } @MainActor func testAssistantPatchIsOneRevisionAndPreservesEveryDraftOnConflict() throws { _ = NSApplication.shared let project = try self.project() let a = try project.readSource(), b = "int value(void);\n" try Data(b.utf8).write(to: project.directory.appendingPathComponent("value.h")) let suite = UUID().uuidString let defaults = try XCTUnwrap(UserDefaults(suiteName: suite)) defer { defaults.removePersistentDomain(forName: suite) } let machine = MachineModel(diskStore: .init(url: folder.appendingPathComponent("disks.json")), displayDefaults: defaults, inputStore: .init(url: folder.appendingPathComponent("input.json"))) let model = CMOCDevelopmentModel(machine: machine, defaults: defaults, buildRoot: folder.appendingPathComponent("build"), recoveryRoot: folder.appendingPathComponent("recovery")) try model.adopt(project) let epoch = model.assistantEditEpoch, id = model.assistantProjectID let first = MCPCMOCEdit(path: "main.c", before: a, after: "int main(void) { return 1; }\n") let second = MCPCMOCEdit(path: "value.h", before: b, after: "int answer(void);\n") let disk = ["main.c": a, "value.h": b] XCTAssertThrowsError(try model.applyAssistantEdits([first, .init(path: "value.h", before: "", after: "wrong")], disk: disk, projectID: id, epoch: epoch)) XCTAssertEqual(model.source, a) XCTAssertEqual(model.documents.count, 1) XCTAssertEqual(model.assistantEditEpoch, epoch) try model.applyAssistantEdits([first, second], disk: disk, projectID: id, epoch: epoch) XCTAssertEqual(model.assistantEditEpoch, epoch + 1) XCTAssertEqual(model.overlays, ["main.c": first.after, "value.h": second.after]) XCTAssertEqual(try project.readSource(), a) XCTAssertEqual(try project.readText(relativePath: "value.h"), b) XCTAssertThrowsError(try model.applyAssistantEdits([first], disk: disk, projectID: id, epoch: epoch)) } @MainActor func testGroupedPatchUndoPreservesEarlierNativeTypingAndSelection() throws { let original = "int value;" var draft = original var editor: NSTextView? var pool: CSourceEditor.Coordinator? let view = CSourceEditor(text: Binding(get: { draft }, set: { draft = $0 }), currentLine: nil, attach: { _, text, coordinator in editor = text; pool = coordinator }) let host = NSHostingView(rootView: view) let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 500, height: 180), styleMask: [.titled], backing: .buffered, defer: false) window.contentView = host; host.layoutSubtreeIfNeeded() let text = try XCTUnwrap(editor), buffers = try XCTUnwrap(pool) let manager = try XCTUnwrap(text.undoManager) manager.groupsByEvent = false manager.beginUndoGrouping() text.insertText(" /* local */", replacementRange: NSRange(location: original.utf16.count, length: 0)) text.breakUndoCoalescing() manager.endUndoGrouping() let local = text.string, selection = text.selectedRange() let changed = "int answer;" buffers.setReviewedBuffers([.init(path: "main.c", before: local, after: changed)], undoing: false) XCTAssertEqual(text.string, changed) XCTAssertFalse(text.undoManager === manager) buffers.setReviewedBuffers([.init(path: "main.c", before: changed, after: local)], undoing: true) XCTAssertEqual(text.string, local) XCTAssertEqual(text.selectedRange(), selection) XCTAssertIdentical(text.undoManager, manager) XCTAssertTrue(manager.canUndo) manager.undo() XCTAssertEqual(text.string, original) } func testOrdinaryProjectCreateOpenSaveAndExternalChangeGuard() throws { let value = try project() XCTAssertEqual(try CMOCProject.open(at: value.directory), value) let original = try value.readSource() XCTAssertEqual(original, CMOCProject.starterSource) XCTAssertThrowsError(try CMOCProject.create(at: value.directory)) let hash = CMOCProject.sha256(Data(original.utf8)) XCTAssertEqual(try value.saveSource("int main(void) { return 1; }\n", replacingSHA256: hash), CMOCProject.sha256(Data("int main(void) { return 1; }\n".utf8))) XCTAssertThrowsError(try value.saveSource(original, replacingSHA256: hash)) XCTAssertTrue(try value.readSource().contains("return 1")) } func testOpeningNeverExecutesMakefileAndRejectsInvalidText() throws { let value = try project() let marker = folder.appendingPathComponent("should-not-exist") try Data("build:\n\ttouch '\(marker.path)'\n".utf8).write(to: value.makefileURL) _ = try CMOCProject.open(at: value.directory) XCTAssertFalse(FileManager.default.fileExists(atPath: marker.path)) try Data([0xff, 0x00]).write(to: value.sourceURL) XCTAssertThrowsError(try CMOCProject.open(at: value.directory)) XCTAssertThrowsError(try value.saveSource(String(repeating: "x", count: CMOCProject.maximumSourceBytes + 1))) } func testBuildUsesEditorSnapshotAndFreshOutputWithoutChangingProject() async throws { let value = try project() let saved = try value.readSource() let tools = try toolchain(make: successful) let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Build Results")) let draft = "int main(void) { return 42; }\n" let first = try await service.build(project: value, source: draft) let second = try await service.build(project: value, source: draft) XCTAssertNotEqual(first.id, second.id) XCTAssertNotEqual(first.directory, second.directory) XCTAssertEqual(first.sourceData, Data(draft.utf8)) XCTAssertEqual(try String(contentsOf: first.sourceURL), draft) XCTAssertEqual(try value.readSource(), saved) XCTAssertTrue(first.matches(source: draft)) XCTAssertFalse(first.matches(source: draft + "\n")) XCTAssertTrue(first.buildLog.contains("compiler stdout")) XCTAssertTrue(first.buildLog.contains("compiler stderr")) XCTAssertEqual(first.binaryData, Data("fixture".utf8)) } func testFailedBuildDoesNotReuseEarlierOutputAndRetainsDiagnostics() async throws { let value = try project() let tools = try toolchain(make: successful) let outputs = folder.appendingPathComponent("Outputs") let service = CMOCBuildService(toolchain: tools, buildRoot: outputs) let good = try await service.build(project: value, source: "int main(void) { return 0; }") try Data("#!/bin/sh\nprintf 'main.c:3: error: missing semicolon\\n' >&2\nexit 2\n".utf8) .write(to: tools.appendingPathComponent("bin/make")) do { _ = try await service.build(project: value, source: "bad source"); XCTFail("Build should fail") } catch let error as CMOCBuildError { XCTAssertTrue(error.localizedDescription.contains("missing semicolon")) XCTAssertTrue(error.localizedDescription.contains("exit 2")) } XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: outputs.path), [good.id.uuidString]) XCTAssertEqual(try Data(contentsOf: good.binaryURL), Data("fixture".utf8)) } func testMissingArtifactsAndModifiedSourceCannotBecomeSuccessfulBuilds() async throws { let value = try project() let tools = try toolchain(make: "printf bin > main.bin\n") let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Outputs")) do { _ = try await service.build(project: value, source: "int main(void){}"); XCTFail("Missing files must fail") } catch { XCTAssertTrue(error.localizedDescription.contains("main.o")) } try Data(("#!/bin/sh\n" + successful + "\nprintf rewritten > main.c\n").utf8) .write(to: tools.appendingPathComponent("bin/make")) do { _ = try await service.build(project: value, source: "int main(void){}"); XCTFail("Changed source must fail") } catch { XCTAssertTrue(error.localizedDescription.contains("modified main.c")) } } func testLargeOutputIsDrainedAndBounded() async throws { let value = try project() let script = "dd if=/dev/zero bs=1024 count=600 2>/dev/null | tr '\\000' X\n" + successful let tools = try toolchain(make: script) let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Outputs")) let result = try await service.build(project: value, source: "int main(void){}") XCTAssertTrue(result.buildLog.contains("Build output truncated")) XCTAssertLessThanOrEqual(result.buildLog.utf8.count, 512 * 1024) XCTAssertTrue(result.buildLog.contains("compiler stderr"), "The final output must survive a verbose compiler") } func testFailedVerboseBuildRetainsFinalLinkerFailureAndHonestCombinedOutput() async throws { let script = """ printf 'main.c:7: warning: fixture warning\\n' dd if=/dev/zero bs=1024 count=600 2>/dev/null | tr '\\000' X printf '\\nlwlink: fatal: section code exceeds 16-bit address space\\n' >&2 printf 'make: *** [fixture-link] Error 37\\n' >&2 exit 2 """ let value = try project() let service = CMOCBuildService(toolchain: try toolchain(make: script), buildRoot: folder.appendingPathComponent("Outputs")) do { _ = try await service.build(project: value, source: "int main(void) { return 0; }") XCTFail("The authored linker failure must fail the build") } catch { let report = CMOCBuildFailureReport.fields(for: error, redacting: [folder]) let log = try XCTUnwrap(report["log"] as? String) XCTAssertEqual(report["exit_code"] as? Int, 2) XCTAssertTrue(log.contains("main.c:7: warning: fixture warning")) XCTAssertTrue(log.contains("lwlink: fatal: section code exceeds 16-bit address space")) XCTAssertTrue(log.contains("make: *** [fixture-link] Error 37")) XCTAssertTrue(error.localizedDescription.contains("exit 2"), "Native errors still explain the failure") XCTAssertEqual(report["log_truncated"] as? Bool, true) XCTAssertEqual(report["process_output_truncated"] as? Bool, true) XCTAssertGreaterThan(try XCTUnwrap(report["process_output_bytes"] as? Int), 600 * 1024) XCTAssertLessThanOrEqual(log.utf8.count, 32_000) XCTAssertEqual(report["output_streams"] as? String, "combined") XCTAssertTrue(report["stdout"] is NSNull) XCTAssertTrue(report["stderr"] is NSNull) XCTAssertFalse(log.contains(folder.path)) } } func testFailureReportRedactsScratchAliasesAndBoundsUnicodeWithoutHidingTail() throws { let root = URL(fileURLWithPath: "/private/tmp/Build scratch fixture", isDirectory: true) let alias = URL(fileURLWithPath: "/tmp/Build scratch fixture", isDirectory: true) let header = "\(root.path)/main.c:7: warning: fixture\n\(alias.absoluteString)main.o\n" let text = header + String(repeating: "界🛠", count: 10_000) + "\nlwlink: fatal: too much code\n" let capture = CMOCBuildOutput(text: text, byteCount: text.utf8.count, truncated: false, workingDirectory: root) let report = CMOCBuildFailureReport.fields(for: CMOCBuildError.failed(status: 37, log: text, capture: capture), maximumLogBytes: 1_024) let log = try XCTUnwrap(report["log"] as? String) XCTAssertEqual(report["exit_code"] as? Int, 37) XCTAssertTrue(log.contains("/main.c:7")) XCTAssertTrue(log.contains("/main.o")) XCTAssertFalse(log.contains("/private/tmp/")) XCTAssertFalse(log.contains("/tmp/")) XCTAssertFalse(log.contains("file:///")) XCTAssertFalse(log.contains("�"), "Clipping valid Unicode must not invent replacement scalars") XCTAssertTrue(log.hasSuffix("lwlink: fatal: too much code\n")) XCTAssertLessThanOrEqual(log.utf8.count, 1_024) XCTAssertEqual(report["log_truncated"] as? Bool, true) XCTAssertEqual(report["process_output_truncated"] as? Bool, false) let ordinary = CMOCBuildFailureReport.fields(for: CMOCBuildError.message(text), redacting: [root], maximumLogBytes: 1_024) XCTAssertTrue(ordinary["exit_code"] is NSNull) XCTAssertLessThanOrEqual(try XCTUnwrap(ordinary["reason"] as? String).utf8.count, 2_048) XCTAssertEqual(ordinary["reason_truncated"] as? Bool, true) } func testRealMakeLinkerFailureKeepsSourceWarningFatalAndMakeStatus() async throws { var settings = CMOCProjectConfiguration() settings.buildTarget = "build" let makefile = """ .PHONY: build build: \t@printf 'main.c:7: warning: fixture warning\\n' \t@printf 'lwlink: fatal: section code exceeds 16-bit address space\\n' >&2; exit 37 """ let value = try configuredProject(settings, files: ["Makefile": makefile]) let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Outputs")) do { _ = try await service.build(project: value, overlays: [:], action: .build) XCTFail("The authored linker-limit fixture must fail") } catch { let report = CMOCBuildFailureReport.fields(for: error, redacting: [folder]) let log = try XCTUnwrap(report["log"] as? String) XCTAssertEqual(report["exit_code"] as? Int, 2, "GNU Make reports its failure independently of the recipe status") XCTAssertTrue(log.contains("main.c:7: warning: fixture warning")) XCTAssertTrue(log.contains("lwlink: fatal: section code exceeds 16-bit address space")) XCTAssertTrue(log.contains("Error 37")) XCTAssertEqual(report["log_truncated"] as? Bool, false) XCTAssertFalse(log.contains(folder.path)) } } func testBuildReportSeparatesWarningsFromErrorsAcrossToolFormats() throws { let samples: [(String, String, String?, Int?)] = [ ("main.c:7:2: error: missing semicolon", "compiler", "main.c", 7), ("main.asm(9) : ERROR : Bad opcode", "assembler", "main.asm", 9), ("lwlink: fatal: section code exceeds limit", "linker", nil, nil), ("External symbol _absent not found in main.o:code", "linker", nil, nil), ("Makefile:3: *** missing separator. Stop.", "make", "Makefile", 3), ("make: *** No rule to make target 'missing.h', needed by 'main.o'. Stop.", "make", nil, nil) ] for (failure, stage, path, number) in samples { let log = "main.c:2: warning: unused local\n" + failure + "\n" let report = CMOCBuildReport(error: CMOCBuildError.failed(status: 2, log: log), visiblePaths: ["main.c", "main.asm", "Makefile"]) let fields = report.fields(), diagnostic = try XCTUnwrap(fields["first_error"] as? [String: Any]) XCTAssertEqual(diagnostic["severity"] as? String, "error") XCTAssertEqual(diagnostic["raw"] as? String, failure) XCTAssertEqual(diagnostic["stage"] as? String, stage) XCTAssertEqual(diagnostic["path"] as? String, path) XCTAssertEqual(diagnostic["line"] as? Int, number) XCTAssertEqual(fields["failure_stage"] as? String, stage) XCTAssertEqual((fields["diagnostics"] as? [[String: Any]])?.first?["severity"] as? String, "warning") } let echoed = "printf 'main.c:2: error: this is command text\\n'\nmain.c:5: error: expected token before 'warning:'\n" let actual = CMOCBuildReport(error: CMOCBuildError.failed(status: 2, log: echoed), visiblePaths: ["main.c"]).fields() XCTAssertEqual((actual["first_error"] as? [String: Any])?["line"] as? Int, 5, "Echoed commands and quoted warning text cannot replace an actual error") let warningFlood = String(repeating: "main.c:2: warning: repeated warning\n", count: 300) + "main.c:8: error: actual failing declaration\n" let report = CMOCBuildReport(error: CMOCBuildError.failed(status: 2, log: warningFlood), visiblePaths: ["main.c"]) let fields = report.fields() XCTAssertEqual(fields["diagnostics_total"] as? Int, 301) XCTAssertEqual(fields["diagnostics_truncated"] as? Bool, true) XCTAssertEqual((fields["first_error"] as? [String: Any])?["line"] as? Int, 8, "A flood of earlier warnings must not hide the actual error") } func testBuildReportPagedLogRetainsRedactedUnicodeWithoutRepeatingOrSkippingBytes() throws { let root = URL(fileURLWithPath: "/private/tmp/diagnostic source", isDirectory: true) let original = root.path + "/main.c:3: warning: sample\n" + String(repeating: "界🛠a\n", count: 10_000) + "lwlink: fatal: final failure\n" let capture = CMOCBuildOutput(text: original, byteCount: original.utf8.count, truncated: false, workingDirectory: root, invocation: [root.appendingPathComponent("bin/make").path, "-f", "Makefile"], exitCode: 2) let report = CMOCBuildReport(error: CMOCBuildError.failed(status: 2, log: original, capture: capture), visiblePaths: ["main.c"]) let fields = report.fields(maximumLogBytes: 512) XCTAssertEqual(fields["log_truncated"] as? Bool, true) XCTAssertEqual(fields["process_output_truncated"] as? Bool, false) XCTAssertEqual(fields["invocation"] as? [String], ["/bin/make", "-f", "Makefile"]) var offset = 0, rebuilt = "", hash: String? repeat { let page = try report.logPage(offset: offset, limit: 1_003) let text = try XCTUnwrap(page["log"] as? String) XCTAssertFalse(text.contains(root.path)); XCTAssertFalse(text.contains("�")) rebuilt += text if let previous = hash { XCTAssertEqual(page["sha256"] as? String, previous) } hash = page["sha256"] as? String guard let next = page["next_offset"] as? Int else { break } XCTAssertGreaterThan(next, offset); offset = next } while true XCTAssertEqual(rebuilt, report.log) XCTAssertEqual(hash, CMOCProject.sha256(Data(rebuilt.utf8))) XCTAssertTrue(rebuilt.hasSuffix("lwlink: fatal: final failure\n")) XCTAssertThrowsError(try report.logPage(offset: Int.max)) XCTAssertThrowsError(try report.logPage(offset: -1)) XCTAssertThrowsError(try report.logPage(offset: 0, limit: 32_769)) let unicode = CMOCBuildReport(error: CMOCBuildError.message("界🛠")) XCTAssertThrowsError(try unicode.logPage(offset: 1)) XCTAssertEqual(try unicode.logPage(offset: 0, limit: 1)["next_offset"] as? Int, 3) } func testBuildReportIncludesSuccessfulWarningsAndHonestCommandEvidence() async throws { let value = try project() let tools = try toolchain(make: "printf 'main.c:2: warning: retained successful warning\\n'\n" + successful) let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Outputs")) let artifact = try await service.build(project: value, source: "int main(void) { return 0; }") let fields = CMOCBuildReport(artifact: artifact, redacting: [folder], visiblePaths: ["main.c"]).fields() XCTAssertEqual(fields["exit_code"] as? Int, 0) XCTAssertEqual((fields["diagnostics"] as? [[String: Any]])?.first?["severity"] as? String, "warning") XCTAssertTrue(fields["first_error"] is NSNull) XCTAssertTrue(fields["failure_stage"] is NSNull) XCTAssertTrue(fields["failing_command"] is NSNull) XCTAssertFalse((fields["invocation"] as? [String])?.isEmpty ?? true) let log = "cmoc -c main.c\nmain.c:2: warning: old warning\nlwasm -o main.o main.asm\nmain.asm(3) : ERROR : Bad opcode\nmake: *** [build] Error 1\n" let failure = CMOCBuildReport(error: CMOCBuildError.failed(status: 2, log: log)).fields() XCTAssertEqual(failure["failing_command"] as? String, "lwasm -o main.o main.asm") XCTAssertEqual(failure["failing_command_evidence"] as? String, "echoed_before_first_retained_error") let silentRecipe = CMOCBuildReport(error: CMOCBuildError.failed(status: 2, log: "main.c:2: error: failing hidden recipe\n")).fields() XCTAssertTrue(silentRecipe["failing_command"] is NSNull, "Do not invent the command hidden by @ recipes") } func testMissingInputsAndPostMakeValidationHaveDifferentFailureStages() async throws { let missing = CMOCProject(directory: folder.appendingPathComponent("missing-project")) let tools = try toolchain(make: successful) let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Outputs")) do { _ = try await service.build(project: missing, overlays: [:]); XCTFail("A missing project cannot build") } catch { let fields = CMOCBuildReport(error: error, redacting: [folder]).fields() XCTAssertEqual(fields["failure_stage"] as? String, "preparation") XCTAssertTrue(fields["exit_code"] is NSNull) XCTAssertNotNil(fields["first_error"] as? [String: Any]) } let value = try project() try Data("#!/bin/sh\nprintf success-without-artifacts\n".utf8).write(to: tools.appendingPathComponent("bin/make")) do { _ = try await service.build(project: value, source: "int main(void) { return 0; }"); XCTFail("Missing output cannot be successful") } catch { let fields = CMOCBuildReport(error: error, redacting: [folder]).fields() XCTAssertEqual(fields["failure_stage"] as? String, "validation") XCTAssertEqual(fields["failure_kind"] as? String, "validation") XCTAssertEqual(fields["exit_code"] as? Int, 0, "The process succeeded; validation rejected its outputs") XCTAssertTrue((fields["log"] as? String)?.contains("main.bin") == true) } } func testRealBundledToolsExposeCompilerAssemblerLinkerAndMakeFailures() async throws { let runtime = vccQualificationToolchain(URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent().appendingPathComponent("LocalResources/ToolchainBundle")) try XCTSkipUnless(CMOCBuildService.requiredExecutables.allSatisfy { FileManager.default.isExecutableFile(atPath: runtime.appendingPathComponent("bin/" + $0).path) }, "Stage the bundled CMOC/LWTools/Make runtime") let cases: [(String, String, String)] = [ ("compiler", "int main(void) { return definitely_missing; }\n", "cmoc --coco --intermediate -c main.c"), ("assembler", "int main(void) { return 0; }\n", "lwasm --6809 --format=obj -o main.o broken.asm"), ("linker", "extern void absent(void); int main(void) { absent(); return 0; }\n", "cmoc --coco --intermediate main.c"), ("make", "int main(void) { return 0; }\n", "$(MAKE) --no-print-directory -f Makefile definitely_missing_target") ] for (stage, source, command) in cases { var settings = CMOCProjectConfiguration(); settings.buildTarget = "build" let value = try configuredProject(settings, files: [ "main.c": source, "broken.asm": " bogusop #1\n", "Makefile": ".PHONY: build\nbuild:\n\t@printf 'main.c:1: warning: authored warning before failure\\n'\n\t" + command + "\n" ], at: folder.appendingPathComponent("Project " + stage)) let service = CMOCBuildService(toolchain: runtime, buildRoot: folder.appendingPathComponent("Real " + stage)) do { _ = try await service.build(project: value, overlays: [:]); XCTFail("The authored " + stage + " failure must fail") } catch { let fields = CMOCBuildReport(error: error, redacting: [folder, runtime], visiblePaths: ["main.c", "broken.asm", "Makefile"]).fields() let first = try XCTUnwrap(fields["first_error"] as? [String: Any], String(describing: fields)) XCTAssertEqual(first["severity"] as? String, "error") XCTAssertEqual(fields["failure_stage"] as? String, stage, String(describing: fields)) XCTAssertEqual(fields["exit_code"] as? Int, 2) XCTAssertTrue((fields["log"] as? String)?.contains("authored warning before failure") == true) } } } func testCancellationStopsCompilerChildrenAndRejectsConcurrentBuild() async throws { let value = try project() let marker = folder.appendingPathComponent("child-finished") let tools = try toolchain(make: "(sleep 2; touch '\(marker.path)') &\nwait\n" + successful) let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Outputs")) let task = Task { try await service.build(project: value, source: "int main(void){}") } try await Task.sleep(nanoseconds: 150_000_000) do { _ = try await service.build(project: value, source: "second"); XCTFail("Concurrent build must fail") } catch { XCTAssertTrue(error.localizedDescription.contains("already running")) } task.cancel() do { _ = try await task.value; XCTFail("Cancelled build must fail") } catch { XCTAssertTrue(error is CancellationError) } try await Task.sleep(nanoseconds: 2_100_000_000) XCTAssertFalse(FileManager.default.fileExists(atPath: marker.path), "Child compiler process must not outlive cancellation") XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: service.buildRoot.path), []) } func testTimeoutAndMissingBundledToolsAreExplicit() async throws { let value = try project() let tools = try toolchain(make: "sleep 10\n" + successful) let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Outputs"), timeout: 0.15) do { _ = try await service.build(project: value, source: "int main(void){}"); XCTFail("Timeout must fail") } catch { XCTAssertTrue(error.localizedDescription.contains("time limit")) } try FileManager.default.removeItem(at: tools.appendingPathComponent("bin/cpp")) do { _ = try await service.build(project: value, source: "int main(void){}"); XCTFail("Missing tools must fail") } catch { XCTAssertTrue(error.localizedDescription.contains("missing cpp")) } } private func configuredProject(_ settings: CMOCProjectConfiguration, files: [String: String], at directory: URL? = nil) throws -> CMOCProject { let value: CMOCProject if let directory { value = try CMOCProject.create(at: directory) } else { value = try project() } let encoder = JSONEncoder(); encoder.outputFormatting = [.prettyPrinted, .sortedKeys] try encoder.encode(settings).write(to: value.directory.appendingPathComponent(CMOCProject.configurationFilename)) for (path, text) in files { let url = value.directory.appendingPathComponent(path) try FileManager.default.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true) try Data(text.utf8).write(to: url) } return try CMOCProject.open(at: value.directory) } private func makeTools() throws -> URL { let runtime = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() .appendingPathComponent("LocalResources/ToolchainBundle/bin/make") guard FileManager.default.isExecutableFile(atPath: runtime.path) else { throw XCTSkip("Stage bundled GNU Make for real Make integration") } return try toolchain(make: "exec '\(runtime.path.replacingOccurrences(of: "'", with: "'\\''"))' \"$@\"\n") } func testAdditionalPlaytestDisksRoundTripAndRejectAmbiguousOrEscapingDeclarations() throws { var settings = CMOCProjectConfiguration() settings.diskImage = "HOME.dsk" settings.playtestDisks = ["build/world.dsk", "build/wrong.OS9"] XCTAssertEqual(try settings.validated().playtestDisks, settings.playtestDisks) XCTAssertEqual(try JSONDecoder().decode(CMOCProjectConfiguration.self, from: JSONEncoder().encode(settings)), settings) let defaults = try JSONDecoder().decode(CMOCProjectConfiguration.self, from: Data("{}".utf8)) XCTAssertTrue(defaults.playtestDisks.isEmpty) XCTAssertFalse(String(decoding: try JSONEncoder().encode(defaults), as: UTF8.self).contains("playtestDisks")) for paths in [["../world.dsk"], ["/tmp/world.dsk"], ["build//world.dsk"], ["a/../world.dsk"], ["build\\world.dsk"], [".git/world.dsk"], ["nested/.svn/world.dsk"], ["world.zip"], ["WORLD.dsk", "world.DSK"], ["home.DSK"], (0..<9).map { "world\($0).dsk" }] { var invalid = settings; invalid.playtestDisks = paths XCTAssertThrowsError(try invalid.validated(), paths.joined(separator: ", ")) } var boundary = settings; boundary.playtestDisks = (0..<8).map { "world\($0).dsk" } XCTAssertNoThrow(try boundary.validated()) var invalid = settings; invalid.playtestDisks = ["world.dsk"]; invalid.resourceInputs = ["WORLD.DSK"] XCTAssertThrowsError(try invalid.validated()) invalid.resourceInputs = []; invalid.generatedInputs = ["world.dsk"] XCTAssertThrowsError(try invalid.validated()) invalid.generatedInputs = []; invalid.binary = "world.dsk" XCTAssertThrowsError(try invalid.validated()) invalid.binary = "main.bin"; invalid.debugManifest = "world.dsk" XCTAssertThrowsError(try invalid.validated()) invalid.debugManifest = nil; var recipe = CMOCMakefileSettings(); recipe.diskFiles = ["world.dsk"]; invalid.makefileSettings = recipe XCTAssertThrowsError(try invalid.validated()) } func testAdditionalPlaytestDisksAreGeneratedOutputsAndChangeTheReviewedRecipeIdentity() throws { var settings = CMOCProjectConfiguration(); settings.diskImage = "home.dsk"; settings.playtestDisks = ["world.dsk"] let value = try configuredProject(settings, files: ["home.dsk": "stale home", "world.dsk": "stale world"]) let manifest = try CMOCProjectInputManifest.capture(project: value) XCTAssertNil(manifest.files["home.dsk"]); XCTAssertNil(manifest.files["world.dsk"]) XCTAssertEqual(manifest.entries.first { $0.path == "world.dsk" }?.role, "generated_output") XCTAssertNil(CMOCProject.filteredInputs(["world.dsk": Data("stale".utf8)], configuration: settings)["world.dsk"]) var changed = value; changed.configuration.playtestDisks = ["other.dsk"] let next = try CMOCProjectInputManifest.capture(project: changed, readConfigurationFile: false) XCTAssertNotEqual(next.identity, manifest.identity, "Additional media must be part of native reviewed recipe identity") try Data("edited externally".utf8).write(to: value.directory.appendingPathComponent("world.dsk")) XCTAssertEqual(try value.currentFileHashes(), manifest.files.mapValues(CMOCProject.sha256), "Stale generated media cannot change source revision") } func testBuildRetainsHashBoundAdditionalPlaytestDisksWithoutTouchingProjectMedia() async throws { var settings = CMOCProjectConfiguration(); settings.diskImage = "home.dsk"; settings.playtestDisks = ["media/world.dsk", "media/wrong.os9"] let value = try configuredProject(settings, files: ["home.dsk": "user home", "media/world.dsk": "user world"]) let tools = try toolchain(make: "test ! -e home.dsk || exit 81\ntest ! -e media/world.dsk || exit 82\nmkdir -p media\nprintf binary > main.bin\nprintf home > home.dsk\nprintf world > media/world.dsk\nprintf wrong > media/wrong.os9\n") let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Artifacts")) let artifact = try await service.build(project: value, overlays: [:]) XCTAssertEqual(artifact.playtestDiskProducts.map(\.relativePath), settings.playtestDisks) for product in artifact.playtestDiskProducts { let expected = Data((product.relativePath.hasSuffix("world.dsk") ? "world" : "wrong").utf8) XCTAssertEqual(product.byteCount, expected.count); XCTAssertEqual(product.sha256, CMOCProject.sha256(expected)) XCTAssertEqual(try artifact.playtestDiskData(for: product), expected) XCTAssertTrue(artifact.outputPaths.contains(product.relativePath)) } XCTAssertEqual(artifact.diskSHA256, CMOCProject.sha256(Data("home".utf8))) XCTAssertEqual(try artifact.playtestPrimaryDiskData(), Data("home".utf8)) XCTAssertEqual(try Data(contentsOf: value.directory.appendingPathComponent("home.dsk")), Data("user home".utf8)) XCTAssertEqual(try Data(contentsOf: value.directory.appendingPathComponent("media/world.dsk")), Data("user world".utf8)) let product = try XCTUnwrap(artifact.playtestDiskProducts.first) try Data("other".utf8).write(to: artifact.fileURL(product.relativePath)) XCTAssertThrowsError(try artifact.playtestDiskData(for: product), "Exact-sized changed bytes cannot reuse a build receipt") XCTAssertEqual(try artifact.playtestDiskData(for: artifact.playtestDiskProducts[1]), Data("wrong".utf8)) XCTAssertThrowsError(try artifact.playtestDiskData(for: CMOCPlaytestDiskProduct(relativePath: "media/unknown.dsk", sha256: product.sha256, byteCount: product.byteCount))) try Data("fake".utf8).write(to: XCTUnwrap(artifact.diskURL)) XCTAssertThrowsError(try artifact.playtestPrimaryDiskData(), "A changed primary cannot reuse the original artifact hash") } func testDeclaredPlaytestDiskReadRejectsSymbolicLeafAndParentEvenWithMatchingBytes() async throws { var settings = CMOCProjectConfiguration(); settings.playtestDisks = ["media/world.dsk"] let value = try configuredProject(settings, files: [:]) let service = CMOCBuildService(toolchain: try toolchain(make: "mkdir -p media\nprintf binary > main.bin\nprintf world > media/world.dsk\n"), buildRoot: folder.appendingPathComponent("Artifacts")) let artifact = try await service.build(project: value, overlays: [:]) let product = try XCTUnwrap(artifact.playtestDiskProducts.first) let disk = artifact.fileURL(product.relativePath), other = artifact.fileURL("world-copy.dsk") try FileManager.default.moveItem(at: disk, to: other) try FileManager.default.createSymbolicLink(at: disk, withDestinationURL: other) XCTAssertThrowsError(try artifact.playtestDiskData(for: product)) try FileManager.default.removeItem(at: disk) try FileManager.default.moveItem(at: other, to: disk) let media = artifact.fileURL("media"), moved = artifact.fileURL("media-original") try FileManager.default.moveItem(at: media, to: moved) try FileManager.default.createSymbolicLink(at: media, withDestinationURL: moved) XCTAssertThrowsError(try artifact.playtestDiskData(for: product)) } func testMissingOrOversizedAdditionalMediaFailsWithoutReplacingEarlierArtifact() async throws { var settings = CMOCProjectConfiguration(); settings.diskImage = "home.dsk"; settings.playtestDisks = ["world.dsk"] let value = try configuredProject(settings, files: [:]) let tools = try toolchain(make: "printf binary > main.bin\nprintf home > home.dsk\nprintf world > world.dsk\n") let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Artifacts")) let first = try await service.build(project: value, overlays: [:]) let original = try XCTUnwrap(first.playtestDiskProducts.first) for extra in ["rm -f world.dsk", ": > world.dsk", "dd if=/dev/zero of=world.dsk bs=524289 count=1 2>/dev/null"] { try Data(("#!/bin/sh\nprintf binary > main.bin\nprintf home > home.dsk\n" + extra + "\n").utf8).write(to: tools.appendingPathComponent("bin/make")) do { _ = try await service.build(project: value, overlays: [:]); XCTFail("Invalid declared media must fail: " + extra) } catch { XCTAssertTrue(error.localizedDescription.contains("declared playtest disk world.dsk"), error.localizedDescription) } XCTAssertEqual(try first.playtestDiskData(for: original), Data("world".utf8)) XCTAssertEqual(try Data(contentsOf: XCTUnwrap(first.diskURL)), Data("home".utf8)) } } func testNewPlaytestMediaDeclarationCannotReuseAnIncidentalCachedDisk() async throws { let settings = CMOCProjectConfiguration() let value = try configuredProject(settings, files: [:]) let tools = try toolchain(make: "printf binary > main.bin\nprintf incidental > world.dsk\n") let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Artifacts")) let first = try await service.build(project: value, overlays: [:]) XCTAssertTrue(first.playtestDiskProducts.isEmpty) XCTAssertTrue(first.outputPaths.contains("world.dsk")) var changed = settings; changed.playtestDisks = ["world.dsk"] try JSONEncoder().encode(changed).write(to: value.directory.appendingPathComponent(CMOCProject.configurationFilename)) try Data("#!/bin/sh\nprintf binary > main.bin\n".utf8).write(to: tools.appendingPathComponent("bin/make")) do { _ = try await service.build(project: value, overlays: [:]); XCTFail("A new declaration needs a fresh produced disk") } catch { XCTAssertTrue(error.localizedDescription.contains("declared playtest disk world.dsk"), error.localizedDescription) } XCTAssertEqual(try Data(contentsOf: first.fileURL("world.dsk")), Data("incidental".utf8)) } func testSuccessfulRecipeCannotDeclareASymbolicLinkAsPlaytestMedia() async throws { var settings = CMOCProjectConfiguration(); settings.playtestDisks = ["world.dsk"] let value = try configuredProject(settings, files: [:]) let service = CMOCBuildService(toolchain: try toolchain(make: "printf binary > main.bin\nprintf world > real-media.raw\nln -s real-media.raw world.dsk\n"), buildRoot: folder.appendingPathComponent("Artifacts")) do { _ = try await service.build(project: value, overlays: [:]); XCTFail("A declared disk must be a regular output, not a link") } catch { XCTAssertEqual(error.localizedDescription, "Copy linked resources into the project before building: world.dsk") } XCTAssertFalse(FileManager.default.fileExists(atPath: value.directory.appendingPathComponent("world.dsk").path)) } func testCustomUtilityTargetDoesNotAdvertiseUnpromisedPlaytestMedia() async throws { var settings = CMOCProjectConfiguration(); settings.playtestDisks = ["world.dsk"] let value = try configuredProject(settings, files: [:]) let service = CMOCBuildService(toolchain: try toolchain(make: "printf utility > utility.txt\n"), buildRoot: folder.appendingPathComponent("Artifacts")) let artifact = try await service.build(project: value, overlays: [:], action: .custom, target: "utility") XCTAssertTrue(artifact.playtestDiskProducts.isEmpty) XCTAssertFalse(artifact.hasDisk); XCTAssertFalse(artifact.hasBinary) } func testBuildSupportDirectoriesAreExplicitAndRoundTripWithoutExpandingScope() throws { var settings = CMOCProjectConfiguration() settings.buildSupportDirectories = ["../tools"] XCTAssertEqual(try settings.validated().buildSupportDirectories, ["../tools"]) let restored = try JSONDecoder().decode(CMOCProjectConfiguration.self, from: JSONEncoder().encode(settings)) XCTAssertEqual(restored, settings) XCTAssertTrue(try JSONDecoder().decode(CMOCProjectConfiguration.self, from: Data("{}".utf8)).buildSupportDirectories.isEmpty) for paths in [["tools"], ["/tmp/tools"], ["../../tools"], ["../tools/subfolder"], ["../"], ["../tools", "../tools"]] { var invalid = settings invalid.buildSupportDirectories = paths XCTAssertThrowsError(try invalid.validated(), paths.joined(separator: ", ")) } } func testDeclaredSiblingSupportBuildsCustomMakeTargetsAndPreservesOriginals() async throws { var settings = CMOCProjectConfiguration() settings.buildSupportDirectories = ["../tools"] settings.buildTarget = "build" settings.diskTarget = "disk" settings.diskImage = "game.dsk" settings.configurations = [.init(name: "Debug", makeArguments: ["VCC_CONFIGURATION=Debug"]), .init(name: "Release", makeArguments: ["VCC_CONFIGURATION=Release"])] let makefile = """ .PHONY: build disk build: main.c ../tools/helper.sh \t../tools/helper.sh '$(VCC_CONFIGURATION)' > main.bin disk: build \tcat main.bin > game.dsk """ let project = try configuredProject(settings, files: ["Makefile": makefile, "main.c": "int main(void) { return 0; }\n"]) let support = folder.appendingPathComponent("tools") try FileManager.default.createDirectory(at: support, withIntermediateDirectories: true) let helper = support.appendingPathComponent("helper.sh") let helperBytes = Data("#!/bin/sh\nprintf 'SUPPORT-v1:%s' \"$1\"\n".utf8) try helperBytes.write(to: helper) try FileManager.default.setAttributes([.posixPermissions: 0o755], ofItemAtPath: helper.path) let unrelated = folder.appendingPathComponent("private-reference") try FileManager.default.createDirectory(at: unrelated, withIntermediateDirectories: true) try Data("not a build input".utf8).write(to: unrelated.appendingPathComponent("private.txt")) let sourceInputs = try project.inputFiles() let originalHashes = try project.currentFileHashes() let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Artifacts")) let debug = try await service.build(project: project, overlays: [:], action: .build, configuration: "Debug") let release = try await service.build(project: project, overlays: [:], action: .disk, configuration: "Release") XCTAssertEqual(debug.binaryData, Data("SUPPORT-v1:Debug".utf8)) XCTAssertEqual(release.binaryData, Data("SUPPORT-v1:Release".utf8)) XCTAssertEqual(try Data(contentsOf: XCTUnwrap(release.diskURL)), release.binaryData) XCTAssertNil(debug.diskSHA256) XCTAssertEqual(release.diskSHA256, CMOCProject.sha256(release.binaryData)) XCTAssertEqual(debug.fileHashes, originalHashes) XCTAssertEqual(release.fileHashes, originalHashes) XCTAssertFalse(originalHashes.keys.contains(where: { $0.contains("private-reference") })) XCTAssertNotEqual(debug.compilationDirectory, release.compilationDirectory) XCTAssertEqual(try project.inputFiles(), sourceInputs) XCTAssertEqual(try Data(contentsOf: helper), helperBytes) XCTAssertFalse(FileManager.default.fileExists(atPath: project.directory.appendingPathComponent("main.bin").path)) XCTAssertFalse(FileManager.default.fileExists(atPath: project.directory.appendingPathComponent("game.dsk").path)) let diskURL = try XCTUnwrap(release.diskURL) try Data("changed after build".utf8).write(to: diskURL) XCTAssertNotEqual(CMOCProject.sha256(try Data(contentsOf: diskURL)), release.diskSHA256, "Artifact ownership must use the build's captured output digest, rather than trusting retained file contents") let changedBytes = Data("#!/bin/sh\nprintf 'SUPPORT-v2:%s' \"$1\"\n".utf8) try changedBytes.write(to: helper) let changedHashes = try project.currentFileHashes() XCTAssertNotEqual(changedHashes, originalHashes) let changed = try await service.build(project: project, overlays: [:], configuration: "Debug") XCTAssertEqual(changed.binaryData, Data("SUPPORT-v2:Debug".utf8)) XCTAssertEqual(changed.fileHashes, changedHashes) XCTAssertEqual(debug.binaryData, Data("SUPPORT-v1:Debug".utf8), "Earlier artifacts must remain immutable") try FileManager.default.setAttributes([.posixPermissions: 0o744], ofItemAtPath: helper.path) XCTAssertNotEqual(try project.currentFileHashes(), changedHashes, "A helper's executable permissions are part of the approved build input") } func testBuildSupportSnapshotsRejectSymlinkRootsAndLinkedMembers() throws { var settings = CMOCProjectConfiguration() settings.buildSupportDirectories = ["../tools"] let project = try configuredProject(settings, files: [:]) let manager = FileManager.default let support = folder.appendingPathComponent("tools") let outside = folder.appendingPathComponent("outside") try manager.createDirectory(at: outside, withIntermediateDirectories: true) try Data("private".utf8).write(to: outside.appendingPathComponent("secret.txt")) try manager.createSymbolicLink(at: support, withDestinationURL: outside) XCTAssertThrowsError(try project.currentFileHashes()) try manager.removeItem(at: support) try manager.createDirectory(at: support, withIntermediateDirectories: true) try manager.createSymbolicLink(at: support.appendingPathComponent("linked.txt"), withDestinationURL: outside.appendingPathComponent("secret.txt")) XCTAssertThrowsError(try project.currentFileHashes()) } func testSupportManifestExcludesEvidenceButPreservesHelpersAndIgnoresNestedProjectAuthority() throws { var settings = CMOCProjectConfiguration(); settings.buildSupportDirectories = ["../tools"] let value = try configuredProject(settings, files: [:]) let tools = folder.appendingPathComponent("tools") let evidence = tools.appendingPathComponent("evidence") let captures = tools.appendingPathComponent("captures") let manager = FileManager.default for directory in [tools, evidence, captures] { try manager.createDirectory(at: directory, withIntermediateDirectories: true) } let helper = tools.appendingPathComponent("helper.sh") try Data("#!/bin/sh\nprintf original\n".utf8).write(to: helper) try manager.setAttributes([.posixPermissions: 0o755], ofItemAtPath: helper.path) // An intentionally retained native helper remains an input in this // explicitly approved support root, even though ordinary host build // products in a project are excluded from source identity. let native = tools.appendingPathComponent("native-helper") try Data([0xcf, 0xfa, 0xed, 0xfe, 0, 0, 0, 0]).write(to: native) try manager.setAttributes([.posixPermissions: 0o755], ofItemAtPath: native.path) let nested = tools.appendingPathComponent(CMOCProject.configurationFilename) try Data("{\"buildSupportDirectories\":[\"../unapproved-neighbor\"],\"resourceInputs\":[\"../private.txt\"]}".utf8).write(to: nested) // No such neighbor exists. Its settings are plain retained bytes; // parsing them would either fail or expand beyond the approved root. let first = try value.supportSnapshot() let originalManifest = try CMOCProjectInputManifest.capture(project: value) XCTAssertNotNil(first.files["../tools/helper.sh"]) XCTAssertNotNil(first.files["../tools/native-helper"]) XCTAssertNotNil(first.files["../tools/" + CMOCProject.configurationFilename]) try Data(repeating: 0x41, count: 128 * 1024).write(to: evidence.appendingPathComponent("notes.json")) try Data(repeating: 0x42, count: 128 * 1024).write(to: captures.appendingPathComponent("frame.png")) try Data("{\"result\":\"observed\"}".utf8).write(to: tools.appendingPathComponent("trial-receipt.json")) XCTAssertEqual(try value.supportSnapshot(), first) XCTAssertEqual(try CMOCProjectInputManifest.capture(project: value).identity, originalManifest.identity) XCTAssertEqual(try value.supportFileHashes(), first.hashes) try Data("#!/bin/sh\nprintf revised\n".utf8).write(to: helper) XCTAssertNotEqual(try value.supportSnapshot(), first) XCTAssertNotEqual(try CMOCProjectInputManifest.capture(project: value).identity, originalManifest.identity) XCTAssertEqual(try Data(contentsOf: native), first.files["../tools/native-helper"]) } func testBuildCannotAcceptAnArtifactAfterMutatingItsCopiedSupportInputs() async throws { var settings = CMOCProjectConfiguration() settings.buildSupportDirectories = ["../tools"] settings.buildTarget = "build" let value = try configuredProject(settings, files: ["Makefile": """ .PHONY: build build: \tprintf changed > ../tools/input.txt \tprintf binary > main.bin """]) let support = folder.appendingPathComponent("tools") try FileManager.default.createDirectory(at: support, withIntermediateDirectories: true) let original = Data("original support input".utf8) let input = support.appendingPathComponent("input.txt") try original.write(to: input) let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Artifacts")) do { _ = try await service.build(project: value, overlays: [:]) XCTFail("A recipe that changes copied support inputs cannot establish build identity") } catch { XCTAssertTrue(error.localizedDescription.contains("modified its build-support files"), error.localizedDescription) } XCTAssertEqual(try Data(contentsOf: input), original, "The original support folder must never be the build working copy") XCTAssertFalse(FileManager.default.fileExists(atPath: value.directory.appendingPathComponent("main.bin").path)) } func testBuildRejectsMutationOfCustomNamedMakefileAndPreservesTheOriginal() async throws { var settings = CMOCProjectConfiguration() settings.makefile = "build.recipe" settings.buildTarget = "build" let recipe = """ .PHONY: build build: \tprintf replaced > build.recipe \tprintf binary > main.bin """ let project = try configuredProject(settings, files: ["build.recipe": recipe]) let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Artifacts")) do { _ = try await service.build(project: project, overlays: [:]) XCTFail("A configured Makefile must remain part of the verified input identity regardless of its filename") } catch { XCTAssertTrue(error.localizedDescription.contains("modified build.recipe"), error.localizedDescription) } XCTAssertEqual(try project.readText(relativePath: "build.recipe"), recipe) XCTAssertFalse(FileManager.default.fileExists(atPath: project.directory.appendingPathComponent("main.bin").path)) } func testMultiFileConfigurationDiscoveryAndSafeDocumentPaths() throws { var settings = CMOCProjectConfiguration() settings.entrySource = "source/start.c"; settings.binary = "output/game.bin"; settings.buildTarget = "all" settings.diskTarget = "disk"; settings.diskImage = "output/game.dsk"; settings.launchMode = .disk settings.debugManifest = "output/game.debug.json" settings.launchCommands = ["DOS"]; settings.jobs = 4 let value = try configuredProject(settings, files: ["source/start.c": "int main(void) { return 0; }\n", "include/game.h": "#define VALUE 1\n", "assets/data.txt": "WORDS\n"]) XCTAssertEqual(value.configuration, settings) XCTAssertEqual(try value.readSource(), "int main(void) { return 0; }\n") XCTAssertTrue(try value.fileEntries().contains(where: { $0.relativePath == "include/game.h" && $0.isEditable })) XCTAssertThrowsError(try value.fileURL(relativePath: "../outside.c")) let original = try value.readText(relativePath: "include/game.h") let hash = CMOCProject.sha256(Data(original.utf8)) _ = try value.saveText("#define VALUE 2\n", relativePath: "include/game.h", replacingSHA256: hash) XCTAssertThrowsError(try value.saveText(original, relativePath: "include/game.h", replacingSHA256: hash)) try FileManager.default.createSymbolicLink(at: value.directory.appendingPathComponent("linked"), withDestinationURL: folder) XCTAssertThrowsError(try value.fileURL(relativePath: "linked/outside.c")) XCTAssertThrowsError(try value.fileEntries()) } func testBankedManifestIsGeneratedOutputAndDoesNotFailAnOtherwiseSuccessfulBuild() async throws { var settings = CMOCProjectConfiguration() settings.debugManifest = "game.debug.json" let value = try configuredProject(settings, files: ["main.c": "int main(void) { return 0; }\n", "game.debug.json": "stale local manifest"]) XCTAssertFalse(try value.fileEntries().contains { $0.relativePath == "game.debug.json" }) let tools = try toolchain(make: "test ! -e game.debug.json || exit 92\nprintf packed > main.bin\nprintf malformed > game.debug.json\n") let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Artifacts")) let artifact = try await service.build(project: value, overlays: [:]) XCTAssertEqual(artifact.debugManifestRelativePath, "game.debug.json") XCTAssertEqual(artifact.binaryData, Data("packed".utf8)) XCTAssertThrowsError(try artifact.bankedDebugLayout()) XCTAssertThrowsError(try CMOCProjectSourceMap.parse(artifact: artifact), "A configured invalid manifest must never fall back to flat mapping") XCTAssertEqual(try String(contentsOf: value.directory.appendingPathComponent("game.debug.json"), encoding: .utf8), "stale local manifest") settings.debugManifest = "../escape.json" XCTAssertThrowsError(try settings.validated()) settings.debugManifest = "main.c" XCTAssertThrowsError(try settings.validated()) } func testProjectWithoutMainOrMetadataDiscoversCEntryWithoutExecutingMake() throws { let value = try project() try FileManager.default.moveItem(at: value.sourceURL, to: value.directory.appendingPathComponent("game.c")) let opened = try CMOCProject.open(at: value.directory) XCTAssertEqual(opened.configuration.entrySource, "game.c") XCTAssertEqual(opened.configuration.binary, "game.bin") XCTAssertEqual(opened.configuration.buildTarget, "") var bad = CMOCProjectConfiguration(); bad.binary = "../wrong.bin" XCTAssertThrowsError(try bad.validated()) bad = .init(); bad.configurations = [.init(name: "Bad", makeArguments: ["--eval=anything"])] XCTAssertThrowsError(try bad.validated()) } func testImportedMakefilesDelegateDefaultGoalToMakeWithoutChangingSources() async throws { let tools = try makeTools() let cases: [(String, String, String?)] = [ ("first", """ package-image: \tprintf FIRST > main.bin build: \t@exit 91 """, nil), ("included", """ include goals.mk wrong-first: \t@exit 92 $(PRODUCT_GOAL): \tprintf INCLUDED > main.bin """, "PRODUCT_GOAL = selected-by-include\n.DEFAULT_GOAL := $(PRODUCT_GOAL)\n"), ("conditional", """ ifeq ($(VCC_CONFIGURATION),Release) .DEFAULT_GOAL := shipping else .DEFAULT_GOAL := development endif development: \tprintf DEBUG > main.bin shipping: \tprintf RELEASE > main.bin """, nil) ] for (name, makefile, include) in cases { let root = folder.appendingPathComponent(name) let original = try CMOCProject.create(at: root) let text = makefile + "\nclean:\n\trm -f main.bin\n" try Data(text.utf8).write(to: original.makefileURL) if let include { try Data(include.utf8).write(to: root.appendingPathComponent("goals.mk")) } let opened = try CMOCProject.open(at: root) XCTAssertTrue(opened.configuration.buildTarget.isEmpty) let inputs = try opened.inputFiles() let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Results-" + name)) let result = try await service.build(project: opened, overlays: [:]) let expected = name == "first" ? "FIRST" : name == "included" ? "INCLUDED" : "DEBUG" XCTAssertEqual(result.binaryData, Data(expected.utf8)) let rebuilt = try await service.build(project: opened, overlays: [:], action: .rebuild) XCTAssertEqual(rebuilt.binaryData, result.binaryData) XCTAssertTrue(rebuilt.buildLog.contains("rm -f main.bin")) if name == "conditional" { let release = try await service.build(project: opened, overlays: [:], configuration: "Release") XCTAssertEqual(release.binaryData, Data("RELEASE".utf8)) } XCTAssertEqual(try opened.inputFiles(), inputs, "Import and build leave the original project unchanged") XCTAssertFalse(FileManager.default.fileExists(atPath: root.appendingPathComponent(CMOCProject.configurationFilename).path)) } } func testExplicitBuildTargetOverridesMakeDefaultAndMissingTargetMeansDefault() async throws { let tools = try makeTools() let makefile = """ .DEFAULT_GOAL := other other: \tprintf DEFAULT > main.bin requested: \tprintf EXPLICIT > main.bin """ var settings = CMOCProjectConfiguration(); settings.buildTarget = "requested" let project = try configuredProject(settings, files: ["Makefile": makefile]) let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Results")) let explicit = try await service.build(project: project, overlays: [:]) XCTAssertEqual(explicit.binaryData, Data("EXPLICIT".utf8)) let missing = try JSONDecoder().decode(CMOCProjectConfiguration.self, from: Data("{}".utf8)) XCTAssertTrue(try missing.validated().buildTarget.isEmpty) let useDefault = try await service.build(project: project, overlays: [CMOCProject.configurationFilename: "{}"]) XCTAssertEqual(useDefault.binaryData, Data("DEFAULT".utf8)) var invalid = missing; invalid.cleanTarget = "" XCTAssertThrowsError(try invalid.validated()) invalid = missing; invalid.diskTarget = "" XCTAssertThrowsError(try invalid.validated()) invalid = missing; invalid.buildTarget = "--eval=unsafe" XCTAssertThrowsError(try invalid.validated()) } func testBundledLibraryBindingsArePortableVerifiedAndPreserveMakeFlags() async throws { let tools = try makeTools(), manager = FileManager.default let archive = Data("ARCHIVE".utf8), header = Data("/* HEADER */".utf8) for (path, bytes) in ["share/cmoc/lib/libexample.a": archive, "share/cmoc/include/example.h": header, "LICENSES/NOTICE.txt": Data("Test notice".utf8)] { let url = tools.appendingPathComponent(path) try manager.createDirectory(at: url.deletingLastPathComponent(), withIntermediateDirectories: true) try bytes.write(to: url) } let manifest: [String: Any] = ["libraries": ["example": ["version": "1.2.3", "license": "Test fixture", "filesSHA256": [ "share/cmoc/lib/libexample.a": CMOCProject.sha256(archive), "share/cmoc/include/example.h": CMOCProject.sha256(header)]]]] try JSONSerialization.data(withJSONObject: manifest).write(to: tools.appendingPathComponent("manifest.json")) var settings = CMOCProjectConfiguration() settings.bundledLibraries = [.init(library: "example", minimumVersion: "1.2", directoryVariable: "EXAMPLE_DIR", linkVariable: "LIBS")] let makefile = """ EXAMPLE_DIR = missing LIBS = -loriginal all: $(EXAMPLE_DIR)/libexample.a \tcp $(EXAMPLE_DIR)/libexample.a main.bin \tprintf '%s' '$(LIBS)' > flags.txt \tcmp $(EXAMPLE_DIR)/example.h expected.h """ let project = try configuredProject(settings, files: ["Makefile": makefile, "expected.h": String(decoding: header, as: UTF8.self)]) let before = try project.inputFiles() let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Build Products With Spaces")) let artifact = try await service.build(project: project, overlays: [:]) XCTAssertEqual(artifact.binaryData, archive) let flags = try String(contentsOf: artifact.fileURL("flags.txt"), encoding: .utf8) XCTAssertTrue(flags.hasPrefix("-loriginal -L")); XCTAssertTrue(flags.hasSuffix(" -lexample")) XCTAssertFalse(flags.contains("Tool Chain"), "Make must receive an isolated space-free copy, never an app-bundle path") XCTAssertEqual(try project.inputFiles(), before) XCTAssertEqual(try Data(contentsOf: tools.appendingPathComponent("share/cmoc/lib/libexample.a")), archive) XCTAssertEqual(try JSONDecoder().decode(CMOCProjectConfiguration.self, from: JSONEncoder().encode(settings)), settings) XCTAssertTrue(try String(contentsOf: artifact.fileURL(".vccplus-libraries/LICENSES/NOTICE.txt"), encoding: .utf8).contains("Test notice")) for bad in [CMOCBundledLibraryBinding(library: "example", minimumVersion: "2.0", directoryVariable: "EXAMPLE_DIR"), CMOCBundledLibraryBinding(library: "absent", directoryVariable: "EXAMPLE_DIR")] { var changed = settings; changed.bundledLibraries = [bad] do { _ = try await service.build(project: project, overlays: [CMOCProject.configurationFilename: String(decoding: JSONEncoder().encode(changed), as: UTF8.self)]) XCTFail("Unavailable or incompatible libraries must fail") } catch { XCTAssertTrue(error.localizedDescription.contains("library") || error.localizedDescription.contains("version")) } } try Data("CORRUPT".utf8).write(to: tools.appendingPathComponent("share/cmoc/lib/libexample.a")) do { _ = try await service.build(project: project, overlays: [:]); XCTFail("Changed archive must fail integrity validation") } catch { XCTAssertTrue(error.localizedDescription.contains("integrity")) } } func testBundledLibraryVariableValidation() throws { let minimal = try JSONDecoder().decode(CMOCBundledLibraryBinding.self, from: Data(#"{"library":"decbfile","directoryVariable":"DISK_LIB"}"#.utf8)) XCTAssertEqual(minimal, .init(library: "decbfile", directoryVariable: "DISK_LIB")) var settings = CMOCProjectConfiguration() for binding in [CMOCBundledLibraryBinding(library: "../escape", directoryVariable: "LIBDIR"), .init(library: "one", directoryVariable: "SHELL"), .init(library: "one", directoryVariable: "X\nY"), .init(library: "one", minimumVersion: "1.x", directoryVariable: "LIBDIR"), .init(library: "one")] { settings.bundledLibraries = [binding]; XCTAssertThrowsError(try settings.validated()) } settings.bundledLibraries = [.init(library: "one", directoryVariable: "DIR"), .init(library: "two", directoryVariable: "DIR")] XCTAssertThrowsError(try settings.validated()) settings.bundledLibraries = [.init(library: "one", directoryVariable: "DIR", linkVariable: "DIR")] XCTAssertThrowsError(try settings.validated()) settings.bundledLibraries = [.init(library: "one", directoryVariable: "DIR")] settings.configurations = [.init(name: "Debug", makeArguments: ["DIR=elsewhere"])] XCTAssertThrowsError(try settings.validated()) XCTAssertTrue(CMOCBundledLibrary.atLeast("0.1.13", "0.1.6")) XCTAssertTrue(CMOCBundledLibrary.atLeast("1.2", "1.2.0")) XCTAssertFalse(CMOCBundledLibrary.atLeast("1.2", "1.2.1")) } func testBundledLibrariesBuildUnmodifiedCoCoLettersMakefile() async throws { let repo = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent() let runtime = vccQualificationToolchain(repo.appendingPathComponent("platforms/macos/LocalResources/ToolchainBundle")) try XCTSkipUnless(FileManager.default.fileExists(atPath: runtime.appendingPathComponent("share/cmoc/lib/libdskcon-standalone.a").path), "Stage the optional standalone disk library") let root = folder.appendingPathComponent("CoCo Letters") try FileManager.default.copyItem(at: repo.appendingPathComponent("third_party/examples/coco-letters"), to: root) var config = CMOCProjectConfiguration() config.binary = "letters.bin"; config.diskImage = "coco-letters-0.1.0.dsk"; config.diskTarget = "all" config.launchMode = .disk; config.launchCommands = ["DOS"] config.configurations = [.init(name: "Debug", makeArguments: ["INTERMEDIATE=--intermediate"])] config.bundledLibraries = [ .init(library: "decbfile", minimumVersion: "0.1.13", directoryVariable: "DECBFILE_LIB_DIR"), .init(library: "bcontrol", minimumVersion: "0.1.6", directoryVariable: "BCONTROL_LIB_DIR"), .init(library: "bsound", minimumVersion: "0.1.4", directoryVariable: "BSOUND_LIB_DIR"), .init(library: "dskcon-standalone", linkVariable: "LIBS")] try JSONEncoder().encode(config).write(to: root.appendingPathComponent(CMOCProject.configurationFilename)) let project = try CMOCProject.open(at: root), before = try project.inputFiles() let service = CMOCBuildService(toolchain: runtime, buildRoot: folder.appendingPathComponent("Game Build")) let result = try await service.build(project: project, overlays: [:]) XCTAssertTrue(result.hasBinary); XCTAssertTrue(result.hasDisk) XCTAssertEqual(try Data(contentsOf: XCTUnwrap(result.diskURL)).count, 35 * 18 * 256) let mapping = try CMOCProjectSourceMap.parse(artifact: result) XCTAssertTrue(mapping.instructions.contains { $0.sourcePath == "main.c" }) XCTAssertGreaterThan(Set(mapping.instructions.map(\.sourcePath)).count, 5) XCTAssertEqual(try project.inputFiles(), before) try await verifyBundledGameExecution(result, mapping: mapping, runtime: runtime) let repeated = try await service.build(project: project, overlays: [:]) XCTAssertEqual(repeated.binaryData, result.binaryData) XCTAssertFalse(repeated.buildLog.contains("cmoc -c"), repeated.buildLog) XCTAssertFalse(repeated.buildLog.contains("cmoc -o"), repeated.buildLog) } @MainActor private func verifyBundledGameExecution(_ build: CMOCBuildArtifact, mapping: CMOCProjectSourceMap, runtime: URL) async throws { let roms = runtime.deletingLastPathComponent().appendingPathComponent("ROMs") try XCTSkipUnless(FileManager.default.fileExists(atPath: roms.appendingPathComponent("coco3.rom").path), "Stage licensed local ROMs for execution checks") let rom = try Data(contentsOf: roms.appendingPathComponent("coco3.rom")) let diskROM = try Data(contentsOf: roms.appendingPathComponent("disk11.rom")) let disk = try Data(contentsOf: XCTUnwrap(build.diskURL)) // The presentation's first keyboard poll is reached after the full dictionary // has been loaded through the standalone driver, not merely after LOADM. let source = try String(contentsOf: build.fileURL("main.c"), encoding: .utf8).components(separatedBy: "\n") let line = try XCTUnwrap(source.firstIndex { $0.contains("while ((key = pollKeyNoLowerCase()) != 'R'") }) + 1 let point = try XCTUnwrap(mapping.instructions.first { $0.sourcePath == "main.c" && $0.sourceLine == line }) func command(_ body: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot { await withCheckedContinuation { continuation in body { continuation.resume(returning: $0) } } } for cpu in [false, true] { let controller = VCCMachineController() _ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) } _ = await command { controller.loadDiskROM(diskROM, name: "Disk BASIC", completion: $0) } _ = 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) } _ = await command { controller.mountDisk(disk, drive: 0, name: "Letters.dsk", readOnly: true, completion: $0) } _ = await command { controller.loadROM(rom, use6309: cpu, completion: $0) } _ = await command(controller.resume) var ready = false for _ in 0..<250 { let text: String? = await withCheckedContinuation { c in controller.copyScreenText { text, _ in c.resume(returning: text) } } if text?.contains("OK") == true { ready = true; break } try await Task.sleep(nanoseconds: 40_000_000) } XCTAssertTrue(ready) let visible = await command(controller.snapshot) for _ in 0..<100 { if await command(controller.snapshot).frames >= visible.frames + 18 { break } try await Task.sleep(nanoseconds: 20_000_000) } _ = await command(controller.pause) let armed = await command { controller.debuggerArmDevelopmentBreakpoints([NSNumber(value: point.address)], guardAddresses: mapping.instructions.map { NSNumber(value: $0.address) }, guardBytes: mapping.instructions.map { Data($0.bytes) }, completion: $0) } XCTAssertNil(armed.errorMessage) _ = await command(controller.resume) let paste = try CocoPaste("DOS\n", mode: .text) _ = await command { controller.pasteChords(paste.chords.map { NSNumber(value: $0) }, completion: $0) } var stopped = await command(controller.snapshot) for _ in 0..<1500 { if stopped.state != .running { break } try await Task.sleep(nanoseconds: 20_000_000) stopped = await command(controller.snapshot) } XCTAssertEqual(stopped.state, .paused, "CoCo Letters must reach its presentation after loading dictionary; 6309=\(cpu)") XCTAssertEqual(stopped.programCounter, point.address) XCTAssertTrue(stopped.debuggerDevelopmentAttached) XCTAssertGreaterThan(stopped.disks[0].readEvents, visible.disks[0].readEvents + 200) XCTAssertFalse(stopped.disks[0].dirty) let gameLine = try XCTUnwrap(source.firstIndex { $0.trimmingCharacters(in: .whitespaces) == "playGame();" }) + 1 let gamePoint = try XCTUnwrap(mapping.instructions.first { $0.sourcePath == "main.c" && $0.sourceLine == gameLine }) _ = await command { controller.debuggerArmDevelopmentBreakpoints([NSNumber(value: gamePoint.address)], guardAddresses: mapping.instructions.map { NSNumber(value: $0.address) }, guardBytes: mapping.instructions.map { Data($0.bytes) }, completion: $0) } _ = await command(controller.resume) for character in ["R", "E", "U"] { controller.setKeyboardMask(try XCTUnwrap(CocoKeyboard.chord(for: character))) try await Task.sleep(nanoseconds: 200_000_000) controller.setKeyboardMask(0) try await Task.sleep(nanoseconds: 500_000_000) } let playing = await command(controller.snapshot) XCTAssertEqual(playing.state, .paused, "RGB/Easy/User inputs must reach gameplay") XCTAssertEqual(playing.programCounter, gamePoint.address) _ = await command(controller.shutdown) } } func testRealMakeIncrementalDependenciesGeneratedSourcesAndImmutableResults() async throws { var settings = CMOCProjectConfiguration() settings.binary = "out/game.bin"; settings.buildTarget = "all"; settings.jobs = 4 let makefile = """ .PHONY: all clean all: out/game.bin out/game.bin: out/a.o out/b.o out/generated.o \tcat $^ > $@ out/a.o: main.c include/common.h \t@mkdir -p out \t@echo CC-main \tcat $^ > $@ out/b.o: nested/other.c include/common.h \t@mkdir -p out \t@echo CC-other \tcat $^ > $@ generated.c: assets/words.txt \tprintf '/* generated */\\n' > $@ \tcat $< >> $@ out/generated.o: generated.c \t@mkdir -p out \t@echo CC-generated \tcp $< $@ clean: \trm -rf out generated.c """ let value = try configuredProject(settings, files: ["Makefile": makefile, "main.c": "int first;\n", "nested/other.c": "int second;\n", "include/common.h": "#define COMMON 1\n", "assets/words.txt": "int generated;\n", "remove-me.txt": "temporary input\n"]) let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Outputs")) let first = try await service.build(project: value, overlays: [:]) XCTAssertTrue(first.buildLog.contains("CC-main")); XCTAssertTrue(first.buildLog.contains("CC-other")) XCTAssertTrue(first.sources.keys.contains("generated.c")) XCTAssertEqual(first.fileHashes, try value.currentFileHashes()) XCTAssertTrue(first.hasBinary) let firstBytes = first.binaryData let second = try await service.build(project: value, overlays: [:]) XCTAssertEqual(first.compilationDirectory, second.compilationDirectory) XCTAssertNotEqual(first.directory, second.directory) XCTAssertFalse(second.buildLog.contains("CC-main")); XCTAssertFalse(second.buildLog.contains("CC-other")) XCTAssertEqual(firstBytes, second.binaryData) let edited = try await service.build(project: value, overlays: ["nested/other.c": "int changed;\n"]) XCTAssertFalse(edited.buildLog.contains("CC-main")); XCTAssertTrue(edited.buildLog.contains("CC-other")) XCTAssertEqual(try value.readText(relativePath: "nested/other.c"), "int second;\n", "Build must not save editor drafts") XCTAssertEqual(try Data(contentsOf: first.binaryURL), firstBytes, "Earlier debug artifacts stay immutable") let headerEdit = try await service.build(project: value, overlays: ["include/common.h": "#define COMMON 2\n"]) XCTAssertTrue(headerEdit.buildLog.contains("CC-main")); XCTAssertTrue(headerEdit.buildLog.contains("CC-other")) try FileManager.default.removeItem(at: value.directory.appendingPathComponent("remove-me.txt")) let deleted = try await service.build(project: value, overlays: [:]) XCTAssertFalse(deleted.outputPaths.contains("remove-me.txt")) let rebuilt = try await service.build(project: value, overlays: [:], action: .rebuild) XCTAssertEqual(rebuilt.binaryData, firstBytes) XCTAssertTrue(rebuilt.buildLog.contains("CC-main")); XCTAssertTrue(rebuilt.buildLog.contains("CC-generated")) let cleaned = try await service.build(project: value, overlays: [:], action: .clean) XCTAssertFalse(cleaned.hasBinary); XCTAssertFalse(cleaned.hasDisk) XCTAssertFalse(cleaned.outputPaths.contains("out/game.bin")) } func testRealMakeRecursiveTargetsConfigurationAndDiskArtifact() async throws { var settings = CMOCProjectConfiguration() settings.buildTarget = "all"; settings.diskTarget = "disk"; settings.diskImage = "game.dsk"; settings.jobs = 4 settings.configurations = [.init(name: "Debug", makeArguments: ["MESSAGE=debug build"]), .init(name: "Release", makeArguments: ["MESSAGE=release build"])] let value = try configuredProject(settings, files: ["Makefile": """ CMOC ?= cmoc .PHONY: all disk clean helper all: helper \t$(CMOC) \tprintf '%s' '$(MESSAGE)' > main.bin helper: \t$(MAKE) -C helper disk: all \tcat main.bin helper/asset > game.dsk clean: \trm -f main.bin game.dsk helper/asset """, "helper/Makefile": "all:\n\tprintf data > asset\n"]) let tools = try makeTools() let bundledMake = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() .appendingPathComponent("LocalResources/ToolchainBundle/bin/make") try FileManager.default.removeItem(at: tools.appendingPathComponent("bin/make")) try FileManager.default.copyItem(at: bundledMake, to: tools.appendingPathComponent("bin/make")) XCTAssertTrue(tools.path.contains(" ")) let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Outputs")) let debug = try await service.build(project: value, overlays: [:], action: .disk, configuration: "Debug") let release = try await service.build(project: value, overlays: [:], action: .disk, configuration: "Release") XCTAssertTrue(debug.hasDisk); XCTAssertTrue(debug.hasBinary) XCTAssertEqual(try Data(contentsOf: XCTUnwrap(debug.diskURL)), Data("debug builddata".utf8)) XCTAssertEqual(try Data(contentsOf: XCTUnwrap(release.diskURL)), Data("release builddata".utf8)) XCTAssertNotEqual(debug.compilationDirectory, release.compilationDirectory) XCTAssertFalse(FileManager.default.fileExists(atPath: value.directory.appendingPathComponent("game.dsk").path)) } func testMultiFileFailureClearsPartialCacheAndCannotExposeStaleExecutable() async throws { let value = try project() let tools = try toolchain(make: "printf good > main.bin\n") let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Outputs")) let original = try await service.build(project: value, overlays: [:]) try Data("#!/bin/sh\nprintf corrupt > main.bin\nprintf 'nested/file.c:7: failure\\n'\nexit 2\n".utf8).write(to: tools.appendingPathComponent("bin/make")) do { _ = try await service.build(project: value, overlays: [:]); XCTFail("Failed Make must fail the build") } catch { XCTAssertTrue(error.localizedDescription.contains("nested/file.c:7")) } XCTAssertFalse(FileManager.default.fileExists(atPath: original.compilationDirectory.path)) XCTAssertEqual(try Data(contentsOf: original.binaryURL), Data("good".utf8)) try Data("#!/bin/sh\nexit 0\n".utf8).write(to: tools.appendingPathComponent("bin/make")) do { _ = try await service.build(project: value, overlays: [:]); XCTFail("No stale output may survive a failed build") } catch { XCTAssertTrue(error.localizedDescription.contains("did not produce main.bin")) } } func testBuildOnlyTargetDoesNotRequireDebugIntermediates() async throws { var settings = CMOCProjectConfiguration(); settings.binary = nil let value = try configuredProject(settings, files: [:]) let service = CMOCBuildService(toolchain: try toolchain(make: "printf library > libgame.a\n"), buildRoot: folder.appendingPathComponent("Outputs")) let artifact = try await service.build(project: value, overlays: [:]) XCTAssertFalse(artifact.hasBinary) XCTAssertTrue(artifact.outputPaths.contains("libgame.a")) XCTAssertEqual(artifact.sources["main.c"], Data(CMOCProject.starterSource.utf8)) } func testGeneratedMakefileBuildsMultipleCFilesDependenciesResourcesAndDiskWithBundledTools() async throws { let runtime = vccQualificationToolchain(URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent().appendingPathComponent("LocalResources/ToolchainBundle")) guard FileManager.default.isExecutableFile(atPath: runtime.appendingPathComponent("bin/perl").path) else { throw XCTSkip("Stage the complete bundled compiler and Perl runtime") } var generated = CMOCMakefileSettings() generated.sources = ["main.c", "src/game.c", "generated/data.c"] generated.includePaths = ["include"] generated.libraryProjects = [.init(directory: "libraries/helper", target: "libhelper.a", archive: "libraries/helper/libhelper.a")] generated.diskImage = "HELLO.dsk"; generated.diskFiles = ["assets/data.txt"]; generated.diskBootMode = .program generated.generatedResources = [.init(outputs: ["generated/data.c"], inputs: ["assets/data.txt"], command: "printf 'int generated(void) { return 3; }\\n' > generated/data.c")] var settings = CMOCProjectConfiguration(); settings.makefileSettings = generated settings.diskImage = generated.diskImage; settings.diskTarget = "disk"; settings.jobs = 4 let value = try configuredProject(settings, files: [ "main.c": "#include \n#include \"game.h\"\nint generated(void);\nint helper(void);\nint main(void) { printf(\"%d %d %d\\n\", game(), generated(), helper()); return 0; }\n", "generated/data.c": "int generated(void) { return 999; }\n", "src/game.c": "#include \"game.h\"\nint game(void) { return VALUE; }\n", "include/game.h": "#define VALUE 4\nint game(void);\n", "assets/data.txt": "DATA\n", "Makefile": try generated.generateMakefile(), "libraries/helper/helper.c": "int helper(void) { return 7; }\n", "libraries/helper/Makefile": "libhelper.a: helper.o\n\tlwar -c $@ $<\nhelper.o: helper.c\n\t\"$(CMOC)\" --coco -O0 --intermediate -c -o $@ $<\nclean:\n\trm -f libhelper.a helper.o helper.s helper.lst\n" ]) let service = CMOCBuildService(toolchain: runtime, buildRoot: folder.appendingPathComponent("Outputs")) let first = try await service.build(project: value, overlays: [:], action: .disk) XCTAssertTrue(first.hasBinary); XCTAssertTrue(first.hasDisk) XCTAssertFalse(first.fileHashes.keys.contains("generated/data.c")) XCTAssertEqual(first.sources["generated/data.c"], Data("int generated(void) { return 3; }\n".utf8)) XCTAssertEqual(try value.readText(relativePath: "generated/data.c"), "int generated(void) { return 999; }\n") XCTAssertEqual(try Data(contentsOf: XCTUnwrap(first.diskURL)).count, 35 * 18 * 256) for path in ["obj/main.o", "obj/src/game.o", "obj/generated/data.o", "obj/src/game.lst", "obj/main.d", "generated/data.c"] { XCTAssertTrue(first.outputPaths.contains(path), "Missing generated product \(path)") } let second = try await service.build(project: value, overlays: [:], action: .disk) XCTAssertEqual(first.binaryData, second.binaryData) XCTAssertFalse(second.buildLog.contains(" -c -o "), "No-op Make must not recompile") XCTAssertFalse(second.buildLog.contains(" --dos "), "No-op Make must not rebuild the loader") let disk = try Data(contentsOf: XCTUnwrap(first.diskURL)) XCTAssertEqual(disk.subdata(in: (34 * 18 * 256)..<(34 * 18 * 256 + 2)), Data("OS".utf8)) let fat = 17 * 18 * 256 + 256 + 66 XCTAssertEqual(disk.subdata(in: fat..<(fat + 2)), Data([0xc0, 0xc0]), "Both boot-track granules must be unavailable to disk files") XCTAssertFalse(first.fileHashes.keys.contains("obj/vcc-dos-boot/loader.c")) XCTAssertFalse(FileManager.default.fileExists(atPath: value.directory.appendingPathComponent("obj/vcc-dos-boot/loader.c").path)) let header = try await service.build(project: value, overlays: ["include/game.h": "#define VALUE 9\nint game(void);\n"], action: .disk) XCTAssertTrue(header.buildLog.contains(" -c -o obj/main.o ")) XCTAssertTrue(header.buildLog.contains(" -c -o obj/src/game.o ")) XCTAssertFalse(header.buildLog.contains(" -c -o obj/generated/data.o ")) XCTAssertNotEqual(first.binaryData, header.binaryData) let libraryEdit = try await service.build(project: value, overlays: ["libraries/helper/helper.c": "int helper(void) { return 12; }\n"], action: .disk) XCTAssertTrue(libraryEdit.buildLog.contains(" -c -o helper.o ")) XCTAssertNotEqual(first.binaryData, libraryEdit.binaryData, "Changed library must relink the executable") XCTAssertEqual(try value.readText(relativePath: "include/game.h"), "#define VALUE 4\nint game(void);\n") XCTAssertFalse(FileManager.default.fileExists(atPath: value.directory.appendingPathComponent("HELLO.dsk").path)) } func testGeneratedMakefileRejectsAmbiguousOrUnsafeNamesAndRetainsNativeSettings() throws { var generated = CMOCMakefileSettings() generated.sources = ["source name.c"] XCTAssertThrowsError(try generated.generateMakefile()) generated.sources = ["first.c", "first.c"] XCTAssertThrowsError(try generated.generateMakefile()) generated.sources = ["first.c"] generated.generatedResources = [.init(outputs: ["generated.c"], inputs: [], command: "echo first"), .init(outputs: ["generated.c"], inputs: [], command: "echo second")] XCTAssertThrowsError(try generated.generateMakefile()) generated.generatedResources = [] generated.libraryProjects = [.init(directory: "libraries/game", target: "libgame.a", archive: "libraries/game/libgame.a")] let makefile = try generated.generateMakefile() XCTAssertTrue(makefile.contains("$(MAKE) -C libraries/game libgame.a")) var settings = CMOCProjectConfiguration(); settings.makefileSettings = generated XCTAssertEqual(try JSONDecoder().decode(CMOCProjectConfiguration.self, from: JSONEncoder().encode(settings)), settings) } func testGeneratedMakefileProtectsDiskNamesAndSourceOutputCollisions() throws { var settings = CMOCMakefileSettings(); settings.executable = "GAME.bin"; settings.diskImage = "GAME.dsk" settings.diskFiles = ["assets/game.BIN"] XCTAssertThrowsError(try settings.generateMakefile(), "Disk BASIC is case-insensitive; the data must not overwrite the executable") settings.diskFiles = ["assets/longfilename.dat"] XCTAssertThrowsError(try settings.generateMakefile()) settings.diskFiles = ["assets/A.DAT", "other/a.dat"] XCTAssertThrowsError(try settings.generateMakefile()) settings.diskFiles = ["assets/WORDS.DAT"] XCTAssertNoThrow(try settings.generateMakefile()) settings.diskImage = "main.c" XCTAssertThrowsError(try settings.generateMakefile()) settings.diskImage = "GAME.dsk"; settings.executable = "Makefile" XCTAssertThrowsError(try settings.generateMakefile()) settings.executable = "GAME.bin" settings.generatedResources = [.init(outputs: ["vccplus-project.json"], inputs: [], command: "echo invalid")] XCTAssertThrowsError(try settings.generateMakefile()) settings.generatedResources = [.init(outputs: ["GAME.bin"], inputs: [], command: "echo invalid")] XCTAssertThrowsError(try settings.generateMakefile()) settings.generatedResources = [] let custom = try settings.generateMakefile(makefileName: "GNUmakefile") XCTAssertTrue(custom.contains("main.c GNUmakefile")) XCTAssertFalse(custom.contains(" main.c Makefile")) } func testDOSBootModesPreserveLegacyConfigurationAndRejectInvalidGeneratedTargets() throws { let plain = try JSONDecoder().decode(CMOCMakefileSettings.self, from: Data("{}".utf8)) XCTAssertEqual(plain.diskBootMode, .none) var legacy = try JSONDecoder().decode(CMOCMakefileSettings.self, from: Data(#"{"diskImage":"GAME.dsk","diskBootLoader":"boot.bin"}"#.utf8)) XCTAssertEqual(legacy.diskBootMode, .custom) XCTAssertTrue(try legacy.generateMakefile().contains("$(INSTALL_LOADER) $@ boot.bin")) legacy.diskBootMode = .none XCTAssertFalse(try legacy.generateMakefile().contains("$(INSTALL_LOADER) $@")) legacy.diskBootMode = .program legacy.executable = "output/GAME.bin" XCTAssertEqual(legacy.programBootCommand, "LOADM\"GAME.BIN\":EXEC") XCTAssertEqual(try JSONDecoder().decode(CMOCMakefileSettings.self, from: JSONEncoder().encode(legacy)), legacy) let generated = try legacy.generateMakefile() XCTAssertTrue(generated.contains("$(INSTALL_LOADER) $@ obj/vcc-dos-boot/loader.bin")) XCTAssertFalse(generated.contains("$(INSTALL_LOADER) $@ boot.bin")) legacy.origin = "2600" XCTAssertThrowsError(try legacy.generateMakefile()) legacy.origin = "2800"; legacy.diskImage = nil XCTAssertThrowsError(try legacy.generateMakefile()) legacy.diskImage = "GAME.dsk" legacy.generatedResources = [.init(outputs: ["obj/vcc-dos-boot/loader.c"], inputs: [], command: "echo collision")] XCTAssertThrowsError(try legacy.generateMakefile()) var configuration = CMOCProjectConfiguration() configuration.makefileSettings = plain let externalProducts = ["main.c": Data("int main(void) { return 0; }".utf8), "obj/vcc-dos-boot/loader.c": Data("stale helper".utf8)] XCTAssertNil(CMOCProject.filteredInputs(externalProducts, configuration: configuration)["obj/vcc-dos-boot/loader.c"], "A prior command-line loader remains a build product even after DOS boot is turned off") XCTAssertNotNil(CMOCProject.filteredInputs(externalProducts, configuration: configuration)["main.c"]) legacy.generatedResources = []; legacy.diskBootMode = .custom; legacy.diskBootLoader = nil XCTAssertThrowsError(try legacy.generateMakefile()) } func testHelloDiskTemplateCreatesIndependentSourceOnlyProjectsWithoutOverwriting() throws { let template = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() .deletingLastPathComponent().deletingLastPathComponent().appendingPathComponent("examples/cmoc/HelloDisk") let original = try CMOCProject.open(at: template) let hashes = try original.currentFileHashes() let destination = folder.appendingPathComponent("My Hello Disk") let copied = try CMOCProject.createHelloDisk(at: destination, templateDirectory: template) XCTAssertEqual(copied.configuration.launchMode, .disk) XCTAssertEqual(copied.configuration.binary, "HELLO.bin") XCTAssertEqual(copied.configuration.diskImage, "HELLO.dsk") XCTAssertEqual(copied.configuration.launchCommands, ["DOS"]) let recipe = try XCTUnwrap(copied.configuration.makefileSettings) XCTAssertEqual(recipe.diskBootMode, .program) XCTAssertEqual(try copied.readText(relativePath: "Makefile"), try recipe.generateMakefile()) XCTAssertEqual(try copied.currentFileHashes(), hashes) XCTAssertFalse(try copied.fileEntries().contains(where: { ["bin", "dsk", "o", "lst"].contains(URL(fileURLWithPath: $0.relativePath).pathExtension) })) _ = try copied.saveText("MY OWN WORDS\n", relativePath: "assets/words.txt") XCTAssertEqual(try original.currentFileHashes(), hashes, "Creating/editing a project must not modify the installed source template") XCTAssertThrowsError(try CMOCProject.createHelloDisk(at: destination, templateDirectory: template)) XCTAssertEqual(try copied.readText(relativePath: "assets/words.txt"), "MY OWN WORDS\n") } private func packagedAppResources() throws -> URL { let products = Bundle(for: Self.self).bundleURL.deletingLastPathComponent() let app = try XCTUnwrap(Bundle(url: products.appendingPathComponent("VCC Plus OSS.app"))) return try XCTUnwrap(app.resourceURL) } func testPackagedTalkingLanderCopiesOnlySourcesAndRegeneratesTheSameMakefile() throws { let template = try packagedAppResources().appendingPathComponent("DevelopmentTemplates/TalkingPlanetLander") let original = try CMOCProject.open(at: template) let destination = folder.appendingPathComponent("My Lander") let project = try CMOCProject.createTalkingLander(at: destination, templateDirectory: template) let expected: Set = [".gitignore", "Makefile", "README.md", "main.c", CMOCProject.configurationFilename] XCTAssertEqual(Set(try FileManager.default.contentsOfDirectory(atPath: destination.path)), expected) let recipe = try XCTUnwrap(project.configuration.makefileSettings) XCTAssertEqual(recipe.libraries, ["ssc", "orch90", "bcontrol", "vcccompat"]) XCTAssertEqual(project.configuration.launchMode, .quickload) XCTAssertEqual(project.configuration.binary, "LANDER.bin") XCTAssertEqual(project.configuration.diskImage, "LANDER.dsk") XCTAssertEqual(try project.readText(relativePath: "Makefile"), try recipe.generateMakefile()) XCTAssertEqual(try project.currentFileHashes(), try original.currentFileHashes()) _ = try project.saveSource("int main(void) { return 0; }\n") XCTAssertNotEqual(try project.readSource(), try original.readSource()) XCTAssertThrowsError(try CMOCProject.createTalkingLander(at: destination, templateDirectory: template)) } func testTalkingLanderBuildDiskAndHeaderNavigationUseTheSelectedGuestSDK() async throws { let resources = try packagedAppResources() let toolchain = resources.appendingPathComponent("Toolchain") guard FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path) else { throw XCTSkip("This app was built without the optional CMOC runtime.") } let project = try CMOCProject.createTalkingLander(at: folder.appendingPathComponent("My Lander"), templateDirectory: resources.appendingPathComponent("DevelopmentTemplates/TalkingPlanetLander")) let service = CMOCBuildService(toolchain: toolchain, buildRoot: folder.appendingPathComponent("Builds")) let hashes = try project.currentFileHashes() let quickload = try await service.build(project: project, overlays: [:]) XCTAssertEqual(quickload.binaryURL.lastPathComponent, "LANDER.bin") XCTAssertEqual(quickload.binaryData.first, 0, "Disk BASIC LOADM header") XCTAssertGreaterThan(quickload.binaryData.count, 5) let disk = try await service.build(project: project, overlays: [:], action: .disk) XCTAssertEqual(disk.binaryData, quickload.binaryData) let bytes = try Data(contentsOf: XCTUnwrap(disk.diskURL)) XCTAssertEqual(bytes.count, 35 * 18 * 256) let directory = 17 * 18 * 256 + 2 * 256 XCTAssertEqual(bytes.subdata(in: directory..<(directory + 11)), Data("LANDER BIN".utf8)) XCTAssertEqual(try project.currentFileHashes(), hashes) let inputs = try CMOCIndexInputs.load(project: project, toolchain: toolchain, configurationName: "Debug", overlays: [:], generated: [:]) let index = CMOCProjectIndex(documents: inputs.documents, defines: inputs.defines, includePaths: inputs.includePaths) for (symbol, header) in [("orch90_play", "vcc/orch90.h"), ("ssc_begin_phrase", "vcc/ssc.h"), ("snprintf", "vcc/compat/stdio.h"), ("fopen", "vcc/compat/stdio.h"), ("fread", "vcc/compat/stdio.h")] { let path = CMOCIndexInputs.libraryPrefix + header XCTAssertTrue(inputs.referencePaths.contains(path)) XCTAssertEqual(index.definitions(named: symbol, from: "main.c", line: 1, column: 1).map(\.path), [path]) } // A project that drops the compatibility library must not accidentally // resolve a host stdio.h, or build using a cached LANDER.bin. var configuration = project.configuration var recipe = try XCTUnwrap(configuration.makefileSettings) recipe.libraries.removeAll { $0 == "vcccompat" } configuration.makefileSettings = recipe try JSONEncoder().encode(configuration).write(to: project.directory.appendingPathComponent(CMOCProject.configurationFilename)) try Data(recipe.generateMakefile().utf8).write(to: project.makefileURL) let ordinary = try CMOCProject.open(at: project.directory) let ordinaryInputs = try CMOCIndexInputs.load(project: ordinary, toolchain: toolchain, configurationName: "Debug", overlays: [:], generated: [:]) XCTAssertFalse(ordinaryInputs.referencePaths.contains(CMOCIndexInputs.libraryPrefix + "vcc/compat/stdio.h")) XCTAssertTrue(ordinaryInputs.referencePaths.contains(CMOCIndexInputs.libraryPrefix + "vcc/ssc.h")) do { _ = try await service.build(project: ordinary, overlays: [:]) XCTFail("The unchanged source requires its opt-in guest stdio.h.") } catch { XCTAssertTrue(error.localizedDescription.contains("stdio.h"), error.localizedDescription) } } func testPackagedGraphicsLanderBuildsAndResolvesThePageFlipDeclaration() async throws { try await checkAuthoredExample("lander.c", libraries: ["gime", "bgraph", "bcontrol"], symbol: "gime_present", header: "vcc/gime.h") } func testPackagedSurveyProbeBuildsAndResolvesTheInputDeclaration() async throws { try await checkAuthoredExample("probe.c", libraries: ["gime", "input", "bcontrol"], symbol: "input_sample", header: "vcc/input.h") } func testPackagedBankedTerrainBuildsAndResolvesItsHeader() async throws { try await checkAuthoredExample("ridge.c", libraries: ["bank", "gime", "hirestxt"], symbol: "bank_read", header: "vcc/bank.h") } func testPackagedFieldLogBuildsAndResolvesFlush() async throws { try await checkAuthoredExample("fieldlog.c", libraries: ["vcccompat", "decbfile"], symbol: "fflush", header: "vcc/compat/stdio.h") } func testPackagedPlanetAtlasBuildsAndResolvesFilePositioning() async throws { try await checkAuthoredExample("atlas.c", libraries: ["vcccompat", "decbfile"], symbol: "fseek", header: "vcc/compat/stdio.h") } func testPackagedAtlasBackupBuildsAndResolvesRename() async throws { try await checkAuthoredExample("atlasbackup.c", libraries: ["vcccompat", "decbfile"], symbol: "rename", header: "vcc/compat/stdio.h") } func testPackagedReturnTripBuildsAndResolvesFormattedOutput() async throws { try await checkAuthoredExample("returntrip.c", libraries: ["vcccompat", "decbfile"], symbol: "fprintf", header: "vcc/compat/stdio.h") } func testPackagedMissionAnnouncerBuildsAndResolvesSpeechHeader() async throws { try await checkAuthoredExample("announcer.c", libraries: ["ssc", "input", "bcontrol"], symbol: "ssc_store_allophones", header: "vcc/ssc.h") } func testPackagedDescentComputerBuildsAndResolvesDecimalHeader() async throws { try await checkAuthoredExample("descent.c", libraries: ["vcccompat"], symbol: "vcc_fixed", header: "vcc/decimal.h") } func testPackagedStereoFlybyBuildsAndResolvesOrchestraHeader() async throws { try await checkAuthoredExample("flyby.c", libraries: ["orch90", "input", "bcontrol"], symbol: "orch90_start", header: "vcc/orch90.h") } func testPackagedFlightRecorderBuildsAndResolvesCassetteHeader() async throws { try await checkAuthoredExample("flightrecorder.c", libraries: ["vcccompat"], symbol: "vcc_tape_open_write", header: "vcc/cassette.h") } func testPackagedFlightReportBuildsAndResolvesPrinterHeader() async throws { try await checkAuthoredExample("flightreport.c", libraries: ["vcccompat"], symbol: "vcc_printer_printf", header: "vcc/printer.h") } @MainActor func testFlightReportAppearsInNativePrinterOutput() async throws { let rom = try packagedAppResources().appendingPathComponent("StarterKit/coco3.rom") try XCTSkipUnless(FileManager.default.fileExists(atPath: rom.path), "Stage the CoCo 3 ROM to exercise its printer routine.") let romData = try Data(contentsOf: rom) let build = try await checkAuthoredExample("flightreport.c", libraries: ["vcccompat"], symbol: "vcc_printer_printf", header: "vcc/printer.h") let controller = VCCMachineController() let printer = PrinterModel(controller: controller) func command(_ body: (@escaping @Sendable (VCCMachineSnapshot) -> Void) -> Void) async -> VCCMachineSnapshot { await withCheckedContinuation { continuation in body { continuation.resume(returning: $0) } } } func waitForScreen(_ marker: String) async throws { for _ in 0..<250 { let text: String? = await withCheckedContinuation { c in controller.copyScreenText { text, _ in c.resume(returning: text) } } if text?.contains(marker) == true { return } try await Task.sleep(nanoseconds: 40_000_000) } throw NSError(domain: "FlightReportTest", code: 1, userInfo: [NSLocalizedDescriptionKey: "Timed out waiting for " + marker]) } defer { controller.shutdown { _ in } } _ = await command { controller.setAudioEnabled(false, volume: 0, completion: $0) } _ = await command { controller.loadROM(romData, use6309: false, completion: $0) } _ = await command(controller.resume) try await waitForScreen("OK") let entry = build.binaryData.suffix(2).reduce(UInt16(0)) { $0 << 8 | UInt16($1) } let loaded = await command { controller.debuggerLoadBinary(build.binaryData, breakpoint: entry, completion: $0) } XCTAssertNil(loaded.errorMessage) _ = await command(controller.debuggerClearDevelopmentBreakpoints) _ = await command(controller.resume) try await waitForScreen("PRESS SPACE") printer.setCapture(true) let started = await command(controller.snapshot) XCTAssertTrue(started.printerEnabled) controller.setKeyboardMask(try XCTUnwrap(CocoKeyboard.chord(for: " "))) try await Task.sleep(nanoseconds: 100_000_000) controller.setKeyboardMask(0) try await waitForScreen("REPORT SENT TO PRINTER PORT") printer.setCapture(false) let expected = "TP-10 FLIGHT REPORT\n01 EARTH BLUE SEA\n02 MARS RED RIDGE\nEND OF REPORT\n" for _ in 0..<50 { printer.observe(await command(controller.snapshot)) if !printer.busy && printer.preview == expected { break } try await Task.sleep(nanoseconds: 20_000_000) } XCTAssertEqual(printer.preview, expected) XCTAssertEqual(printer.byteCount, expected.utf8.count) XCTAssertFalse(printer.enabled) XCTAssertTrue(printer.unsaved) let window = NSWindow(contentRect: NSRect(x: 0, y: 0, width: 760, height: 550), styleMask: [.borderless], backing: .buffered, defer: false) window.appearance = NSAppearance(named: .aqua) let view = NSHostingView(rootView: PrinterOutputView(printer: printer).background(Color(nsColor: .windowBackgroundColor))) window.contentView = view view.layoutSubtreeIfNeeded() let pixels = try XCTUnwrap(view.bitmapImageRepForCachingDisplay(in: view.bounds)) view.cacheDisplay(in: view.bounds, to: pixels) let png = try XCTUnwrap(pixels.representation(using: .png, properties: [:])) let attachment = XCTAttachment(data: png, uniformTypeIdentifier: "public.png") attachment.name = "TP-10 Flight Report" attachment.lifetime = .keepAlways add(attachment) } func testPackagedManualProjectsMatchCanonicalSources() throws { let resources = try packagedAppResources() try TestBuildContent.requireFullManuals(resources: resources) let root = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() .deletingLastPathComponent().deletingLastPathComponent() for name in ["PlanetExpedition", "MissionRecorder", "PlanetSurvey"] { let destination = folder.appendingPathComponent("Packaged-" + name) try FileManager.default.createDirectory(at: destination, withIntermediateDirectories: false) let extract = Process() extract.executableURL = URL(fileURLWithPath: "/usr/bin/ditto") extract.arguments = ["-x", "-k", resources.appendingPathComponent("ManualLibrary/programming-in-c/examples/\(name).zip").path, destination.path] try extract.run(); extract.waitUntilExit() XCTAssertEqual(extract.terminationStatus, 0) let packaged = try CMOCProject.open(at: destination.appendingPathComponent(name)) let canonical = try CMOCProject.open(at: root.appendingPathComponent("examples/cmoc/\(name)")) // Manual downloads may omit repository-only ignore rules. Every // executable source, resource and project/build control must match. let packagedHashes = try packaged.currentFileHashes().filter { $0.key != ".gitignore" } let canonicalHashes = try canonical.currentFileHashes().filter { $0.key != ".gitignore" } XCTAssertEqual(packagedHashes, canonicalHashes, name) XCTAssertEqual(try Data(contentsOf: packaged.makefileURL), try Data(contentsOf: canonical.makefileURL), name) } } func testPackagedManualExercisesMatchAuthoredCompilerFixtures() throws { let resources = try packagedAppResources() try TestBuildContent.requireFullManuals(resources: resources) let fixtures = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/ManualC") for filename in ["lander.c", "probe.c", "ridge.c", "fieldlog.c", "atlas.c", "atlasbackup.c", "returntrip.c", "announcer.c", "descent.c", "flyby.c", "flightrecorder.c", "flightreport.c", "crew.c"] { let packaged = resources.appendingPathComponent("ManualLibrary/programming-in-c/examples/\(filename)") XCTAssertEqual(try Data(contentsOf: packaged), try Data(contentsOf: fixtures.appendingPathComponent(filename)), filename) } } @discardableResult private func checkAuthoredExample(_ filename: String, libraries: [String], symbol: String, header: String) async throws -> CMOCBuildArtifact { let resources = try packagedAppResources() let toolchain = resources.appendingPathComponent("Toolchain") guard FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path) else { throw XCTSkip("Stage the optional CMOC toolchain to build the manual exercise.") } let example = URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/ManualC/\(filename)") let source = try String(contentsOf: example, encoding: .utf8) var settings = CMOCProjectConfiguration() settings.bundledLibraries = libraries.map { .init(library: $0, linkVariable: "LIBS") } let project = try configuredProject(settings, files: ["main.c": source]) let service = CMOCBuildService(toolchain: toolchain, buildRoot: folder.appendingPathComponent("Builds")) let artifact = try await service.build(project: project, overlays: [:]) XCTAssertTrue(artifact.hasBinary) let inputs = try CMOCIndexInputs.load(project: project, toolchain: toolchain, configurationName: "Debug", overlays: [:], generated: [:]) let index = CMOCProjectIndex(documents: inputs.documents, defines: inputs.defines, includePaths: inputs.includePaths) let definitions = index.definitions(named: symbol, from: "main.c", line: 1, column: 1) XCTAssertEqual(definitions.map(\.path), [CMOCIndexInputs.libraryPrefix + header]) return artifact } func testPackagedHeapExerciseBuildsWithTheProjectLibrarySettings() async throws { let resources = try packagedAppResources() let source = try String(contentsOf: URL(fileURLWithPath: #filePath).deletingLastPathComponent().appendingPathComponent("Fixtures/ManualC/crew.c"), encoding: .utf8) let toolchain = resources.appendingPathComponent("Toolchain") guard FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path) else { throw XCTSkip("Stage the optional CMOC toolchain to build the crew example.") } var settings = CMOCProjectConfiguration() settings.bundledLibraries = [ .init(library: "vcccompat", minimumVersion: "0.3.0", linkVariable: "LIBS"), .init(library: "wydealloc", linkVariable: "LIBS") ] let project = try configuredProject(settings, files: ["main.c": source]) let service = CMOCBuildService(toolchain: toolchain, buildRoot: folder.appendingPathComponent("Builds")) let artifact = try await service.build(project: project, overlays: [:]) XCTAssertTrue(artifact.hasBinary) let inputs = try CMOCIndexInputs.load(project: project, toolchain: toolchain, configurationName: "Debug", overlays: [:], generated: [:]) let index = CMOCProjectIndex(documents: inputs.documents, defines: inputs.defines, includePaths: inputs.includePaths) let header = CMOCIndexInputs.libraryPrefix + "vcc/compat/stdlib.h" for symbol in ["vcc_heap_init", "malloc", "calloc", "realloc", "free"] { XCTAssertEqual(index.definitions(named: symbol, from: "main.c", line: 1, column: 1).map(\.path), [header], symbol) } } private func openAuthoredProject(_ name: String) throws -> CMOCProject { let root = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() .deletingLastPathComponent().deletingLastPathComponent() let source = root.appendingPathComponent("examples/cmoc/\(name)") let destination = folder.appendingPathComponent(name) try FileManager.default.copyItem(at: source, to: destination) return try CMOCProject.open(at: destination) } func testManualPlanetExpeditionBuildsThePracticeCard() async throws { let resources = try packagedAppResources() let project = try openAuthoredProject("PlanetExpedition") let toolchain = resources.appendingPathComponent("Toolchain") guard FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path) else { throw XCTSkip("Stage the optional CMOC toolchain to build the manual exercise.") } let service = CMOCBuildService(toolchain: toolchain, buildRoot: folder.appendingPathComponent("Builds")) let result = try await service.build(project: project, overlays: [:], action: .build) XCTAssertTrue(result.hasBinary) let card = result.directory.appendingPathComponent("EXPED") for (image, firstFile) in [("EXPLORE", "EXPLORE BIN"), ("EARTH", "LANDING TXT"), ("MARS", "LANDING TXT")] { let disk = try Data(contentsOf: card.appendingPathComponent(image + ".DSK")) XCTAssertEqual(disk.count, 35 * 18 * 256, image) let directory = (17 * 18 + 2) * 256 XCTAssertEqual(disk.subdata(in: directory..<(directory + 11)), Data(firstFile.utf8), image) } let inputs = try CMOCIndexInputs.load(project: project, toolchain: toolchain, configurationName: "Debug", overlays: [:], generated: [:]) let index = CMOCProjectIndex(documents: inputs.documents, defines: inputs.defines, includePaths: inputs.includePaths) let completions = index.completionSymbols(from: "expedition.c", offset: 0, prefix: "sdc_m") XCTAssertEqual(Set(completions.map(\.name)), ["sdc_mount", "sdc_mounted"]) let definitions = index.definitions(named: "sdc_mount", from: "expedition.c", line: 1, column: 1) XCTAssertEqual(definitions.map(\.path), [CMOCIndexInputs.libraryPrefix + "vcc/sdc.h"]) } func testManualMissionRecorderBuildsAndPackagesItsFlightDisk() async throws { let resources = try packagedAppResources() let project = try openAuthoredProject("MissionRecorder") XCTAssertEqual(project.configuration.launchMode, .quickload, "Keep the pilot's practice disk mounted on Run.") XCTAssertEqual(project.configuration.buildTarget, "build") let settings = try XCTUnwrap(project.configuration.makefileSettings) XCTAssertEqual(try project.readText(relativePath: "Makefile"), try settings.generateMakefile()) let toolchain = resources.appendingPathComponent("Toolchain") guard FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path) else { throw XCTSkip("Stage the optional CMOC toolchain to build the manual exercise.") } let service = CMOCBuildService(toolchain: toolchain, buildRoot: folder.appendingPathComponent("Builds")) let result = try await service.build(project: project, overlays: [:], action: .disk) XCTAssertEqual(result.binaryURL.lastPathComponent, "RECORDER.bin") let disk = try Data(contentsOf: XCTUnwrap(result.diskURL)) guard disk.count == 35 * 18 * 256 else { return XCTFail("Expected a standard 35-track flight disk.") } let directory = (17 * 18 + 2) * 256 XCTAssertEqual(disk.subdata(in: directory..<(directory + 11)), Data("RECORDERBIN".utf8)) XCTAssertEqual(disk[directory + 32], 0xff, "The pilot creates the first flight log.") } func testManualPlanetSurveyBuildsThroughTheWorkspaceWithItsDataDisk() async throws { let resources = try packagedAppResources() let project = try openAuthoredProject("PlanetSurvey") let recipe = try XCTUnwrap(project.configuration.makefileSettings) XCTAssertEqual(recipe.libraries, ["vcccompat", "decbfile"]) XCTAssertEqual(try project.readText(relativePath: "Makefile"), try recipe.generateMakefile()) let toolchain = resources.appendingPathComponent("Toolchain") guard FileManager.default.isExecutableFile(atPath: toolchain.appendingPathComponent("bin/cmoc").path) else { throw XCTSkip("Stage the optional CMOC runtime to build the manual example.") } let service = CMOCBuildService(toolchain: toolchain, buildRoot: folder.appendingPathComponent("Builds")) let result = try await service.build(project: project, overlays: [:], action: .disk) XCTAssertEqual(result.binaryURL.lastPathComponent, "SURVEY.bin") let disk = try Data(contentsOf: XCTUnwrap(result.diskURL)) XCTAssertEqual(disk.count, 35 * 18 * 256) let directory = (17 * 18 + 2) * 256 XCTAssertEqual(disk.subdata(in: directory..<(directory + 11)), Data("SURVEY BIN".utf8)) XCTAssertEqual(disk.subdata(in: (directory + 32)..<(directory + 43)), Data("PLANETS TXT".utf8)) let inputs = try CMOCIndexInputs.load(project: project, toolchain: toolchain, configurationName: "Debug", overlays: [:], generated: [:]) let index = CMOCProjectIndex(documents: inputs.documents, defines: inputs.defines, includePaths: inputs.includePaths) let header = CMOCIndexInputs.libraryPrefix + "vcc/compat/string.h" XCTAssertEqual(index.definitions(named: "strtok_r", from: "main.c", line: 1, column: 1).map(\.path), [header]) XCTAssertEqual(index.completionSymbols(from: "main.c", offset: 0, prefix: "strtok_r").map(\.path), [header]) } func testHelloDiskTemplateRejectsUnexpectedProductsAndLinkedFiles() throws { let original = URL(fileURLWithPath: #filePath).deletingLastPathComponent().deletingLastPathComponent() .deletingLastPathComponent().deletingLastPathComponent().appendingPathComponent("examples/cmoc/HelloDisk") let template = folder.appendingPathComponent("Template") try FileManager.default.copyItem(at: original, to: template) let extra = template.appendingPathComponent("personal.dsk") try Data([0, 1, 2]).write(to: extra) let destination = folder.appendingPathComponent("New Project") XCTAssertThrowsError(try CMOCProject.createHelloDisk(at: destination, templateDirectory: template)) XCTAssertFalse(FileManager.default.fileExists(atPath: destination.path)) try FileManager.default.removeItem(at: extra) let source = template.appendingPathComponent("main.c") try FileManager.default.removeItem(at: source) try FileManager.default.createSymbolicLink(at: source, withDestinationURL: original.appendingPathComponent("main.c")) XCTAssertThrowsError(try CMOCProject.createHelloDisk(at: destination, templateDirectory: template)) XCTAssertFalse(FileManager.default.fileExists(atPath: destination.path)) } func testGeneratedDefinitionsAndOptionsReachCompilerAsLiteralArguments() async throws { var generated = CMOCMakefileSettings() let definition = "DISPLAY_NAME=\"It's #$5 \\# and $(printf never-executed)\"" generated.defines = [definition, "MAX_WORD_LEN=5"] generated.compilerOptions = ["-Werror", "-fomit-frame-pointer"] generated.linkerOptions = ["--verbose"] generated.limit = "7F80" var settings = CMOCProjectConfiguration(); settings.makefileSettings = generated let value = try configuredProject(settings, files: ["Makefile": try generated.generateMakefile()]) let tools = try makeTools() let fakeCompiler = """ #!/bin/sh printf '%s\\n' BEGIN "$@" END >> arguments.txt output= while test "$#" -gt 0; do if test "$1" = -o; then shift; output="$1"; fi shift done test -n "$output" || exit 80 printf compiled > "$output" """ try Data(fakeCompiler.utf8).write(to: tools.appendingPathComponent("bin/cmoc")) let service = CMOCBuildService(toolchain: tools, buildRoot: folder.appendingPathComponent("Results")) let artifact = try await service.build(project: value, overlays: [:]) let arguments = try String(contentsOf: artifact.fileURL("arguments.txt"), encoding: .utf8).components(separatedBy: "\n") XCTAssertTrue(arguments.contains("-D" + definition), "Quotes, dollars, hashes, apostrophes and backslashes must survive Make and the shell unchanged") for argument in ["-DMAX_WORD_LEN=5", "-Werror", "-fomit-frame-pointer", "--verbose", "--limit=7F80"] { XCTAssertTrue(arguments.contains(argument)) } XCTAssertEqual(try JSONDecoder().decode(CMOCMakefileSettings.self, from: JSONEncoder().encode(generated)), generated) generated.defines = ["9INVALID=1"] XCTAssertThrowsError(try generated.generateMakefile()) generated.defines = []; generated.compilerOptions = ["-O0\nrm anything"] XCTAssertThrowsError(try generated.generateMakefile()) generated.compilerOptions = []; generated.limit = "not-hex" XCTAssertThrowsError(try generated.generateMakefile()) } func testExistingCompilerProductsCannotMasqueradeAsFreshBuildInputs() async throws { let value = try project() let makefile = """ build: main.bin main.bin: main.o Makefile \tcp main.o main.bin main.o: main.c \t@echo REBUILT-SOURCE \tcp main.c main.o clean: \trm -f main.bin main.o main.d -include main.d """ try Data(makefile.utf8).write(to: value.makefileURL) let files = ["main.o": "STALE OBJECT", "main.bin": "STALE EXECUTABLE", "main.d": "main.o: /outside/project/old-source.c\n", "main.s": "STALE COMPILER ASSEMBLY", "main.lst": "STALE LISTING", "main.map": "STALE MAP", "standalone.s": " rts\n", "libprebuilt.a": "INTENTIONAL ARCHIVE", "assets.dat": "GAME DATA"] for (path, text) in files { let url = value.directory.appendingPathComponent(path) try Data(text.utf8).write(to: url) try FileManager.default.setAttributes([.modificationDate: Date(timeIntervalSinceNow: 3600)], ofItemAtPath: url.path) } let inputs = try value.inputFiles() for path in ["main.o", "main.bin", "main.d", "main.s", "main.lst", "main.map"] { XCTAssertNil(inputs[path]) } for path in ["standalone.s", "libprebuilt.a", "assets.dat"] { XCTAssertNotNil(inputs[path]) } let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Outputs")) let artifact = try await service.build(project: value, overlays: [:]) XCTAssertTrue(artifact.buildLog.contains("REBUILT-SOURCE")) XCTAssertEqual(artifact.binaryData, Data(CMOCProject.starterSource.utf8)) XCTAssertEqual(artifact.fileHashes, try value.currentFileHashes()) XCTAssertEqual(try String(contentsOf: value.directory.appendingPathComponent("main.bin"), encoding: .utf8), "STALE EXECUTABLE", "The user's old external build products remain untouched") let before = try value.currentFileHashes() try Data("EXTERNAL REBUILD".utf8).write(to: value.directory.appendingPathComponent("main.bin")) XCTAssertEqual(before, try value.currentFileHashes(), "Generated output changes do not alter source identity") } func testAbsoluteSnapshotDependenciesRebuildSafelyAfterHeaderEditAndSnapshotRemoval() async throws { let oldSnapshot = folder.appendingPathComponent("Prior Source Snapshot") try FileManager.default.createDirectory(at: oldSnapshot, withIntermediateDirectories: true) let oldHeader = oldSnapshot.appendingPathComponent("value.h") try Data("old snapshot header\n".utf8).write(to: oldHeader) let escapedHeader = oldHeader.path.replacingOccurrences(of: " ", with: "\\ ") var settings = CMOCProjectConfiguration(); settings.buildTarget = "build" let makefile = """ build: main.bin main.bin: main.c value.h Makefile \t@printf 'COMPILED-HEADER\\n' \tcat value.h > main.bin \tcp dependency.template main.d -include main.d """ let value = try configuredProject(settings, files: ["Makefile": makefile, "value.h": "#define VALUE 1\n", "dependency.template": "main.bin: " + escapedHeader + "\n"]) let before = try value.inputFiles() let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Artifacts")) let first = try await service.build(project: value, overlays: [:]) XCTAssertEqual(first.binaryData, Data("#define VALUE 1\n".utf8)) let second = try await service.build(project: value, overlays: [:]) XCTAssertTrue(second.buildLog.contains("generated dependencies refer outside the captured workspace"), second.buildLog) XCTAssertTrue(second.buildLog.contains("COMPILED-HEADER"), "An old external snapshot must never decide cache freshness") XCTAssertEqual(second.binaryData, first.binaryData) let header = value.directory.appendingPathComponent("value.h") try Data("#define VALUE 2\n".utf8).write(to: header) try FileManager.default.setAttributes([.modificationDate: Date(timeIntervalSince1970: 1)], ofItemAtPath: header.path) let edited = try await service.build(project: value, overlays: [:]) XCTAssertEqual(edited.binaryData, Data("#define VALUE 2\n".utf8)) try FileManager.default.removeItem(at: oldSnapshot) let recovered = try await service.build(project: value, overlays: [:]) XCTAssertEqual(recovered.binaryData, edited.binaryData, "Make must not read a dependency on the deleted snapshot") XCTAssertTrue(recovered.buildLog.contains("Rebuilding isolated cache")) XCTAssertEqual(first.binaryData, Data("#define VALUE 1\n".utf8), "Earlier receipts remain immutable") XCTAssertFalse(FileManager.default.fileExists(atPath: value.directory.appendingPathComponent("main.bin").path)) XCTAssertFalse(FileManager.default.fileExists(atPath: value.directory.appendingPathComponent("main.d").path)) let after = try value.inputFiles() XCTAssertEqual(after["Makefile"], before["Makefile"]) XCTAssertEqual(after["dependency.template"], before["dependency.template"], "Do not rewrite authored dependency data") } func testRemovedHeaderInvalidatesGeneratedDependenciesWhileRelativeCacheRemainsIncremental() async throws { var settings = CMOCProjectConfiguration(); settings.buildTarget = "build" let makefile = """ build: main.bin main.bin: main.c Makefile \t@printf 'COMPILED-INPUTS\\n' \tcp main.c main.bin \tprintf 'main.bin: main.c' > main.d \t@if test -f obsolete.h; then cat obsolete.h >> main.bin; printf ' obsolete.h' >> main.d; fi \tprintf '\\n' >> main.d -include main.d """ let value = try configuredProject(settings, files: ["Makefile": makefile, "obsolete.h": "original header\n"]) let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Artifacts")) let first = try await service.build(project: value, overlays: [:]) let unchanged = try await service.build(project: value, overlays: [:]) XCTAssertFalse(unchanged.buildLog.contains("COMPILED-INPUTS"), "Safe relative dependencies should keep incremental builds") XCTAssertEqual(unchanged.binaryData, first.binaryData) try FileManager.default.removeItem(at: value.directory.appendingPathComponent("obsolete.h")) let removed = try await service.build(project: value, overlays: [:]) XCTAssertTrue(removed.buildLog.contains("a previously captured input was removed"), removed.buildLog) XCTAssertEqual(removed.binaryData, Data(try value.readSource().utf8)) XCTAssertTrue(String(decoding: first.binaryData, as: UTF8.self).hasSuffix("original header\n")) let again = try await service.build(project: value, overlays: [:]) XCTAssertEqual(again.binaryData, removed.binaryData) XCTAssertFalse(again.buildLog.contains("COMPILED-INPUTS")) } func testPopulatedCacheWithoutValidInputReceiptIsRebuiltRatherThanTrusted() async throws { var settings = CMOCProjectConfiguration(); settings.buildTarget = "build" let value = try configuredProject(settings, files: ["Makefile": """ build: main.bin main.bin: main.c \t@printf 'COMPILED-RECEIPT\\n' \tcp main.c main.bin """]) let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Artifacts")) let first = try await service.build(project: value, overlays: [:]) let receipt = first.compilationDirectory.deletingLastPathComponent().appendingPathComponent("inputs.json") try Data("not a valid cache input receipt".utf8).write(to: receipt) let rebuilt = try await service.build(project: value, overlays: [:]) XCTAssertTrue(rebuilt.buildLog.contains("the previous input receipt is missing or invalid")) XCTAssertTrue(rebuilt.buildLog.contains("COMPILED-RECEIPT")) XCTAssertEqual(rebuilt.binaryData, first.binaryData) } func testExplicitInputOutputDeclarationsRoundTripAndRejectAmbiguousRoles() throws { var settings = CMOCProjectConfiguration() settings.outputDirectories = ["build"] settings.resourceInputs = ["build/seed.raw"] settings.generatedInputs = ["build/generated.s"] XCTAssertNoThrow(try settings.validated(), "Explicit inputs may override an otherwise excluded output folder") XCTAssertEqual(try JSONDecoder().decode(CMOCProjectConfiguration.self, from: JSONEncoder().encode(settings)), settings) let defaults = try JSONDecoder().decode(CMOCProjectConfiguration.self, from: Data("{}".utf8)) XCTAssertTrue(defaults.resourceInputs.isEmpty && defaults.generatedInputs.isEmpty && defaults.outputDirectories.isEmpty) for path in ["../outside", "/absolute", "a/../b", "a//b", "a\\b", ".git/config", "nested/.svn/entries"] { var invalid = settings; invalid.resourceInputs = [path] XCTAssertThrowsError(try invalid.validated(), path) } var duplicate = settings; duplicate.generatedInputs = ["BUILD/SEED.RAW"] XCTAssertThrowsError(try duplicate.validated()) var conflicting = settings; conflicting.resourceInputs = ["main.bin"] XCTAssertThrowsError(try conflicting.validated()) conflicting.resourceInputs = []; conflicting.generatedInputs = ["main.bin"] XCTAssertThrowsError(try conflicting.validated()) } func testBuildPreservesExplicitResourcesAndPreGeneratedInputsInsideOutputFolders() async throws { var settings = CMOCProjectConfiguration(); settings.buildTarget = "build" settings.outputDirectories = ["build"] settings.resourceInputs = ["build/seed.raw"] settings.generatedInputs = ["build/generated.s"] let recipe = """ .PHONY: build build: \tcat build/seed.raw build/generated.s > main.bin \tprintf incidental > build/compiler-output.raw """ let value = try configuredProject(settings, files: ["Makefile": recipe, "build/seed.raw": "RESOURCE\n", "build/generated.s": " rts\n", "build/old-output.raw": "stale output"]) let inputs = try value.inputFiles() XCTAssertNotNil(inputs["build/seed.raw"]) XCTAssertNotNil(inputs["build/generated.s"]) XCTAssertNil(inputs["build/old-output.raw"]) let service = CMOCBuildService(toolchain: try makeTools(), buildRoot: folder.appendingPathComponent("Artifacts")) let artifact = try await service.build(project: value, overlays: [:]) XCTAssertEqual(artifact.binaryData, Data("RESOURCE\n rts\n".utf8)) XCTAssertEqual(artifact.fileHashes, try value.currentFileHashes()) XCTAssertEqual(try Data(contentsOf: value.directory.appendingPathComponent("build/seed.raw")), inputs["build/seed.raw"]) XCTAssertFalse(FileManager.default.fileExists(atPath: value.directory.appendingPathComponent("build/compiler-output.raw").path)) // Both explicit roles are captured inputs even where filename/parent // heuristics would normally classify them as disposable products. for path in ["build/seed.raw", "build/generated.s"] { let mutating = recipe + "\tprintf changed > " + path + "\n" try Data(mutating.utf8).write(to: value.makefileURL) do { _ = try await service.build(project: value, overlays: [:]) XCTFail("A recipe cannot replace a captured input: " + path) } catch { XCTAssertTrue(error.localizedDescription.contains("The build modified " + path), error.localizedDescription) } XCTAssertEqual(try Data(contentsOf: value.directory.appendingPathComponent(path)), inputs[path]) } } }