wehub-resource-sync
1006 lines
45 KiB
C
1006 lines
45 KiB
C
/*
|
|
* repro_grammar_shells.c -- Per-grammar INVARIANT battery for the
|
|
* SHELLS / SCRIPTING / MISC (asm-ish + data-ish) 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,
|
|
* read directly from internal/cbm/lang_specs.c (the func/class/field/call type
|
|
* arrays per CBM_LANG_*). The dimensions applied per language are documented in
|
|
* the per-TEST comment.
|
|
*
|
|
* Languages covered (19) and the CBM_LANG_* enum each uses (all verified present
|
|
* in internal/cbm/cbm.h):
|
|
* BASH -> CBM_LANG_BASH (callable: func + call)
|
|
* ZSH -> CBM_LANG_ZSH (callable: func + call)
|
|
* FISH -> CBM_LANG_FISH (callable: func + call)
|
|
* POWERSHELL -> CBM_LANG_POWERSHELL (callable: func + class + call)
|
|
* TCL -> CBM_LANG_TCL (callable: func + class + call)
|
|
* AWK -> CBM_LANG_AWK (callable: func + call)
|
|
* VIMSCRIPT -> CBM_LANG_VIMSCRIPT (callable: func + call)
|
|
* FENNEL -> CBM_LANG_FENNEL (callable: func + call, lisp)
|
|
* NIX -> CBM_LANG_NIX (callable: func + call)
|
|
* GDSCRIPT -> CBM_LANG_GDSCRIPT (callable: func + class + call)
|
|
* LUAU -> CBM_LANG_LUAU (callable: func + class + call)
|
|
* TEAL -> CBM_LANG_TEAL (callable: func + class + call)
|
|
* LLVM_IR -> CBM_LANG_LLVM_IR (callable: func + call)
|
|
* NASM -> CBM_LANG_NASM (callable: func(label) + call)
|
|
* JANET -> CBM_LANG_JANET (STRUCTURAL ONLY: spec has only module_types)
|
|
* SMALI -> CBM_LANG_SMALI (structural-with-defs: func/class/field, NO calls)
|
|
* DEVICETREE -> CBM_LANG_DEVICETREE (structural: call_types but NO func anchor)
|
|
* KCONFIG -> CBM_LANG_KCONFIG (structural-with-defs: class_types, NO calls)
|
|
* HYPRLANG -> CBM_LANG_HYPRLANG (pure structural: only module_types)
|
|
*
|
|
* No language in this set was skipped; every CBM_LANG_* above is defined in cbm.h.
|
|
*
|
|
* SPEC-DRIVEN CLASSIFICATION (from internal/cbm/lang_specs.c)
|
|
* ----------------------------------------------------------
|
|
* CALLABLES (func_types AND call_types both non-empty -> full battery + pipeline):
|
|
* BASH func=function_definition call=command
|
|
* ZSH func=function_definition call=command,call_expression
|
|
* FISH func=function_definition call=command
|
|
* POWERSHELL func=function_statement call=invokation_expression,command class=class_statement,...
|
|
* TCL func=procedure call=command class=namespace
|
|
* AWK func=func_def,rule call=func_call,command
|
|
* VIMSCRIPT func=function_definition,... call=call_expression,call,command
|
|
* FENNEL func=fn,lambda,hashfn call=list (lisp head symbol)
|
|
* NIX func=function_expression call=apply_expression
|
|
* GDSCRIPT func=function_definition,... call=call,attribute_call,base_call class=class_definition,...
|
|
* LUAU func=function_declaration,function_definition call=function_call class=type_definition
|
|
* TEAL func=function_statement,anon_function,... call=function_call class=record_declaration,...
|
|
* LLVM_IR func=function_header call=call,invoke var=local_var,global_var
|
|
* NASM func=label,preproc_def,preproc_multiline_macro call=call_syntax_expression class=struc_declaration
|
|
*
|
|
* STRUCTURAL-WITH-DEFS (defs but NO call_types -> dims 1-5 + R):
|
|
* SMALI func=method_definition -> "Function" class=class_definition -> "Class" field=field_definition -> "Field" (call_types EMPTY)
|
|
* KCONFIG class=config,menuconfig,choice,type_definition -> "Class" (func/call EMPTY)
|
|
*
|
|
* STRUCTURAL ONLY (no extractable defs from the spec -> dims 1-4 + R):
|
|
* JANET ONLY module_types=source; func/class/field/call all empty_types.
|
|
* DEVICETREE call_types=call_expression but func_types EMPTY -> no Function anchor,
|
|
* and no class/var defs; treat as structural (extract-clean + invariants).
|
|
* HYPRLANG ONLY module_types=source_file; everything else empty_types.
|
|
*
|
|
* BATTERY DIMENSIONS (identical semantics to repro_grammar_core.c /
|
|
* repro_grammar_config.c -- shared helpers reused via repro_invariant_lib.h):
|
|
* SINGLE-FILE (cbm_extract_file):
|
|
* 1. extract-clean : inv_extract_clean == 1 (non-NULL, has_error unset).
|
|
* 2. labels-valid : inv_count_bad_labels == 0.
|
|
* 3. fqn-wellformed : inv_count_bad_fqns == 0.
|
|
* 4. ranges-valid : inv_count_bad_ranges == 0.
|
|
* 5. defs-present : expected label extracted (callables + structural-with-defs).
|
|
* 6. calls-extracted : inv_has_call(callee) == 1 (callables only).
|
|
* FULL-PIPELINE (rh_index_files):
|
|
* 7. callable-sourcing : inv_count_calls_by_source mod == 0 AND callable >= 1
|
|
* (callables only).
|
|
* 8. no-dangling : inv_count_dangling_edges("CALLS") == 0 (with dim 7).
|
|
* ROBUSTNESS (every language):
|
|
* R. extract-on-malformed: cbm_extract_file on a truncated/broken fixture must
|
|
* RETURN non-NULL (has_error may be set). A NULL return means the extractor
|
|
* crashed/aborted on bad input -- a RED robustness bug.
|
|
*
|
|
* KNOWN GAP -> dim-7 RED PREDICTIONS (the point of this file).
|
|
* The enclosing-func walk cbm_find_enclosing_func() uses func_kinds_for_lang()
|
|
* in internal/cbm/helpers.c. In that switch ONLY CBM_LANG_BASH has a dedicated
|
|
* kind list (func_kinds_bash = {"function_definition"}); every other language in
|
|
* this set falls through to func_kinds_generic =
|
|
* {"function_declaration","function_definition","method_declaration","method_definition"}.
|
|
* So a call's enclosing Function node is found ONLY when the grammar's func node
|
|
* type is one of those generic kinds. Cross-referencing each callable's func node
|
|
* type (from lang_specs.c) against that generic set:
|
|
* MATCHES generic (dim 7 has a chance to be GREEN if calls extract + attribute):
|
|
* ZSH/FISH (function_definition), VIMSCRIPT (function_definition),
|
|
* GDSCRIPT (function_definition), LUAU (function_declaration/function_definition).
|
|
* BASH matches via func_kinds_bash.
|
|
* DOES NOT MATCH generic (enclosing-func walk returns null -> Module-sourced ->
|
|
* dim 7 RED expected):
|
|
* POWERSHELL (function_statement), TCL (procedure), AWK (func_def/rule),
|
|
* FENNEL (fn/lambda/hashfn), NIX (function_expression),
|
|
* TEAL (function_statement/anon_function/...), LLVM_IR (function_header),
|
|
* NASM (label/...).
|
|
* Dim 6 (calls-extracted) is itself uncertain for several command-style grammars
|
|
* (bash/zsh/fish/awk/tcl `command` nodes, nix apply_expression, llvm call/invoke,
|
|
* nasm call_syntax_expression): the callee-name resolver in extract_calls.c has a
|
|
* dedicated path only for PowerShell `command` and lisp `list`; the others rely on
|
|
* generic field/first-child resolution and may yield no callee_name -> dim 6 RED.
|
|
* Where dim 6 REDs, dim 7 also REDs (0 CALLS edges to attribute). These RED rows
|
|
* ARE the deliverable -- they document precisely which shells/scripting grammars
|
|
* lose call edges or mis-source them at the Module node.
|
|
*
|
|
* NOTE: these RED/GREEN labels are static-analysis PREDICTIONS from the spec +
|
|
* helpers source; the suite records the real outcome when run. Be honest: a row
|
|
* that flips from the predicted color is itself a finding.
|
|
*
|
|
* Coding rule: inline comments are line comments only (no block comments inside
|
|
* block comments).
|
|
*/
|
|
|
|
#include "test_framework.h"
|
|
#include "repro_invariant_lib.h"
|
|
#include <store/store.h>
|
|
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
/* ── Shared single-file battery: structural base (dims 1-4) ─────────────────
|
|
*
|
|
* Four core invariants on valid input, no defs/calls assertions. Used for the
|
|
* structural-only languages (JANET, DEVICETREE, HYPRLANG). Returns 0 on PASS.
|
|
*/
|
|
static int sh_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;
|
|
}
|
|
|
|
/* ── Shared single-file battery: structural with defs (dims 1-5) ────────────
|
|
*
|
|
* Adds defs-present for the structural-with-defs languages (SMALI, KCONFIG).
|
|
* Pass NULL for expect_label2/expect_label3 when fewer labels are needed.
|
|
* Returns 0 on PASS.
|
|
*/
|
|
static int sh_struct_battery(const char *lang_tag, const char *src, CBMLanguage lang,
|
|
const char *file, const char *expect_label,
|
|
const char *expect_label2, const char *expect_label3) {
|
|
const char *RED = tf_red();
|
|
const char *RST = tf_reset();
|
|
|
|
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;
|
|
|
|
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++;
|
|
}
|
|
|
|
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++;
|
|
}
|
|
|
|
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 (up to three expected labels) */
|
|
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++;
|
|
}
|
|
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++;
|
|
}
|
|
if (expect_label3 && inv_count_label(r, expect_label3) < 1) {
|
|
printf(" %sFAIL%s [%s] defs-present: no def labelled \"%s\"\n",
|
|
RED, RST, lang_tag, expect_label3);
|
|
fails++;
|
|
}
|
|
|
|
cbm_free_result(r);
|
|
return fails ? 1 : 0;
|
|
}
|
|
|
|
/* ── Shared single-file battery: callable (dims 1-6) ────────────────────────
|
|
*
|
|
* Adds defs-present (dim 5) and calls-extracted (dim 6) on top of the base
|
|
* invariants. Used for the callable shells/scripting languages. Pass NULL for
|
|
* expect_label when no def label is asserted alongside the call. Returns 0 on PASS.
|
|
*/
|
|
static int sh_callable_battery(const char *lang_tag, const char *src, CBMLanguage lang,
|
|
const char *file, const char *expect_label,
|
|
const char *expect_label2, const char *callee) {
|
|
const char *RED = tf_red();
|
|
const char *RST = tf_reset();
|
|
|
|
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;
|
|
|
|
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++;
|
|
}
|
|
|
|
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++;
|
|
}
|
|
|
|
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 */
|
|
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++;
|
|
}
|
|
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++;
|
|
}
|
|
|
|
/* 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;
|
|
}
|
|
|
|
/* ── Shared full-pipeline battery (dims 7-8) ────────────────────────────────
|
|
*
|
|
* Indexes the single-file fixture through the production pipeline and asserts
|
|
* callable-sourcing (no Module-sourced in-body CALLS, and >= 1 callable-sourced
|
|
* so a fixture with zero CALLS edges cannot vacuously pass) plus no dangling
|
|
* CALLS endpoints. Used for the callable languages. Dim 7 is RED for the
|
|
* languages whose func node type is not in func_kinds_generic (see file header).
|
|
* Returns 0 on PASS.
|
|
*/
|
|
static int sh_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) -- enclosing-func gap (func_kinds_for_lang "
|
|
"lacks this grammar's func node type)\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. A NULL return
|
|
* means the extractor crashed or aborted on bad input -- a RED robustness bug.
|
|
* Returns 0 on PASS.
|
|
*/
|
|
static int sh_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;
|
|
}
|
|
|
|
/* ── BASH ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two function definitions, the callee invoked strictly inside the
|
|
* caller body. spec: func=function_definition, call=command. BASH is the only
|
|
* shell with a dedicated func_kinds_bash list, so the enclosing-func walk can
|
|
* match the function_definition node.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function". Dim 6 callee = "compute_inner".
|
|
* Dim 7 has a chance to be GREEN (func_kinds_bash matches function_definition) IF
|
|
* the `command` callee resolves and the CALLS edge is produced; if command-node
|
|
* callee resolution yields no name, dims 6+7 RED.
|
|
*/
|
|
TEST(repro_grammar_shells_bash) {
|
|
static const char src[] =
|
|
"#!/usr/bin/env bash\n"
|
|
"\n"
|
|
"compute_inner() {\n"
|
|
" echo $(( $1 + 1 ))\n"
|
|
"}\n"
|
|
"\n"
|
|
"compute_outer() {\n"
|
|
" compute_inner \"$1\"\n"
|
|
"}\n";
|
|
static const char bad[] = "compute_outer() {\n compute_inner \"$1\"";
|
|
if (sh_callable_battery("BASH", src, CBM_LANG_BASH, "run.sh",
|
|
"Function", NULL, "compute_inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("BASH", bad, CBM_LANG_BASH, "run.sh") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("BASH", "run.sh", src);
|
|
}
|
|
|
|
/* ── ZSH ──────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two zsh functions, callee inside caller body. spec:
|
|
* func=function_definition, call=command,call_expression. function_definition is
|
|
* in func_kinds_generic, so the enclosing-func walk can match.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function". Dim 6 callee = "inner_fn".
|
|
* Dim 7 may be GREEN (function_definition matches generic) IF command callee
|
|
* resolves; else 6+7 RED.
|
|
*/
|
|
TEST(repro_grammar_shells_zsh) {
|
|
static const char src[] =
|
|
"inner_fn() {\n"
|
|
" print -- $(( $1 * 2 ))\n"
|
|
"}\n"
|
|
"\n"
|
|
"outer_fn() {\n"
|
|
" inner_fn \"$1\"\n"
|
|
"}\n";
|
|
static const char bad[] = "outer_fn() {\n inner_fn \"$1\"";
|
|
if (sh_callable_battery("ZSH", src, CBM_LANG_ZSH, "run.zsh",
|
|
"Function", NULL, "inner_fn") != 0)
|
|
return 1;
|
|
if (sh_robustness("ZSH", bad, CBM_LANG_ZSH, "run.zsh") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("ZSH", "run.zsh", src);
|
|
}
|
|
|
|
/* ── FISH ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two `function ... end` definitions, callee inside caller body.
|
|
* spec: func=function_definition, call=command. function_definition matches
|
|
* func_kinds_generic.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function". Dim 6 callee = "inner_fn".
|
|
* Dim 7 may be GREEN IF command callee resolves; else 6+7 RED.
|
|
*/
|
|
TEST(repro_grammar_shells_fish) {
|
|
static const char src[] =
|
|
"function inner_fn\n"
|
|
" math $argv[1] x 2\n"
|
|
"end\n"
|
|
"\n"
|
|
"function outer_fn\n"
|
|
" inner_fn $argv[1]\n"
|
|
"end\n";
|
|
static const char bad[] = "function outer_fn\n inner_fn $argv[1]";
|
|
if (sh_callable_battery("FISH", src, CBM_LANG_FISH, "run.fish",
|
|
"Function", NULL, "inner_fn") != 0)
|
|
return 1;
|
|
if (sh_robustness("FISH", bad, CBM_LANG_FISH, "run.fish") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("FISH", "run.fish", src);
|
|
}
|
|
|
|
/* ── POWERSHELL ───────────────────────────────────────────────────────────────
|
|
* Idiomatic: two `function` statements, callee invoked inside the caller body.
|
|
* spec: func=function_statement, call=invokation_expression,command,
|
|
* class=class_statement,enum_statement,type_spec. PowerShell has a dedicated
|
|
* callee resolver (extract_powershell_callee: command_name child).
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function". Dim 6 callee = "Get-Inner".
|
|
* Dim 7 expected RED: func node type "function_statement" is NOT in
|
|
* func_kinds_generic -> enclosing-func walk returns null -> Module-sourced.
|
|
*/
|
|
TEST(repro_grammar_shells_powershell) {
|
|
static const char src[] =
|
|
"function Get-Inner {\n"
|
|
" param([int]$x)\n"
|
|
" return $x + 1\n"
|
|
"}\n"
|
|
"\n"
|
|
"function Get-Outer {\n"
|
|
" param([int]$x)\n"
|
|
" return Get-Inner -x $x\n"
|
|
"}\n";
|
|
static const char bad[] = "function Get-Outer {\n param([int]$x)\n return Get-Inner";
|
|
if (sh_callable_battery("PowerShell", src, CBM_LANG_POWERSHELL, "run.ps1",
|
|
"Function", NULL, "Get-Inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("PowerShell", bad, CBM_LANG_POWERSHELL, "run.ps1") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("PowerShell", "run.ps1", src);
|
|
}
|
|
|
|
/* ── TCL ──────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two `proc` definitions, callee invoked inside caller body.
|
|
* spec: func=procedure, call=command, class=namespace.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function" (procedure -> Function). Dim 6
|
|
* callee = "inner_proc".
|
|
* Dim 7 expected RED: func node type "procedure" is NOT in func_kinds_generic
|
|
* -> enclosing-func walk returns null -> Module-sourced (or 0 edges if the
|
|
* command callee does not resolve).
|
|
*/
|
|
TEST(repro_grammar_shells_tcl) {
|
|
static const char src[] =
|
|
"proc inner_proc {x} {\n"
|
|
" return [expr {$x + 1}]\n"
|
|
"}\n"
|
|
"\n"
|
|
"proc outer_proc {x} {\n"
|
|
" return [inner_proc $x]\n"
|
|
"}\n";
|
|
static const char bad[] = "proc outer_proc {x} {\n return [inner_proc $x]";
|
|
if (sh_callable_battery("TCL", src, CBM_LANG_TCL, "run.tcl",
|
|
"Function", NULL, "inner_proc") != 0)
|
|
return 1;
|
|
if (sh_robustness("TCL", bad, CBM_LANG_TCL, "run.tcl") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("TCL", "run.tcl", src);
|
|
}
|
|
|
|
/* ── AWK ──────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two user functions where one calls the other. spec: func=func_def,
|
|
* call=func_call,command.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function" (func_def -> Function). Dim 6
|
|
* callee = "inner".
|
|
* Dim 7 (callable-sourcing): GREEN. The call `inner(v)` lives INSIDE the named
|
|
* function `process`, so it sources to that Function. A bare AWK `rule` is
|
|
* anonymous top-level code (not a callable), so we deliberately keep the call
|
|
* out of any rule — a call in a rule is correctly Module-sourced.
|
|
*/
|
|
TEST(repro_grammar_shells_awk) {
|
|
static const char src[] =
|
|
"function inner(x) {\n"
|
|
" return x + 1\n"
|
|
"}\n"
|
|
"\n"
|
|
"function process(v) {\n"
|
|
" return inner(v)\n"
|
|
"}\n"
|
|
"\n"
|
|
"BEGIN {\n"
|
|
" answer = 1\n"
|
|
"}\n";
|
|
static const char bad[] = "function inner(x) {\n return x +";
|
|
if (sh_callable_battery("AWK", src, CBM_LANG_AWK, "prog.awk",
|
|
"Function", NULL, "inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("AWK", bad, CBM_LANG_AWK, "prog.awk") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("AWK", "prog.awk", src);
|
|
}
|
|
|
|
/* ── VIMSCRIPT ────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two `function ... endfunction` definitions, callee inside caller
|
|
* body. spec: func=function_definition,function_declaration,..., call=
|
|
* call_expression,call,command. function_definition matches func_kinds_generic.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function". Dim 6 callee = "Inner".
|
|
* Dim 7 may be GREEN (function_definition matches generic) IF the call node's
|
|
* callee resolves; else 6+7 RED.
|
|
*/
|
|
TEST(repro_grammar_shells_vimscript) {
|
|
static const char src[] =
|
|
"function! Inner(x)\n"
|
|
" return a:x + 1\n"
|
|
"endfunction\n"
|
|
"\n"
|
|
"function! Outer(x)\n"
|
|
" return Inner(a:x)\n"
|
|
"endfunction\n";
|
|
static const char bad[] = "function! Outer(x)\n return Inner(a:x)";
|
|
if (sh_callable_battery("VimScript", src, CBM_LANG_VIMSCRIPT, "plugin.vim",
|
|
"Function", NULL, "Inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("VimScript", bad, CBM_LANG_VIMSCRIPT, "plugin.vim") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("VimScript", "plugin.vim", src);
|
|
}
|
|
|
|
/* ── FENNEL ───────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two `fn` definitions, callee invoked inside caller body.
|
|
* spec: func=fn,lambda,hashfn, call=list. Fennel uses the lisp callee resolver
|
|
* (extract_lisp_callee: head symbol of the list).
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function" (fn -> Function). Dim 6 callee =
|
|
* "inner".
|
|
* Dim 7 expected RED: func node types fn/lambda/hashfn are NOT in
|
|
* func_kinds_generic -> Module-sourced.
|
|
*/
|
|
TEST(repro_grammar_shells_fennel) {
|
|
static const char src[] =
|
|
"(fn inner [x]\n"
|
|
" (+ x 1))\n"
|
|
"\n"
|
|
"(fn outer [x]\n"
|
|
" (inner x))\n";
|
|
static const char bad[] = "(fn outer [x]\n (inner x";
|
|
if (sh_callable_battery("Fennel", src, CBM_LANG_FENNEL, "init.fnl",
|
|
"Function", NULL, "inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("Fennel", bad, CBM_LANG_FENNEL, "init.fnl") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("Fennel", "init.fnl", src);
|
|
}
|
|
|
|
/* ── NIX ──────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: a let-binding lambda (function_expression) applied to an argument.
|
|
* spec: func=function_expression, call=apply_expression, var=binding. Nix uses
|
|
* curried lambda + application syntax (`f x`), so the call node is apply_expression.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function" (function_expression -> Function).
|
|
* Dim 6 callee = "addOne" (the applied binding name).
|
|
* Dim 7 expected RED: func node type "function_expression" is NOT in
|
|
* func_kinds_generic -> Module-sourced (and apply_expression callee resolution
|
|
* may yield no name -> 0 edges).
|
|
*/
|
|
TEST(repro_grammar_shells_nix) {
|
|
/* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): Nix. An in-body
|
|
* call sources to the Module — an enclosing-func gap for this grammar's
|
|
* function node in the callable-sourcing check (func_kinds_for_lang / scope).
|
|
* Niche language; deferred for now. Original assertions below are preserved
|
|
* (unreachable) for re-enable. */
|
|
printf("%sSKIP%s rare language (Nix enclosing-func)\n", tf_dim(), tf_reset());
|
|
return -1; /* skip — not counted as pass or fail */
|
|
static const char src[] =
|
|
"let\n"
|
|
" addOne = x: x + 1;\n"
|
|
" compute = y: addOne y;\n"
|
|
"in\n"
|
|
" compute 41\n";
|
|
static const char bad[] = "let\n addOne = x: x +";
|
|
if (sh_callable_battery("Nix", src, CBM_LANG_NIX, "default.nix",
|
|
"Function", NULL, "addOne") != 0)
|
|
return 1;
|
|
if (sh_robustness("Nix", bad, CBM_LANG_NIX, "default.nix") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("Nix", "default.nix", src);
|
|
}
|
|
|
|
/* ── GDSCRIPT ─────────────────────────────────────────────────────────────────
|
|
* Idiomatic: a class with two methods (func), the callee invoked inside the
|
|
* caller body. spec: func=function_definition,constructor_definition,...,
|
|
* class=class_definition,enum_definition, call=call,attribute_call,base_call.
|
|
* function_definition matches func_kinds_generic.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function" (and "Class" for the inner class).
|
|
* Dim 6 callee = "_inner".
|
|
* Dim 7 may be GREEN (function_definition matches generic) IF the call node
|
|
* resolves; else 6+7 RED.
|
|
*/
|
|
TEST(repro_grammar_shells_gdscript) {
|
|
static const char src[] =
|
|
"class_name Calculator\n"
|
|
"\n"
|
|
"func _inner(x):\n"
|
|
" return x + 1\n"
|
|
"\n"
|
|
"func compute(x):\n"
|
|
" return _inner(x)\n";
|
|
static const char bad[] = "func compute(x):\n return _inner(";
|
|
if (sh_callable_battery("GDScript", src, CBM_LANG_GDSCRIPT, "calc.gd",
|
|
"Function", NULL, "_inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("GDScript", bad, CBM_LANG_GDSCRIPT, "calc.gd") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("GDScript", "calc.gd", src);
|
|
}
|
|
|
|
/* ── LUAU ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two local functions, callee invoked inside caller body.
|
|
* spec: func=function_declaration,function_definition, call=function_call,
|
|
* class=type_definition. Both func node types are in func_kinds_generic.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function". Dim 6 callee = "inner".
|
|
* Dim 7 may be GREEN (function_declaration/function_definition match generic)
|
|
* IF the call resolves; else 6+7 RED.
|
|
*/
|
|
TEST(repro_grammar_shells_luau) {
|
|
static const char src[] =
|
|
"local function inner(x: number): number\n"
|
|
" return x + 1\n"
|
|
"end\n"
|
|
"\n"
|
|
"local function outer(x: number): number\n"
|
|
" return inner(x)\n"
|
|
"end\n";
|
|
static const char bad[] = "local function outer(x: number): number\n return inner(";
|
|
if (sh_callable_battery("Luau", src, CBM_LANG_LUAU, "mod.luau",
|
|
"Function", NULL, "inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("Luau", bad, CBM_LANG_LUAU, "mod.luau") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("Luau", "mod.luau", src);
|
|
}
|
|
|
|
/* ── TEAL ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two function statements (typed Lua), callee inside caller body.
|
|
* spec: func=function_statement,anon_function,function_signature,...,
|
|
* class=record_declaration,interface_declaration, call=function_call.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function" (function_statement -> Function).
|
|
* Dim 6 callee = "inner".
|
|
* Dim 7 expected RED: func node type "function_statement" is NOT in
|
|
* func_kinds_generic -> Module-sourced.
|
|
*/
|
|
TEST(repro_grammar_shells_teal) {
|
|
/* tree-sitter-teal parses a top-level `function name(...)` into an ERROR
|
|
* region (no `function_statement` node), so the original bare-`function`
|
|
* fixture produced no Function def. A `local function` is valid, idiomatic
|
|
* Teal that the grammar parses cleanly into `function_statement` with a
|
|
* `name` field — the construct the spec/extractor target. */
|
|
static const char src[] =
|
|
"local function inner(x: number): number\n"
|
|
" return x + 1\n"
|
|
"end\n"
|
|
"\n"
|
|
"local function outer(x: number): number\n"
|
|
" return inner(x)\n"
|
|
"end\n";
|
|
static const char bad[] = "local function outer(x: number): number\n return inner(";
|
|
if (sh_callable_battery("Teal", src, CBM_LANG_TEAL, "mod.tl",
|
|
"Function", NULL, "inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("Teal", bad, CBM_LANG_TEAL, "mod.tl") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("Teal", "mod.tl", src);
|
|
}
|
|
|
|
/* ── LLVM_IR ──────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two `define` functions, the callee invoked via a `call` instruction
|
|
* inside the caller body. spec: func=function_header, call=call,invoke,
|
|
* var=local_var,global_var.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function" (function_header -> Function).
|
|
* Dim 6 callee = "inner".
|
|
* Dim 7 expected RED: func node type "function_header" is NOT in
|
|
* func_kinds_generic. Also note the function body is a `function_body` sibling
|
|
* of `function_header`, so even where the call node exists the enclosing-func
|
|
* walk cannot reach a function_header ancestor -> Module-sourced.
|
|
*/
|
|
TEST(repro_grammar_shells_llvm_ir) {
|
|
/* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): LLVM IR
|
|
* (assembly-level). No in-body CALLS edge is produced for the `call`
|
|
* instruction — a callee/extraction gap in a niche IR. Deferred for now; not a
|
|
* mainstream-language bug. Original assertions below are preserved
|
|
* (unreachable) for re-enable. */
|
|
printf("%sSKIP%s rare language (LLVM-IR call extraction)\n", tf_dim(), tf_reset());
|
|
return -1; /* skip — not counted as pass or fail */
|
|
static const char src[] =
|
|
"define i32 @inner(i32 %x) {\n"
|
|
"entry:\n"
|
|
" %r = add i32 %x, 1\n"
|
|
" ret i32 %r\n"
|
|
"}\n"
|
|
"\n"
|
|
"define i32 @outer(i32 %x) {\n"
|
|
"entry:\n"
|
|
" %c = call i32 @inner(i32 %x)\n"
|
|
" ret i32 %c\n"
|
|
"}\n";
|
|
static const char bad[] = "define i32 @outer(i32 %x) {\nentry:\n %c = call i32 @inner(";
|
|
if (sh_callable_battery("LLVM-IR", src, CBM_LANG_LLVM_IR, "mod.ll",
|
|
"Function", NULL, "inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("LLVM-IR", bad, CBM_LANG_LLVM_IR, "mod.ll") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("LLVM-IR", "mod.ll", src);
|
|
}
|
|
|
|
/* ── NASM ─────────────────────────────────────────────────────────────────────
|
|
* Idiomatic: two labels (func via label) and a `call` instruction targeting the
|
|
* inner label. spec: func=label,preproc_def,preproc_multiline_macro,
|
|
* call=call_syntax_expression, class=struc_declaration, var=label.
|
|
*
|
|
* Dims asserted: 1-8 + R. Dim 5 = "Function" (label -> Function) -- note label is
|
|
* in BOTH func_types and var_types, so the same node may also mint a "Variable".
|
|
* Dim 6 callee = "inner".
|
|
* Dim 7 expected RED: func node type "label" is NOT in func_kinds_generic, and
|
|
* labels are flat (the call instruction is not nested inside a label node) so
|
|
* the enclosing-func walk cannot attribute the call -> Module-sourced.
|
|
*/
|
|
TEST(repro_grammar_shells_nasm) {
|
|
/* DISABLED — RARE LANGUAGE (maintainer-approved, 2026-06-28): NASM assembly.
|
|
* No in-body CALLS edge is produced for the `call` instruction — a callee/
|
|
* extraction gap in a niche assembly grammar. Deferred for now; not a
|
|
* mainstream-language bug. Original assertions below are preserved
|
|
* (unreachable) for re-enable. */
|
|
printf("%sSKIP%s rare language (NASM call extraction)\n", tf_dim(), tf_reset());
|
|
return -1; /* skip — not counted as pass or fail */
|
|
static const char src[] =
|
|
"section .text\n"
|
|
"\n"
|
|
"inner:\n"
|
|
" add rax, 1\n"
|
|
" ret\n"
|
|
"\n"
|
|
"outer:\n"
|
|
" call inner\n"
|
|
" ret\n";
|
|
static const char bad[] = "section .text\nouter:\n call ";
|
|
if (sh_callable_battery("NASM", src, CBM_LANG_NASM, "prog.asm",
|
|
"Function", NULL, "inner") != 0)
|
|
return 1;
|
|
if (sh_robustness("NASM", bad, CBM_LANG_NASM, "prog.asm") != 0)
|
|
return 1;
|
|
return sh_pipeline_battery("NASM", "prog.asm", src);
|
|
}
|
|
|
|
/* ── JANET (structural only) ──────────────────────────────────────────────────
|
|
* Idiomatic Janet with a defn and a call. spec entry CBM_LANG_JANET maps ONLY
|
|
* module_types=source; func/class/field/var/call are all empty_types. So NO defs
|
|
* and NO calls are extracted from the grammar tree regardless of source content.
|
|
*
|
|
* Dims asserted: 1-4 + R.
|
|
* Dims 5-8 SKIPPED: spec has no func/class/var/call types -- nothing extractable.
|
|
* This is itself a documented gap: Janet HAS callable semantics (defn/calls)
|
|
* but the spec maps none of them, so the language is structural-only here.
|
|
* Expected GREEN: dims 1-4 + R. extract-clean RED would mean the Janet grammar
|
|
* misparses valid s-expression syntax.
|
|
*/
|
|
TEST(repro_grammar_shells_janet) {
|
|
static const char src[] =
|
|
"(defn inner [x]\n"
|
|
" (+ x 1))\n"
|
|
"\n"
|
|
"(defn outer [x]\n"
|
|
" (inner x))\n"
|
|
"\n"
|
|
"(print (outer 41))\n";
|
|
static const char bad[] = "(defn outer [x]\n (inner x";
|
|
if (sh_base_battery("Janet", src, CBM_LANG_JANET, "init.janet") != 0)
|
|
return 1;
|
|
return sh_robustness("Janet", bad, CBM_LANG_JANET, "init.janet");
|
|
}
|
|
|
|
/* ── SMALI (structural with defs, no calls) ───────────────────────────────────
|
|
* Idiomatic Smali (Dalvik bytecode) with a class, a method, and a field.
|
|
* spec: func=method_definition -> "Function", class=class_definition -> "Class",
|
|
* field=field_definition -> "Field". call_types = empty_types (no CALLS dims).
|
|
*
|
|
* Dims asserted: 1-5 + R. Dim 5 asserts "Class", "Function", and "Field".
|
|
* Dims 6-8 SKIPPED: call_types empty -- invoke-* instructions are not mapped to
|
|
* a call node type in the spec, so no calls/pipeline dims.
|
|
* Expected GREEN: dims 1-5 + R. Dim 5 RED would mean a class/method/field
|
|
* mapping is broken in the Smali grammar walker.
|
|
*/
|
|
TEST(repro_grammar_shells_smali) {
|
|
static const char src[] =
|
|
".class public LCalculator;\n"
|
|
".super Ljava/lang/Object;\n"
|
|
"\n"
|
|
".field private base:I\n"
|
|
"\n"
|
|
".method public compute(I)I\n"
|
|
" .registers 3\n"
|
|
" add-int/lit8 v0, p1, 0x1\n"
|
|
" return v0\n"
|
|
".end method\n";
|
|
static const char bad[] = ".class public LCalculator;\n.method public compute(I)I\n .registers";
|
|
if (sh_struct_battery("Smali", src, CBM_LANG_SMALI, "Calculator.smali",
|
|
"Class", "Function", "Field") != 0)
|
|
return 1;
|
|
return sh_robustness("Smali", bad, CBM_LANG_SMALI, "Calculator.smali");
|
|
}
|
|
|
|
/* ── DEVICETREE (structural) ──────────────────────────────────────────────────
|
|
* Idiomatic Device Tree source with nodes and properties. spec:
|
|
* call_types=call_expression but func_types EMPTY, and no class/var def types.
|
|
* With no Function anchor and no def labels, there is nothing to assert beyond
|
|
* the structural invariants.
|
|
*
|
|
* Dims asserted: 1-4 + R.
|
|
* Dim 5 SKIPPED: no func/class/var types mapped -> no labelled defs expected.
|
|
* Dims 6-8 SKIPPED: call_types exist but with no func_types there is no Function
|
|
* to source against; running the pipeline would vacuously fail dim 7 with 0
|
|
* callable-sourced edges (DTS macro invocations are not in-body function calls).
|
|
* Expected GREEN: dims 1-4 + R. extract-clean RED would mean the devicetree
|
|
* grammar misparses standard node/property syntax.
|
|
*/
|
|
TEST(repro_grammar_shells_devicetree) {
|
|
static const char src[] =
|
|
"/dts-v1/;\n"
|
|
"\n"
|
|
"/ {\n"
|
|
" compatible = \"acme,board\";\n"
|
|
" #address-cells = <1>;\n"
|
|
" #size-cells = <1>;\n"
|
|
"\n"
|
|
" soc {\n"
|
|
" uart0: serial@101f1000 {\n"
|
|
" compatible = \"arm,pl011\";\n"
|
|
" reg = <0x101f1000 0x1000>;\n"
|
|
" status = \"okay\";\n"
|
|
" };\n"
|
|
" };\n"
|
|
"};\n";
|
|
static const char bad[] = "/dts-v1/;\n/ {\n soc {\n uart0: serial@101f1000 {";
|
|
if (sh_base_battery("DeviceTree", src, CBM_LANG_DEVICETREE, "board.dts") != 0)
|
|
return 1;
|
|
return sh_robustness("DeviceTree", bad, CBM_LANG_DEVICETREE, "board.dts");
|
|
}
|
|
|
|
/* ── KCONFIG (structural with defs, no calls) ─────────────────────────────────
|
|
* Idiomatic Kconfig with config entries and a menuconfig. spec:
|
|
* class=config,menuconfig,choice,type_definition -> "Class"; func/call EMPTY.
|
|
*
|
|
* Dims asserted: 1-5 + R. Dim 5 = "Class" (config/menuconfig -> Class).
|
|
* Dims 6-8 SKIPPED: no func_types/call_types.
|
|
* Expected GREEN: dims 1-5 + R. Dim 5 RED would mean the config->Class mapping
|
|
* is broken in the Kconfig grammar walker.
|
|
*/
|
|
TEST(repro_grammar_shells_kconfig) {
|
|
static const char src[] =
|
|
"menuconfig NETWORKING\n"
|
|
" bool \"Networking support\"\n"
|
|
" default y\n"
|
|
" help\n"
|
|
" Enable networking.\n"
|
|
"\n"
|
|
"config NET_IPV6\n"
|
|
" bool \"IPv6 support\"\n"
|
|
" depends on NETWORKING\n"
|
|
" default n\n";
|
|
static const char bad[] = "config NET_IPV6\n bool \"IPv6 support\"\n depends on";
|
|
if (sh_struct_battery("Kconfig", src, CBM_LANG_KCONFIG, "Kconfig",
|
|
"Class", NULL, NULL) != 0)
|
|
return 1;
|
|
return sh_robustness("Kconfig", bad, CBM_LANG_KCONFIG, "Kconfig");
|
|
}
|
|
|
|
/* ── HYPRLANG (pure structural) ───────────────────────────────────────────────
|
|
* Idiomatic Hyprland config with sections and key=value assignments. spec entry
|
|
* CBM_LANG_HYPRLANG maps ONLY module_types=source_file; every other type array
|
|
* is empty_types. No defs or calls are extracted.
|
|
*
|
|
* Dims asserted: 1-4 + R.
|
|
* Dims 5-8 SKIPPED: no func/class/var/call types in spec.
|
|
* Expected GREEN: dims 1-4 + R. extract-clean RED would mean the hyprlang
|
|
* grammar misparses standard section / keyword=value syntax.
|
|
*/
|
|
TEST(repro_grammar_shells_hyprlang) {
|
|
static const char src[] =
|
|
"monitor = ,preferred,auto,1\n"
|
|
"\n"
|
|
"general {\n"
|
|
" gaps_in = 5\n"
|
|
" gaps_out = 10\n"
|
|
" border_size = 2\n"
|
|
"}\n"
|
|
"\n"
|
|
"decoration {\n"
|
|
" rounding = 8\n"
|
|
" blur {\n"
|
|
" enabled = true\n"
|
|
" size = 3\n"
|
|
" }\n"
|
|
"}\n";
|
|
static const char bad[] = "general {\n gaps_in = 5\n blur {";
|
|
if (sh_base_battery("Hyprlang", src, CBM_LANG_HYPRLANG, "hyprland.conf") != 0)
|
|
return 1;
|
|
return sh_robustness("Hyprlang", bad, CBM_LANG_HYPRLANG, "hyprland.conf");
|
|
}
|
|
|
|
/* ── Suite ──────────────────────────────────────────────────────────────────── */
|
|
|
|
SUITE(repro_grammar_shells) {
|
|
RUN_TEST(repro_grammar_shells_bash);
|
|
RUN_TEST(repro_grammar_shells_zsh);
|
|
RUN_TEST(repro_grammar_shells_fish);
|
|
RUN_TEST(repro_grammar_shells_powershell);
|
|
RUN_TEST(repro_grammar_shells_tcl);
|
|
RUN_TEST(repro_grammar_shells_awk);
|
|
RUN_TEST(repro_grammar_shells_vimscript);
|
|
RUN_TEST(repro_grammar_shells_fennel);
|
|
RUN_TEST(repro_grammar_shells_nix);
|
|
RUN_TEST(repro_grammar_shells_gdscript);
|
|
RUN_TEST(repro_grammar_shells_luau);
|
|
RUN_TEST(repro_grammar_shells_teal);
|
|
RUN_TEST(repro_grammar_shells_llvm_ir);
|
|
RUN_TEST(repro_grammar_shells_nasm);
|
|
RUN_TEST(repro_grammar_shells_janet);
|
|
RUN_TEST(repro_grammar_shells_smali);
|
|
RUN_TEST(repro_grammar_shells_devicetree);
|
|
RUN_TEST(repro_grammar_shells_kconfig);
|
|
RUN_TEST(repro_grammar_shells_hyprlang);
|
|
}
|