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,119 @@
// SPDX-License-Identifier: GPL-3.0-or-later
import XCTest
final class CMOCCompletionTests: XCTestCase {
private func fixture(_ marked: String, headers: [String: String] = [:]) -> (CMOCProjectIndex, String, Int) {
let offset = (marked as NSString).range(of: "|").location
XCTAssertNotEqual(offset, NSNotFound)
let text = marked.replacingOccurrences(of: "|", with: "")
return (CMOCProjectIndex(documents: headers.merging(["main.c": text]) { _, new in new }, includePaths: ["@toolchain/include"]), text, offset)
}
func testIncludedSymbolsKeywordsAndWholeTokenUnicodeReplacement() throws {
let (index, text, offset) = fixture("#include <cmoc.h>\n// 🙂\nint main(void) { pri|ntf; }", headers: [
"@toolchain/include/cmoc.h": "int printf(const char *format, ...);",
"unrelated.h": "int private_unincluded(void);",
"other.c": "static int private_other(void) { return 0; }"
])
let suggestions = CMOCCompletion.suggestions(index: index, path: "main.c", text: text, offset: offset)
let candidate = try XCTUnwrap(suggestions.first { $0.name == "printf" })
XCTAssertEqual(candidate.insertion, "printf")
XCTAssertEqual((text as NSString).substring(with: candidate.replacementRange), "printf")
XCTAssertEqual(candidate.replacementRange.location, offset - 3)
XCTAssertFalse(suggestions.contains { $0.name.hasPrefix("private") })
let keywords = CMOCCompletion.suggestions(index: index, path: "main.c", text: text, offset: offset - 3)
XCTAssertTrue(keywords.contains { $0.name == "while" })
}
func testLocalsShadowAndDoNotLeakAcrossScopesOrForLoops() throws {
let marked = "int shared; int main(int parameter) { { int shared; sha|red++; } return 0; } int other(void) { return 0; }"
let (index, text, offset) = fixture(marked)
let shared = try XCTUnwrap(CMOCCompletion.suggestions(index: index, path: "main.c", text: text, offset: offset).first)
XCTAssertEqual(shared.name, "shared")
XCTAssertTrue(shared.detail.contains("int shared"))
let other = (text as NSString).range(of: "return 0", options: .backwards).location
let outside = CMOCCompletion.suggestions(index: index, path: "main.c", text: text, offset: other)
XCTAssertFalse(outside.contains { $0.name == "parameter" })
let (loopIndex, loopText, loopOffset) = fixture("int main(void) { for (int loopOnly = 0; loopOnly < 2; ++loopOnly) {} lo|; }")
XCTAssertFalse(CMOCCompletion.suggestions(index: loopIndex, path: "main.c", text: loopText, offset: loopOffset).contains { $0.name == "loopOnly" })
}
func testNoSuggestionsInCommentsLiteralsDirectivesNumbersOrMembers() {
for marked in ["int main(void) { // pri|\n}", "int main(void) { /* pri| */ }", "int main(void) { \"pri|\"; }", "int main(void) { 'p|'; }", "#include <pri|>\n", "#define X \\\npri|", "// continued \\\npri|", "int main(void) { object.pri|; }", "int main(void) { object->pri|; }", "int main(void) { 123|; }"] {
let (index, text, offset) = fixture(marked)
XCTAssertTrue(CMOCCompletion.suggestions(index: index, path: "main.c", text: text, offset: offset).isEmpty, marked)
}
}
func testStaleIdentifierEditMapsScopesWithoutRebuildingIndex() throws {
let old = "int main(int localCount) { loc; }"
let index = CMOCProjectIndex(documents: ["main.c": old])
let text = old.replacingOccurrences(of: "loc;", with: "local;")
let offset = (text as NSString).range(of: "local;").location + 5
let candidate = try XCTUnwrap(CMOCCompletion.suggestions(index: index, path: "main.c", text: text, offset: offset).first { $0.name == "localCount" })
XCTAssertTrue(candidate.conditional)
let restructured = text.replacingOccurrences(of: " { local; }", with: " {} int other(void) { local; }")
let changedOffset = (restructured as NSString).range(of: "local;").location + 5
XCTAssertFalse(CMOCCompletion.suggestions(index: index, path: "main.c", text: restructured, offset: changedOffset).contains { $0.name == "localCount" })
let renamed = old.replacingOccurrences(of: "localCount", with: "differentName")
let renamedOffset = (renamed as NSString).range(of: "loc;").location + 3
XCTAssertFalse(CMOCCompletion.suggestions(index: index, path: "main.c", text: renamed, offset: renamedOffset).contains { $0.name == "localCount" })
}
func testNestedCallParametersIgnoreNonArgumentCommas() throws {
let (index, text, offset) = fixture("#include \"api.h\"\nint main(void) { outer(inner(1, 2), \"x,y\", items[i,j], (int[]){1,2}, |); }", headers: ["api.h": "int inner(int a, int b); int outer(int a, const char *b, int c, int *d, int e);"])
let hint = try XCTUnwrap(CMOCCompletion.parameterHints(index: index, path: "main.c", text: text, offset: offset).first)
XCTAssertEqual(hint.name, "outer")
XCTAssertEqual(hint.parameters.count, 5)
XCTAssertEqual(hint.activeParameter, 4)
let innerOffset = (text as NSString).range(of: "inner(1, 2)").location + "inner(1, ".utf16.count
XCTAssertEqual(CMOCCompletion.parameterHints(index: index, path: "main.c", text: text, offset: innerOffset).first?.name, "inner")
XCTAssertEqual(CMOCCompletion.parameterHints(index: index, path: "main.c", text: text, offset: innerOffset).first?.activeParameter, 1)
}
func testGroupingCommentsAndEscapedStringsPreserveOuterParameter() throws {
let (index, text, offset) = fixture("#include \"api.h\"\nint main(void) { outer(\"a\\\",b\", /* , ) */ (1 + |)); }", headers: ["api.h": "int outer(const char *text, int value);"])
let hint = try XCTUnwrap(CMOCCompletion.parameterHints(index: index, path: "main.c", text: text, offset: offset).first)
XCTAssertEqual(hint.name, "outer"); XCTAssertEqual(hint.activeParameter, 1)
}
func testVoidVariadicAndFunctionPointerParameterSignatures() throws {
let headers = ["api.h": "void clear(void); int printf(const char *format, ...); int apply(int (*callback)(int a, int b), int value);"]
for (marked, name, count, active) in [
("#include \"api.h\"\nint main(void) { clear(|); }", "clear", 0, 0),
("#include \"api.h\"\nint main(void) { printf(\"%d%d\", 1, |); }", "printf", 2, 2),
("#include \"api.h\"\nint main(void) { apply(callback, |); }", "apply", 2, 1)
] {
let (index, text, offset) = fixture(marked, headers: headers)
let hint = try XCTUnwrap(CMOCCompletion.parameterHints(index: index, path: "main.c", text: text, offset: offset).first)
XCTAssertEqual(hint.name, name); XCTAssertEqual(hint.parameters.count, count); XCTAssertEqual(hint.activeParameter, active)
}
}
func testNoHintsForDeclarationsControlsMembersOrPointerCalls() {
for marked in ["int example(int |value);", "int main(void) { if (|) {} }", "int main(void) { sizeof(|); }", "int main(void) { object.example(|); }", "int main(void) { int (*example)(int); example(|); }", "Widget example(int |value);"] {
let (index, text, offset) = fixture(marked, headers: ["api.h": "int example(int value);"])
XCTAssertTrue(CMOCCompletion.parameterHints(index: index, path: "main.c", text: text, offset: offset).isEmpty, marked)
}
}
func testConditionalMacroAndAlternativesRemainExplicit() throws {
let (index, text, offset) = fixture("#include \"api.h\"\nint main(void) { choose(|); }", headers: ["api.h": "#if SOMETHING\nint choose(int x);\n#else\nint choose(int x, int y);\n#endif"])
let hints = CMOCCompletion.parameterHints(index: index, path: "main.c", text: text, offset: offset)
XCTAssertEqual(hints.count, 2); XCTAssertTrue(hints.allSatisfy(\.conditional))
let (macroIndex, macroText, macroOffset) = fixture("#define MAXIMUM(a,b) ((a) > (b) ? (a) : (b))\nint main(void) { MAXIMUM(1, |); }")
let macro = try XCTUnwrap(CMOCCompletion.parameterHints(index: macroIndex, path: "main.c", text: macroText, offset: macroOffset).first)
XCTAssertEqual(macro.parameters, ["a", "b"]); XCTAssertTrue(macro.conditional)
}
func testLiteralArgumentKeepsHintAndObjectMacroIsNotCallable() throws {
let (index, text, offset) = fixture("#include \"api.h\"\nint main(void) { printf(\"value, |\"); }", headers: ["api.h": "int printf(const char *format, ...);"])
let hint = try XCTUnwrap(CMOCCompletion.parameterHints(index: index, path: "main.c", text: text, offset: offset).first)
XCTAssertEqual(hint.name, "printf"); XCTAssertEqual(hint.activeParameter, 0)
XCTAssertTrue(CMOCCompletion.suggestions(index: index, path: "main.c", text: text, offset: offset).isEmpty)
let (objectIndex, objectText, objectOffset) = fixture("#define OBJECT (a,b)\nint main(void) { OBJECT(|); }")
XCTAssertTrue(CMOCCompletion.parameterHints(index: objectIndex, path: "main.c", text: objectText, offset: objectOffset).isEmpty)
}
func testBoundsMalformedInputsAndTruncatedSignatures() {
let (index, text, offset) = fixture("int main(void) { | }")
XCTAssertEqual(CMOCCompletion.suggestions(index: index, path: "main.c", text: text, offset: offset, limit: 3).count, 3)
XCTAssertTrue(CMOCCompletion.suggestions(index: index, path: "Makefile", text: text, offset: offset).isEmpty)
XCTAssertTrue(CMOCCompletion.suggestions(index: index, path: "main.c", text: text, offset: -1).isEmpty)
XCTAssertTrue(CMOCCompletion.parameterHints(index: index, path: "main.c", text: text, offset: text.utf16.count + 1).isEmpty)
let params = (0..<60).map { "int parameter\($0)" }.joined(separator: ",")
let (longIndex, longText, longOffset) = fixture("#include \"api.h\"\nint main(void) { huge(|); }", headers: ["api.h": "int huge(\(params));"])
XCTAssertTrue(CMOCCompletion.parameterHints(index: longIndex, path: "main.c", text: longText, offset: longOffset).isEmpty)
let tooLarge = String(repeating: " ", count: CMOCProjectIndex.maximumFileBytes + 1)
XCTAssertTrue(CMOCCompletion.suggestions(index: index, path: "main.c", text: tooLarge, offset: 1).isEmpty)
}
}