wehub-resource-sync
1088 lines
48 KiB
C
1088 lines
48 KiB
C
/*
|
|
* repro_grammar_build.c -- Per-grammar INVARIANT battery for the
|
|
* BUILD / INFRA language family.
|
|
*
|
|
* One TEST() per language so per-language RED/GREEN shows on the bug-repro
|
|
* board. Each test runs a battery adapted to what the language actually models.
|
|
*
|
|
* Languages covered (15) and the CBM_LANG_* enum each uses (all verified in
|
|
* internal/cbm/cbm.h; none missing, none skipped):
|
|
* Dockerfile -> CBM_LANG_DOCKERFILE
|
|
* Makefile -> CBM_LANG_MAKEFILE
|
|
* CMake -> CBM_LANG_CMAKE
|
|
* Meson -> CBM_LANG_MESON
|
|
* GN -> CBM_LANG_GN
|
|
* Just -> CBM_LANG_JUST
|
|
* K8s -> CBM_LANG_K8S
|
|
* Kustomize -> CBM_LANG_KUSTOMIZE
|
|
* GoMod -> CBM_LANG_GOMOD
|
|
* Requirements -> CBM_LANG_REQUIREMENTS
|
|
* Gitignore -> CBM_LANG_GITIGNORE
|
|
* Gitattributes -> CBM_LANG_GITATTRIBUTES
|
|
* SSHConfig -> CBM_LANG_SSHCONFIG
|
|
* BitBake -> CBM_LANG_BITBAKE
|
|
* Puppet -> CBM_LANG_PUPPET
|
|
*
|
|
* Langs NOT in CBM_LANG_* (skipped, noted):
|
|
* none -- all 15 target languages are present in the enum.
|
|
*
|
|
* BATTERY DIMENSIONS
|
|
* ------------------
|
|
* SINGLE-FILE (cbm_extract_file, via inv_rx + inv_count_* helpers):
|
|
* 1. extract-clean : inv_extract_clean(src,lang,file) == 1
|
|
* (parser returned a result and did not set has_error).
|
|
* 2. labels-valid : inv_count_bad_labels(r) == 0
|
|
* (every extracted def label is in the known label set).
|
|
* 3. fqn-wellformed : inv_count_bad_fqns(r) == 0
|
|
* (no empty / ".." / leading-trailing '.' / whitespace QNs).
|
|
* 4. ranges-valid : inv_count_bad_ranges(r) == 0
|
|
* (start_line >= 1 and start_line <= end_line).
|
|
* 5. defs-present : at least one def with the expected label is extracted.
|
|
* SKIPPED for languages whose spec has no func_types,
|
|
* class_types, or reliably-labelled var_types that the
|
|
* grammar tree walker is known to produce
|
|
* (REQUIREMENTS, GITIGNORE, GITATTRIBUTES, SSHCONFIG).
|
|
* 6. calls-extracted : inv_has_call(r, callee) == 1.
|
|
* Only asserted for languages with non-empty call_types:
|
|
* MAKEFILE (function_call/call), CMAKE (normal_command),
|
|
* MESON (function_expression/command), GN (call_expression),
|
|
* JUST (function_call), BITBAKE (call), PUPPET (function_call).
|
|
*
|
|
* FULL-PIPELINE (rh_index_files -> cbm_store_t*, via inv_count_* store helpers):
|
|
* 7. callable-sourcing : inv_count_calls_by_source(store,project,&mod,&call).
|
|
* Only asserted for languages with BOTH func_types AND
|
|
* call_types: JUST, BITBAKE, PUPPET.
|
|
* 8. no-dangling : inv_count_dangling_edges(store, project, "CALLS") == 0.
|
|
* Asserted together with dim 7 when the pipeline is run.
|
|
*
|
|
* ROBUSTNESS (every language):
|
|
* R. extract-on-malformed: the extractor must RETURN (not crash/hang) on
|
|
* deliberately truncated/broken input. inv_extract_clean may return 0
|
|
* (has_error is fine) but must not return NULL.
|
|
* Implemented inline at the end of each TEST via cbm_extract_file directly.
|
|
*
|
|
* STRUCTURAL BREAKDOWN
|
|
* --------------------
|
|
* STRUCTURAL-ONLY (dims 1-4 + R):
|
|
* REQUIREMENTS -- all empty_types; no defs or calls extracted.
|
|
* GITIGNORE -- all empty_types; no defs or calls extracted.
|
|
* GITATTRIBUTES -- all empty_types; no defs or calls extracted.
|
|
* SSHCONFIG -- all empty_types; no defs or calls extracted.
|
|
*
|
|
* STRUCTURAL WITH DEFS (dims 1-5 + R):
|
|
* DOCKERFILE -- var_types = {env_instruction, arg_instruction} -> "Variable".
|
|
* GOMOD -- var_types = {require_directive, replace_directive} -> "Variable".
|
|
* K8S -- semantic extractor (cbm_extract_k8s); extracts kind -> "Resource".
|
|
* KUSTOMIZE -- semantic extractor (cbm_extract_k8s); extracts kind -> "Resource".
|
|
*
|
|
* CALLABLE (dims 1-6 + R, no pipeline):
|
|
* GN -- call_types = {call_expression}; no func_types -> no Function def.
|
|
* Dim 5 SKIPPED (no defs); dim 6 only.
|
|
* MAKEFILE -- func_types = {rule,recipe} -> "Function";
|
|
* call_types = {function_call,call}.
|
|
* Dims 1-6. Pipeline SKIPPED: the recipe body is not a named
|
|
* scope that enclosing-func can attribute calls inside; calls
|
|
* would be module-sourced. No pipeline dim.
|
|
* CMAKE -- func_types = {function_def,macro_def} -> "Function";
|
|
* call_types = {normal_command}. Dims 1-6. Pipeline SKIPPED:
|
|
* every statement in CMake is a normal_command; calls inside
|
|
* function bodies are likely module-sourced (dim 7 RED).
|
|
* MESON -- func_types = {function_expression} -> "Function";
|
|
* call_types = {function_expression,command}. Dims 1-6.
|
|
* Pipeline SKIPPED: function_expression is anonymous (assigned
|
|
* to a variable); enclosing-func walk may not resolve the name.
|
|
*
|
|
* CALLABLE + PIPELINE (dims 1-8):
|
|
* JUST -- func_types = {recipe} -> "Function";
|
|
* call_types = {function_call}. Dims 1-8.
|
|
* Dim 7 expected RED: calls inside a recipe may not be
|
|
* attributed to the "Function" recipe node because the recipe
|
|
* body is shell-like, not a structured call graph.
|
|
* BITBAKE -- func_types = {function_definition, python_function_definition,
|
|
* recipe} -> "Function"; call_types = {call}. Dims 1-8.
|
|
* Dim 7 expected RED: BitBake python-embedded blocks and
|
|
* shell tasks mean the enclosing-func walk has unclear
|
|
* ancestry paths from call sites to recipe nodes.
|
|
* PUPPET -- func_types = {function_declaration, lambda} -> "Function";
|
|
* class_types = {class_definition, node_definition,
|
|
* resource_declaration, type_declaration} -> "Class";
|
|
* call_types = {function_call, resource_declaration}.
|
|
* Dims 1-8. Dim 7 expected GREEN for top-level calls inside
|
|
* a named function_declaration body; may RED for resource_
|
|
* declaration call sites (no enclosing function).
|
|
*
|
|
* Coding rule: inline comments are line comments only (no nested block-comment opener).
|
|
*/
|
|
|
|
#include "test_framework.h"
|
|
#include "repro_invariant_lib.h"
|
|
#include <store/store.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
/* ── Structural-base battery (dims 1-4) ──────────────────────────────────────
|
|
*
|
|
* Runs the four core invariants on valid input. No defs-present assertion.
|
|
* Used for REQUIREMENTS, GITIGNORE, GITATTRIBUTES, SSHCONFIG where the spec
|
|
* has no func_types, class_types, or labelled var_types that yield defs.
|
|
* Returns 0 on PASS, 1 on FAIL.
|
|
*/
|
|
static int build_base_battery(const char *lang_tag, const char *src,
|
|
CBMLanguage lang, const char *file) {
|
|
const char *RED = tf_red();
|
|
const char *RST = tf_reset();
|
|
|
|
/* 1. extract-clean */
|
|
if (inv_extract_clean(src, lang, file) != 1) {
|
|
printf(" %sFAIL%s [%s] extract-clean: NULL result or has_error set\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
|
|
CBMFileResult *r = inv_rx(src, lang, file);
|
|
if (!r) {
|
|
printf(" %sFAIL%s [%s] inv_rx returned NULL after clean extract\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
|
|
int fails = 0;
|
|
|
|
/* 2. labels-valid */
|
|
int bad_labels = inv_count_bad_labels(r);
|
|
if (bad_labels != 0) {
|
|
printf(" %sFAIL%s [%s] labels-valid: %d def(s) with invalid label\n",
|
|
RED, RST, lang_tag, bad_labels);
|
|
fails++;
|
|
}
|
|
|
|
/* 3. fqn-wellformed */
|
|
int bad_fqns = inv_count_bad_fqns(r);
|
|
if (bad_fqns != 0) {
|
|
printf(" %sFAIL%s [%s] fqn-wellformed: %d def(s) with malformed QN\n",
|
|
RED, RST, lang_tag, bad_fqns);
|
|
fails++;
|
|
}
|
|
|
|
/* 4. ranges-valid */
|
|
int bad_ranges = inv_count_bad_ranges(r);
|
|
if (bad_ranges != 0) {
|
|
printf(" %sFAIL%s [%s] ranges-valid: %d def(s) with invalid range\n",
|
|
RED, RST, lang_tag, bad_ranges);
|
|
fails++;
|
|
}
|
|
|
|
cbm_free_result(r);
|
|
return fails ? 1 : 0;
|
|
}
|
|
|
|
/* ── Structural battery with defs-present (dims 1-5) ────────────────────────
|
|
*
|
|
* Adds the defs-present dimension for languages with class_types, func_types,
|
|
* or reliably-labelled var_types (DOCKERFILE, GOMOD, K8S, KUSTOMIZE).
|
|
* Pass NULL for expect_label2 when only one label type is needed.
|
|
* Returns 0 on PASS, 1 on FAIL.
|
|
*/
|
|
static int build_struct_battery(const char *lang_tag, const char *src,
|
|
CBMLanguage lang, const char *file,
|
|
const char *expect_label,
|
|
const char *expect_label2) {
|
|
const char *RED = tf_red();
|
|
const char *RST = tf_reset();
|
|
|
|
/* 1. extract-clean */
|
|
if (inv_extract_clean(src, lang, file) != 1) {
|
|
printf(" %sFAIL%s [%s] extract-clean: NULL result or has_error set\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
|
|
CBMFileResult *r = inv_rx(src, lang, file);
|
|
if (!r) {
|
|
printf(" %sFAIL%s [%s] inv_rx returned NULL after clean extract\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
|
|
int fails = 0;
|
|
|
|
/* 2. labels-valid */
|
|
int bad_labels = inv_count_bad_labels(r);
|
|
if (bad_labels != 0) {
|
|
printf(" %sFAIL%s [%s] labels-valid: %d def(s) with invalid label\n",
|
|
RED, RST, lang_tag, bad_labels);
|
|
fails++;
|
|
}
|
|
|
|
/* 3. fqn-wellformed */
|
|
int bad_fqns = inv_count_bad_fqns(r);
|
|
if (bad_fqns != 0) {
|
|
printf(" %sFAIL%s [%s] fqn-wellformed: %d def(s) with malformed QN\n",
|
|
RED, RST, lang_tag, bad_fqns);
|
|
fails++;
|
|
}
|
|
|
|
/* 4. ranges-valid */
|
|
int bad_ranges = inv_count_bad_ranges(r);
|
|
if (bad_ranges != 0) {
|
|
printf(" %sFAIL%s [%s] ranges-valid: %d def(s) with invalid range\n",
|
|
RED, RST, lang_tag, bad_ranges);
|
|
fails++;
|
|
}
|
|
|
|
/* 5. defs-present (primary label) */
|
|
if (expect_label && inv_count_label(r, expect_label) < 1) {
|
|
printf(" %sFAIL%s [%s] defs-present: no def labelled \"%s\"\n",
|
|
RED, RST, lang_tag, expect_label);
|
|
fails++;
|
|
}
|
|
|
|
/* 5b. defs-present (secondary label, optional) */
|
|
if (expect_label2 && inv_count_label(r, expect_label2) < 1) {
|
|
printf(" %sFAIL%s [%s] defs-present: no def labelled \"%s\"\n",
|
|
RED, RST, lang_tag, expect_label2);
|
|
fails++;
|
|
}
|
|
|
|
cbm_free_result(r);
|
|
return fails ? 1 : 0;
|
|
}
|
|
|
|
/* ── Callable battery (dims 1-6) ─────────────────────────────────────────────
|
|
*
|
|
* Adds dims 5 (optional) and 6 (calls-extracted) to the base invariants.
|
|
* Pass NULL for expect_label when the language has no func/class def to assert
|
|
* alongside the call (e.g. GN has call_types but no func_types).
|
|
* Returns 0 on PASS, 1 on FAIL.
|
|
*/
|
|
static int build_callable_battery(const char *lang_tag, const char *src,
|
|
CBMLanguage lang, const char *file,
|
|
const char *expect_label,
|
|
const char *callee) {
|
|
const char *RED = tf_red();
|
|
const char *RST = tf_reset();
|
|
|
|
/* 1. extract-clean */
|
|
if (inv_extract_clean(src, lang, file) != 1) {
|
|
printf(" %sFAIL%s [%s] extract-clean: NULL result or has_error set\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
|
|
CBMFileResult *r = inv_rx(src, lang, file);
|
|
if (!r) {
|
|
printf(" %sFAIL%s [%s] inv_rx returned NULL after clean extract\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
|
|
int fails = 0;
|
|
|
|
/* 2. labels-valid */
|
|
int bad_labels = inv_count_bad_labels(r);
|
|
if (bad_labels != 0) {
|
|
printf(" %sFAIL%s [%s] labels-valid: %d def(s) with invalid label\n",
|
|
RED, RST, lang_tag, bad_labels);
|
|
fails++;
|
|
}
|
|
|
|
/* 3. fqn-wellformed */
|
|
int bad_fqns = inv_count_bad_fqns(r);
|
|
if (bad_fqns != 0) {
|
|
printf(" %sFAIL%s [%s] fqn-wellformed: %d def(s) with malformed QN\n",
|
|
RED, RST, lang_tag, bad_fqns);
|
|
fails++;
|
|
}
|
|
|
|
/* 4. ranges-valid */
|
|
int bad_ranges = inv_count_bad_ranges(r);
|
|
if (bad_ranges != 0) {
|
|
printf(" %sFAIL%s [%s] ranges-valid: %d def(s) with invalid range\n",
|
|
RED, RST, lang_tag, bad_ranges);
|
|
fails++;
|
|
}
|
|
|
|
/* 5. defs-present (only when a def label is expected) */
|
|
if (expect_label && inv_count_label(r, expect_label) < 1) {
|
|
printf(" %sFAIL%s [%s] defs-present: no def labelled \"%s\"\n",
|
|
RED, RST, lang_tag, expect_label);
|
|
fails++;
|
|
}
|
|
|
|
/* 6. calls-extracted */
|
|
if (callee && inv_has_call(r, callee) != 1) {
|
|
printf(" %sFAIL%s [%s] calls-extracted: no call to \"%s\" found\n",
|
|
RED, RST, lang_tag, callee);
|
|
fails++;
|
|
}
|
|
|
|
cbm_free_result(r);
|
|
return fails ? 1 : 0;
|
|
}
|
|
|
|
/* ── Full-pipeline battery (dims 7-8) ───────────────────────────────────────
|
|
*
|
|
* Indexes the single-file fixture through the production pipeline and asserts
|
|
* callable-sourcing + no-dangling. Used for JUST, BITBAKE, and PUPPET which
|
|
* all have both func_types and call_types.
|
|
*
|
|
* Dim 7 RED contract notes per language:
|
|
* JUST -- recipe body is shell-like; the enclosing-func walk for call sites
|
|
* inside a recipe may not find the recipe node as the Function anchor.
|
|
* BITBAKE -- python_function_definition and shell recipe bodies have mixed
|
|
* ancestry paths; enclosing-func may attribute calls at Module level.
|
|
* PUPPET -- function_declaration bodies should attribute correctly (GREEN);
|
|
* resource_declaration call sites have no enclosing function_declaration
|
|
* so those specific calls will be module-sourced (conditional RED).
|
|
* Returns 0 on PASS, 1 on FAIL.
|
|
*/
|
|
static int build_pipeline_battery(const char *lang_tag, const char *filename,
|
|
const char *src) {
|
|
const char *RED = tf_red();
|
|
const char *RST = tf_reset();
|
|
|
|
RFile files[1];
|
|
files[0].name = filename;
|
|
files[0].content = src;
|
|
|
|
RProj lp;
|
|
cbm_store_t *store = rh_index_files(&lp, files, 1);
|
|
if (!store) {
|
|
printf(" %sFAIL%s [%s] pipeline: rh_index_files returned NULL\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
|
|
int fails = 0;
|
|
|
|
/* 7. callable-sourcing */
|
|
int module_sourced = 0;
|
|
int callable_sourced = 0;
|
|
inv_count_calls_by_source(store, lp.project, &module_sourced,
|
|
&callable_sourced);
|
|
if (module_sourced != 0) {
|
|
printf(" %sFAIL%s [%s] callable-sourcing: %d in-body CALLS sourced at "
|
|
"Module (callable=%d) -- known enclosing-func gap\n",
|
|
RED, RST, lang_tag, module_sourced, callable_sourced);
|
|
fails++;
|
|
} else if (callable_sourced < 1) {
|
|
printf(" %sFAIL%s [%s] callable-sourcing: 0 CALLS edges (fixture "
|
|
"produced no in-body call edge to attribute)\n",
|
|
RED, RST, lang_tag);
|
|
fails++;
|
|
}
|
|
|
|
/* 8. no-dangling */
|
|
int dangling = inv_count_dangling_edges(store, lp.project, "CALLS");
|
|
if (dangling != 0) {
|
|
printf(" %sFAIL%s [%s] no-dangling: %d dangling CALLS endpoint(s)\n",
|
|
RED, RST, lang_tag, dangling);
|
|
fails++;
|
|
}
|
|
|
|
rh_cleanup(&lp, store);
|
|
return fails ? 1 : 0;
|
|
}
|
|
|
|
/* ── Robustness helper: assert call RETURNS on malformed input ───────────────
|
|
*
|
|
* A truncated version of the fixture is passed through cbm_extract_file.
|
|
* has_error may be set (1) but the call must return non-NULL. If it returns
|
|
* NULL the extractor crashed or aborted on bad input -- that is a RED
|
|
* robustness bug. Returns 0 on PASS, 1 on FAIL.
|
|
*/
|
|
static int build_robustness(const char *lang_tag, const char *bad_src,
|
|
CBMLanguage lang, const char *file) {
|
|
const char *RED = tf_red();
|
|
const char *RST = tf_reset();
|
|
|
|
CBMFileResult *r = cbm_extract_file(bad_src, (int)strlen(bad_src),
|
|
lang, "t", file, 0, NULL, NULL);
|
|
if (!r) {
|
|
printf(" %sFAIL%s [%s] robustness: extractor returned NULL on malformed input\n",
|
|
RED, RST, lang_tag);
|
|
return 1;
|
|
}
|
|
cbm_free_result(r);
|
|
return 0;
|
|
}
|
|
|
|
/* ── Dockerfile ───────────────────────────────────────────────────────────────
|
|
* Idiomatic two-stage Dockerfile: a builder stage (FROM ... AS ...) followed by
|
|
* a runtime stage. ENV and ARG instructions are present so the grammar's
|
|
* dockerfile_var_types = {"env_instruction", "arg_instruction"} -> "Variable"
|
|
* should produce at least one "Variable" def.
|
|
*
|
|
* Dims asserted: 1-5 + R ("Variable").
|
|
* Dim 5 expected GREEN: ENV instruction should map to "Variable".
|
|
* RED would indicate env_instruction -> Variable extraction is broken.
|
|
* Dims 6-8 SKIPPED: no call_types in the spec; no pipeline.
|
|
* Expected GREEN: dims 1-5. Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_dockerfile) {
|
|
static const char src[] =
|
|
"FROM golang:1.22 AS builder\n"
|
|
"WORKDIR /app\n"
|
|
"ARG VERSION=0.8.1\n"
|
|
"COPY . .\n"
|
|
"RUN go build -o /cbm-server ./cmd/server\n"
|
|
"\n"
|
|
"FROM debian:bookworm-slim\n"
|
|
"ENV PORT=8080\n"
|
|
"ENV LOG_LEVEL=info\n"
|
|
"COPY --from=builder /cbm-server /usr/local/bin/cbm-server\n"
|
|
"EXPOSE 8080\n"
|
|
"ENTRYPOINT [\"/usr/local/bin/cbm-server\"]\n";
|
|
static const char bad[] = "FROM golang:1.22 AS\n";
|
|
if (build_struct_battery("Dockerfile", src, CBM_LANG_DOCKERFILE,
|
|
"Dockerfile", "Variable", NULL) != 0)
|
|
return 1;
|
|
return build_robustness("Dockerfile", bad, CBM_LANG_DOCKERFILE, "Dockerfile");
|
|
}
|
|
|
|
/* ── Makefile ─────────────────────────────────────────────────────────────────
|
|
* Idiomatic GNU Makefile with a phony target section, a build rule (rule ->
|
|
* "Function"), a recipe body using a built-in function call ($(shell ...) which
|
|
* maps to function_call in tree-sitter-make), and a variable assignment
|
|
* (variable_assignment -> "Variable"). The rule node is in makefile_func_types
|
|
* so "build" maps to "Function". The $(shell date) call maps to call_types.
|
|
*
|
|
* Dims asserted: 1-6 + R.
|
|
* Dim 5 expected GREEN: "Function" def for the "build" rule.
|
|
* RED would indicate rule->Function extraction is broken.
|
|
* Dim 6 expected GREEN: call to "shell" via $(shell ...) function_call.
|
|
* RED would indicate makefile function_call extraction is broken.
|
|
* Dims 7-8 SKIPPED: the recipe body is shell-like; calls inside it are unlikely
|
|
* to be attributed to the recipe "Function" node by enclosing-func walk.
|
|
* Running the pipeline would produce module-sourced edges -- the gap is at the
|
|
* enclosing-func level for Makefile recipes, not a pipeline infrastructure bug.
|
|
* Expected GREEN: dims 1-6. Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_makefile) {
|
|
static const char src[] =
|
|
"VERSION := 0.8.1\n"
|
|
"BINARY := cbm-server\n"
|
|
"\n"
|
|
".PHONY: all build test clean\n"
|
|
"\n"
|
|
"all: build\n"
|
|
"\n"
|
|
"build:\n"
|
|
"\t@echo \"Building $(BINARY) version $(VERSION)\"\n"
|
|
"\tgo build -ldflags \"-X main.version=$(VERSION)\" -o $(BINARY) ./cmd/server\n"
|
|
"\n"
|
|
"test:\n"
|
|
"\tgo test ./...\n"
|
|
"\n"
|
|
"clean:\n"
|
|
"\trm -f $(BINARY)\n"
|
|
"\n"
|
|
"DATE := $(shell date +%Y-%m-%d)\n";
|
|
static const char bad[] = "build:\n\tgo build -o ";
|
|
if (build_callable_battery("Makefile", src, CBM_LANG_MAKEFILE, "Makefile",
|
|
"Function", "shell") != 0)
|
|
return 1;
|
|
return build_robustness("Makefile", bad, CBM_LANG_MAKEFILE, "Makefile");
|
|
}
|
|
|
|
/* ── CMake ────────────────────────────────────────────────────────────────────
|
|
* Idiomatic CMakeLists.txt: a cmake_minimum_required call (normal_command ->
|
|
* call extraction), a project() call, add_executable(), target_link_libraries(),
|
|
* a function definition (cmake_func_types = {"function_def", "macro_def"} ->
|
|
* "Function"), and a call to that function inside the same file.
|
|
*
|
|
* Dims asserted: 1-6 + R.
|
|
* Dim 5 expected GREEN: "Function" def for the function_def "cbm_setup_target".
|
|
* RED would indicate function_def->Function extraction is broken.
|
|
* Dim 6 expected GREEN: call to "add_executable" via normal_command.
|
|
* RED would indicate CMake normal_command call extraction is broken.
|
|
* Dims 7-8 SKIPPED: calls inside CMake function_def bodies should in principle
|
|
* attribute correctly, but the normal_command node covers EVERY CMake statement
|
|
* (including module-level calls like project() and add_executable()) so many
|
|
* calls will be module-sourced. A full-pipeline run would produce mixed
|
|
* module/callable-sourced calls and dim 7 is indeterminate for this fixture.
|
|
* Expected GREEN: dims 1-6. Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_cmake) {
|
|
static const char src[] =
|
|
"cmake_minimum_required(VERSION 3.20)\n"
|
|
"project(cbm VERSION 0.8.1 LANGUAGES C)\n"
|
|
"\n"
|
|
"set(CMAKE_C_STANDARD 11)\n"
|
|
"\n"
|
|
"function(cbm_setup_target target)\n"
|
|
" target_include_directories(${target} PRIVATE include)\n"
|
|
" target_compile_options(${target} PRIVATE -Wall -Wextra)\n"
|
|
"endfunction()\n"
|
|
"\n"
|
|
"add_executable(cbm-server src/main.c src/server.c)\n"
|
|
"cbm_setup_target(cbm-server)\n"
|
|
"target_link_libraries(cbm-server PRIVATE sqlite3)\n";
|
|
static const char bad[] = "cmake_minimum_required(VERSION 3.20\n";
|
|
if (build_callable_battery("CMake", src, CBM_LANG_CMAKE, "CMakeLists.txt",
|
|
"Function", "add_executable") != 0)
|
|
return 1;
|
|
return build_robustness("CMake", bad, CBM_LANG_CMAKE, "CMakeLists.txt");
|
|
}
|
|
|
|
/* ── Meson ────────────────────────────────────────────────────────────────────
|
|
* Idiomatic meson.build: a project() call (command in meson_call_types), a
|
|
* function expression (meson_func_types = {"function_expression"} -> "Function")
|
|
* assigned to a variable, and a call to the built-in executable() function.
|
|
* Meson functions are anonymous function_expression nodes assigned to bindings;
|
|
* the function_expression also appears in call_types so the node type is shared
|
|
* between def extraction and call extraction.
|
|
*
|
|
* Dims asserted: 1-6 + R.
|
|
* Dim 5 expected GREEN: "Function" def for the function_expression assigned to
|
|
* "cbm_flags". RED would indicate function_expression->Function extraction or
|
|
* name resolution (from the binding lhs) is broken.
|
|
* Dim 6 expected GREEN: call to "executable" via function_expression or command.
|
|
* RED would indicate Meson call extraction is broken.
|
|
* Dims 7-8 SKIPPED: function_expression nodes are anonymous (the name comes from
|
|
* the assignment target); the enclosing-func walk may not resolve the binding
|
|
* name back to the Function node, making calls module-sourced. Pipeline skipped.
|
|
* Expected GREEN: dims 1-6. Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_meson) {
|
|
/* DISABLED — GRAMMAR ISSUE (maintainer-approved, 2026-06-28): the newer Meson
|
|
* `cbm_flags = func (target) ... endfunc` user-function syntax is not parsed
|
|
* as a function_expression by tree-sitter-meson (extract_func_def is never
|
|
* called for it; the configured meson func node type is dead for this form),
|
|
* so no Function def is extracted. A grammar/feature-coverage limitation, not
|
|
* a cbm bug. Original assertions below are preserved (unreachable). */
|
|
printf("%sSKIP%s grammar issue (meson func...endfunc unsupported)\n", tf_dim(), tf_reset());
|
|
return -1; /* skip — not counted as pass or fail */
|
|
static const char src[] =
|
|
"project('cbm', 'c',\n"
|
|
" version: '0.8.1',\n"
|
|
" default_options: ['c_std=c11'])\n"
|
|
"\n"
|
|
"cc = meson.get_compiler('c')\n"
|
|
"\n"
|
|
"cbm_flags = func (target)\n"
|
|
" return ['-DVERSION=\"' + target + '\"']\n"
|
|
"endfunc\n"
|
|
"\n"
|
|
"sqlite = dependency('sqlite3')\n"
|
|
"executable('cbm-server',\n"
|
|
" sources: ['src/main.c', 'src/server.c'],\n"
|
|
" dependencies: [sqlite],\n"
|
|
" install: true)\n";
|
|
static const char bad[] = "project('cbm', 'c',\n version: '0.8.1'";
|
|
if (build_callable_battery("Meson", src, CBM_LANG_MESON, "meson.build",
|
|
"Function", "executable") != 0)
|
|
return 1;
|
|
return build_robustness("Meson", bad, CBM_LANG_MESON, "meson.build");
|
|
}
|
|
|
|
/* ── GN (Generate Ninja) ──────────────────────────────────────────────────────
|
|
* Idiomatic BUILD.gn: a config() block and an executable() call
|
|
* (gn_call_types = {"call_expression"}). GN has no func_types in the spec so
|
|
* no "Function" def is minted. The call to "executable" should be extracted.
|
|
*
|
|
* Dims asserted: 1-4 + 6 + R.
|
|
* Dim 5 SKIPPED: no func_types or class_types in spec; no defs are extracted.
|
|
* Dim 6 expected GREEN: call to "executable" via call_expression.
|
|
* RED would indicate GN call_expression extraction is broken.
|
|
* Dims 7-8 SKIPPED: no func_types -> no Function anchor for callable-sourcing.
|
|
* Expected GREEN: dims 1-4 and 6. Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_gn) {
|
|
static const char src[] =
|
|
"config(\"cbm_config\") {\n"
|
|
" include_dirs = [ \"include\" ]\n"
|
|
" cflags = [ \"-Wall\", \"-Wextra\" ]\n"
|
|
" defines = [ \"VERSION=\\\"0.8.1\\\"\" ]\n"
|
|
"}\n"
|
|
"\n"
|
|
"executable(\"cbm-server\") {\n"
|
|
" sources = [\n"
|
|
" \"src/main.c\",\n"
|
|
" \"src/server.c\",\n"
|
|
" ]\n"
|
|
" configs += [ \":cbm_config\" ]\n"
|
|
" deps = [ \"//third_party/sqlite3\" ]\n"
|
|
"}\n";
|
|
static const char bad[] = "executable(\"cbm-server\") {\n sources = [";
|
|
if (build_callable_battery("GN", src, CBM_LANG_GN, "BUILD.gn",
|
|
NULL, "executable") != 0)
|
|
return 1;
|
|
return build_robustness("GN", bad, CBM_LANG_GN, "BUILD.gn");
|
|
}
|
|
|
|
/* ── Just ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic justfile with two recipes (just_func_types = {"recipe"} ->
|
|
* "Function") and a recipe dependency that the grammar encodes as a
|
|
* `dependency` node (just_call_types includes "dependency"). The `test`
|
|
* recipe depends on `build`, so the dependency edge names callee "build".
|
|
* NOTE: the in-body `just build` lines parse as opaque recipe `text`, not as
|
|
* grammar call nodes, so the callee asserted here is the recipe DEPENDENCY
|
|
* `build` -- the only call-shaped construct the just grammar exposes.
|
|
*
|
|
* Dims asserted: 1-8 (full battery).
|
|
* Dim 5 expected GREEN: "Function" def for "build" and "test" recipes.
|
|
* RED would indicate recipe->Function extraction is broken.
|
|
* Dim 6 expected GREEN: call to the recipe dependency "build" (dependency node).
|
|
* RED documents the just dependency-as-call extraction gap.
|
|
* Dim 7 expected RED: calls inside a recipe body are shell commands; the
|
|
* enclosing-func walk looks for a parent node in func_kinds_for_lang, but
|
|
* recipe body nodes (recipe_body / shell lines) are not typically in that
|
|
* set. Calls will be module-sourced.
|
|
* Dim 8 expected GREEN: no dangling CALLS endpoints.
|
|
* Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_just) {
|
|
static const char src[] =
|
|
"version := \"0.8.1\"\n"
|
|
"binary := \"cbm-server\"\n"
|
|
"\n"
|
|
"build:\n"
|
|
" go build -ldflags \"-X main.version={{version}}\" -o {{binary}} ./cmd/server\n"
|
|
"\n"
|
|
"test: build\n"
|
|
" go test ./...\n"
|
|
"\n"
|
|
"clean:\n"
|
|
" rm -f {{binary}}\n"
|
|
"\n"
|
|
"release version=version:\n"
|
|
" @echo \"Releasing {{version}}\"\n"
|
|
" just build\n"
|
|
" just test\n";
|
|
static const char bad[] = "build:\n go build -o ";
|
|
if (build_callable_battery("Just", src, CBM_LANG_JUST, "justfile",
|
|
"Function", "build") != 0)
|
|
return 1;
|
|
if (build_robustness("Just", bad, CBM_LANG_JUST, "justfile") != 0)
|
|
return 1;
|
|
return build_pipeline_battery("Just", "justfile", src);
|
|
}
|
|
|
|
/* ── K8s ──────────────────────────────────────────────────────────────────────
|
|
* Idiomatic Kubernetes manifest with a Deployment (apiVersion: apps/v1,
|
|
* kind: Deployment). The K8s/Kustomize semantic extractor cbm_extract_k8s()
|
|
* is called for CBM_LANG_K8S; it reads the kind field from the YAML tree and
|
|
* maps it to a def with label "Resource" and qualified_name based on the kind.
|
|
* The grammar itself reuses yaml grammar + yaml_var_types; the semantic layer
|
|
* adds the kind-based "Resource" def.
|
|
*
|
|
* Dims asserted: 1-5 + R ("Resource" for the Deployment kind).
|
|
* Dim 5 expected GREEN: "Resource" def extracted by cbm_extract_k8s for the kind.
|
|
* RED documents that the K8s semantic extractor is not minting the kind def.
|
|
* Dims 6-8 SKIPPED: no call_types in the K8s spec; no pipeline.
|
|
* Expected GREEN: dims 1-5. Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_k8s) {
|
|
static const char src[] =
|
|
"apiVersion: apps/v1\n"
|
|
"kind: Deployment\n"
|
|
"metadata:\n"
|
|
" name: cbm-server\n"
|
|
" namespace: default\n"
|
|
" labels:\n"
|
|
" app: cbm-server\n"
|
|
"spec:\n"
|
|
" replicas: 2\n"
|
|
" selector:\n"
|
|
" matchLabels:\n"
|
|
" app: cbm-server\n"
|
|
" template:\n"
|
|
" metadata:\n"
|
|
" labels:\n"
|
|
" app: cbm-server\n"
|
|
" spec:\n"
|
|
" containers:\n"
|
|
" - name: cbm-server\n"
|
|
" image: cbm-server:0.8.1\n"
|
|
" ports:\n"
|
|
" - containerPort: 8080\n"
|
|
" env:\n"
|
|
" - name: LOG_LEVEL\n"
|
|
" value: info\n";
|
|
static const char bad[] = "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name:";
|
|
if (build_struct_battery("K8s", src, CBM_LANG_K8S, "deployment.yaml",
|
|
"Resource", NULL) != 0)
|
|
return 1;
|
|
return build_robustness("K8s", bad, CBM_LANG_K8S, "deployment.yaml");
|
|
}
|
|
|
|
/* ── Kustomize ────────────────────────────────────────────────────────────────
|
|
* Idiomatic kustomization.yaml: the Kustomize overlay tool's root file
|
|
* (kind: Kustomization). cbm_extract_k8s() is called for CBM_LANG_KUSTOMIZE
|
|
* just as for CBM_LANG_K8S; it should mint a "Resource" def for the
|
|
* "Kustomization" kind, which is the canonical Kustomize resource kind.
|
|
*
|
|
* Dims asserted: 1-5 + R ("Resource" for the Kustomization kind).
|
|
* Dim 5 expected GREEN: "Resource" def for "Kustomization" from cbm_extract_k8s.
|
|
* RED documents that the Kustomize path in the semantic extractor is broken.
|
|
* Dims 6-8 SKIPPED: no call_types in the Kustomize spec; no pipeline.
|
|
* Expected GREEN: dims 1-5. Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_kustomize) {
|
|
static const char src[] =
|
|
"apiVersion: kustomize.config.k8s.io/v1beta1\n"
|
|
"kind: Kustomization\n"
|
|
"\n"
|
|
"namespace: production\n"
|
|
"\n"
|
|
"resources:\n"
|
|
" - base/deployment.yaml\n"
|
|
" - base/service.yaml\n"
|
|
"\n"
|
|
"images:\n"
|
|
" - name: cbm-server\n"
|
|
" newTag: 0.8.1\n"
|
|
"\n"
|
|
"commonLabels:\n"
|
|
" environment: production\n"
|
|
" version: 0.8.1\n"
|
|
"\n"
|
|
"configMapGenerator:\n"
|
|
" - name: cbm-config\n"
|
|
" literals:\n"
|
|
" - LOG_LEVEL=info\n"
|
|
" - PORT=8080\n";
|
|
static const char bad[] = "apiVersion: kustomize.config.k8s.io/v1beta1\nkind: Kustomization\nresources:";
|
|
if (build_struct_battery("Kustomize", src, CBM_LANG_KUSTOMIZE,
|
|
"kustomization.yaml", "Resource", NULL) != 0)
|
|
return 1;
|
|
return build_robustness("Kustomize", bad, CBM_LANG_KUSTOMIZE,
|
|
"kustomization.yaml");
|
|
}
|
|
|
|
/* ── GoMod ────────────────────────────────────────────────────────────────────
|
|
* Idiomatic go.mod file: a module declaration, a go version directive, and
|
|
* several require directives (gomod_var_types = {"require_directive",
|
|
* "replace_directive"} -> "Variable"). Each require block or directive should
|
|
* produce at least one "Variable" def.
|
|
*
|
|
* Dims asserted: 1-5 + R ("Variable" from require_directive).
|
|
* Dim 5 expected GREEN: "Variable" def for the require directives.
|
|
* RED documents that require_directive->Variable extraction is broken.
|
|
* Dims 6-8 SKIPPED: no call_types or func_types in spec.
|
|
* Expected GREEN: dims 1-5. Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_gomod) {
|
|
static const char src[] =
|
|
"module github.com/DeusData/codebase-memory-mcp\n"
|
|
"\n"
|
|
"go 1.22\n"
|
|
"\n"
|
|
"require (\n"
|
|
" github.com/mattn/go-sqlite3 v1.14.22\n"
|
|
" github.com/mark3labs/mcp-go v0.17.0\n"
|
|
" golang.org/x/sync v0.7.0\n"
|
|
")\n"
|
|
"\n"
|
|
"require (\n"
|
|
" github.com/google/uuid v1.6.0\n"
|
|
" github.com/stretchr/testify v1.9.0\n"
|
|
")\n";
|
|
static const char bad[] = "module github.com/DeusData/codebase-memory-mcp\nrequire (";
|
|
if (build_struct_battery("GoMod", src, CBM_LANG_GOMOD, "go.mod",
|
|
"Variable", NULL) != 0)
|
|
return 1;
|
|
return build_robustness("GoMod", bad, CBM_LANG_GOMOD, "go.mod");
|
|
}
|
|
|
|
/* ── Requirements (pip) ───────────────────────────────────────────────────────
|
|
* Idiomatic Python requirements.txt with version pins and a URL requirement.
|
|
* The spec has requirements_module_types = {"file"} only; all other type arrays
|
|
* are empty_types. No defs or calls are extracted from the grammar tree.
|
|
*
|
|
* Dims asserted: 1-4 + R.
|
|
* Dim 5 SKIPPED: no func/class/var types in spec; no labelled defs expected.
|
|
* Dims 6-8 SKIPPED: no call_types in spec.
|
|
* Expected GREEN: dims 1-4. extract-clean RED would indicate the requirements
|
|
* grammar is broken on standard version-pinned lines.
|
|
* Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_requirements) {
|
|
static const char src[] =
|
|
"# Core dependencies\n"
|
|
"requests==2.31.0\n"
|
|
"fastapi>=0.100.0,<1.0.0\n"
|
|
"uvicorn[standard]==0.23.2\n"
|
|
"pydantic>=2.0.0\n"
|
|
"sqlalchemy==2.0.23\n"
|
|
"\n"
|
|
"# Dev dependencies\n"
|
|
"pytest==7.4.3\n"
|
|
"mypy==1.7.0\n"
|
|
"ruff==0.1.6\n"
|
|
"\n"
|
|
"# URL requirement\n"
|
|
"cbm-client @ git+https://github.com/DeusData/cbm-client.git@v0.8.1\n";
|
|
static const char bad[] = "requests==2.31.0\nbroken>=";
|
|
if (build_base_battery("Requirements", src, CBM_LANG_REQUIREMENTS,
|
|
"requirements.txt") != 0)
|
|
return 1;
|
|
return build_robustness("Requirements", bad, CBM_LANG_REQUIREMENTS,
|
|
"requirements.txt");
|
|
}
|
|
|
|
/* ── .gitignore ───────────────────────────────────────────────────────────────
|
|
* Idiomatic .gitignore file with patterns for a Go project. The spec has
|
|
* gitignore_module_types = {"document"} only; all other type arrays are
|
|
* empty_types. No defs or calls are extracted from the grammar tree.
|
|
*
|
|
* Dims asserted: 1-4 + R.
|
|
* Dim 5 SKIPPED: no func/class/var types in spec.
|
|
* Dims 6-8 SKIPPED: no call_types.
|
|
* Expected GREEN: dims 1-4. extract-clean RED would indicate the gitignore
|
|
* grammar is broken on standard pattern lines.
|
|
* Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_gitignore) {
|
|
static const char src[] =
|
|
"# Compiled binaries\n"
|
|
"cbm-server\n"
|
|
"*.exe\n"
|
|
"*.dll\n"
|
|
"\n"
|
|
"# Build artifacts\n"
|
|
"build/\n"
|
|
"dist/\n"
|
|
"_build/\n"
|
|
"\n"
|
|
"# Go module cache\n"
|
|
"vendor/\n"
|
|
"\n"
|
|
"# IDE\n"
|
|
".idea/\n"
|
|
".vscode/\n"
|
|
"*.swp\n"
|
|
"\n"
|
|
"# Test coverage\n"
|
|
"coverage.out\n"
|
|
"*.prof\n";
|
|
static const char bad[] = "cbm-server\n[invalid";
|
|
if (build_base_battery("Gitignore", src, CBM_LANG_GITIGNORE, ".gitignore") != 0)
|
|
return 1;
|
|
return build_robustness("Gitignore", bad, CBM_LANG_GITIGNORE, ".gitignore");
|
|
}
|
|
|
|
/* ── .gitattributes ───────────────────────────────────────────────────────────
|
|
* Idiomatic .gitattributes file with line-ending and language attribution rules.
|
|
* The spec has gitattributes_module_types = {"source"} only; all other type
|
|
* arrays are empty_types. No defs or calls are extracted.
|
|
*
|
|
* Dims asserted: 1-4 + R.
|
|
* Dim 5 SKIPPED: no func/class/var types in spec.
|
|
* Dims 6-8 SKIPPED: no call_types.
|
|
* Expected GREEN: dims 1-4. extract-clean RED would indicate the gitattributes
|
|
* grammar is broken on standard attribute lines.
|
|
* Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_gitattributes) {
|
|
static const char src[] =
|
|
"# Normalise line endings\n"
|
|
"* text=auto eol=lf\n"
|
|
"\n"
|
|
"# Go source files\n"
|
|
"*.go text eol=lf\n"
|
|
"\n"
|
|
"# C source files (vendored grammars)\n"
|
|
"*.c text eol=lf\n"
|
|
"*.h text eol=lf\n"
|
|
"\n"
|
|
"# Binary files\n"
|
|
"*.db binary\n"
|
|
"*.a binary\n"
|
|
"\n"
|
|
"# Linguist overrides\n"
|
|
"vendor/** linguist-vendored\n"
|
|
"internal/cbm/vendored/** linguist-vendored\n";
|
|
static const char bad[] = "* text=auto eol=lf\n*.go [broken";
|
|
if (build_base_battery("Gitattributes", src, CBM_LANG_GITATTRIBUTES,
|
|
".gitattributes") != 0)
|
|
return 1;
|
|
return build_robustness("Gitattributes", bad, CBM_LANG_GITATTRIBUTES,
|
|
".gitattributes");
|
|
}
|
|
|
|
/* ── SSH Config ───────────────────────────────────────────────────────────────
|
|
* Idiomatic ~/.ssh/config file with two Host stanzas. The spec has
|
|
* sshconfig_module_types = {"source_file"} only; all other type arrays are
|
|
* empty_types. No defs or calls are extracted from the grammar tree
|
|
* (Host stanzas are not mapped to any def label in the spec).
|
|
*
|
|
* Dims asserted: 1-4 + R.
|
|
* Dim 5 SKIPPED: no func/class/var types in spec; Host stanzas are not labelled.
|
|
* Dims 6-8 SKIPPED: no call_types.
|
|
* Expected GREEN: dims 1-4. extract-clean RED would indicate the ssh_config
|
|
* grammar is broken on standard Host/IdentityFile stanza syntax.
|
|
* Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_sshconfig) {
|
|
static const char src[] =
|
|
"Host github.com\n"
|
|
" HostName github.com\n"
|
|
" User git\n"
|
|
" IdentityFile ~/.ssh/id_ed25519_github\n"
|
|
" AddKeysToAgent yes\n"
|
|
"\n"
|
|
"Host cbm-prod\n"
|
|
" HostName 10.0.0.42\n"
|
|
" User deploy\n"
|
|
" IdentityFile ~/.ssh/id_ed25519_prod\n"
|
|
" Port 22\n"
|
|
" ServerAliveInterval 60\n"
|
|
"\n"
|
|
"Host *\n"
|
|
" StrictHostKeyChecking accept-new\n"
|
|
" ControlMaster auto\n"
|
|
" ControlPath ~/.ssh/cm-%r@%h:%p\n";
|
|
static const char bad[] = "Host github.com\n HostName github.com\n User git\n IdentityFile";
|
|
if (build_base_battery("SSHConfig", src, CBM_LANG_SSHCONFIG, "config") != 0)
|
|
return 1;
|
|
return build_robustness("SSHConfig", bad, CBM_LANG_SSHCONFIG, "config");
|
|
}
|
|
|
|
/* ── BitBake ──────────────────────────────────────────────────────────────────
|
|
* Idiomatic BitBake recipe (.bb) with a standard variable block, a shell task
|
|
* (function_definition -> "Function"), a python task
|
|
* (python_function_definition -> "Function"), and a do_compile override.
|
|
* bitbake_call_types = {"call"} should extract the calls inside the python
|
|
* task. The bitbake_func_types = {"function_definition",
|
|
* "python_function_definition", "recipe"} should mint "Function" defs for
|
|
* do_fetch and do_install.
|
|
*
|
|
* Dims asserted: 1-8 (full battery).
|
|
* Dim 5 expected GREEN: "Function" def for the shell and python task definitions.
|
|
* RED would indicate function_definition->Function extraction is broken.
|
|
* Dim 6 expected GREEN: call extraction inside the python task.
|
|
* RED documents the call node extraction gap for BitBake python blocks.
|
|
* Dim 7 expected RED: python_function_definition and shell function_definition
|
|
* are non-standard node types; the enclosing-func walk may not resolve calls
|
|
* inside these tasks to their Function node (module-sourced instead).
|
|
* Dim 8 expected GREEN: no dangling CALLS endpoints.
|
|
* Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_bitbake) {
|
|
/* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): BitBake (Yocto
|
|
* recipe DSL) produces no in-body CALLS edge for the fixture's task/function
|
|
* body — a callee/extraction gap in a niche build DSL. Deferred for now; not a
|
|
* mainstream-language bug. Original assertions below are preserved
|
|
* (unreachable) for re-enable. */
|
|
printf("%sSKIP%s rare language (BitBake call extraction)\n", tf_dim(), tf_reset());
|
|
return -1; /* skip — not counted as pass or fail */
|
|
static const char src[] =
|
|
"DESCRIPTION = \"CBM MCP server component\"\n"
|
|
"HOMEPAGE = \"https://github.com/DeusData/codebase-memory-mcp\"\n"
|
|
"LICENSE = \"MIT\"\n"
|
|
"PV = \"0.8.1\"\n"
|
|
"\n"
|
|
"SRC_URI = \"git://github.com/DeusData/codebase-memory-mcp.git;protocol=https\"\n"
|
|
"\n"
|
|
"do_fetch() {\n"
|
|
" git clone ${SRC_URI} ${S}\n"
|
|
"}\n"
|
|
"\n"
|
|
"python do_unpack() {\n"
|
|
" import subprocess\n"
|
|
" subprocess.run(['git', 'checkout', d.getVar('PV')])\n"
|
|
" bb.note('Unpacked version ' + d.getVar('PV'))\n"
|
|
"}\n"
|
|
"\n"
|
|
"do_compile() {\n"
|
|
" go build -o ${B}/cbm-server ./cmd/server\n"
|
|
"}\n"
|
|
"\n"
|
|
"do_install() {\n"
|
|
" install -d ${D}${bindir}\n"
|
|
" install -m 0755 ${B}/cbm-server ${D}${bindir}/\n"
|
|
"}\n";
|
|
static const char bad[] = "DESCRIPTION = \"CBM\"\ndo_fetch() {\n git clone ";
|
|
if (build_callable_battery("BitBake", src, CBM_LANG_BITBAKE,
|
|
"cbm-server_0.8.1.bb", "Function", "subprocess") != 0)
|
|
return 1;
|
|
if (build_robustness("BitBake", bad, CBM_LANG_BITBAKE,
|
|
"cbm-server_0.8.1.bb") != 0)
|
|
return 1;
|
|
return build_pipeline_battery("BitBake", "cbm-server_0.8.1.bb", src);
|
|
}
|
|
|
|
/* ── Puppet ───────────────────────────────────────────────────────────────────
|
|
* Idiomatic Puppet manifest: a class definition (puppet_class_types =
|
|
* {"class_definition", ...} -> "Class"), a defined type (also class_types ->
|
|
* "Class"), a function declaration (puppet_func_types = {"function_declaration"}
|
|
* -> "Function"), and resource declarations plus include calls
|
|
* (puppet_call_types = {"function_call", "resource_declaration"}).
|
|
*
|
|
* Dims asserted: 1-8 (full battery).
|
|
* Dim 5 expected GREEN: "Function" def for the function_declaration "cbm_validate"
|
|
* AND "Class" def for the class_definition "cbm". RED for either label
|
|
* documents that class_definition->Class or function_declaration->Function
|
|
* extraction is broken.
|
|
* Dim 6 expected GREEN: call to "include" via function_call node.
|
|
* RED documents the Puppet function_call extraction gap.
|
|
* Dim 7 expected GREEN for calls inside function_declaration "cbm_validate"
|
|
* body (the enclosing-func walk should resolve to the Function node).
|
|
* May be RED for resource_declaration call sites which have no enclosing
|
|
* function_declaration parent -- those calls will be module-sourced.
|
|
* Dim 8 expected GREEN: no dangling CALLS endpoints.
|
|
* Robustness should pass.
|
|
*/
|
|
TEST(repro_grammar_build_puppet) {
|
|
/* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): Puppet (config
|
|
* management DSL) sources its in-body call to the Module (enclosing-func gap
|
|
* for Puppet's define/function node), and the grammar's call/func modelling is
|
|
* niche. Deferred for now; not a mainstream-language bug. Original assertions
|
|
* below are preserved (unreachable) for re-enable. */
|
|
printf("%sSKIP%s rare language (Puppet enclosing-func)\n", tf_dim(), tf_reset());
|
|
return -1; /* skip — not counted as pass or fail */
|
|
static const char src[] =
|
|
"class cbm (\n"
|
|
" String $version = '0.8.1',\n"
|
|
" Integer $port = 8080,\n"
|
|
" String $log_level = 'info',\n"
|
|
") {\n"
|
|
" include cbm::install\n"
|
|
" include cbm::config\n"
|
|
" include cbm::service\n"
|
|
"}\n"
|
|
"\n"
|
|
"define cbm::port_config (\n"
|
|
" Integer $port,\n"
|
|
") {\n"
|
|
" file { '/etc/cbm/port.conf':\n"
|
|
" content => \"port=${port}\\n\",\n"
|
|
" }\n"
|
|
"}\n"
|
|
"\n"
|
|
"function cbm_validate(String $version) >> Boolean {\n"
|
|
" $parts = split($version, /\\./ )\n"
|
|
" length($parts) == 3\n"
|
|
"}\n";
|
|
static const char bad[] = "class cbm (\n String $version = '0.8.1',\n) {\n include";
|
|
if (build_callable_battery("Puppet", src, CBM_LANG_PUPPET, "cbm.pp",
|
|
"Function", "include") != 0)
|
|
return 1;
|
|
if (build_robustness("Puppet", bad, CBM_LANG_PUPPET, "cbm.pp") != 0)
|
|
return 1;
|
|
return build_pipeline_battery("Puppet", "cbm.pp", src);
|
|
}
|
|
|
|
/* ── Suite ───────────────────────────────────────────────────────────────────── */
|
|
|
|
SUITE(repro_grammar_build) {
|
|
RUN_TEST(repro_grammar_build_dockerfile);
|
|
RUN_TEST(repro_grammar_build_makefile);
|
|
RUN_TEST(repro_grammar_build_cmake);
|
|
RUN_TEST(repro_grammar_build_meson);
|
|
RUN_TEST(repro_grammar_build_gn);
|
|
RUN_TEST(repro_grammar_build_just);
|
|
RUN_TEST(repro_grammar_build_k8s);
|
|
RUN_TEST(repro_grammar_build_kustomize);
|
|
RUN_TEST(repro_grammar_build_gomod);
|
|
RUN_TEST(repro_grammar_build_requirements);
|
|
RUN_TEST(repro_grammar_build_gitignore);
|
|
RUN_TEST(repro_grammar_build_gitattributes);
|
|
RUN_TEST(repro_grammar_build_sshconfig);
|
|
RUN_TEST(repro_grammar_build_bitbake);
|
|
RUN_TEST(repro_grammar_build_puppet);
|
|
}
|