Publish VCC Plus OSS source distribution for 3.6.2 build 60

This commit is contained in:
Brian Holman committed 2026-11-13 00:14:03 -07:00
commit c652a5276d
1192 files changed
+272368

No files matched your search

@@ -0,0 +1,230 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
import Darwin
final class CMOCWorkspaceRecoveryTests: XCTestCase {
private struct Fixture {
let root: URL
var project: URL { root.appendingPathComponent("Project") }
var store: URL { root.appendingPathComponent("Recovery") }
func recovery(session: UUID = UUID(), pid: Int32 = Int32.max) -> CMOCWorkspaceRecovery {
CMOCWorkspaceRecovery(root: store, sessionID: session, processID: pid)
}
var projectFolder: URL { store.appendingPathComponent(CMOCProject.sha256(Data(project.resolvingSymlinksInPath().path.utf8))) }
func remove() { try? FileManager.default.removeItem(at: root) }
}
private func fixture() throws -> Fixture {
let fixture = Fixture(root: FileManager.default.temporaryDirectory.appendingPathComponent("CRecovery-" + UUID().uuidString))
try FileManager.default.createDirectory(at: fixture.project, withIntermediateDirectories: true)
return fixture
}
private func draft(_ path: String = "main.c", text: String = "int changed;", saved: String = "int original;") -> CMOCWorkspaceRecovery.Draft {
.init(path: path, text: text, savedText: saved, savedHash: CMOCProject.sha256(Data(saved.utf8)))
}
func testRecoveryRetainsDraftAndOriginalIdentityWithoutWritingProject() throws {
let f = try fixture(); defer { f.remove() }
let file = f.project.appendingPathComponent("main.c")
try Data("int original;".utf8).write(to: file)
let owner = f.recovery()
try owner.save(projectDirectory: f.project, drafts: [draft(), draft("sub/header.h")])
XCTAssertEqual(try String(contentsOf: file, encoding: .utf8), "int original;")
XCTAssertFalse(FileManager.default.fileExists(atPath: f.project.appendingPathComponent("sub/header.h").path))
let reopened = f.recovery()
let record = try XCTUnwrap(reopened.records(projectDirectory: f.project).first)
XCTAssertFalse(record.isFromRunningSession)
XCTAssertEqual(record.drafts, [draft(), draft("sub/header.h")])
// A missing source does not make its unsaved recovery copy disappear.
try FileManager.default.removeItem(at: file)
XCTAssertEqual(try reopened.records(projectDirectory: f.project).first?.drafts[0].text, "int changed;")
try reopened.save(projectDirectory: f.project, drafts: record.drafts)
try reopened.discard(record)
XCTAssertEqual(try reopened.records(projectDirectory: f.project).count, 1)
XCTAssertFalse(FileManager.default.fileExists(atPath: file.path))
}
func testConcurrentSessionsKeepSeparateCopiesAndRejectLiveDiscard() throws {
let f = try fixture(); defer { f.remove() }
let first = f.recovery(pid: getpid()), second = f.recovery()
try first.save(projectDirectory: f.project, drafts: [draft(text: "first session")])
try second.save(projectDirectory: f.project, drafts: [draft(text: "second session")])
let scan = try second.scan(projectDirectory: f.project)
XCTAssertEqual(scan.records.count, 2)
let live = try XCTUnwrap(scan.records.first { $0.id == first.sessionID })
XCTAssertTrue(live.isFromRunningSession)
XCTAssertThrowsError(try second.discard(live))
try second.save(projectDirectory: f.project, drafts: [])
let left = try second.records(projectDirectory: f.project)
XCTAssertEqual(left.count, 1); XCTAssertEqual(left[0].drafts[0].text, "first session")
XCTAssertFalse(try first.records(projectDirectory: f.project)[0].isFromRunningSession)
}
func testInvalidDraftsKeepPreviousRecoveryCopy() throws {
let f = try fixture(); defer { f.remove() }
let store = f.recovery()
try store.save(projectDirectory: f.project, drafts: [draft()])
for drafts in [[draft("../escape.c")], [draft("/absolute.c")], [draft("main.c"), draft("MAIN.C")],
[draft(text: String(repeating: "x", count: CMOCProject.maximumSourceBytes + 1))],
[CMOCWorkspaceRecovery.Draft(path: "main.c", text: "new", savedText: "old", savedHash: "wrong")],
(0...CMOCWorkspaceRecovery.maximumDrafts).map { draft("file\($0).c") }] {
XCTAssertThrowsError(try store.save(projectDirectory: f.project, drafts: drafts))
XCTAssertEqual(try store.records(projectDirectory: f.project)[0].drafts, [draft()])
}
}
func testDamagedRecordIsReportedWithoutHidingHealthySession() throws {
let f = try fixture(); defer { f.remove() }
let store = f.recovery()
try store.save(projectDirectory: f.project, drafts: [draft()])
let broken = f.projectFolder.appendingPathComponent(UUID().uuidString + ".json")
try Data("{truncated".utf8).write(to: broken)
let scan = try store.scan(projectDirectory: f.project)
XCTAssertEqual(scan.records.count, 1)
XCTAssertEqual(scan.issues.count, 1)
XCTAssertTrue(scan.issues[0].contains("damaged"))
XCTAssertThrowsError(try store.records(projectDirectory: f.project))
XCTAssertTrue(FileManager.default.fileExists(atPath: broken.path))
}
func testChangedRecordCannotBeDiscardedUsingAnOlderSelection() throws {
let f = try fixture(); defer { f.remove() }
let owner = f.recovery(), reader = f.recovery()
try owner.save(projectDirectory: f.project, drafts: [draft(text: "first")])
let first = try XCTUnwrap(reader.records(projectDirectory: f.project).first)
try owner.save(projectDirectory: f.project, drafts: [draft(text: "newer")])
XCTAssertThrowsError(try reader.discard(first))
XCTAssertEqual(try reader.records(projectDirectory: f.project)[0].drafts[0].text, "newer")
let other = CMOCWorkspaceRecovery(root: f.root.appendingPathComponent("OtherRecovery"))
XCTAssertThrowsError(try other.discard(first))
}
func testRecoveryRefusesLinkedRootsFoldersAndRecords() throws {
let f = try fixture(); defer { f.remove() }
let external = f.root.appendingPathComponent("External")
try FileManager.default.createDirectory(at: external, withIntermediateDirectories: true)
let linkedRoot = f.root.appendingPathComponent("LinkedRecovery")
try FileManager.default.createSymbolicLink(at: linkedRoot, withDestinationURL: external)
XCTAssertThrowsError(try CMOCWorkspaceRecovery(root: linkedRoot).save(projectDirectory: f.project, drafts: [draft()]))
let store = f.recovery()
try store.save(projectDirectory: f.project, drafts: [draft()])
let record = try XCTUnwrap(store.records(projectDirectory: f.project).first)
let recordURL = f.projectFolder.appendingPathComponent(record.id.uuidString + ".json")
let canary = external.appendingPathComponent("canary")
try Data("unchanged".utf8).write(to: canary)
try FileManager.default.removeItem(at: recordURL)
try FileManager.default.createSymbolicLink(at: recordURL, withDestinationURL: canary)
XCTAssertEqual(try store.scan(projectDirectory: f.project).issues.count, 1)
XCTAssertThrowsError(try store.save(projectDirectory: f.project, drafts: []))
XCTAssertThrowsError(try store.discard(record))
XCTAssertEqual(try String(contentsOf: canary, encoding: .utf8), "unchanged")
try FileManager.default.removeItem(at: f.projectFolder)
try FileManager.default.createSymbolicLink(at: f.projectFolder, withDestinationURL: external)
XCTAssertThrowsError(try store.scan(projectDirectory: f.project))
XCTAssertThrowsError(try store.save(projectDirectory: f.project, drafts: [draft()]))
XCTAssertEqual(try String(contentsOf: canary, encoding: .utf8), "unchanged")
}
@MainActor private func waitForRecovery(_ model: CMOCDevelopmentModel) async throws {
for _ in 0..<500 where model.recoveryBusy { try await Task.sleep(nanoseconds: 10_000_000) }
XCTAssertFalse(model.recoveryBusy)
}
@MainActor private func flush(_ model: CMOCDevelopmentModel) async {
await withCheckedContinuation { continuation in model.flushDraftRecovery { continuation.resume() } }
}
@MainActor private func model(_ f: Fixture, defaults: UserDefaults) -> (MachineModel, CMOCDevelopmentModel) {
let machine = MachineModel(diskStore: .init(url: f.root.appendingPathComponent("disks.json")), displayDefaults: defaults,
inputStore: .init(url: f.root.appendingPathComponent("input.json")))
return (machine, CMOCDevelopmentModel(machine: machine, defaults: defaults,
buildRoot: f.root.appendingPathComponent("Builds"), recoveryRoot: f.store))
}
private func populateProject(_ f: Fixture) throws -> CMOCProject {
try Data(CMOCProject.starterSource.utf8).write(to: f.project.appendingPathComponent("main.c"))
try Data(CMOCProject.starterMakefile.utf8).write(to: f.project.appendingPathComponent("Makefile"))
return try CMOCProject.open(at: f.project)
}
@MainActor func testModelRestoresConflictingAndMissingDraftsWithoutOverwritingSources() async throws {
let f = try fixture(); defer { f.remove() }
let suite = "CRecoveryModel." + UUID().uuidString, defaults: UserDefaults
defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
let project = try populateProject(f)
let original = try project.readText(relativePath: "main.c")
let old = f.recovery()
try old.save(projectDirectory: f.project, drafts: [draft(text: original + "\n/* recovered */", saved: original), draft("missing.h")])
try Data((original + "\n/* outside edit */").utf8).write(to: project.sourceURL)
let (machine, model) = model(f, defaults: defaults)
try model.adopt(project); try await waitForRecovery(model)
let selected = try XCTUnwrap(model.recoveryRecords.first)
model.restoreRecovery(selected); try await waitForRecovery(model); await flush(model)
let main = try XCTUnwrap(model.documents.first { $0.id == "main.c" })
XCTAssertTrue(main.conflict); XCTAssertFalse(main.missing)
XCTAssertTrue(main.text.contains("recovered")); XCTAssertEqual(main.savedText, original)
let missing = try XCTUnwrap(model.documents.first { $0.id == "missing.h" })
XCTAssertTrue(missing.missing); XCTAssertTrue(missing.conflict)
XCTAssertFalse(model.save(), "Recovery must not authorize overwriting externally changed source")
XCTAssertEqual(try project.readText(relativePath: "main.c"), original + "\n/* outside edit */")
XCTAssertFalse(FileManager.default.fileExists(atPath: f.project.appendingPathComponent("missing.h").path))
let durable = try f.recovery().records(projectDirectory: f.project)
XCTAssertEqual(durable.count, 1)
XCTAssertNotEqual(durable[0].id, old.sessionID, "The adopted copy must replace the prior session only after it is durable")
XCTAssertEqual(durable[0].drafts.count, 2)
XCTAssertTrue(durable[0].drafts.first { $0.path == "main.c" }!.text.contains("recovered"))
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
@MainActor func testModelKeepsPriorCopyWhenDurableAdoptionCannotBeWritten() async throws {
let f = try fixture(); defer { f.remove() }
let suite = "CRecoveryModel." + UUID().uuidString, defaults: UserDefaults
defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
let project = try populateProject(f), old = f.recovery()
let original = try project.readText(relativePath: "main.c")
try old.save(projectDirectory: f.project, drafts: [draft(text: "recovered source", saved: original)])
let (machine, model) = model(f, defaults: defaults)
try model.adopt(project); try await waitForRecovery(model)
let selected = try XCTUnwrap(model.recoveryRecords.first)
let kept = f.root.appendingPathComponent("RecoveryKept")
try FileManager.default.moveItem(at: f.store, to: kept)
try Data("not a directory".utf8).write(to: f.store)
model.restoreRecovery(selected); try await waitForRecovery(model)
XCTAssertEqual(model.source, "recovered source", "A failed recovery write must not erase the in-memory draft")
XCTAssertTrue(model.message?.contains("real directory") == true)
let priorFile = kept.appendingPathComponent(f.projectFolder.lastPathComponent).appendingPathComponent(old.sessionID.uuidString + ".json")
XCTAssertTrue(FileManager.default.fileExists(atPath: priorFile.path), "Failed adoption must leave the old durable copy intact")
XCTAssertEqual(try project.readText(relativePath: "main.c"), original)
try FileManager.default.removeItem(at: f.store)
try FileManager.default.moveItem(at: kept, to: f.store)
await flush(model)
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
@MainActor func testMissingProjectStillOffersItsDraftsForExport() async throws {
let f = try fixture(); defer { f.remove() }
let suite = "CRecoveryModel." + UUID().uuidString, defaults: UserDefaults
defaults = UserDefaults(suiteName: suite)!
defer { defaults.removePersistentDomain(forName: suite) }
let old = f.recovery()
try old.save(projectDirectory: f.project, drafts: [draft()])
defaults.set(f.project.path, forKey: "CMOCWorkspace.directory")
try FileManager.default.removeItem(at: f.project)
let (machine, model) = model(f, defaults: defaults)
model.restoreWorkspace(); try await waitForRecovery(model)
XCTAssertNil(model.project)
let record = try XCTUnwrap(model.recoveryRecords.first)
XCTAssertEqual(record.drafts, [draft()], "Export has the full draft text even when the project cannot open")
model.restoreRecovery(record)
XCTAssertTrue(model.message?.contains("export") == true)
XCTAssertEqual(try old.records(projectDirectory: f.project).count, 1)
XCTAssertFalse(FileManager.default.fileExists(atPath: f.project.path))
await withCheckedContinuation { continuation in machine.shutdown { continuation.resume() } }
}
func testScanBoundsRetainedSessionsWithoutDeletingUnreviewedCopies() throws {
let f = try fixture(); defer { f.remove() }
for _ in 0...CMOCWorkspaceRecovery.maximumScanRecords {
try f.recovery().save(projectDirectory: f.project, drafts: [draft()])
}
let reader = f.recovery()
let first = try reader.scan(projectDirectory: f.project)
XCTAssertEqual(first.records.count, CMOCWorkspaceRecovery.maximumScanRecords)
XCTAssertEqual(first.issues.count, 1)
XCTAssertEqual(try FileManager.default.contentsOfDirectory(atPath: f.projectFolder.path).count, CMOCWorkspaceRecovery.maximumScanRecords + 1)
try reader.discard(first.records[0])
let next = try reader.scan(projectDirectory: f.project)
XCTAssertEqual(next.records.count, CMOCWorkspaceRecovery.maximumScanRecords)
XCTAssertTrue(next.issues.isEmpty)
XCTAssertFalse(Set(first.records.map(\.id)).isSuperset(of: Set(next.records.map(\.id))), "The remaining record becomes reviewable after explicit cleanup")
}
}