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.
2189 lines
147 KiB
Swift
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])
|
|
}
|
|
}
|
|
}
|