Files
VCCPlusOSS/platforms/macos/Tests/CMOCBuildServiceTests.swift
Brian Holman 5534005799 Sync VCC Plus 3.7.1 build 67 source
Refresh reviewed MCP output export, four-drive owned playtests, bounded BASIC readiness, and pinned CMOC 0.1.101 source/patches. Preserve independent source-edition identity, empty libraries, notices and privacy boundaries.

Validated 74 export/privacy checks, pinned dependency sources, and an independent unsigned universal Release build. A subsequent documentation-only correction removes an excluded qualification link; all build inputs remain identical.
2026-11-17 08:42:27 -07:00

2189 lines
147 KiB
Swift

// 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<Void, Never>?
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<Void, Never>?
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<Void, Never> { }
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: <build>/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 <unshared.h>", "#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 <vcc/ssc.h>
#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("<build>/main.c:7"))
XCTAssertTrue(log.contains("<build>/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], ["<build>/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 <cmoc.h>\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<String> = [".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])
}
}
}