deusdata--codebase-memory-mcp/tests/test_extraction.c

/*
 * test_extraction.c — Regression tests for the extraction module.
 *
 * Port of internal/cbm/regression_test.go (1282 LOC, ~80 test cases).
 * Exercises cbm_extract_file() on code snippets across 30+ languages,
 * verifying definitions, calls, and imports are correctly extracted.
 */
#include "test_framework.h"
#include "cbm.h"
#include "../src/foundation/compat.h" /* cbm_clock_gettime (wide-flat scaling guard) */
#include "../src/foundation/compat_fs.h"
#include <time.h>
#include "macro_table.h"
#include "iris_export_xml.h"

/* ── Helpers ───────────────────────────────────────────────────── */

/* Check if any definition with the given label has the given name. */
static int has_def(CBMFileResult *r, const char *label, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, label) == 0 && strcmp(r->defs.items[i].name, name) == 0)
            return 1;
    }
    return 0;
}

/* Check if any definition has the given name (any label). */
static int has_def_any(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, name) == 0)
            return 1;
    }
    return 0;
}

/* Check if any call to the given callee exists. */
static int has_call(CBMFileResult *r, const char *callee) {
    for (int i = 0; i < r->calls.count; i++) {
        if (strstr(r->calls.items[i].callee_name, callee) != NULL)
            return 1;
    }
    return 0;
}

/* Check if any import with the given module path exists. */
static int __attribute__((unused)) has_import(CBMFileResult *r, const char *path_substr) {
    for (int i = 0; i < r->imports.count; i++) {
        if (r->imports.items[i].module_path &&
            strstr(r->imports.items[i].module_path, path_substr) != NULL)
            return 1;
    }
    return 0;
}

/* Count definitions with a given label. */
/* Check for a definition with the given qualified name. Distinct from
 * find_def_by_name, which returns the first match by NAME and so cannot tell two
 * same-named definitions in different scopes apart — exactly the case that
 * attrpath qualification exists to separate. */
static int has_def_qn(CBMFileResult *r, const char *qn) {
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].qualified_name && strcmp(r->defs.items[i].qualified_name, qn) == 0)
            return 1;
    }
    return 0;
}

static int count_defs_with_label(CBMFileResult *r, const char *label) {
    int count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, label) == 0)
            count++;
    }
    return count;
}

/* Convenience: extract, assert no error, return result. Caller frees. */
static CBMFileResult *extract(const char *src, CBMLanguage lang, const char *proj,
                              const char *path) {
    CBMFileResult *r = cbm_extract_file(src, (int)strlen(src), lang, proj, path, 0, NULL, NULL);
    return r;
}

/* As extract(), but threads an ObjectScript macro table through. */
static CBMFileResult *extract_with_macros(const char *src, CBMLanguage lang, const char *proj,
                                          const char *path, const CBMMacroTable *mt) {
    CBMFileResult *r =
        cbm_extract_file_ex(src, (int)strlen(src), lang, proj, path, 0, NULL, NULL, mt, NULL);
    return r;
}

/* ═══════════════════════════════════════════════════════════════════
 * Group A: OOP Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- R: box::use imports (#218) + module$fn calls (#219) --- */
TEST(extract_r_box_use_imports_issue218) {
    CBMFileResult *r = extract("box::use(\n"
                               "  shiny[moduleServer, NS],\n"
                               "  app/logic/validation[validate_input],\n"
                               ")\n"
                               "library(dplyr)\n"
                               "source(\"helpers.R\")\n",
                               CBM_LANG_R, "t", "app.R");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* box::use specs → one IMPORTS edge per module (symbol list stripped). */
    ASSERT(has_import(r, "shiny"));
    ASSERT(has_import(r, "app/logic/validation"));
    /* base-R imports work too. */
    ASSERT(has_import(r, "dplyr"));
    ASSERT(has_import(r, "helpers"));
    cbm_free_result(r);
    PASS();
}

TEST(extract_r_dollar_call_issue219) {
    CBMFileResult *r = extract("validation$validate_input(x)\n", CBM_LANG_R, "t", "app.R");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* module$fn() now produces a CALLS edge (was silently dropped). */
    ASSERT(has_call(r, "validation.validate_input"));
    cbm_free_result(r);
    PASS();
}

/* --- TS: object-literal arrow methods from a factory (Zustand, #341) --- */
TEST(extract_ts_factory_object_methods_issue341) {
    CBMFileResult *r = extract("export function createItemActions(set, get) {\n"
                               "  return {\n"
                               "    addItem: (type, id) => { return 1; },\n"
                               "    moveItem: (id, target) => { return 2; },\n"
                               "    deleteItem: (id) => { return 3; },\n"
                               "  };\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "item-actions.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* The factory itself + each returned arrow method are Function nodes. */
    ASSERT(has_def_any(r, "createItemActions"));
    ASSERT(has_def_any(r, "addItem"));
    ASSERT(has_def_any(r, "moveItem"));
    ASSERT(has_def_any(r, "deleteItem"));
    cbm_free_result(r);
    PASS();
}

/* --- C/C++ preprocessor macros become Macro nodes (#375) --- */
TEST(extract_c_macros_issue375) {
    CBMFileResult *r = extract("#define SIMPLE_MACRO 1\n"
                               "#define FN_MACRO(x) (2 * (x))\n"
                               "#define EMPTY_MACRO\n"
                               "int main(void) { return FN_MACRO(SIMPLE_MACRO); }\n",
                               CBM_LANG_C, "p", "macros.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Macro", "SIMPLE_MACRO"));
    ASSERT(has_def(r, "Macro", "FN_MACRO"));
    ASSERT(has_def(r, "Macro", "EMPTY_MACRO"));
    ASSERT(has_def(r, "Function", "main")); /* macros don't displace function defs */
    cbm_free_result(r);
    PASS();
}

TEST(extract_cpp_macros_issue375) {
    CBMFileResult *r = extract("#define MAX(a, b) ((a) > (b) ? (a) : (b))\n"
                               "#define PI 3.14159\n"
                               "namespace n {\n"
                               "int f() { return MAX(1, 2); }\n"
                               "}\n",
                               CBM_LANG_CPP, "p", "macros.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Macro", "MAX"));
    ASSERT(has_def(r, "Macro", "PI"));
    cbm_free_result(r);
    PASS();
}

/* #1071: a function-like macro invocation whose argument is a TYPE token
 * (SYNTH_ALLOC_ARRAY(char, n)) makes tree-sitter's C++ grammar emit an ERROR
 * node — it parses `char` in expression position — which cbm_collect_error_regions
 * records as a `parse_partial` coverage gap, even though the file is a valid,
 * in-file macro use with nothing actually missing from the graph. */
TEST(extract_cpp_functionlike_macro_type_arg_no_false_parse_partial_issue1071) {
    CBMFileResult *r = extract("#include <cstddef>\n"
                               "#include <cstdlib>\n"
                               "\n"
                               "#define SYNTH_ALLOC_ARRAY(Type, Count) \\\n"
                               "  ((Type*)std::malloc(sizeof(Type) * (Count)))\n"
                               "\n"
                               "struct Buffer {\n"
                               "  char* data;\n"
                               "  std::size_t size;\n"
                               "};\n"
                               "\n"
                               "Buffer make_buffer(std::size_t n) {\n"
                               "  Buffer b;\n"
                               "  b.data = SYNTH_ALLOC_ARRAY(char, n);\n"
                               "  b.size = n;\n"
                               "  return b;\n"
                               "}\n",
                               CBM_LANG_CPP, "t", "alloc.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->parse_incomplete); /* benign in-body macro call — not a coverage gap */
    ASSERT(has_def(r, "Function", "make_buffer"));
    ASSERT(has_def(r, "Macro", "SYNTH_ALLOC_ARRAY"));
    cbm_free_result(r);
    PASS();
}

/* #1071 guard: the suppression must be tight. A REAL parse error inside a
 * function (not a macro call) must STILL be flagged, and a top-level macro
 * invocation is covered by extract_cpp_preproc_macro_generated_callable_skipped_issue949. */
TEST(extract_cpp_real_in_body_error_still_flagged_issue1071) {
    /* `int x = ;` is a genuine syntax error inside foo()'s body — no macro
     * involved, so the coverage gap must not be suppressed. */
    CBMFileResult *r = extract("int foo() {\n"
                               "  int x = ;\n"
                               "  return x;\n"
                               "}\n",
                               CBM_LANG_CPP, "t", "broken.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_TRUE(r->parse_incomplete); /* real gap stays reported */
    cbm_free_result(r);
    PASS();
}

/* --- GDScript: AST -> graph visitor (Godot, #186) --- */
TEST(extract_gdscript_issue186) {
    CBMFileResult *r = extract("extends Node\n"
                               "class_name Player\n"
                               "\n"
                               "var health = 100\n"
                               "\n"
                               "func _ready():\n"
                               "    take_damage(10)\n"
                               "\n"
                               "func take_damage(amount):\n"
                               "    health -= amount\n"
                               "\n"
                               "class Inner:\n"
                               "    func helper():\n"
                               "        pass\n",
                               CBM_LANG_GDSCRIPT, "game", "player.gd");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "_ready"));
    ASSERT(has_def(r, "Function", "take_damage"));
    ASSERT(has_def(r, "Class", "Inner"));
    ASSERT(has_call(r, "take_damage"));
    cbm_free_result(r);
    PASS();
}

/* --- PowerShell: AST -> graph visitor (#35) --- */
TEST(extract_powershell_issue35) {
    CBMFileResult *r = extract("function Get-Greeting {\n"
                               "    param($Name)\n"
                               "    Write-Output \"Hello $Name\"\n"
                               "}\n"
                               "\n"
                               "function Set-Config {\n"
                               "    Get-Greeting -Name 'World'\n"
                               "}\n",
                               CBM_LANG_POWERSHELL, "ops", "greet.ps1");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(count_defs_with_label(r, "Function") >= 2);
    cbm_free_result(r);
    PASS();
}

/* --- Luau: AST -> graph visitor (Roblox, #39) --- */
TEST(extract_luau_issue39) {
    CBMFileResult *r = extract("local function add(a, b)\n"
                               "    return a + b\n"
                               "end\n"
                               "\n"
                               "function multiply(a, b)\n"
                               "    return add(a, a) * b\n"
                               "end\n",
                               CBM_LANG_LUAU, "game", "math.luau");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(count_defs_with_label(r, "Function") >= 2);
    cbm_free_result(r);
    PASS();
}

/* --- QML: AST -> graph visitor (Qt, #42) --- */
TEST(extract_qml_issue42) {
    CBMFileResult *r = extract("import QtQuick 2.15\n"
                               "\n"
                               "Rectangle {\n"
                               "    id: root\n"
                               "    width: 100\n"
                               "    property int counter: 0\n"
                               "    signal clicked(int value)\n"
                               "\n"
                               "    function increment() {\n"
                               "        counter += 1\n"
                               "        compute(counter)\n"
                               "    }\n"
                               "\n"
                               "    function compute(n) {\n"
                               "        return n * 2\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_QML, "app", "Main.qml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "increment"));
    ASSERT(has_def(r, "Function", "compute"));
    ASSERT(has_call(r, "compute"));
    cbm_free_result(r);
    PASS();
}

/* --- CFML script dialect: .cfc components (Lucee/ColdFusion, #38) --- */
TEST(extract_cfscript_issue38) {
    CBMFileResult *r = extract("component {\n"
                               "    public function getUser(numeric id) {\n"
                               "        return loadUser(id);\n"
                               "    }\n"
                               "    function loadUser(id) {\n"
                               "        return id * 2;\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_CFSCRIPT, "app", "User.cfc");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(count_defs_with_label(r, "Function") >= 2);
    ASSERT(has_def(r, "Function", "getUser"));
    ASSERT(has_def(r, "Function", "loadUser"));
    ASSERT(has_call(r, "loadUser"));
    cbm_free_result(r);
    PASS();
}

/* --- CFML tag dialect: .cfm templates with <cffunction> (#38) --- */
TEST(extract_cfml_tag_issue38) {
    CBMFileResult *r = extract("<cffunction name=\"greet\" returntype=\"string\">\n"
                               "    <cfargument name=\"who\" type=\"string\">\n"
                               "    <cfreturn \"Hello \" & arguments.who>\n"
                               "</cffunction>\n",
                               CBM_LANG_CFML, "app", "index.cfm");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- Helm / Go template: named templates + include calls (#338) --- */
TEST(extract_helm_templates_issue338) {
    CBMFileResult *r = extract("{{- define \"chart.fullname\" -}}\n"
                               "{{- .Release.Name -}}\n"
                               "{{- end -}}\n"
                               "\n"
                               "{{- define \"chart.labels\" -}}\n"
                               "app: {{ include \"chart.fullname\" . }}\n"
                               "chart: {{ template \"chart.fullname\" . }}\n"
                               "{{- end -}}\n",
                               CBM_LANG_GOTEMPLATE, "chart", "templates/_helpers.tpl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* define -> Function nodes */
    ASSERT(has_def(r, "Function", "chart.fullname"));
    ASSERT(has_def(r, "Function", "chart.labels"));
    /* include / template -> CALLS to the named template (not to "include") */
    ASSERT(has_call(r, "chart.fullname"));
    cbm_free_result(r);
    PASS();
}

/* --- Helm values.yaml: top-level keys only, no leaf flood (#338) --- */
TEST(extract_helm_values_toplevel_issue338) {
    CBMFileResult *r = extract("image:\n"
                               "  repository: nginx\n"
                               "  tag: latest\n"
                               "replicaCount: 3\n"
                               "service:\n"
                               "  port: 80\n",
                               CBM_LANG_YAML, "chart", "values.yaml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Variable", "image"));
    ASSERT(has_def(r, "Variable", "replicaCount"));
    ASSERT(has_def(r, "Variable", "service"));
    /* Nested leaf keys must NOT explode into separate nodes. */
    ASSERT(!has_def(r, "Variable", "repository"));
    ASSERT(!has_def(r, "Variable", "tag"));
    ASSERT(!has_def(r, "Variable", "port"));
    ASSERT_EQ(count_defs_with_label(r, "Variable"), 3);
    cbm_free_result(r);
    PASS();
}

/* --- Java --- */
TEST(java_class) {
    CBMFileResult *r = extract(
        "public class Animal { private String name; public String getName() { return name; } }",
        CBM_LANG_JAVA, "t", "Animal.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Animal"));
    cbm_free_result(r);
    PASS();
}

TEST(java_method) {
    CBMFileResult *r = extract(
        "public class Svc { public void doWork() {} public int compute(int x) { return x; } }",
        CBM_LANG_JAVA, "t", "Svc.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "doWork"));
    ASSERT(has_def(r, "Method", "compute"));
    cbm_free_result(r);
    PASS();
}

TEST(java_interface) {
    CBMFileResult *r =
        extract("public interface Repository { void save(Object o); Object findById(long id); }",
                CBM_LANG_JAVA, "t", "Repo.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "Repository"));
    cbm_free_result(r);
    PASS();
}

/* Regression for #1234: Java interface/enum methods were emitted as both a
 * Method node (correct, via extract_class_methods) and a duplicate Function
 * node (incorrect, via walk_defs). Prevention in push_class_body_children
 * (gated to Java) recognizes interface_body and enum_body as class body
 * containers, stopping the fallback path from re-walking method_declaration
 * children as top-level functions. */
TEST(java_interface_no_duplicate_function_issue1234) {
    CBMFileResult *r =
        extract("public interface MarketplaceService {\n"
                "    ReservationDTO createReservation(Authentication auth, RequestDTO req);\n"
                "    void cancelReservation(long id);\n"
                "}\n",
                CBM_LANG_JAVA, "t", "MarketplaceService.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT(has_def(r, "Interface", "MarketplaceService"));
    ASSERT(has_def(r, "Method", "createReservation"));
    ASSERT(has_def(r, "Method", "cancelReservation"));
    ASSERT_EQ(count_defs_with_label(r, "Function"), 0);

    cbm_free_result(r);
    PASS();
}

TEST(java_enum_dedup_preserves_calls_issue1234) {
    CBMFileResult *r =
        extract("package app;\n\nenum Day {\n"
                "    MON, TUE, WED, THU, FRI, SAT, SUN;\n\n"
                "    public boolean isWeekend() { return this == SAT || this == SUN; }\n"
                "    public String label() { return name().toLowerCase(); }\n}\n\n"
                "class DayUtil {\n"
                "    static String describe(Day d) {\n"
                "        return d.label() + (d.isWeekend() ? \"(rest)\" : \"(work)\");\n    }\n}\n",
                CBM_LANG_JAVA, "t", "Day.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    ASSERT(has_def(r, "Enum", "Day"));
    ASSERT(has_def(r, "Method", "isWeekend"));
    ASSERT(has_def(r, "Method", "label"));
    ASSERT(has_def(r, "Class", "DayUtil"));
    ASSERT(has_def(r, "Method", "describe"));
    ASSERT_EQ(count_defs_with_label(r, "Function"), 0);

    cbm_free_result(r);
    PASS();
}

/* Regression for #279: a Java class declaring both `extends` and
 * `implements` must produce one INHERITS edge per base — the extends parent
 * AND every implements interface — with bare type names (not the keyword
 * text "extends Bar" / "implements Baz, Qux"). Before the fix:
 *   1) the field loop returned on the first match → only the superclass
 *      was emitted, the interfaces were dropped.
 *   2) the emitted name was the full field text including the keyword. */
TEST(java_class_extends_and_implements) {
    CBMFileResult *r = extract("public class DefaultLinkTool extends DefaultDiagramTool implements "
                               "ILinkTool, Closeable { }",
                               CBM_LANG_JAVA, "t", "DefaultLinkTool.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Find the class def and inspect its base_classes list. */
    CBMDefinition *cls = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Class") == 0 &&
            strcmp(r->defs.items[i].name, "DefaultLinkTool") == 0) {
            cls = &r->defs.items[i];
            break;
        }
    }
    ASSERT_NOT_NULL(cls);
    ASSERT_NOT_NULL(cls->base_classes);

    bool saw_super = false;
    bool saw_iface_a = false;
    bool saw_iface_b = false;
    for (const char **b = cls->base_classes; *b; b++) {
        /* The keyword-text bug would surface as "extends ..." or
         * "implements ..." literally inside one of the entries. */
        ASSERT_NULL(strstr(*b, "extends"));
        ASSERT_NULL(strstr(*b, "implements"));
        if (strcmp(*b, "DefaultDiagramTool") == 0)
            saw_super = true;
        if (strcmp(*b, "ILinkTool") == 0)
            saw_iface_a = true;
        if (strcmp(*b, "Closeable") == 0)
            saw_iface_b = true;
    }
    ASSERT_TRUE(saw_super);
    ASSERT_TRUE(saw_iface_a);
    ASSERT_TRUE(saw_iface_b);

    cbm_free_result(r);
    PASS();
}

/* REPRODUCTION (RED until fixed) — Python `class Animal(Base):` must extract the
 * BARE base name "Base", but extract_base_classes captures the whole
 * `superclasses` argument_list text "(Base)" instead: collect_bases_from_field
 * (internal/cbm/extract_defs.c) matches only type_identifier / generic_type /
 * qualified_name / scoped_type_identifier / user_type, while tree-sitter-python
 * uses a plain `identifier` node for the base — so no child matches and the
 * raw-field fallback grabs the argument_list text "(Base)" (parens included).
 * DOWNSTREAM SYMPTOM: that malformed name never resolves to the Base class node,
 * so EVERY Python subclass yields ZERO INHERITS edges (observed in the P6
 * graph-contract suite). Fix: have collect_bases_from_field accept `identifier`
 * (or strip the argument_list parens). This test stays RED as the regression
 * guard / reproduction until the fix lands — see CLAUDE.md "Bug Fixing —
 * Reproduce-First". */
TEST(python_class_base_extracted_bare) {
    CBMFileResult *r = extract("class Base:\n    pass\n\n\nclass Animal(Base):\n    pass\n",
                               CBM_LANG_PYTHON, "t", "models.py");
    ASSERT_NOT_NULL(r);

    CBMDefinition *cls = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].label && strcmp(r->defs.items[i].label, "Class") == 0 &&
            r->defs.items[i].name && strcmp(r->defs.items[i].name, "Animal") == 0) {
            cls = &r->defs.items[i];
            break;
        }
    }
    ASSERT_NOT_NULL(cls);
    ASSERT_NOT_NULL(cls->base_classes); /* a subclass must record at least one base */

    bool saw_bare_base = false;
    for (const char **b = cls->base_classes; *b; b++) {
        if (strcmp(*b, "Base") == 0) {
            saw_bare_base = true;
        }
    }
    /* CURRENTLY FAILS: base_classes holds "(Base)" (argument_list text), not the
     * bare "Base" needed for INHERITS resolution. */
    ASSERT_TRUE(saw_bare_base);

    cbm_free_result(r);
    PASS();
}

/* --- PHP --- */
TEST(php_class) {
    CBMFileResult *r = extract("<?php\nclass User { public string $name; public function "
                               "getName(): string { return $this->name; } }",
                               CBM_LANG_PHP, "t", "User.php");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "User"));
    ASSERT(has_def(r, "Method", "getName"));
    cbm_free_result(r);
    PASS();
}

TEST(php_function) {
    CBMFileResult *r =
        extract("<?php\nfunction greet(string $name): string { return 'Hello ' . $name; }",
                CBM_LANG_PHP, "t", "helpers.php");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- Ruby --- */
TEST(ruby_class) {
    CBMFileResult *r = extract("class Animal\n  def initialize(name)\n    @name = name\n  end\n  "
                               "def speak\n    puts @name\n  end\nend\n",
                               CBM_LANG_RUBY, "t", "animal.rb");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Animal"));
    ASSERT(has_def(r, "Method", "speak"));
    cbm_free_result(r);
    PASS();
}

TEST(ruby_module) {
    CBMFileResult *r = extract("module Greetable\n  def greet\n    \"Hello\"\n  end\nend\n",
                               CBM_LANG_RUBY, "t", "greetable.rb");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "Greetable"));
    cbm_free_result(r);
    PASS();
}

/* --- C# --- */
TEST(csharp_class) {
    CBMFileResult *r = extract("namespace App { public class Service { public void Run() {} public "
                               "int Compute(int x) => x * 2; } }",
                               CBM_LANG_CSHARP, "t", "Service.cs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Service"));
    ASSERT(has_def(r, "Method", "Run"));
    cbm_free_result(r);
    PASS();
}

TEST(csharp_interface) {
    CBMFileResult *r = extract("public interface IService { void Execute(); string GetStatus(); }",
                               CBM_LANG_CSHARP, "t", "IService.cs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "IService"));
    cbm_free_result(r);
    PASS();
}

/* --- Swift --- */
TEST(swift_class) {
    CBMFileResult *r = extract("class Vehicle {\n    var speed: Int = 0\n    func accelerate() { "
                               "speed += 10 }\n    func stop() { speed = 0 }\n}\n",
                               CBM_LANG_SWIFT, "t", "Vehicle.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Vehicle"));
    ASSERT(has_def(r, "Method", "accelerate"));
    cbm_free_result(r);
    PASS();
}

/* --- Kotlin --- */
TEST(kotlin_function) {
    CBMFileResult *r = extract("fun greet(name: String): String = \"Hello $name\"\nfun main() { "
                               "println(greet(\"World\")) }\n",
                               CBM_LANG_KOTLIN, "t", "main.kt");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    ASSERT(has_def(r, "Function", "main"));
    cbm_free_result(r);
    PASS();
}

TEST(kotlin_class) {
    CBMFileResult *r =
        extract("class User(val name: String) {\n    fun display(): String = \"User: $name\"\n}\n",
                CBM_LANG_KOTLIN, "t", "User.kt");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "User"));
    cbm_free_result(r);
    PASS();
}

/* --- Scala --- */
TEST(scala_function) {
    CBMFileResult *r =
        extract("object Main {\n  def greet(name: String): String = s\"Hello $name\"\n  def "
                "main(args: Array[String]): Unit = println(greet(\"World\"))\n}\n",
                CBM_LANG_SCALA, "t", "Main.scala");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(scala_class) {
    CBMFileResult *r =
        extract("class Animal(val name: String) {\n  def speak(): String = s\"I am $name\"\n}\n",
                CBM_LANG_SCALA, "t", "Animal.scala");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Animal"));
    cbm_free_result(r);
    PASS();
}

/* --- Dart --- */
TEST(dart_class) {
    CBMFileResult *r = extract("class Animal {\n  String name;\n  Animal(this.name);\n  String "
                               "speak() => 'I am $name';\n}\n",
                               CBM_LANG_DART, "t", "animal.dart");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Animal"));
    ASSERT(has_def(r, "Method", "speak"));
    cbm_free_result(r);
    PASS();
}

/* --- Groovy --- */
TEST(groovy_class) {
    CBMFileResult *r =
        extract("class Greeter {\n    String name\n    String greet() { \"Hello, $name\" }\n    "
                "static void main(args) { println new Greeter(name:'World').greet() }\n}\n",
                CBM_LANG_GROOVY, "t", "Greeter.groovy");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Greeter"));
    ASSERT(has_def(r, "Method", "greet"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group B: Systems Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- Rust --- */
TEST(rust_function) {
    CBMFileResult *r =
        extract("fn main() { println!(\"Hello\"); }\npub fn add(a: i32, b: i32) -> i32 { a + b }\n",
                CBM_LANG_RUST, "t", "main.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "main"));
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

TEST(rust_struct) {
    CBMFileResult *r = extract("pub struct Point { pub x: f64, pub y: f64 }\nimpl Point { pub fn "
                               "new(x: f64, y: f64) -> Self { Point { x, y } } }\n",
                               CBM_LANG_RUST, "t", "point.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Struct", "Point"));
    ASSERT(has_def(r, "Method", "new"));
    cbm_free_result(r);
    PASS();
}

/* --- Go --- */
TEST(go_function) {
    CBMFileResult *r = extract("package main\nfunc Greet(name string) string { return \"Hello, \" "
                               "+ name }\nfunc main() { Greet(\"World\") }\n",
                               CBM_LANG_GO, "t", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Greet"));
    ASSERT(has_def(r, "Function", "main"));
    cbm_free_result(r);
    PASS();
}

TEST(go_struct) {
    CBMFileResult *r = extract("package main\ntype Server struct { Host string; Port int }\nfunc "
                               "(s *Server) Start() error { return nil }\n",
                               CBM_LANG_GO, "t", "server.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Struct", "Server"));
    ASSERT(has_def(r, "Method", "Start"));
    cbm_free_result(r);
    PASS();
}

TEST(go_interface) {
    CBMFileResult *r =
        extract("package main\ntype Handler interface { ServeHTTP() error; Close() }\n",
                CBM_LANG_GO, "t", "handler.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def_any(r, "Handler"));
    cbm_free_result(r);
    PASS();
}

/* --- Zig --- */
TEST(zig_function) {
    CBMFileResult *r =
        extract("const std = @import(\"std\");\npub fn add(a: i32, b: i32) i32 { return a + b; }\n",
                CBM_LANG_ZIG, "t", "main.zig");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- C --- */
TEST(c_function) {
    CBMFileResult *r =
        extract("int add(int a, int b) { return a + b; }\nvoid greet() { printf(\"Hello\"); }\n",
                CBM_LANG_C, "t", "math.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(c_struct) {
    CBMFileResult *r =
        extract("struct Point { int x; int y; };\nvoid init_point(struct Point *p) { p->x = 0; }\n",
                CBM_LANG_C, "t", "point.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "init_point"));
    cbm_free_result(r);
    PASS();
}

/* --- C++ --- */
TEST(cpp_class) {
    CBMFileResult *r = extract(
        "class Widget {\npublic:\n    void draw() {}\n    int width() const { return 0; }\n};\n",
        CBM_LANG_CPP, "t", "widget.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Widget"));
    ASSERT(has_def(r, "Method", "draw"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group C: Scripting / Dynamic Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- Python --- */
TEST(python_function) {
    CBMFileResult *r = extract(
        "def greet(name):\n    return f\"Hello {name}\"\n\ndef main():\n    greet(\"World\")\n",
        CBM_LANG_PYTHON, "t", "main.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    ASSERT(has_def(r, "Function", "main"));
    cbm_free_result(r);
    PASS();
}

TEST(python_class) {
    CBMFileResult *r =
        extract("class Dog:\n    def __init__(self, name):\n        self.name = name\n    def "
                "speak(self):\n        return f\"Woof from {self.name}\"\n",
                CBM_LANG_PYTHON, "t", "dog.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Dog"));
    ASSERT(has_def(r, "Method", "speak"));
    cbm_free_result(r);
    PASS();
}

/* --- JavaScript --- */
TEST(js_function) {
    CBMFileResult *r =
        extract("function greet(name) { return `Hello ${name}`; }\nconst add = (a, b) => a + b;\n",
                CBM_LANG_JAVASCRIPT, "t", "util.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(js_class) {
    CBMFileResult *r =
        extract("class Counter {\n  constructor() { this.count = 0; }\n  increment() { "
                "this.count++; }\n  get value() { return this.count; }\n}\n",
                CBM_LANG_JAVASCRIPT, "t", "counter.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Counter"));
    ASSERT(has_def(r, "Method", "increment"));
    cbm_free_result(r);
    PASS();
}

/* --- TypeScript --- */
TEST(ts_function) {
    CBMFileResult *r = extract("export function greet(name: string): string { return `Hello "
                               "${name}`; }\nfunction helper(): void {}\n",
                               CBM_LANG_TYPESCRIPT, "t", "util.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(ts_class) {
    CBMFileResult *r =
        extract("class Service {\n  private name: string;\n  constructor(name: string) { this.name "
                "= name; }\n  getName(): string { return this.name; }\n}\n",
                CBM_LANG_TYPESCRIPT, "t", "service.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Service"));
    cbm_free_result(r);
    PASS();
}

TEST(body_tokens_type_identifier) {
    CBMFileResult *r = extract("function serialize(obj: MyModel): SerializedResult {\n"
                               "  const result: SerializedResult = new SerializedResult();\n"
                               "  return result;\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "serial.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "serialize") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].body_tokens);
            ASSERT(strstr(r->defs.items[i].body_tokens, "SerializedResult") != NULL);
            break;
        }
    }
    cbm_free_result(r);
    PASS();
}

/* --- Lua --- */
TEST(lua_function) {
    CBMFileResult *r = extract(
        "function greet(name)\n  return \"Hello \" .. name\nend\nlocal function helper() end\n",
        CBM_LANG_LUA, "t", "main.lua");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- Bash --- */
TEST(bash_function) {
    CBMFileResult *r =
        extract("greet() {\n  echo \"Hello $1\"\n}\nmain() {\n  greet \"World\"\n}\n",
                CBM_LANG_BASH, "t", "script.sh");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- Perl --- */
TEST(perl_function) {
    CBMFileResult *r = extract("sub greet {\n    my ($name) = @_;\n    return \"Hello "
                               "$name\";\n}\nsub main { greet(\"World\"); }\n",
                               CBM_LANG_PERL, "t", "main.pl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- R --- */
TEST(r_function) {
    CBMFileResult *r = extract("add <- function(x, y) x + y\nmultiply <- function(x, y) x * y\n",
                               CBM_LANG_R, "t", "math.R");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group D: Functional Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- Elixir --- */
TEST(elixir_function) {
    CBMFileResult *r = extract("defmodule Greeter do\n  def greet(name), do: \"Hello #{name}\"\n  "
                               "defp helper, do: nil\nend\n",
                               CBM_LANG_ELIXIR, "t", "greeter.ex");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- Haskell --- */
TEST(haskell_function) {
    CBMFileResult *r = extract("add :: Int -> Int -> Int\nadd x y = x + y\n\nmultiply :: Int -> "
                               "Int -> Int\nmultiply x y = x * y\n",
                               CBM_LANG_HASKELL, "t", "Math.hs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- OCaml --- */
TEST(ocaml_function) {
    CBMFileResult *r =
        extract("let add x y = x + y\nlet multiply x y = x * y\n", CBM_LANG_OCAML, "t", "math.ml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- Erlang --- */
TEST(erlang_function) {
    CBMFileResult *r = extract(
        "-module(math).\n-export([add/2]).\nadd(X, Y) -> X + Y.\nmultiply(X, Y) -> X * Y.\n",
        CBM_LANG_ERLANG, "t", "math.erl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group E: Markup / Config / Helper Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- YAML --- */
TEST(yaml_variables) {
    CBMFileResult *r =
        extract("name: myapp\nversion: 1.0\ndatabase:\n  host: localhost\n  port: 5432\n",
                CBM_LANG_YAML, "t", "config.yml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* YAML should extract top-level keys as variables */
    ASSERT_GT(r->defs.count, 0);
    cbm_free_result(r);
    PASS();
}

/* --- HCL --- */
TEST(hcl_blocks) {
    CBMFileResult *r = extract("resource \"aws_instance\" \"web\" {\n  ami = \"abc-123\"\n  "
                               "instance_type = \"t2.micro\"\n}\n"
                               "variable \"region\" {\n  default = \"us-east-1\"\n}\n",
                               CBM_LANG_HCL, "t", "main.tf");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->defs.count, 0);
    /* Block labels are folded into the name so blocks are distinguishable (#337). */
    ASSERT(has_def(r, "Class", "resource.aws_instance.web"));
    ASSERT(has_def(r, "Class", "variable.region"));
    cbm_free_result(r);
    PASS();
}

/* --- SQL --- */
TEST(sql_create_table) {
    CBMFileResult *r = extract("CREATE TABLE users (\n  id INTEGER PRIMARY KEY,\n  name TEXT NOT "
                               "NULL\n);\nCREATE VIEW active_users AS SELECT * FROM users;\n",
                               CBM_LANG_SQL, "t", "schema.sql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- Dockerfile --- */
TEST(dockerfile_stages) {
    CBMFileResult *r = extract(
        "FROM node:18 AS builder\nRUN npm install\nFROM node:18-slim\nCOPY --from=builder /app .\n",
        CBM_LANG_DOCKERFILE, "t", "Dockerfile");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group F: Scientific / Math Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- MATLAB --- */
TEST(matlab_function) {
    CBMFileResult *r =
        extract("function y = square(x)\n  y = x.^2;\nend\n", CBM_LANG_MATLAB, "t", "square.m");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "square"));
    cbm_free_result(r);
    PASS();
}

/* --- Lean 4 --- */
TEST(lean_function) {
    CBMFileResult *r =
        extract("def add (x y : Nat) : Nat := x + y\n", CBM_LANG_LEAN, "t", "Math.lean");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- FORM --- */
TEST(form_procedure) {
    CBMFileResult *r = extract("#procedure doSomething\n  id x = y;\n#endprocedure\n",
                               CBM_LANG_FORM, "t", "test.frm");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "doSomething"));
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram --- */
TEST(wolfram_function) {
    CBMFileResult *r =
        extract("square[x_] := x^2\nadd[x_, y_] := x + y\n", CBM_LANG_WOLFRAM, "t", "math.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "square"));
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- Magma --- */
TEST(magma_function) {
    CBMFileResult *r = extract("function Factorial(n)\n  if n le 1 then\n    return 1;\n  end "
                               "if;\n  return n * Factorial(n - 1);\nend function;\n",
                               CBM_LANG_MAGMA, "t", "test.m");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Factorial"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group G: v0.5 Expansion Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- F# --- */
TEST(fsharp_function) {
    /* Go test only asserts >=1 def — F# name extraction is incomplete */
    CBMFileResult *r = extract("module Greeter\nlet greet name = sprintf \"Hello %s\" name\n",
                               CBM_LANG_FSHARP, "t", "Greeter.fs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Julia --- */
TEST(julia_function) {
    CBMFileResult *r = extract("function add(x, y)\n    x + y\nend\nadd2(x, y) = x + y\n",
                               CBM_LANG_JULIA, "t", "math.jl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- Elm --- */
TEST(elm_function) {
    CBMFileResult *r =
        extract("add x y = x + y\nmultiply x y = x * y\n", CBM_LANG_ELM, "t", "Math.elm");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "add"));
    cbm_free_result(r);
    PASS();
}

/* --- Nix --- */
TEST(nix_function) {
    CBMFileResult *r =
        extract("{ pkgs ? import <nixpkgs> {} }:\nlet\n  hello = pkgs.writeShellScriptBin "
                "\"hello\" ''echo hello'';\nin { inherit hello; }\n",
                CBM_LANG_NIX, "t", "default.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* A Nix file's root expression is normally itself a function (`{ pkgs, lib, ... }:`)
 * — the near-universal library/module header. Definitions must survive that header.
 * Each shape below is asserted separately so a regression names the shape it broke.
 * `nix_function` above deliberately stays as-is: its binding is an application, not
 * a function, so it pins the "parses, no def" case and cannot cover this. */
TEST(nix_defs_in_let_rooted_file) {
    CBMFileResult *r = extract("let\n  alpha = x: x + 1;\n  beta = { a, b }: a + b;\nin\n"
                               "{ inherit alpha beta; }\n",
                               CBM_LANG_NIX, "t", "bare.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "alpha"));
    ASSERT(has_def(r, "Function", "beta"));
    cbm_free_result(r);
    PASS();
}

TEST(nix_defs_in_attrset_rooted_file) {
    CBMFileResult *r = extract("{\n  epsilon = x: x + 1;\n  zeta = { a, b }: a + b;\n}\n",
                               CBM_LANG_NIX, "t", "attrset.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "epsilon"));
    ASSERT(has_def(r, "Function", "zeta"));
    cbm_free_result(r);
    PASS();
}

TEST(nix_defs_in_nested_let) {
    CBMFileResult *r = extract("let\n  outer =\n    let theta = x: x + 1;\n    in theta;\n"
                               "in\n{ inherit outer; }\n",
                               CBM_LANG_NIX, "t", "nested.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "theta"));
    cbm_free_result(r);
    PASS();
}

/* The regression this suite previously could not see: the root `{ prelude }:` matches
 * nix_func_types, resolves no name of its own, and — before the fix — terminated the
 * walk, so nothing below the header was ever visited. */
TEST(nix_defs_survive_function_header_let) {
    CBMFileResult *r = extract("{ prelude }:\nlet\n  gamma = x: x + 1;\n"
                               "  delta = { a, b }: a + b;\nin\n{ inherit gamma delta; }\n",
                               CBM_LANG_NIX, "t", "wrapped.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "gamma"));
    ASSERT(has_def(r, "Function", "delta"));
    cbm_free_result(r);
    PASS();
}

TEST(nix_defs_survive_function_header_attrset) {
    CBMFileResult *r = extract("{ prelude }:\n{\n  eta = x: x + 1;\n}\n", CBM_LANG_NIX, "t",
                               "wrapped_attrset.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "eta"));
    cbm_free_result(r);
    PASS();
}

/* A curried header — `final: prev: { … }` is the standard nixpkgs overlay signature, and
 * the most common multi-arm header in the ecosystem. Two nested function_expressions sit
 * between the file root and the body. */
TEST(nix_defs_survive_curried_header) {
    CBMFileResult *r =
        extract("final: prev: {\n  kappa = x: x + 1;\n}\n", CBM_LANG_NIX, "t", "overlay.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "kappa"));
    cbm_free_result(r);
    PASS();
}

/* A Nix binding's name is a PATH, and the extractor previously took only its first
 * segment. Convention here matches C++ namespaces — `ns::serialize` is name
 * `serialize`, QN `proj.file.ns.serialize` — so a Nix binding is name = leaf
 * segment, QN = enclosing scope + leaf. */
TEST(nix_attrset_scope_disambiguates_leaf_names) {
    CBMFileResult *r =
        extract("{\n  setA = { dup = x: x + 1; };\n  setB = { dup = y: y + 2; };\n}\n",
                CBM_LANG_NIX, "t", "collide.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Both survive. Unqualified, these shared one QN, so the second definition —
     * and every CALLS edge sourced from it — was silently discarded at write. */
    ASSERT(count_defs_with_label(r, "Function") == 2);
    ASSERT(has_def_qn(r, "t.collide.setA.dup"));
    ASSERT(has_def_qn(r, "t.collide.setB.dup"));
    cbm_free_result(r);
    PASS();
}

/* `a.b.fn = …` is sugar for `a = { b = { fn = …; }; }`. Both spellings must yield
 * the same name and the same QN; the leading segments are scope, not name. */
TEST(nix_dotted_attrpath_qualifies_like_nested) {
    CBMFileResult *r = extract("{\n  wrap.deep.fn = z: z + 1;\n}\n", CBM_LANG_NIX, "t", "d.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "fn"));
    ASSERT(has_def_qn(r, "t.d.wrap.deep.fn"));

    CBMFileResult *n =
        extract("{\n  wrap = { deep = { fn = z: z + 1; }; };\n}\n", CBM_LANG_NIX, "t", "d.nix");
    ASSERT_NOT_NULL(n);
    ASSERT_FALSE(n->has_error);
    /* The equality that makes this a correctness fix rather than a preference. */
    ASSERT(has_def_qn(n, "t.d.wrap.deep.fn"));
    cbm_free_result(n);
    cbm_free_result(r);
    PASS();
}

/* A quoted segment is an ordinary name that merely needs quoting in source. The
 * delimiters are not part of it, and leaving them in means every consumer keying
 * on the name has to know to re-quote. */
TEST(nix_quoted_attr_name_strips_quotes) {
    CBMFileResult *r = extract("{\n  \"kebab-case\" = a: a;\n  svc.\"my.name\" = b: b;\n}\n",
                               CBM_LANG_NIX, "t", "q.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "kebab-case"));
    ASSERT_FALSE(has_def_any(r, "\"kebab-case\""));
    ASSERT(has_def_qn(r, "t.q.kebab-case"));
    /* A quoted segment may itself contain dots; they are part of the name, not
     * path separators, but the QN is a dotted string either way. */
    ASSERT(has_def(r, "Function", "my.name"));
    cbm_free_result(r);
    PASS();
}

/* `"${x}" = …` has no statically knowable name. Minting it produces a def named
 * `"${x}"` that nothing can look up or resolve a call against, so mint nothing —
 * the same call the Makefile dot-prefix guard makes. */
TEST(nix_interpolated_attr_mints_no_def) {
    CBMFileResult *r =
        extract("{\n  \"${dynamic}\" = a: a;\n  fixed = b: b;\n}\n", CBM_LANG_NIX, "t", "i.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "fixed"));
    ASSERT(count_defs_with_label(r, "Function") == 1);
    cbm_free_result(r);
    PASS();
}

/* Nix Variables. `nix_var_types` has always declared `binding`, but no Nix name
 * resolver existed, so the count was unconditionally zero.
 *
 * Scope follows the rule every other language uses: extract_variables mints FILE
 * scope and never locals — a C++ declaration inside a function body is not a
 * Variable. For Nix, file scope is the `let` bindings and the returned attrset;
 * anything in a deeper attrset is not. Without that bound a NixOS module's
 * settings tree would mint a node per `enable = true`. */
TEST(nix_module_level_bindings_mint_variables) {
    CBMFileResult *r = extract("{ pkgs, lib, ... }:\n"
                               "let\n"
                               "  privateConst = 42;\n"
                               "in\n"
                               "{\n"
                               "  exported = \"value\";\n"
                               "  services.nginx.enable = true;\n"
                               "}\n",
                               CBM_LANG_NIX, "t", "mod.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* A let binding is file scope in the same sense a C++ file-static is. */
    ASSERT(has_def(r, "Variable", "privateConst"));
    ASSERT(has_def(r, "Variable", "exported"));
    /* The QN carries the attrpath, exactly as it does for functions. */
    ASSERT(has_def(r, "Variable", "enable"));
    ASSERT(has_def_qn(r, "t.mod.services.nginx.enable"));
    cbm_free_result(r);
    PASS();
}

/* The flood guard. Each absence assertion is paired with a positive one on the
 * same predicate in the same result, so none can pass by extracting nothing. */
TEST(nix_nested_bindings_are_not_module_level) {
    CBMFileResult *r = extract("{ pkgs }:\n"
                               "{\n"
                               "  topLevel = 1;\n"
                               "  deep = {\n"
                               "    nested = {\n"
                               "      shouldNotAppear = 2;\n"
                               "    };\n"
                               "  };\n"
                               "}\n",
                               CBM_LANG_NIX, "t", "deep.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Variable", "topLevel")); /* positive control */
    ASSERT_FALSE(has_def_any(r, "shouldNotAppear"));
    /* `deep` is an attrset — a scope, not a value — so not a Variable either. */
    ASSERT_FALSE(has_def(r, "Variable", "deep"));
    ASSERT_FALSE(has_def(r, "Variable", "nested"));
    cbm_free_result(r);
    PASS();
}

/* A lambda-valued binding is already minted as a Function by the def walk. Minting
 * it again here would double-count every helper in the ecosystem. */
TEST(nix_lambda_binding_is_function_not_variable) {
    CBMFileResult *r =
        extract("{\n  fn = x: x + 1;\n  val = 7;\n}\n", CBM_LANG_NIX, "t", "mix.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "fn"));
    ASSERT_FALSE(has_def(r, "Variable", "fn"));
    ASSERT(has_def(r, "Variable", "val")); /* positive control */
    ASSERT_FALSE(has_def(r, "Function", "val"));
    cbm_free_result(r);
    PASS();
}

/* Descending past the header must not mint a second def from a curried lambda's inner
 * arm: `iota = a: b: ...` is one named function, not two. The inner `b:` has a
 * function_expression parent, resolves no name, and must stay out. */
TEST(nix_curried_lambda_mints_one_def) {
    CBMFileResult *r = extract("{ prelude }:\nlet\n  iota = a: b: a + b;\nin\n{ inherit iota; }\n",
                               CBM_LANG_NIX, "t", "curried.nix");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "iota"));
    ASSERT(count_defs_with_label(r, "Function") == 1);
    cbm_free_result(r);
    PASS();
}

/* --- Fortran --- */
TEST(fortran_function) {
    /* Fortran subroutine name extraction is incomplete — just verify no crash */
    CBMFileResult *r = extract("subroutine greet(name)\n  character(*), intent(in) :: name\n  "
                               "print *, 'Hello ', name\nend subroutine\n",
                               CBM_LANG_FORTRAN, "t", "greet.f90");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group A2: Missing OOP / Systems variants
 * ═══════════════════════════════════════════════════════════════════ */

/* --- Swift struct --- */
TEST(swift_struct) {
    CBMFileResult *r = extract("struct Point {\n    var x: Double\n    var y: Double\n    func "
                               "distance() -> Double { return (x*x + y*y).squareRoot() }\n}\n",
                               CBM_LANG_SWIFT, "t", "Point.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "distance"));
    cbm_free_result(r);
    PASS();
}

/* --- Swift calls (port of PR #47 Go tests) --- */
TEST(swift_simple_call) {
    CBMFileResult *r = extract("func main() { greet() }\nfunc greet() { print(\"hello\") }\n",
                               CBM_LANG_SWIFT, "t", "main.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "greet"));
    cbm_free_result(r);
    PASS();
}

TEST(swift_method_call) {
    CBMFileResult *r =
        extract("class Foo {\n    func bar() { baz.run() }\n}\n", CBM_LANG_SWIFT, "t", "Foo.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "baz.run"));
    cbm_free_result(r);
    PASS();
}

TEST(swift_constructor_call) {
    CBMFileResult *r =
        extract("func create() { let x = MyClass() }\n", CBM_LANG_SWIFT, "t", "create.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "MyClass"));
    cbm_free_result(r);
    PASS();
}

TEST(swift_chained_call) {
    CBMFileResult *r = extract("func setup() { AlarmScheduler.shared.startKeepAlive() }\n",
                               CBM_LANG_SWIFT, "t", "setup.swift");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(r->calls.count > 0);
    cbm_free_result(r);
    PASS();
}

/* --- Objective-C --- */
TEST(objc_interface) {
    CBMFileResult *r =
        extract("@interface Animal : NSObject\n- (NSString *)name;\n- (void)speak;\n@end\n",
                CBM_LANG_OBJC, "t", "Animal.h");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

TEST(objc_implementation) {
    CBMFileResult *r = extract("@implementation Animal\n- (NSString *)name { return @\"Animal\"; "
                               "}\n- (void)speak { NSLog(@\"...\"); }\n@end\n",
                               CBM_LANG_OBJC, "t", "Animal.m");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Dart top-level function --- */
TEST(dart_top_level_function) {
    CBMFileResult *r = extract(
        "void main() {\n  print('Hello');\n}\nString greet(String name) => 'Hello $name';\n",
        CBM_LANG_DART, "t", "main.dart");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "main"));
    ASSERT(has_def(r, "Function", "greet"));
    cbm_free_result(r);
    PASS();
}

/* --- Rust enum --- */
TEST(rust_enum) {
    CBMFileResult *r =
        extract("pub enum Direction { North, South, East, West }\n", CBM_LANG_RUST, "t", "dir.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Zig struct --- */
TEST(zig_struct) {
    CBMFileResult *r = extract("const Point = struct { x: f32, y: f32, pub fn dist(self: Point) "
                               "f32 { return self.x + self.y; } };\n",
                               CBM_LANG_ZIG, "t", "point.zig");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- C++ function (standalone) --- */
TEST(cpp_function) {
    CBMFileResult *r = extract("#include <string>\nstd::string greet(const std::string& name) { "
                               "return \"Hello \" + name; }\nint main() { return 0; }\n",
                               CBM_LANG_CPP, "t", "main.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* #1266: GoogleTest TEST() macros with the same name collapse into a single
 * node when multiple tests share a file. Each must mint a distinct Function
 * node whose name encodes the suite and case arguments. */
TEST(cpp_gtest_same_name_collision_issue1266) {
    CBMFileResult *r = extract(
        "namespace demo { int assembleWidget(int s) { return s * 2; } }\n"
        "TEST(WidgetSuite, DoublesSmallSize) { demo::assembleWidget(1); }\n"
        "TEST(WidgetSuite, DoublesZero) { demo::assembleWidget(0); }\n"
        "TEST(WidgetSuite, DoublesLargeSize) {\n"
        "  demo::assembleWidget(1000);\n"
        "}\n",
        CBM_LANG_CPP, "t", "direct_test.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Function", "TEST_WidgetSuite_DoublesSmallSize"));
    ASSERT(has_def(r, "Function", "TEST_WidgetSuite_DoublesZero"));
    ASSERT(has_def(r, "Function", "TEST_WidgetSuite_DoublesLargeSize"));
    ASSERT(!has_def(r, "Function", "TEST"));
    cbm_free_result(r);
    PASS();
}

/* #1266: TEST_F fixture macro also produces unique names. */
TEST(cpp_gtest_f_unique_name_issue1266) {
    CBMFileResult *r = extract(
        "TEST_F(MyFixture, FirstTest) { doStuff(); }\n"
        "TEST_F(MyFixture, SecondTest) { doOtherStuff(); }\n",
        CBM_LANG_CPP, "t", "fixture_test.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Function", "TEST_F_MyFixture_FirstTest"));
    ASSERT(has_def(r, "Function", "TEST_F_MyFixture_SecondTest"));
    ASSERT(!has_def(r, "Function", "TEST_F"));
    cbm_free_result(r);
    PASS();
}

/* --- C++ out-of-line method definitions (#428) ---
 * A .cpp defining methods of a class declared elsewhere (not in this TU).
 * Pre-fix these were recorded as free Functions (label "Function", no
 * parent_class); they must be Methods linked to their enclosing class via
 * parent_class. (The helper also descends nested scopes `ns::Class::method` to
 * the immediate class, but tree-sitter-cpp parses a synthetic doubly-qualified
 * out-of-line def in isolation as an ERROR node, so that path is exercised by
 * real codebases rather than this isolated unit fixture.) */
TEST(cpp_out_of_line_method_issue428) {
    CBMFileResult *r = extract("void Foo::bar() {}\n"
                               "int Foo::baz() { return 0; }\n",
                               CBM_LANG_CPP, "t", "foo.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT(has_def(r, "Method", "bar"));
    ASSERT(has_def(r, "Method", "baz"));
    ASSERT(!has_def(r, "Function", "bar")); /* not a free function */
    /* parent_class links to the enclosing class QN */
    int checked = 0;
    for (int i = 0; i < r->defs.count; i++) {
        const CBMDefinition *d = &r->defs.items[i];
        if (strcmp(d->name, "bar") == 0 && strcmp(d->label, "Method") == 0) {
            ASSERT_NOT_NULL(d->parent_class);
            ASSERT(strstr(d->parent_class, "Foo") != NULL);
            checked = 1;
        }
    }
    ASSERT(checked);
    cbm_free_result(r);
    PASS();
}

/* --- COBOL paragraph --- */
TEST(cobol_paragraph) {
    CBMFileResult *r =
        extract("IDENTIFICATION DIVISION.\nPROGRAM-ID. HELLO.\nPROCEDURE DIVISION.\n    "
                "DISPLAY-GREETING.\n        DISPLAY 'HELLO WORLD'.\n        STOP RUN.\n",
                CBM_LANG_COBOL, "t", "hello.cbl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Verilog module --- */
TEST(verilog_module) {
    CBMFileResult *r =
        extract("module adder(input a, input b, output sum);\n  assign sum = a + b;\nendmodule\n",
                CBM_LANG_VERILOG, "t", "adder.v");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- CUDA kernel --- */
TEST(cuda_kernel) {
    CBMFileResult *r = extract("__global__ void vectorAdd(float *a, float *b, float *c, int n) {\n "
                               "   int i = blockIdx.x * blockDim.x + threadIdx.x;\n    if (i < n) "
                               "c[i] = a[i] + b[i];\n}\nint main() { return 0; }\n",
                               CBM_LANG_CUDA, "t", "vector.cu");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Python decorator --- */
TEST(python_decorator) {
    CBMFileResult *r = extract("class Router:\n    @staticmethod\n    def route(path: str):\n      "
                               "  def decorator(func): return func\n        return decorator\n",
                               CBM_LANG_PYTHON, "t", "router.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Router"));
    cbm_free_result(r);
    PASS();
}

/* --- TypeScript interface --- */
TEST(ts_interface) {
    CBMFileResult *r = extract("export interface Repository<T> { findById(id: number): T; "
                               "save(entity: T): void; delete(id: number): void; }\n",
                               CBM_LANG_TYPESCRIPT, "t", "repo.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- TSX component --- */
TEST(tsx_component) {
    CBMFileResult *r = extract(
        "import React from 'react';\ninterface Props { name: string; }\nexport function Greeting({ "
        "name }: Props) {\n    return <div>Hello {name}</div>;\n}\nexport default Greeting;\n",
        CBM_LANG_TSX, "t", "Greeting.tsx");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Greeting"));
    cbm_free_result(r);
    PASS();
}

/* --- Lua table method --- */
TEST(lua_table_method) {
    CBMFileResult *r =
        extract("local M = {}\nfunction M.create(name)\n    return { name = name }\nend\nfunction "
                "M.greet(self)\n    return 'Hi ' .. self.name\nend\nreturn M\n",
                CBM_LANG_LUA, "t", "module.lua");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Should extract at least one Function from Lua table method */
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    ASSERT_GTE(fn_count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Emacs Lisp defun --- */
TEST(emacs_lisp_defun) {
    CBMFileResult *r = extract("(defun greet (name)\n  (message \"Hello %s\" name))\n(defun main "
                               "()\n  (greet \"World\"))\n",
                               CBM_LANG_EMACSLISP, "t", "init.el");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "greet"));
    ASSERT(has_def(r, "Function", "main"));
    cbm_free_result(r);
    PASS();
}

/* --- Emacs Lisp defvar --- */
TEST(emacs_lisp_defvar) {
    CBMFileResult *r = extract("(defvar my-count 0 \"A counter.\")\n(defcustom my-name \"World\" "
                               "\"The name.\"\n  :type 'string)\n",
                               CBM_LANG_EMACSLISP, "t", "vars.el");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Haskell data type --- */
TEST(haskell_data_type) {
    CBMFileResult *r =
        extract("data Shape = Circle Double | Rectangle Double Double\narea :: Shape -> "
                "Double\narea (Circle r) = pi * r * r\narea (Rectangle w h) = w * h\n",
                CBM_LANG_HASKELL, "t", "Shape.hs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Clojure function (known limitation: defn produces list_lit) --- */
TEST(clojure_function) {
    CBMFileResult *r = extract("(ns greeter.core)\n(defn greet [name]\n  (str \"Hello \" "
                               "name))\n(defn -main [& args]\n  (println (greet \"World\")))\n",
                               CBM_LANG_CLOJURE, "t", "core.clj");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Clojure uses list_lit for all forms — no function defs extracted (known limitation) */
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group E2: Missing Config / Markup Languages
 * ═══════════════════════════════════════════════════════════════════ */

/* --- HTML elements --- */
TEST(html_elements) {
    CBMFileResult *r = extract(
        "<!DOCTYPE "
        "html><html><head><title>Test</title></head><body><h1>Hello</h1><p>World</p></body></html>",
        CBM_LANG_HTML, "t", "index.html");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- SQL function (CREATE FUNCTION) --- */
TEST(sql_function) {
    CBMFileResult *r = extract("CREATE FUNCTION get_user_count() RETURNS INTEGER AS $$ SELECT "
                               "COUNT(*) FROM users; $$ LANGUAGE SQL;\n",
                               CBM_LANG_SQL, "t", "funcs.sql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Meson project --- */
TEST(meson_project) {
    CBMFileResult *r = extract(
        "project('myapp', 'c', version: '1.0.0')\nexecutable('myapp', 'main.c', install: true)\n",
        CBM_LANG_MESON, "t", "meson.build");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- CSS rules --- */
TEST(css_rules) {
    CBMFileResult *r = extract(
        ".container { display: flex; width: 100%; }\n.button { background: #007bff; color: white; "
        "border: none; }\n@media (max-width: 768px) { .container { flex-direction: column; } }\n",
        CBM_LANG_CSS, "t", "styles.css");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- SCSS rules --- */
TEST(scss_rules) {
    CBMFileResult *r = extract("$primary: #007bff;\n.container {\n  width: 100%;\n  .button {\n    "
                               "background: $primary;\n    &:hover { opacity: 0.8; }\n  }\n}\n",
                               CBM_LANG_SCSS, "t", "styles.scss");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- TOML basic --- */
TEST(toml_basic) {
    CBMFileResult *r = extract("[server]\nhost = \"localhost\"\nport = 8080\n\n[database]\nurl = "
                               "\"postgres://localhost/db\"\nmax_connections = 10\n",
                               CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "server"));
    ASSERT(has_def(r, "Class", "database"));
    ASSERT(has_def(r, "Variable", "host"));
    ASSERT(has_def(r, "Variable", "port"));
    cbm_free_result(r);
    PASS();
}

/* --- CMake function --- */
TEST(cmake_function) {
    CBMFileResult *r = extract(
        "cmake_minimum_required(VERSION 3.16)\nproject(MyApp VERSION 1.0)\nadd_executable(myapp "
        "main.cpp)\ntarget_compile_features(myapp PRIVATE cxx_std_17)\n",
        CBM_LANG_CMAKE, "t", "CMakeLists.txt");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- JSON object --- */
TEST(json_object) {
    CBMFileResult *r = extract("{\"name\": \"myapp\", \"version\": \"1.0.0\", \"scripts\": "
                               "{\"build\": \"go build\", \"test\": \"go test ./...\"}}",
                               CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Variable", "name"));
    ASSERT(has_def(r, "Variable", "version"));
    cbm_free_result(r);
    PASS();
}

/* --- Protobuf message --- */
TEST(protobuf_message) {
    CBMFileResult *r = extract(
        "syntax = \"proto3\";\npackage user;\nmessage User { int64 id = 1; string name = 2; string "
        "email = 3; }\nservice UserService { rpc GetUser(User) returns (User); }\n",
        CBM_LANG_PROTOBUF, "t", "user.proto");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- GraphQL type --- */
TEST(graphql_type) {
    CBMFileResult *r = extract("type User {\n  id: ID!\n  name: String!\n  email: String!\n}\ntype "
                               "Query {\n  user(id: ID!): User\n  users: [User!]!\n}\n",
                               CBM_LANG_GRAPHQL, "t", "schema.graphql");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Svelte component --- */
TEST(svelte_component) {
    CBMFileResult *r = extract("<script>\n  let name = 'World';\n  function greet() {\n    return "
                               "`Hello ${name}`;\n  }\n</script>\n<h1>{greet()}</h1>\n",
                               CBM_LANG_SVELTE, "t", "App.svelte");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- Vue component --- */
TEST(vue_component) {
    CBMFileResult *r =
        extract("<template><div>{{ message }}</div></template>\n<script>\nexport default {\n  "
                "name: 'App',\n  data() { return { message: 'Hello World' }; },\n  methods: { "
                "greet() { return this.message; } }\n};\n</script>\n",
                CBM_LANG_VUE, "t", "App.vue");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- GLSL shader --- */
TEST(glsl_shader) {
    CBMFileResult *r = extract(
        "#version 330 core\nvoid main() {\n    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n}\nvec3 "
        "transform(vec3 pos, mat4 mvp) {\n    return (mvp * vec4(pos, 1.0)).xyz;\n}\n",
        CBM_LANG_GLSL, "t", "vertex.glsl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* --- VimScript function --- */
TEST(vimscript_function) {
    CBMFileResult *r = extract("function! SayHello()\n  echo 'Hello'\nendfunction\n",
                               CBM_LANG_VIMSCRIPT, "t", "plugin.vim");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* VimScript extraction may or may not produce named functions */
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "SayHello"));
    }
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group H: Scientific / Math — extended tests
 * ═══════════════════════════════════════════════════════════════════ */

/* --- MATLAB parse (simple expression) --- */
TEST(matlab_parse) {
    CBMFileResult *r = extract("x = 1;\ny = x + 2;\n", CBM_LANG_MATLAB, "t", "simple.matlab");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- MATLAB call --- */
TEST(matlab_call) {
    CBMFileResult *r = extract("function y = foo(x)\n  y = inv(x);\n  disp hello\nend\n",
                               CBM_LANG_MATLAB, "t", "foo.matlab");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "inv"));
    ASSERT(has_call(r, "disp"));
    cbm_free_result(r);
    PASS();
}

/* --- Lean parse (theorem) --- */
TEST(lean_parse) {
    CBMFileResult *r = extract("theorem add_comm (a b : Nat) : a + b = b + a := by omega\n",
                               CBM_LANG_LEAN, "t", "Comm.lean");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- Lean call (recursive fib) --- */
TEST(lean_call) {
    CBMFileResult *r = extract("def fib : Nat \xe2\x86\x92 Nat\n  | 0 => 1\n  | 1 => 1\n  | n + 2 "
                               "=> fib (n + 1) + fib n\n",
                               CBM_LANG_LEAN, "t", "Fib.lean");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "fib"));
    cbm_free_result(r);
    PASS();
}

/* --- Lean type annotation not call --- */
TEST(lean_type_annotation_not_call) {
    CBMFileResult *r = extract(
        "def listLen (xs : List Nat) : Nat := 0\ndef greet : IO Unit := IO.println \"hi\"\n",
        CBM_LANG_LEAN, "t", "Types.lean");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* "List" in binder type position should NOT be extracted as a call */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(strcmp(r->calls.items[i].callee_name, "List") == 0);
    }
    /* IO.println in the body should be present */
    int found_println = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strstr(r->calls.items[i].callee_name, "println") != NULL) {
            found_println = 1;
        }
    }
    ASSERT_TRUE(found_println);
    cbm_free_result(r);
    PASS();
}

/* --- FORM parse (simple expression) --- */
TEST(form_parse) {
    CBMFileResult *r = extract("Symbols x, y;\nLocal F = x + y;\nPrint;\n.end\n", CBM_LANG_FORM,
                               "t", "example.frm");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- FORM call (#call) --- */
TEST(form_call) {
    CBMFileResult *r = extract("#procedure myproc(x)\n  id `x' = 0;\n#endprocedure\n#procedure "
                               "caller()\n  #call myproc(1)\n#endprocedure\n",
                               CBM_LANG_FORM, "t", "calc.frm");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "myproc"));
    cbm_free_result(r);
    PASS();
}

/* --- Magma procedure --- */
TEST(magma_procedure) {
    CBMFileResult *r = extract("procedure PrintHello()\n  print \"Hello\";\nend procedure;\n",
                               CBM_LANG_MAGMA, "t", "hello.mag");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "PrintHello"));
    }
    cbm_free_result(r);
    PASS();
}

/* --- Magma parse (simple) --- */
TEST(magma_parse) {
    CBMFileResult *r = extract("x := 42;\ny := x + 1;\n", CBM_LANG_MAGMA, "t", "simple.mag");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- Magma import (load) --- */
TEST(magma_import) {
    CBMFileResult *r = extract("load \"utils.mag\";\nload \"lib/helpers.mag\";\n", CBM_LANG_MAGMA,
                               "t", "main.mag");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->imports.count, 2);
    cbm_free_result(r);
    PASS();
}

/* --- Magma call --- */
TEST(magma_call) {
    CBMFileResult *r = extract("function Foo(x)\n  y := Bar(x);\n  return y;\nend function;\n",
                               CBM_LANG_MAGMA, "t", "calls.mag");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "Bar"));
    cbm_free_result(r);
    PASS();
}

/* --- Magma disambiguation (.m file as Magma) --- */
TEST(magma_disambiguation) {
    CBMFileResult *r = extract("function Factorial(n)\n  if n le 1 then\n    return 1;\n  end "
                               "if;\n  return n * Factorial(n - 1);\nend function;\n",
                               CBM_LANG_MAGMA, "t", "test.m");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    ASSERT_GTE(fn_count, 1);
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "Factorial"));
    }
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram function (both := and =) --- */
TEST(wolfram_function_extended) {
    CBMFileResult *r = extract("f[x_] := x^2\ng[x_] = x + 1\n", CBM_LANG_WOLFRAM, "t", "funcs.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    ASSERT_GTE(fn_count, 2);
    ASSERT(has_def(r, "Function", "f"));
    ASSERT(has_def(r, "Function", "g"));
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram call --- */
TEST(wolfram_call) {
    CBMFileResult *r = extract("f[x_] := g[x] + h[x]\n", CBM_LANG_WOLFRAM, "t", "calls.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    ASSERT(has_call(r, "g"));
    ASSERT(has_call(r, "h"));
    /* "f" should NOT appear as a call (it's the definition LHS) */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(strcmp(r->calls.items[i].callee_name, "f") == 0);
    }
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram caller attribution --- */
TEST(wolfram_caller_attribution) {
    CBMFileResult *r = extract("f[x_] := g[x] + h[x]\n", CBM_LANG_WOLFRAM, "t", "caller.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    /* Calls inside f[] should have f as enclosing function, not the module path */
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "g") == 0 ||
            strcmp(r->calls.items[i].callee_name, "h") == 0) {
            /* enclosing_func_qn must NOT be empty or the file path */
            ASSERT_NOT_NULL(r->calls.items[i].enclosing_func_qn);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "") == 0);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "t.caller") == 0);
        }
    }
    cbm_free_result(r);
    PASS();
}

/* Issue #438: a C function_definition has no `name` field — the name lives in the
 * declarator chain. Calls inside a C function must be attributed to the enclosing
 * function, not the module. Pre-fix, enclosing_func_qn fell back to the module QN. */
TEST(c_caller_attribution) {
    CBMFileResult *r = extract("int helper(int x) { return x; }\n"
                               "int caller(void) { return helper(1); }\n",
                               CBM_LANG_C, "t", "main.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    int saw_helper = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "helper") == 0) {
            saw_helper = 1;
            /* enclosing_func_qn must be the function, NOT empty and NOT the module QN. */
            ASSERT_NOT_NULL(r->calls.items[i].enclosing_func_qn);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "") == 0);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "t.main") == 0);
        }
    }
    ASSERT(saw_helper);
    cbm_free_result(r);
    PASS();
}

/* adc8304 (the dedup refactor bundled into #463) re-pointed the C/C++ enclosing-
 * function resolver at the canonical declarator walker: qualified names (Foo::bar)
 * now resolve via resolve_qualified_name(), and `type_identifier` was dropped from
 * the terminal-name set. These guard that out-of-line C++ method / ctor / dtor
 * definitions still attribute their inner calls to the enclosing function, not the
 * module — i.e. that the dedup did not reintroduce the #438 regression on the
 * qualified-declarator path. Module QN for "m.cpp" under prefix "t" is "t.m". */
TEST(cpp_out_of_line_method_caller_attribution) {
    CBMFileResult *r = extract("struct Foo { void bar(); };\n"
                               "int helper(int x) { return x; }\n"
                               "void Foo::bar() { helper(1); }\n",
                               CBM_LANG_CPP, "t", "m.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    int saw_helper = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "helper") == 0) {
            saw_helper = 1;
            /* enclosing must be the out-of-line method, NOT empty and NOT the module. */
            ASSERT_NOT_NULL(r->calls.items[i].enclosing_func_qn);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "") == 0);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "t.m") == 0);
        }
    }
    ASSERT(saw_helper);
    cbm_free_result(r);
    PASS();
}

/* Out-of-line constructor (Foo::Foo) and destructor (Foo::~Foo) exercise the
 * identifier and destructor_name branches of resolve_qualified_name(). A call
 * inside either must attribute to that special member, not the module. */
TEST(cpp_out_of_line_ctor_dtor_caller_attribution) {
    CBMFileResult *r = extract("struct Foo { Foo(); ~Foo(); };\n"
                               "int helper(int x) { return x; }\n"
                               "Foo::Foo() { helper(1); }\n"
                               "Foo::~Foo() { helper(2); }\n",
                               CBM_LANG_CPP, "t", "m.cpp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->calls.count, 0);
    int helper_calls = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "helper") == 0) {
            helper_calls++;
            ASSERT_NOT_NULL(r->calls.items[i].enclosing_func_qn);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "") == 0);
            ASSERT_FALSE(strcmp(r->calls.items[i].enclosing_func_qn, "t.m") == 0);
        }
    }
    ASSERT(helper_calls >= 1);
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram parse (simple assignment) --- */
TEST(wolfram_parse) {
    CBMFileResult *r = extract("x = 42;\ny = x + 1;\n", CBM_LANG_WOLFRAM, "t", "simple.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram import --- */
TEST(wolfram_import) {
    CBMFileResult *r =
        extract("<< \"utils.wl\"\nNeeds[\"Package`\"]\n", CBM_LANG_WOLFRAM, "t", "main.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    cbm_free_result(r);
    PASS();
}

/* --- Wolfram nested def --- */
TEST(wolfram_nested_def) {
    CBMFileResult *r = extract("main[x_] := Module[{localF}, localF[t_] := t + 1; localF[x]]\n",
                               CBM_LANG_WOLFRAM, "t", "nested.wl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "main"));
    ASSERT(has_def(r, "Function", "localF"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group I: cbm_test.go ports
 * ═══════════════════════════════════════════════════════════════════ */

TEST(python_docstring) {
    CBMFileResult *r = extract(
        "def compute(x, y):\n    \"\"\"Compute the sum of x and y.\"\"\"\n    return x + y\n",
        CBM_LANG_PYTHON, "test", "test.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "compute"));
    /* Check docstring is present */
    int found = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "compute") == 0) {
            found = 1;
            ASSERT_NOT_NULL(r->defs.items[i].docstring);
            ASSERT_TRUE(strlen(r->defs.items[i].docstring) > 0);
        }
    }
    ASSERT_TRUE(found);
    cbm_free_result(r);
    PASS();
}

TEST(go_function_extraction) {
    CBMFileResult *r =
        extract("package main\n\n// Greet returns a greeting.\nfunc Greet(name string) string "
                "{\n\treturn \"Hello, \" + name\n}\n\nfunc main() {\n\tGreet(\"world\")\n}\n",
                CBM_LANG_GO, "test", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Greet"));
    ASSERT(has_def(r, "Function", "main"));
    ASSERT(has_call(r, "Greet"));
    cbm_free_result(r);
    PASS();
}

TEST(js_arrow_function) {
    CBMFileResult *r = extract("const greet = (name) => {\n  return \"Hello \" + "
                               "name;\n};\n\nconst result = greet(\"world\");\n",
                               CBM_LANG_JAVASCRIPT, "test", "app.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->defs.count, 1);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group J: language_failures_test.go ports
 * ═══════════════════════════════════════════════════════════════════ */

/* CommonLisp — defun extraction (known limitation: grammar produces list_lit) */
TEST(commonlisp_defun) {
    CBMFileResult *r =
        extract("(defun hello () \"world\")\n", CBM_LANG_COMMONLISP, "test", "hello.lisp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Known limitation: CommonLisp grammar produces list_lit, not defun nodes.
     * Function extraction returns 0 — this test documents the limitation. */
    cbm_free_result(r);
    PASS();
}

TEST(commonlisp_multiple_functions) {
    CBMFileResult *r = extract("(defun add (a b) (+ a b))\n(defun mul (a b) (* a b))\n",
                               CBM_LANG_COMMONLISP, "test", "math.lisp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

TEST(commonlisp_defmacro) {
    CBMFileResult *r =
        extract("(defmacro when2 (condition &body body)\n  `(if ,condition (progn ,@body)))\n",
                CBM_LANG_COMMONLISP, "test", "macros.lisp");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    cbm_free_result(r);
    PASS();
}

TEST(makefile_rule_as_function) {
    CBMFileResult *r = extract("all:\n\t@echo hello\n", CBM_LANG_MAKEFILE, "test", "Makefile");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "all"));
    cbm_free_result(r);
    PASS();
}

TEST(makefile_multiple_targets) {
    CBMFileResult *r = extract("all: main.o\n\tgcc -o all main.o\n\nbuild:\n\tgo build ./...\n",
                               CBM_LANG_MAKEFILE, "test", "Makefile");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "all"));
    ASSERT(has_def(r, "Function", "build"));
    cbm_free_result(r);
    PASS();
}

TEST(makefile_variable_extraction) {
    CBMFileResult *r =
        extract("CC := gcc\nCFLAGS := -Wall\n", CBM_LANG_MAKEFILE, "test", "Makefile");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Variable extraction may or may not work depending on Makefile grammar support */
    cbm_free_result(r);
    PASS();
}

TEST(vimscript_function_extraction) {
    CBMFileResult *r = extract("function! SayHello()\n  echo 'Hello'\nendfunction\n",
                               CBM_LANG_VIMSCRIPT, "test", "plugin.vim");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* VimScript function extraction may or may not produce named functions */
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "SayHello"));
    }
    cbm_free_result(r);
    PASS();
}

TEST(vimscript_function_without_bang) {
    CBMFileResult *r = extract("function MyFunc(arg)\n  return arg\nendfunction\n",
                               CBM_LANG_VIMSCRIPT, "test", "plugin.vim");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "MyFunc"));
    }
    cbm_free_result(r);
    PASS();
}

TEST(julia_function_extraction) {
    CBMFileResult *r = extract("function hello()\n  println(\"Hello, World!\")\nend\n",
                               CBM_LANG_JULIA, "test", "hello.jl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "hello"));
    }
    cbm_free_result(r);
    PASS();
}

TEST(julia_function_with_args) {
    CBMFileResult *r = extract("function add(a::Int, b::Int)::Int\n  return a + b\nend\n",
                               CBM_LANG_JULIA, "test", "math.jl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int fn_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Function") == 0)
            fn_count++;
    }
    if (fn_count > 0) {
        ASSERT(has_def(r, "Function", "add"));
    }
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Cross-cutting: Calls + Imports
 * ═══════════════════════════════════════════════════════════════════ */

TEST(python_calls) {
    CBMFileResult *r =
        extract("import os\ndef main():\n    os.path.exists('/tmp')\n    print('hello')\n",
                CBM_LANG_PYTHON, "t", "main.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Python unified extraction produces calls — verify at least some exist */
    ASSERT_GT(r->calls.count, 0);
    cbm_free_result(r);
    PASS();
}

TEST(python_iris_classMethodValue) {
    CBMFileResult *r =
        extract("import iris\n"
                "iris_obj = iris.cls('%Library.ObjectScript')\n"
                "def call_bfs(n):\n"
                "    return iris_obj.classMethodValue('Graph.KG.TraversalBFS', 'BFSFastJson', n)\n",
                CBM_LANG_PYTHON, "t", "store.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "Graph.KG.TraversalBFS.BFSFastJson"));
    cbm_free_result(r);
    PASS();
}

TEST(go_calls) {
    CBMFileResult *r =
        extract("package main\nimport \"fmt\"\nfunc main() { fmt.Println(\"hello\") }\n",
                CBM_LANG_GO, "t", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "fmt.Println"));
    cbm_free_result(r);
    PASS();
}

TEST(python_imports) {
    CBMFileResult *r =
        extract("import os\nfrom sys import argv\nfrom collections import defaultdict\n",
                CBM_LANG_PYTHON, "t", "main.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    cbm_free_result(r);
    PASS();
}

TEST(js_imports) {
    CBMFileResult *r = extract("import React from 'react';\nimport { useState } from "
                               "'react';\nconst fs = require('fs');\n",
                               CBM_LANG_JAVASCRIPT, "t", "app.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    cbm_free_result(r);
    PASS();
}

TEST(go_imports) {
    CBMFileResult *r =
        extract("package main\n\nimport \"fmt\"\nimport (\n    \"os\"\n    net \"net/http\"\n)\n",
                CBM_LANG_GO, "t", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "fmt"));
    cbm_free_result(r);
    PASS();
}

TEST(java_imports) {
    CBMFileResult *r = extract(
        "import java.util.List;\nimport java.util.ArrayList;\nimport static java.lang.Math.PI;\n"
        "public class Foo {}\n",
        CBM_LANG_JAVA, "t", "Foo.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "java.util.List"));
    cbm_free_result(r);
    PASS();
}

TEST(rust_imports) {
    CBMFileResult *r = extract(
        "use std::collections::HashMap;\nuse std::io::{self, Write};\nuse serde::Serialize;\n"
        "fn main() {}\n",
        CBM_LANG_RUST, "t", "main.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "std::collections::HashMap"));
    cbm_free_result(r);
    PASS();
}

TEST(c_imports) {
    CBMFileResult *r = extract("#include <stdio.h>\n#include <stdlib.h>\n#include "
                               "\"mylib.h\"\n\nint main() { return 0; }\n",
                               CBM_LANG_C, "t", "main.c");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "stdio.h"));
    cbm_free_result(r);
    PASS();
}

TEST(ruby_imports) {
    CBMFileResult *r = extract(
        "require 'json'\nrequire 'net/http'\nrequire_relative 'helpers'\n\nclass Foo; end\n",
        CBM_LANG_RUBY, "t", "app.rb");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "json"));
    cbm_free_result(r);
    PASS();
}

TEST(lua_imports) {
    CBMFileResult *r = extract("local json = require(\"dkjson\")\nlocal http = "
                               "require(\"socket.http\")\n\nlocal function greet() end\n",
                               CBM_LANG_LUA, "t", "main.lua");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GT(r->imports.count, 0);
    ASSERT(has_import(r, "dkjson"));
    cbm_free_result(r);
    PASS();
}

TEST(import_stress_go) {
    /* Stress test: 5,000 single-line Go imports.
     * Verifies O(N) behaviour — would hang indefinitely with the O(N²) loop. */
    const int N = 5000;
    /* Each line: import "pkg/NNNNN"\n  = ~20 chars; total ~100KB */
    int buf_size = N * 24 + 64;
    char *src = malloc((size_t)buf_size);
    ASSERT_NOT_NULL(src);

    int pos = 0;
    pos += snprintf(src + pos, (size_t)(buf_size - pos), "package stress\n");
    for (int k = 0; k < N; k++) {
        pos += snprintf(src + pos, (size_t)(buf_size - pos), "import \"pkg/%05d\"\n", k);
    }

    CBMFileResult *r = extract(src, CBM_LANG_GO, "t", "stress.go");
    free(src);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(r->imports.count, N);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Embedded-language import extraction
 * Host grammars (Svelte, Vue, HTML, Astro) keep <script> bodies as
 * raw_text — the embedded-imports walker re-parses each block with the
 * JS grammar so the standard ES import extractor sees real
 * import_statement nodes.
 * ═══════════════════════════════════════════════════════════════════ */

TEST(svelte_imports_basic) {
    /* Default import + named imports + namespace import */
    CBMFileResult *r = extract("<script>\n"
                               "import Foo from './Foo.svelte';\n"
                               "import { bar, baz } from '../lib/utils';\n"
                               "import * as helpers from './helpers';\n"
                               "export let value = 42;\n"
                               "</script>\n"
                               "<h1>Hello {value}</h1>\n",
                               CBM_LANG_SVELTE, "t", "Comp.svelte");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->imports.count, 3);
    ASSERT(has_import(r, "Foo.svelte"));
    ASSERT(has_import(r, "lib/utils"));
    ASSERT(has_import(r, "helpers"));
    cbm_free_result(r);
    PASS();
}

TEST(svelte_imports_no_script) {
    /* .svelte with no <script> block must not crash, 0 imports */
    CBMFileResult *r = extract("<h1>Static page</h1>\n"
                               "<p>No script here.</p>\n",
                               CBM_LANG_SVELTE, "t", "Static.svelte");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(r->imports.count, 0);
    cbm_free_result(r);
    PASS();
}

TEST(vue_imports_basic) {
    /* Vue SFC: same document→script_element→raw_text AST structure */
    CBMFileResult *r = extract("<template><div>{{ msg }}</div></template>\n"
                               "<script>\n"
                               "import MyComp from './MyComp.vue';\n"
                               "import { ref } from 'vue';\n"
                               "export default { name: 'App' };\n"
                               "</script>\n",
                               CBM_LANG_VUE, "t", "App.vue");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->imports.count, 2);
    ASSERT(has_import(r, "MyComp.vue"));
    ASSERT(has_import(r, "vue"));
    cbm_free_result(r);
    PASS();
}

TEST(html_imports_basic) {
    /* Plain HTML with inline ES module imports — same generic walker. */
    CBMFileResult *r = extract("<!DOCTYPE html><html><head>\n"
                               "<script type=\"module\">\n"
                               "import { renderApp } from './app.js';\n"
                               "import * as utils from './utils.js';\n"
                               "renderApp();\n"
                               "</script>\n"
                               "</head><body></body></html>\n",
                               CBM_LANG_HTML, "t", "index.html");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(r->imports.count, 2);
    ASSERT(has_import(r, "app.js"));
    ASSERT(has_import(r, "utils.js"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * config_extraction_test.go ports (25 tests)
 * ═══════════════════════════════════════════════════════════════════ */

/* --- TOML (8 tests) --- */

TEST(toml_basic_table_and_pair) {
    CBMFileResult *r = extract("[database]\nhost = \"localhost\"\nport = 5432\n", CBM_LANG_TOML,
                               "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 1);
    ASSERT(has_def(r, "Class", "database"));
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    ASSERT(has_def(r, "Variable", "host"));
    ASSERT(has_def(r, "Variable", "port"));
    cbm_free_result(r);
    PASS();
}

TEST(toml_nested_table) {
    CBMFileResult *r = extract("[server.http]\nport = 8080\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(toml_table_array_element) {
    CBMFileResult *r = extract("[[servers]]\nname = \"alpha\"\n[[servers]]\nname = \"beta\"\n",
                               CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 2);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(toml_dotted_key) {
    CBMFileResult *r =
        extract("database.host = \"localhost\"\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(toml_quoted_key) {
    CBMFileResult *r = extract("\"unusual-key\" = \"value\"\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(toml_empty_table) {
    CBMFileResult *r = extract("[empty]\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 1);
    ASSERT(has_def(r, "Class", "empty"));
    ASSERT_EQ(count_defs_with_label(r, "Variable"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(toml_comments_only) {
    CBMFileResult *r =
        extract("# just a comment\n# another comment\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 0);
    ASSERT_EQ(count_defs_with_label(r, "Variable"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(toml_boolean_and_integer_values) {
    CBMFileResult *r =
        extract("enabled = true\ncount = 42\nname = \"test\"\n", CBM_LANG_TOML, "t", "config.toml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 3);
    cbm_free_result(r);
    PASS();
}

/* --- INI (4 tests) --- */

TEST(ini_basic_section_and_setting) {
    CBMFileResult *r =
        extract("[database]\nhost = localhost\nport = 5432\n", CBM_LANG_INI, "t", "config.ini");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 1);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(ini_multiple_sections) {
    CBMFileResult *r = extract("[section1]\nkey1 = val1\n[section2]\nkey2 = val2\n", CBM_LANG_INI,
                               "t", "config.ini");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 2);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(ini_global_keys) {
    CBMFileResult *r = extract("key1 = value1\nkey2 = value2\n", CBM_LANG_INI, "t", "config.ini");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 0);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(ini_comments) {
    CBMFileResult *r = extract("; comment\n# another comment\n[section]\nkey = val\n", CBM_LANG_INI,
                               "t", "config.ini");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 1);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 1);
    cbm_free_result(r);
    PASS();
}

/* --- JSON (5 tests) --- */

TEST(json_basic_pair) {
    CBMFileResult *r =
        extract("{\"host\": \"localhost\", \"port\": 5432}", CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 2);
    ASSERT(has_def(r, "Variable", "host"));
    ASSERT(has_def(r, "Variable", "port"));
    cbm_free_result(r);
    PASS();
}

TEST(json_nested_object) {
    CBMFileResult *r = extract("{\"database\": {\"host\": \"localhost\", \"port\": 5432}}",
                               CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 3);
    cbm_free_result(r);
    PASS();
}

TEST(json_empty_object) {
    CBMFileResult *r = extract("{}", CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Variable"), 0);
    cbm_free_result(r);
    PASS();
}

TEST(json_boolean_null_values) {
    CBMFileResult *r = extract("{\"enabled\": true, \"value\": null, \"name\": \"test\"}",
                               CBM_LANG_JSON, "t", "config.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 3);
    cbm_free_result(r);
    PASS();
}

TEST(json_package_json_deps) {
    CBMFileResult *r =
        extract("{\"name\":\"pkg\",\"dependencies\":{\"express\":\"^4.0\",\"lodash\":\"^4.17\"}}",
                CBM_LANG_JSON, "t", "package.json");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Variable"), 4);
    ASSERT(has_def(r, "Variable", "name"));
    ASSERT(has_def(r, "Variable", "dependencies"));
    ASSERT(has_def(r, "Variable", "express"));
    ASSERT(has_def(r, "Variable", "lodash"));
    cbm_free_result(r);
    PASS();
}

/* --- XML (4 tests) --- */

TEST(xml_basic_element) {
    CBMFileResult *r = extract(
        "<?xml version=\"1.0\"?><config><database><host>localhost</host></database></config>",
        CBM_LANG_XML, "t", "config.xml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 3);
    ASSERT(has_def(r, "Class", "config"));
    ASSERT(has_def(r, "Class", "database"));
    ASSERT(has_def(r, "Class", "host"));
    cbm_free_result(r);
    PASS();
}

TEST(xml_self_closing_tag) {
    CBMFileResult *r =
        extract("<?xml version=\"1.0\"?><config><feature enabled=\"true\"/></config>", CBM_LANG_XML,
                "t", "config.xml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(xml_empty_document) {
    CBMFileResult *r = extract("<?xml version=\"1.0\"?><root/>", CBM_LANG_XML, "t", "config.xml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 1);
    cbm_free_result(r);
    PASS();
}

TEST(xml_multiple_children) {
    CBMFileResult *r =
        extract("<?xml version=\"1.0\"?><servers><server/><server/><server/></servers>",
                CBM_LANG_XML, "t", "config.xml");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Class"), 4); /* servers + 3x server */
    cbm_free_result(r);
    PASS();
}

/* --- Markdown (4 tests) --- */

TEST(markdown_atx_headings) {
    CBMFileResult *r =
        extract("# Title\n## Section\n### Subsection\n", CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Section"), 3);
    ASSERT_EQ(count_defs_with_label(r, "Class"), 0); /* Markdown: Section, not Class */
    cbm_free_result(r);
    PASS();
}

TEST(markdown_setext_headings) {
    CBMFileResult *r =
        extract("Title\n=====\nSection\n------\n", CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Section"), 2);
    cbm_free_result(r);
    PASS();
}

TEST(markdown_heading_content) {
    CBMFileResult *r = extract("# Installation Guide\n## Prerequisites\n## Setup\n",
                               CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_GTE(count_defs_with_label(r, "Section"), 3);
    ASSERT(has_def(r, "Section", "Installation Guide"));
    ASSERT(has_def(r, "Section", "Prerequisites"));
    ASSERT(has_def(r, "Section", "Setup"));
    cbm_free_result(r);
    PASS();
}

TEST(markdown_no_headings) {
    CBMFileResult *r =
        extract("Just a paragraph\n\nAnother paragraph\n", CBM_LANG_MARKDOWN, "t", "README.md");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_EQ(count_defs_with_label(r, "Section"), 0);
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Python __init__.py Module QN collision regression
 * ═══════════════════════════════════════════════════════════════════ */

TEST(python_init_module_qn_not_collide_with_folder) {
    /* Bug: __init__.py Module QN was identical to the Folder QN for the
     * same directory, causing the Folder node to be overwritten when the
     * Module was upserted. The Module QN must contain "__init__" to
     * distinguish it from the Folder QN. */
    CBMFileResult *r = extract("class Config:\n    DEBUG = True\n\ndef setup():\n    pass\n",
                               CBM_LANG_PYTHON, "proj", "mypackage/__init__.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Module node must exist */
    ASSERT_GTE(r->defs.count, 1);
    ASSERT_STR_EQ(r->defs.items[0].label, "Module");

    /* Module QN must contain __init__ (not be stripped to just "proj.mypackage") */
    ASSERT_NOT_NULL(r->module_qn);
    ASSERT_NOT_NULL(strstr(r->module_qn, "__init__"));

    /* But symbols inside __init__.py should NOT have __init__ in their QN */
    int found_config = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "Config") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].qualified_name);
            /* Should be "proj.mypackage.Config", NOT "proj.mypackage.__init__.Config" */
            ASSERT_STR_EQ(r->defs.items[i].qualified_name, "proj.mypackage.Config");
            found_config = 1;
        }
    }
    ASSERT_EQ(found_config, 1);

    cbm_free_result(r);
    PASS();
}

TEST(python_init_nested_module_qn) {
    /* Deeply nested __init__.py — same collision must not happen */
    CBMFileResult *r = extract("def greet():\n    return 'hello'\n", CBM_LANG_PYTHON, "proj",
                               "docker-images/cloud-runs/bq-sync-api/__init__.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_NOT_NULL(r->module_qn);
    /* Must contain __init__ to not collide with Folder QN */
    ASSERT_NOT_NULL(strstr(r->module_qn, "__init__"));
    cbm_free_result(r);
    PASS();
}

TEST(js_index_module_qn_not_collide_with_folder) {
    /* Same bug for JS/TS index.ts files */
    CBMFileResult *r = extract("export function App() { return null; }\n", CBM_LANG_TYPESCRIPT,
                               "proj", "src/components/index.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_NOT_NULL(r->module_qn);
    /* Must contain "index" to not collide with Folder QN */
    ASSERT_NOT_NULL(strstr(r->module_qn, "index"));
    cbm_free_result(r);
    PASS();
}

TEST(python_regular_module_qn_unchanged) {
    /* Non-__init__.py Python files should be unaffected */
    CBMFileResult *r =
        extract("def helper():\n    pass\n", CBM_LANG_PYTHON, "proj", "mypackage/utils.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT_NOT_NULL(r->module_qn);
    /* Regular module QN should not contain __init__ or index */
    ASSERT_STR_EQ(r->module_qn, "proj.mypackage.utils");
    cbm_free_result(r);
    PASS();
}

/* Find a definition by name; returns the item or NULL. */
static const CBMDefinition *find_def_by_name(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].name && strcmp(r->defs.items[i].name, name) == 0) {
            return &r->defs.items[i];
        }
    }
    return NULL;
}

static int decorators_contain(const CBMDefinition *d, const char *needle) {
    if (!d || !d->decorators) {
        return 0;
    }
    for (int i = 0; d->decorators[i]; i++) {
        if (strstr(d->decorators[i], needle)) {
            return 1;
        }
    }
    return 0;
}

/* Issue #382: Java Method nodes had empty decorators / signature. */
TEST(extract_java_method_annotations_issue382) {
    CBMFileResult *r = extract("public class C {\n"
                               "  @GetMapping(\"/x\")\n"
                               "  public String cmd(String c) { return c; }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "C.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *m = find_def_by_name(r, "cmd");
    ASSERT_NOT_NULL(m);
    ASSERT(decorators_contain(m, "GetMapping"));
    ASSERT_NOT_NULL(m->signature);
    ASSERT(m->signature[0] != '\0');
    cbm_free_result(r);
    PASS();
}

/* Issue #1005: JAX-RS splits a route across two annotations (@GET carries the
 * verb, a sibling @Path carries the path). Returning on the first mapping
 * annotation dropped every method-level @Path, and the class-level @Path
 * prefix was never recognized at all. */
TEST(extract_java_jaxrs_path_composition_issue1005) {
    CBMFileResult *r = extract("import jakarta.ws.rs.GET;\n"
                               "import jakarta.ws.rs.Path;\n"
                               "@Path(\"/api/v1/widgets\")\n"
                               "public class WidgetResource {\n"
                               "  @GET\n"
                               "  public String list() { return \"\"; }\n"
                               "  @GET\n"
                               "  @Path(\"/count\")\n"
                               "  public String count() { return \"\"; }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "WidgetResource.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *list = find_def_by_name(r, "list");
    ASSERT_NOT_NULL(list);
    ASSERT_NOT_NULL(list->route_path);
    ASSERT_STR_EQ(list->route_path, "/api/v1/widgets");
    ASSERT_STR_EQ(list->route_method, "GET");
    const CBMDefinition *count = find_def_by_name(r, "count");
    ASSERT_NOT_NULL(count);
    ASSERT_NOT_NULL(count->route_path);
    ASSERT_STR_EQ(count->route_path, "/api/v1/widgets/count");
    ASSERT_STR_EQ(count->route_method, "GET");
    cbm_free_result(r);
    PASS();
}

/* A comment between decorators must not drop the decorators above it.
 * Comments are NAMED tree-sitter nodes, so the prev-sibling walk used to stop
 * at one — a documented route (@Post + @HttpCode above an explanatory comment)
 * silently lost those decorators and disappeared from route/authz queries. */
TEST(extract_ts_decorators_survive_interleaved_comment) {
    CBMFileResult *r = extract("class AuthController {\n"
                               "  @Post('login')\n"
                               "  @HttpCode(HttpStatus.OK)\n"
                               "  // throttled per IP and per account\n"
                               "  @Throttle({ default: { ttl: 900_000, limit: 5 } })\n"
                               "  async login(dto: LoginDto) { return 1; }\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "auth.controller.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *m = find_def_by_name(r, "login");
    ASSERT_NOT_NULL(m);
    ASSERT(decorators_contain(m, "Throttle"));  /* below the comment — always worked */
    ASSERT(decorators_contain(m, "HttpCode"));  /* above the comment — was dropped */
    ASSERT(decorators_contain(m, "Post"));      /* above the comment — was dropped */
    cbm_free_result(r);
    PASS();
}

/* Find an in-body call by its raw callee text; returns the call or NULL. */
static const CBMCall *find_call_by_callee(CBMFileResult *r, const char *callee) {
    for (int i = 0; i < r->calls.count; i++) {
        if (r->calls.items[i].callee_name && strcmp(r->calls.items[i].callee_name, callee) == 0) {
            return &r->calls.items[i];
        }
    }
    return NULL;
}

/* Issue #1006: JS/TS template-literal URLs must flatten ${...} substitutions
 * to the canonical "{}" placeholder, both as call arguments (HTTP_CALLS) and
 * as URL-shaped string_refs collected from const/return positions. */
TEST(extract_ts_template_string_url_issue1006) {
    CBMFileResult *r = extract("export function detailPath(id: string): string {\n"
                               "  return `/api/v1/things/${id}/detail`;\n"
                               "}\n"
                               "export function load(id: string) {\n"
                               "  return fetch(`/api/v1/things/${id}`);\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "paths.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMCall *c = find_call_by_callee(r, "fetch");
    ASSERT_NOT_NULL(c);
    ASSERT_NOT_NULL(c->first_string_arg);
    ASSERT_STR_EQ(c->first_string_arg, "/api/v1/things/{}");
    int found = 0;
    for (int i = 0; i < r->string_refs.count; i++) {
        if (r->string_refs.items[i].value &&
            strcmp(r->string_refs.items[i].value, "/api/v1/things/{}/detail") == 0) {
            found = 1;
            break;
        }
    }
    ASSERT(found);
    cbm_free_result(r);
    PASS();
}

/* Issue #1249: a mux route built as `configVar + "/literal"` (Go's idiomatic
 * configurable-base-path pattern) must index the literal suffix, both for a
 * route registration and for an outbound URL built the same way. A real BFF
 * with 47 such registrations produced only 9 Route nodes before this fix. */
TEST(extract_go_binary_concat_url_issue1249) {
    CBMFileResult *r = extract("package main\n"
                               "import \"net/http\"\n"
                               "func setup(mux *http.ServeMux, base string) {\n"
                               "    mux.HandleFunc(base+\"/login\", loginHandler)\n"
                               "}\n"
                               "func report(host string, port string) {\n"
                               "    http.Get(\"http://\" + host + \":\" + port + \"/log\")\n"
                               "}\n",
                               CBM_LANG_GO, "t", "routes.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMCall *reg = find_call_by_callee(r, "mux.HandleFunc");
    ASSERT_NOT_NULL(reg);
    ASSERT_NOT_NULL(reg->first_string_arg);
    ASSERT_STR_EQ(reg->first_string_arg, "/login");

    const CBMCall *out = find_call_by_callee(r, "http.Get");
    ASSERT_NOT_NULL(out);
    ASSERT_NOT_NULL(out->first_string_arg);
    ASSERT_STR_EQ(out->first_string_arg, "/log");

    cbm_free_result(r);
    PASS();
}

/* Same issue: when the right side of the concatenation is not itself a
 * literal (`base + suffixVar`), there is no literal route to recover. The
 * fix must leave this unresolved rather than fabricate a path. */
TEST(extract_go_binary_concat_url_no_literal_suffix_issue1249) {
    CBMFileResult *r = extract("package main\n"
                               "func setup(mux *http.ServeMux, base string, suffix string) {\n"
                               "    mux.HandleFunc(base+suffix, dynHandler)\n"
                               "}\n",
                               CBM_LANG_GO, "t", "routes.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    const CBMCall *reg = find_call_by_callee(r, "mux.HandleFunc");
    ASSERT_NOT_NULL(reg);
    ASSERT_NULL(reg->first_string_arg);

    cbm_free_result(r);
    PASS();
}


/* Reproduce-first: Java module QN must derive from the CONTAINING DIRECTORY, not
 * the filename stem, so a top-level class `Outer` in `Outer.java` is `t.Outer`,
 * NOT the doubled `t.Outer.Outer`. The nested method def QN must also equal the
 * QN the textual calls-enclosing path records for an in-body call (the
 * lsp_resolve join keys on exact caller_qn == enclosing_func_qn equality). */
TEST(extract_java_no_double_class_qn) {
    CBMFileResult *r = extract("class Outer {\n"
                               "    int helper(int x) { return x + 2; }\n"
                               "    class Inner {\n"
                               "        int run(int v) { return helper(v); }\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_JAVA, "t", "Outer.java");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Module QN is the directory (root) → just the project. */
    ASSERT_NOT_NULL(r->module_qn);
    ASSERT_STR_EQ(r->module_qn, "t");

    /* No def QN anywhere may double the top-level class name. */
    for (int i = 0; i < r->defs.count; i++) {
        const char *qn = r->defs.items[i].qualified_name;
        if (qn) {
            ASSERT_EQ(strstr(qn, "Outer.Outer"), NULL);
        }
    }

    /* The nested class and its method carry the single-form QN. */
    const CBMDefinition *outer = find_def_by_name(r, "Outer");
    ASSERT_NOT_NULL(outer);
    ASSERT_STR_EQ(outer->qualified_name, "t.Outer");

    const CBMDefinition *run = find_def_by_name(r, "run");
    ASSERT_NOT_NULL(run);
    ASSERT_STR_EQ(run->qualified_name, "t.Outer.Inner.run");

    /* The in-body call to helper() must be attributed to the SAME QN as the
     * method def — this is the equality the LSP cross-resolution join relies on
     * for nested classes (the lsp_outer_dispatch repro). */
    const CBMCall *call = find_call_by_callee(r, "helper");
    ASSERT_NOT_NULL(call);
    ASSERT_NOT_NULL(call->enclosing_func_qn);
    ASSERT_STR_EQ(call->enclosing_func_qn, run->qualified_name);

    cbm_free_result(r);
    PASS();
}

/* Reproduce-first: Go module QN must derive from the CONTAINING DIRECTORY
 * (package), not the filename stem, so a type/method in `myapp/db/conn.go`
 * belongs to module `proj.myapp.db` and is NOT polluted with the `.conn.`
 * filename segment. */
TEST(extract_go_no_filename_in_module_qn) {
    CBMFileResult *r = extract("package db\n\n"
                               "type Conn struct{}\n\n"
                               "func (c *Conn) Query() {}\n",
                               CBM_LANG_GO, "proj", "myapp/db/conn.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    /* Module is the directory `myapp/db`, NOT `myapp/db/conn`. */
    ASSERT_NOT_NULL(r->module_qn);
    ASSERT_STR_EQ(r->module_qn, "proj.myapp.db");

    /* The type and method QNs must not contain the filename segment `.conn.`. */
    const CBMDefinition *conn = find_def_by_name(r, "Conn");
    ASSERT_NOT_NULL(conn);
    ASSERT_STR_EQ(conn->qualified_name, "proj.myapp.db.Conn");

    /* Go method nodes keep a FLAT QN (module + name) with a separate
     * parent_class link to the receiver type — the QN must carry the
     * directory-based module and NOT the `.conn.` filename segment. */
    const CBMDefinition *query = find_def_by_name(r, "Query");
    ASSERT_NOT_NULL(query);
    ASSERT_STR_EQ(query->qualified_name, "proj.myapp.db.Query");
    ASSERT_EQ(strstr(query->qualified_name, ".conn."), NULL);
    /* The method's parent_class must match the type node QN (for DEFINES_METHOD). */
    ASSERT_NOT_NULL(query->parent_class);
    ASSERT_STR_EQ(query->parent_class, "proj.myapp.db.Conn");

    cbm_free_result(r);
    PASS();
}

/* Issue #213: large TS files were indexed as a File node with zero children. */
TEST(extract_large_ts_has_functions_issue213) {
    enum { NFUNCS = 4000 };
    size_t cap = (size_t)NFUNCS * 80 + 64;
    char *src = (char *)malloc(cap);
    ASSERT_NOT_NULL(src);
    size_t off = 0;
    for (int i = 0; i < NFUNCS; i++) {
        off +=
            (size_t)snprintf(src + off, cap - off,
                             "export function fn%d(a: number): number { return a + %d; }\n", i, i);
    }
    CBMFileResult *r =
        cbm_extract_file(src, (int)off, CBM_LANG_TYPESCRIPT, "t", "big.ts", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    int fns = count_defs_with_label(r, "Function");
    ASSERT_GT(fns, 0); /* must not silently produce zero children */
    cbm_free_result(r);
    free(src);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group: per-function complexity metrics (Tier A — local AST metrics)
 *
 * cbm_compute_complexity stamps each Function/Method with cyclomatic,
 * cognitive, loop_count and loop_depth in the same tree-sitter walk that
 * extracts the definition. loop_depth (max nested-loop depth) is the
 * polynomial-degree proxy used as a queryable bottleneck signal.
 * ═══════════════════════════════════════════════════════════════════ */

/* Return the first definition with the given name, or NULL. */
static const CBMDefinition *find_def(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, name) == 0)
            return &r->defs.items[i];
    }
    return NULL;
}

TEST(complexity_nested_loops_depth) {
    CBMFileResult *r = extract("package p\n"
                               "func deepLoops() {\n"
                               "    for i := 0; i < 10; i++ {\n"
                               "        for j := 0; j < 10; j++ {\n"
                               "            for k := 0; k < 10; k++ {\n"
                               "                doWork()\n"
                               "            }\n"
                               "        }\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_GO, "t", "deep.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "deepLoops");
    ASSERT_NOT_NULL(d);
    ASSERT_EQ(d->loop_depth, 3); /* three nested for-loops */
    ASSERT_EQ(d->loop_count, 3);
    cbm_free_result(r);
    PASS();
}

TEST(complexity_loop_with_branch) {
    CBMFileResult *r = extract("package p\n"
                               "func single() {\n"
                               "    for i := 0; i < 10; i++ {\n"
                               "        if i > 5 {\n"
                               "            doWork()\n"
                               "        }\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_GO, "t", "single.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "single");
    ASSERT_NOT_NULL(d);
    ASSERT_EQ(d->loop_depth, 1);
    ASSERT_EQ(d->loop_count, 1);
    /* the nested `if` contributes a branch, so cyclomatic > 1 and the
     * nesting-weighted cognitive score is non-zero. */
    ASSERT_GT(d->complexity, 1);
    ASSERT_GT(d->cognitive, 0);
    cbm_free_result(r);
    PASS();
}

TEST(complexity_flat_no_loops) {
    CBMFileResult *r = extract("package p\n"
                               "func flat() {\n"
                               "    doWork()\n"
                               "    doMore()\n"
                               "}\n",
                               CBM_LANG_GO, "t", "flat.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "flat");
    ASSERT_NOT_NULL(d);
    ASSERT_EQ(d->loop_depth, 0);
    ASSERT_EQ(d->loop_count, 0);
    cbm_free_result(r);
    PASS();
}

/* A linear-scan call (contains) inside a loop → hidden O(n^2) signal. */
TEST(complexity_linear_scan_in_loop) {
    CBMFileResult *r = extract("package p\n"
                               "func scanInLoop(xs []int, t int) bool {\n"
                               "    for i := 0; i < len(xs); i++ {\n"
                               "        if contains(xs, t) {\n"
                               "            return true\n"
                               "        }\n"
                               "    }\n"
                               "    return false\n"
                               "}\n",
                               CBM_LANG_GO, "t", "scan.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "scanInLoop");
    ASSERT_NOT_NULL(d);
    ASSERT_GT(d->linear_scan_in_loop, 0); /* contains() called inside the for-loop */
    cbm_free_result(r);
    PASS();
}

/* Self-call inside a loop, not guarded by any conditional → recursion_in_loop
 * and unguarded_recursion both set. */
TEST(complexity_recursion_in_loop_unguarded) {
    CBMFileResult *r = extract("package p\n"
                               "func recurInLoop(n int) {\n"
                               "    for i := 0; i < n; i++ {\n"
                               "        recurInLoop(n - 1)\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_GO, "t", "recur.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "recurInLoop");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);
    ASSERT_TRUE(d->recursion_in_loop);
    ASSERT_TRUE(d->unguarded_recursion); /* no self-call inside a conditional */
    cbm_free_result(r);
    PASS();
}

/* Self-call inside an `if` (a base-case guard) → recursive but NOT unguarded. */
TEST(complexity_guarded_recursion) {
    CBMFileResult *r = extract("package p\n"
                               "func guarded(n int) int {\n"
                               "    if n > 0 {\n"
                               "        return guarded(n - 1)\n"
                               "    }\n"
                               "    return 0\n"
                               "}\n",
                               CBM_LANG_GO, "t", "guarded.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "guarded");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);
    ASSERT_FALSE(d->recursion_in_loop);
    ASSERT_FALSE(d->unguarded_recursion); /* self-call is guarded by `if n > 0` */
    cbm_free_result(r);
    PASS();
}

/* #599: super().save() inside a method named save is a parent-class call —
 * the receiver is super(), never self — so it must NOT flag self-recursion.
 * super()-ONLY fixture: no self.save() alongside, so the assertion cannot pass
 * vacuously off a genuine self-call. */
TEST(complexity_super_only_not_recursive) {
    CBMFileResult *r = extract("class B(A):\n"
                               "    def save(self):\n"
                               "        super().save()\n",
                               CBM_LANG_PYTHON, "t", "super_only.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "save");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* parent-class call, not self-recursion */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);
    PASS();
}

/* #599: a same-named call on an unrelated receiver (axios.get inside a
 * function also named get) is delegation, not self-recursion. */
TEST(complexity_same_name_other_receiver_not_recursive) {
    CBMFileResult *r = extract("function get(url) {\n"
                               "    return axios.get(url);\n"
                               "}\n",
                               CBM_LANG_JAVASCRIPT, "t", "axios_get.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "get");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* axios.get targets axios, not this fn */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);
    PASS();
}

/* Guard: genuine self-recursion through self/this receivers still trips the
 * detector after the receiver-aware narrowing (#599). */
TEST(complexity_self_receiver_still_recursive) {
    /* Python: self.recur() — same object. */
    CBMFileResult *r = extract("class C:\n"
                               "    def recur(self, n):\n"
                               "        if n > 0:\n"
                               "            self.recur(n - 1)\n",
                               CBM_LANG_PYTHON, "t", "self_recur.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "recur");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);
    ASSERT_FALSE(d->unguarded_recursion); /* guarded by `if n > 0` */
    cbm_free_result(r);

    /* JS: this.step() — same object. */
    r = extract("class C {\n"
                "    step(n) {\n"
                "        if (n > 0) { this.step(n - 1); }\n"
                "    }\n"
                "}\n",
                CBM_LANG_JAVASCRIPT, "t", "this_step.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    d = find_def(r, "step");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);
    ASSERT_FALSE(d->unguarded_recursion); /* guarded by `if (n > 0)` */
    cbm_free_result(r);
    PASS();
}

/* #599: chained receiver — self.obj.recur() inside recur targets self's FIELD
 * obj, a different object. The whole receiver chain ("self.obj") must be
 * compared, not just its first segment ("self"). */
TEST(complexity_chained_receiver_not_self) {
    CBMFileResult *r = extract("class C:\n"
                               "    def recur(self, n):\n"
                               "        self.obj.recur(n)\n",
                               CBM_LANG_PYTHON, "t", "chained_recur.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "recur");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* self.obj is not self */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);
    PASS();
}

/* #599: Go method receiver — the enclosing def's own receiver identifier
 * (`s` in `func (s *Store) save()`) is whitelisted dynamically from
 * CBMDefinition.receiver, so s.save() still counts as self-recursion while
 * s.backup.save() (a field's same-named method) does not. */
TEST(complexity_go_method_receiver_self_recursion) {
    CBMFileResult *r = extract("package p\n"
                               "type Store struct{}\n"
                               "func (s *Store) save(n int) {\n"
                               "    if n > 0 {\n"
                               "        s.save(n - 1)\n"
                               "    }\n"
                               "}\n",
                               CBM_LANG_GO, "t", "store.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "save");
    ASSERT_NOT_NULL(d);
    ASSERT_TRUE(d->is_recursive);         /* s.save() == receiver s → self */
    ASSERT_FALSE(d->unguarded_recursion); /* guarded by `if n > 0` */
    cbm_free_result(r);

    /* Same-named method on a field of the receiver: NOT self-recursion. */
    r = extract("package p\n"
                "type Store struct{ backup *Store }\n"
                "func (s *Store) save(n int) {\n"
                "    s.backup.save(n)\n"
                "}\n",
                CBM_LANG_GO, "t", "store_backup.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    d = find_def(r, "save");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* s.backup is not s */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);
    PASS();
}

/* #876: the delegation/store bucket left open after #599 — same-named calls
 * whose receiver is a CALL RESULT (_get_store().get), a module singleton
 * (_default.check), or a local cursor inside a loop (cur.execute) are not
 * self-recursion. All three are the reporter's exact v0.8.1 false positives;
 * fixed by the receiver-aware narrowing (87091ed), guarded here so the
 * bucket never regresses. */
TEST(complexity_delegation_receivers_not_recursive_issue876) {
    /* Store wrapper: _get_store().get() inside get — receiver is the call
     * result, a different object. */
    CBMFileResult *r = extract("def _get_store():\n"
                               "    return object()\n"
                               "\n"
                               "def get(collection, record_id):\n"
                               "    rec = _get_store().get(collection, record_id)\n"
                               "    return rec\n",
                               CBM_LANG_PYTHON, "t", "soil.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "get");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* _get_store() result is not this fn */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);

    /* Module-singleton delegation: _default.check() inside check. */
    r = extract("class _Checker:\n"
                "    def check(self, app_id, tool_name):\n"
                "        return (True, \"ok\")\n"
                "\n"
                "_default = _Checker()\n"
                "\n"
                "def check(app_id, tool_name):\n"
                "    return _default.check(app_id, tool_name)\n",
                CBM_LANG_PYTHON, "t", "gleipnir.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* The module-level wrapper (not the method) must stay clean. */
    d = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].name && strcmp(r->defs.items[i].name, "check") == 0 &&
            strcmp(r->defs.items[i].label, "Function") == 0) {
            d = &r->defs.items[i];
        }
    }
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* _default is not this fn */
    ASSERT_FALSE(d->unguarded_recursion);
    cbm_free_result(r);

    /* Same-named method on a local, called inside a loop (willow.nuke case):
     * neither recursive nor recursion_in_loop. */
    r = extract("def execute(conn, paths):\n"
                "    for p in paths:\n"
                "        cur = conn.cursor()\n"
                "        cur.execute(\"DELETE FROM t WHERE p = %s\", (p,))\n"
                "    return True\n",
                CBM_LANG_PYTHON, "t", "nuke.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    d = find_def(r, "execute");
    ASSERT_NOT_NULL(d);
    ASSERT_FALSE(d->is_recursive); /* cur is not this fn */
    ASSERT_FALSE(d->unguarded_recursion);
    ASSERT_FALSE(d->recursion_in_loop);
    cbm_free_result(r);
    PASS();
}

/* Deep chained member access + parameter count structure smells. */
TEST(complexity_access_depth_and_params) {
    CBMFileResult *r = extract("package p\n"
                               "func deepAccess(x Foo, a int, b int, c int) int {\n"
                               "    return x.alpha.beta.gamma.delta\n"
                               "}\n",
                               CBM_LANG_GO, "t", "access.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    const CBMDefinition *d = find_def(r, "deepAccess");
    ASSERT_NOT_NULL(d);
    ASSERT_GT(d->max_access_depth, 2); /* x.alpha.beta.gamma.delta */
    ASSERT_GTE(d->param_count, 3);     /* x, a, b, c (grouping may vary) */
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Perl call-graph noise (#459 follow-up)
 * ═══════════════════════════════════════════════════════════════════ */

/* Count calls whose callee_name is exactly `name` (has_call is substring). */
static int count_calls_exact(CBMFileResult *r, const char *name) {
    int n = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (r->calls.items[i].callee_name && strcmp(r->calls.items[i].callee_name, name) == 0)
            n++;
    }
    return n;
}

/* (b) A dotted config string must never be extracted as a callee. */
TEST(extract_perl_config_string_not_a_callee) {
    CBMFileResult *r = extract("package C;\n"
                               "sub run {\n"
                               "  my $cfg = { \"log4perl.appender.File.utf8\" => 1 };\n"
                               "  helper();\n"
                               "}\n"
                               "sub helper { return 1; }\n"
                               "1;\n",
                               CBM_LANG_PERL, "t", "app.pl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* No callee may contain a '.' (config/string tokens are rejected). */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_TRUE(strchr(r->calls.items[i].callee_name, '.') == NULL);
    }
    /* (d) The genuine intra-file function call is still extracted. */
    ASSERT_TRUE(count_calls_exact(r, "helper") >= 1);
    cbm_free_result(r);
    PASS();
}

/* (a) A Perl builtin call is extracted as a non-method callee. Suppression of
 *     the resulting CALLS edge happens in the resolver (see test_registry.c /
 *     end-to-end); extraction itself keeps the bare builtin token. */
TEST(extract_perl_builtin_call_is_function_not_method) {
    CBMFileResult *r = extract("package B;\n"
                               "sub run {\n"
                               "  my @x;\n"
                               "  push @x, 1;\n"
                               "  keys %h;\n"
                               "}\n"
                               "1;\n",
                               CBM_LANG_PERL, "t", "b.pl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* push / keys are extracted (they are valid identifiers) ... */
    ASSERT_TRUE(has_call(r, "push"));
    /* ... and crucially are NOT flagged as method calls. */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(r->calls.items[i].is_method);
    }
    cbm_free_result(r);
    PASS();
}

/* (c) An arrow/method call is extracted with is_method=true so the resolver
 *     can suppress generic short-name matching for it. */
TEST(extract_perl_method_call_flags_is_method) {
    CBMFileResult *r = extract("package M;\n"
                               "sub run {\n"
                               "  my $self = shift;\n"
                               "  $self->commit();\n"
                               "  $dbh->commit();\n"
                               "  helper();\n"
                               "}\n"
                               "sub helper { return 1; }\n"
                               "1;\n",
                               CBM_LANG_PERL, "t", "m.pl");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Every "commit" call is a method call (is_method set). */
    int commit_calls = 0;
    for (int i = 0; i < r->calls.count; i++) {
        if (strcmp(r->calls.items[i].callee_name, "commit") == 0) {
            commit_calls++;
            ASSERT_TRUE(r->calls.items[i].is_method);
        }
        /* The genuine function call is NOT a method. */
        if (strcmp(r->calls.items[i].callee_name, "helper") == 0) {
            ASSERT_FALSE(r->calls.items[i].is_method);
        }
    }
    ASSERT_TRUE(commit_calls >= 1);
    /* (d) genuine intra-file function call still extracted. */
    ASSERT_TRUE(count_calls_exact(r, "helper") >= 1);
    cbm_free_result(r);
    PASS();
}

/* Languages OUTSIDE the is_method flag set (only Perl and TS/JS/TSX set it) must
 * be unaffected: a Go method call never sets is_method. */
TEST(extract_flag_exempt_method_call_not_flagged_is_method) {
    CBMFileResult *r = extract("package m\n"
                               "func run(o Obj) { o.Commit(); helper() }\n",
                               CBM_LANG_GO, "t", "x.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(r->calls.items[i].is_method);
    }
    cbm_free_result(r);
    PASS();
}

/* TS/JS/TSX receiver-aware flag (#592/#606; same intent as the Perl flag above).
 * A member call x.foo() with a non-this/super receiver is flagged is_method so
 * the resolver can suppress a weak short-name match (`re.test()` must not bind a
 * project `test`); a bare call is not flagged. */
TEST(extract_ts_member_call_flags_is_method) {
    CBMFileResult *r = extract("const re = /^a+$/;\n"
                               "export function checkFormat(s: string) { return re.test(s); }\n"
                               "function helper() { return 1; }\n"
                               "export function run() { return helper(); }\n",
                               CBM_LANG_TYPESCRIPT, "t", "a.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int member = 0;
    int bare = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const char *cn = r->calls.items[i].callee_name;
        if (strcmp(cn, "re.test") == 0) {
            member++;
            ASSERT_TRUE(r->calls.items[i].is_method);
        }
        if (strcmp(cn, "helper") == 0) {
            bare++;
            ASSERT_FALSE(r->calls.items[i].is_method);
        }
    }
    ASSERT_TRUE(member >= 1); /* re.test() flagged */
    ASSERT_TRUE(bare >= 1);   /* helper() not flagged */
    cbm_free_result(r);
    PASS();
}

/* this/super receivers keep the enclosing-class target, where a weak
 * namespace-proximity match is usually correct — so they are NOT flagged. A
 * new_expression has no member receiver and is never flagged either. */
TEST(extract_ts_this_super_receiver_not_flagged) {
    CBMFileResult *r = extract("class A extends B {\n"
                               "  m() { this.helper(); super.render(); return new A(); }\n"
                               "  helper() {}\n"
                               "}\n",
                               CBM_LANG_TYPESCRIPT, "t", "b.ts");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    /* Every call here has a self receiver (this/super) or is a new-expression,
     * so NONE may be flagged. */
    for (int i = 0; i < r->calls.count; i++) {
        ASSERT_FALSE(r->calls.items[i].is_method);
    }
    /* Sanity: the this/super member calls were actually extracted. */
    ASSERT_TRUE(has_call(r, "helper")); /* this.helper */
    ASSERT_TRUE(has_call(r, "render")); /* super.render */
    cbm_free_result(r);
    PASS();
}

/* JS dialect behaves like TS (the flag is gated on the language set, not the
 * dialect). Replaces the pre-#592 test that asserted JS never flags is_method. */
TEST(extract_js_member_call_flags_is_method) {
    CBMFileResult *r =
        extract("function run(o){ o.commit(); helper(); }\n", CBM_LANG_JAVASCRIPT, "t", "x.js");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int member = 0;
    int bare = 0;
    for (int i = 0; i < r->calls.count; i++) {
        const char *cn = r->calls.items[i].callee_name;
        if (strcmp(cn, "o.commit") == 0) {
            member++;
            ASSERT_TRUE(r->calls.items[i].is_method);
        }
        if (strcmp(cn, "helper") == 0) {
            bare++;
            ASSERT_FALSE(r->calls.items[i].is_method);
        }
    }
    ASSERT_TRUE(member >= 1); /* o.commit() flagged */
    ASSERT_TRUE(bare >= 1);   /* helper() not flagged */
    cbm_free_result(r);
    PASS();
}

/* #961: a C function whose body braces are split across #ifdef/#else
 * branches (one open brace per branch, a single shared close) parses with
 * an ERROR region on the raw source — both branches are present at once —
 * and the defs walk silently dropped the function while its callers stayed
 * (cbm_path_within_root, handle_process_kill). The preprocessed second
 * pass (simplecpp picks one branch, same-file token lines stay aligned)
 * must recover the definition with its original line. */
TEST(extract_c_ifdef_split_brace_fn_recovered_issue961) {
    CBMFileResult *r = extract("static int a(void) { return 1; }\n"
                               "static int b(void) { return 2; }\n"
                               "int split_brace_fn(int x) {\n"
                               "#ifdef _WIN32\n"
                               "    if (a() && b()) {\n"
                               "#else\n"
                               "    if (a() || b()) {\n"
                               "#endif\n"
                               "        x += 1;\n"
                               "    }\n"
                               "    return x;\n"
                               "}\n"
                               "int after_fn(int x) { return x; }\n",
                               CBM_LANG_C, "t", "split.c");
    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = find_def(r, "split_brace_fn");
    if (!d) {
        fprintf(stderr, "  [961] FAIL split_brace_fn dropped (defs walk lost the "
                        "#ifdef-split function)\n");
    }
    ASSERT_NOT_NULL(d);
    ASSERT_EQ((int)d->start_line, 3);
    /* Error recovery must stay localized: neighbours extract either way. */
    ASSERT_NOT_NULL(find_def(r, "a"));
    ASSERT_NOT_NULL(find_def(r, "after_fn"));
    cbm_free_result(r);
    PASS();
}

static const char *CPP_PREPROC_SIGNATURE_GAP_SRC =
    "struct Rect {};\n"
    "struct IBinder {};\n"
    "struct IRegionSamplingListener {};\n"
    "typedef int status_t;\n"
    "\n"
    "class SurfaceFlinger {\n"
    "public:\n"
    "    status_t addRegionSamplingListener(const Rect&, const IBinder&,\n"
    "                                       const IRegionSamplingListener&, bool);\n"
    "    status_t addRegionSamplingListener(const Rect&, const IBinder&,\n"
    "                                       const IRegionSamplingListener&);\n"
    "    void commit();\n"
    "    void composite();\n"
    "};\n"
    "\n"
    "#ifdef FLYME_GRAPHICS_EXTEND_LUMARGB\n"
    "status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,\n"
    "                                                   const IBinder& stopLayerHandle,\n"
    "                                                   const IRegionSamplingListener& listener,\n"
    "                                                   const bool rgbSample) {\n"
    "#else\n"
    "status_t SurfaceFlinger::addRegionSamplingListener(const Rect& samplingArea,\n"
    "                                                   const IBinder& stopLayerHandle,\n"
    "                                                   const IRegionSamplingListener& listener) "
    "{\n"
    "#endif\n"
    "    return 0;\n"
    "}\n"
    "\n"
    "void SurfaceFlinger::commit() {}\n"
    "\n"
    "void SurfaceFlinger::composite() {}\n";

/* #946 fixture from the original report: both preprocessor choices must keep
 * raw definitions primary while recovering later methods at original lines. */
TEST(extract_cpp_preproc_signature_gap_issue946) {
    const char *defines[] = {"FLYME_GRAPHICS_EXTEND_LUMARGB", NULL};
    for (int enabled = 0; enabled < 2; enabled++) {
        CBMFileResult *r = cbm_extract_file(
            CPP_PREPROC_SIGNATURE_GAP_SRC, (int)strlen(CPP_PREPROC_SIGNATURE_GAP_SRC), CBM_LANG_CPP,
            "t", "SurfaceFlinger.cpp", 0, enabled ? defines : NULL, NULL);
        ASSERT_NOT_NULL(r);
        const CBMDefinition *add = find_def(r, "addRegionSamplingListener");
        const CBMDefinition *commit = find_def(r, "commit");
        const CBMDefinition *composite = find_def(r, "composite");
        ASSERT_NOT_NULL(add);
        ASSERT_NOT_NULL(commit);
        ASSERT_NOT_NULL(composite);
        ASSERT_EQ(add->start_line, 22u);
        ASSERT_EQ(add->end_line, 27u);
        ASSERT_EQ(commit->start_line, 29u);
        ASSERT_EQ(commit->end_line, 29u);
        ASSERT_EQ(composite->start_line, 31u);
        ASSERT_EQ(composite->end_line, 31u);
        cbm_free_result(r);
    }
    PASS();
}

/* Macro expansion can produce callable-looking AST nodes, but no callable
 * definition exists in the original span; recovery must fail closed. */
TEST(extract_cpp_preproc_macro_generated_callable_skipped_issue949) {
    const char *src = "#define MAKE_FN(name) int name() { return 1; }\n"
                      "#ifdef ENABLE_GENERATED\n"
                      "MAKE_FN(generated)\n"
                      "#endif\n"
                      "int visible() { return 0; }\n";
    const char *defines[] = {"ENABLE_GENERATED", NULL};
    CBMFileResult *r =
        cbm_extract_file(src, (int)strlen(src), CBM_LANG_CPP, "t", "macro.cpp", 0, defines, NULL);
    ASSERT_NOT_NULL(r);
    ASSERT_NULL(find_def(r, "generated"));
    ASSERT_NOT_NULL(find_def(r, "visible"));
    ASSERT_TRUE(r->parse_incomplete);
    ASSERT_GTE(r->error_region_count, 1);
    ASSERT_NOT_NULL(r->error_ranges);
    cbm_free_result(r);
    PASS();
}

/* #949 follow-up: an included header shifts physical lines in simplecpp's
 * expanded output. The #1050 name-on-same-line guard skipped this recoverable
 * definition; explicit source ownership mapping must restore its original
 * coordinates while keeping header definitions out of the main file. */
TEST(extract_c_ifdef_split_brace_after_include_remapped_issue949) {
    char tmpdir[512];
    snprintf(tmpdir, sizeof(tmpdir), "%s/cbm_line_map_XXXXXX", cbm_tmpdir());
    ASSERT_NOT_NULL(cbm_mkdtemp(tmpdir));

    char header_path[512];
    snprintf(header_path, sizeof(header_path), "%s/padding.h", tmpdir);
    FILE *header = cbm_fopen(header_path, "wb");
    ASSERT_NOT_NULL(header);
    for (int i = 0; i < 40; i++) {
        ASSERT_GTE(fprintf(header, "static int header_pad_%d(void) { return %d; }\n", i, i), 0);
    }
    ASSERT_EQ(fclose(header), 0);

    const char *includes[] = {tmpdir, NULL};
    const char *src = "#include \"padding.h\"\n"
                      "static int before(void) { return 1; }\n"
                      "int shifted_split(int x) {\n"
                      "#ifdef _WIN32\n"
                      "    if (before()) {\n"
                      "#else\n"
                      "    if (x > 0) {\n"
                      "#endif\n"
                      "        x += 1;\n"
                      "    }\n"
                      "    return x;\n"
                      "}\n"
                      "int after(void) { return 2; }\n";
    CBMFileResult *r =
        cbm_extract_file(src, (int)strlen(src), CBM_LANG_C, "t", "shifted.c", 0, NULL, includes);
    cbm_unlink(header_path);
    cbm_rmdir(tmpdir);

    ASSERT_NOT_NULL(r);
    const CBMDefinition *d = find_def(r, "shifted_split");
    ASSERT_NOT_NULL(d);
    ASSERT_EQ(d->start_line, 3u);
    ASSERT_EQ(d->end_line, 12u);
    ASSERT_NULL(find_def(r, "header_pad_0"));
    ASSERT_NOT_NULL(find_def(r, "after"));
    ASSERT_FALSE(r->parse_incomplete);
    ASSERT_EQ(r->error_region_count, 0);
    ASSERT_NULL(r->error_ranges);
    cbm_free_result(r);
    PASS();
}

/* #961 inverse guard: a clean C file must not gain duplicate or phantom
 * defs from the recovery path (it only engages on raw-parse ERROR regions). */
TEST(extract_c_clean_file_no_recovery_duplicates_issue961) {
    CBMFileResult *r = extract("#ifdef _WIN32\n"
                               "static int w(void) { return 1; }\n"
                               "#else\n"
                               "static int u(void) { return 2; }\n"
                               "#endif\n"
                               "int use(int x) { return x; }\n",
                               CBM_LANG_C, "t", "clean.c");
    ASSERT_NOT_NULL(r);
    int use_count = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (r->defs.items[i].name && strcmp(r->defs.items[i].name, "use") == 0)
            use_count++;
    }
    ASSERT_EQ(use_count, 1);
    cbm_free_result(r);
    PASS();
}

/* #668: walk_defs used a fixed `walk_defs_frame_t stack[4096]` — a ~160 KB
 * C-stack frame that overflowed small thread stacks (the reporter's crash was in
 * the "definitions pass" on a large SQL file), and whose `top < 4096` push guards
 * SILENTLY DROPPED every top-level definition past 4096. The growable heap stack
 * fixes both: a file with > 4096 top-level defs must extract ALL of them. RED
 * before the fix (extracted count capped near 4096), GREEN after. */
TEST(walk_defs_no_truncation_over_4096_issue668) {
    enum { N = 5000 };
    /* N top-level Python defs → N Function defs, all direct module children, so
     * walk_defs pushes all N children at once — the >4096 truncation site. */
    size_t cap = (size_t)N * 24 + 1;
    char *src = (char *)malloc(cap);
    ASSERT_NOT_NULL(src);
    size_t off = 0;
    for (int i = 0; i < N; i++) {
        off += (size_t)snprintf(src + off, cap - off, "def f%d(): pass\n", i);
    }
    CBMFileResult *r = extract(src, CBM_LANG_PYTHON, "t", "big.py");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int nfuncs = count_defs_with_label(r, "Function");
    ASSERT(nfuncs >= N); /* all N present — not truncated at the old 4096 cap */
    cbm_free_result(r);
    free(src);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Suite
 * ═══════════════════════════════════════════════════════════════════ */

/* Rust: inline #[test]/#[tokio::test] functions must be marked is_test so the
 * store.c `is_test != 1` filter excludes them from graph context. Detection is
 * otherwise file-path-based (cbm_is_test_file), so test fns in a regular .rs
 * file leak. (#855) */
TEST(extract_rust_test_attr_marks_is_test_issue855) {
    CBMFileResult *r = extract("pub fn real_fn() {}\n"
                               "\n"
                               "#[test]\n"
                               "fn sync_test() {}\n"
                               "\n"
                               "#[tokio::test]\n"
                               "async fn async_test() {}\n",
                               CBM_LANG_RUST, "t", "src/lib.rs");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);

    int real = -1, sync = -1, asyn = -1;
    for (int i = 0; i < r->defs.count; i++) {
        const char *n = r->defs.items[i].name;
        if (!n) {
            continue;
        }
        if (strcmp(n, "real_fn") == 0) {
            real = r->defs.items[i].is_test ? 1 : 0;
        } else if (strcmp(n, "sync_test") == 0) {
            sync = r->defs.items[i].is_test ? 1 : 0;
        } else if (strcmp(n, "async_test") == 0) {
            asyn = r->defs.items[i].is_test ? 1 : 0;
        }
    }
    ASSERT(real >= 0 && sync >= 0 && asyn >= 0 && "all three fns extracted");
    ASSERT(real == 0 && "real_fn is NOT a test");
    ASSERT(sync == 1 && "#[test] fn is_test");
    ASSERT(asyn == 1 && "#[tokio::test] fn is_test");

    cbm_free_result(r);
    PASS();
}

/* #1017: docstring truncation at MAX_COMMENT_LEN (500 bytes) can split a
 * multi-byte UTF-8 character, leaving an incomplete byte sequence.
 * Craft a Go comment whose 498th-500th bytes are a 3-byte CJK character
 * (U+6210 = 成 = e6 88 90).  The raw byte truncation at offset 500 lands
 * one byte past the character start, splitting it.  After the fix the
 * truncated string must end on a complete codepoint boundary. */
TEST(docstring_utf8_truncation_boundary_issue1017) {
    /* Build a comment: "// " (3 bytes) + 495 ASCII 'A' + "成成成" (9 bytes)
     * Total comment text = 3 + 495 + 9 = 507 bytes.
     * MAX_COMMENT_LEN = 500.  The first kanji (成 = e6 88 90) occupies
     * offsets 498-500, so text[500] = '\0' keeps bytes 0-499: the lead
     * byte 0xe6 plus one continuation 0x88 — an incomplete 2-of-3 sequence.
     * Before fix: the truncated string ended with that broken pair. */
    char comment[600];
    int off = 0;
    comment[off++] = '/';
    comment[off++] = '/';
    comment[off++] = ' ';
    for (int i = 0; i < 495; i++)
        comment[off++] = 'A';
    /* U+6210 (成) = 0xe6 0x88 0x90 — 3-byte UTF-8 */
    const char *kanji = "\xe6\x88\x90";
    for (int k = 0; k < 3; k++) {
        memcpy(comment + off, kanji, 3);
        off += 3;
    }
    comment[off] = '\0';

    /* Wrap in a Go function so the comment becomes the docstring. */
    char src[800];
    snprintf(src, sizeof(src), "package main\n\n%s\nfunc Compute() {}\n", comment);

    CBMFileResult *r = extract(src, CBM_LANG_GO, "test", "main.go");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Compute"));

    const char *doc = NULL;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "Compute") == 0) {
            doc = r->defs.items[i].docstring;
            break;
        }
    }
    ASSERT_NOT_NULL(doc);

    /* Verify every byte in the truncated docstring is valid UTF-8:
     * no trailing incomplete multi-byte sequence. */
    size_t len = strlen(doc);
    ASSERT_TRUE(len <= 500);
    const unsigned char *u = (const unsigned char *)doc;
    size_t i = 0;
    while (i < len) {
        unsigned char c = u[i];
        int seq_len;
        if (c < 0x80)
            seq_len = 1;
        else if ((c & 0xE0) == 0xC0)
            seq_len = 2;
        else if ((c & 0xF0) == 0xE0)
            seq_len = 3;
        else if ((c & 0xF8) == 0xF0)
            seq_len = 4;
        else
            FAIL("invalid UTF-8 lead byte");
        ASSERT_TRUE(i + (size_t)seq_len <= len);
        for (int j = 1; j < seq_len; j++)
            ASSERT_TRUE((u[i + (size_t)j] & 0xC0) == 0x80);
        i += (size_t)seq_len;
    }

    cbm_free_result(r);
    PASS();
}

/* Reproduce-first (ms-typescript reallyLargeFile.ts, 2026-07-07): a file
 * whose root node has hundreds of thousands of FLAT SIBLINGS (580k ////
 * comment lines in the 3.5 MB fourslash fixture) hung extraction for over
 * 15 minutes: walk_defs pushed children via index-based ts_node_child(i),
 * which is O(i) per call in tree-sitter — O(n^2) per wide node (~1.7e11
 * iterator steps on the real file; 100% of stack samples inside
 * ts_node_child_iterator_next). The supervisor then killed the silent
 * worker as a hang and, via the stale extraction marker, quarantined
 * INNOCENT files on every retry.
 *
 * This fixture is an 80k-sibling flat file: quadratic child access needs
 * minutes under ASan; the linear TSTreeCursor collection finishes in
 * milliseconds. The 30 s bound has ~100x headroom over the fixed cost —
 * RED on index-based child pushes, GREEN on the cursor walk. The def-count
 * guard keeps the test honest: extraction must actually process the whole
 * breadth, not skip it. */
/* Extract a wide-flat comment-sibling fixture of n lines (the exact shape of
 * ms-typescript's reallyLargeFile.ts: hundreds of thousands of flat comment
 * children under the root, plus sparse real defs so the breadth check cannot
 * pass vacuously). Returns elapsed milliseconds; stores the def count. */
static long extract_wide_flat_ms(int n, int *out_defs) {
    const size_t cap = (size_t)n * 24 + (size_t)8192; /* "// wide filler N\n" <= 24 chars */
    char *src = malloc(cap);
    if (!src) {
        return -1;
    }
    size_t off = 0;
    /* CONSTANT def count (10), independent of n: defs that scale WITH n make
     * the fixture superlinear through the separate per-def sibling-scan cost
     * (O(defs x siblings)) — on windows-CLANG64 ASan that pushed the ratio
     * of LINEAR walk code to 43x. Ten spread-out defs keep the breadth check
     * honest while the sibling-scan term stays 10 x n = linear. */
    const int def_stride = n / 10;
    for (int i = 0; i < n; i++) {
        off += (size_t)snprintf(src + off, cap - off, "// wide filler %d\n", i);
        if (i % def_stride == 0) {
            off += (size_t)snprintf(src + off, cap - off, "var wide_a%d = %d;\n", i, i);
        }
    }
    struct timespec a;
    struct timespec b;
    cbm_clock_gettime(CLOCK_MONOTONIC, &a);
    CBMFileResult *r =
        cbm_extract_file(src, (int)off, CBM_LANG_JAVASCRIPT, "proj", "wide.js", 0, NULL, NULL);
    cbm_clock_gettime(CLOCK_MONOTONIC, &b);
    free(src);
    if (!r) {
        return -1;
    }
    *out_defs = r->defs.count;
    cbm_free_result(r);
    return (b.tv_sec - a.tv_sec) * 1000L + (b.tv_nsec - a.tv_nsec) / 1000000L;
}

/* Best-of-N. Timing noise only ever ADDS time, so the minimum of a few runs is
 * the cheapest good estimate of the noise-free cost. A single sample at each
 * size made the RATIO carry the noise of BOTH measurements: on a loaded Windows
 * VM this read 184ms -> 9387ms (51x) for code that measures ~20x unloaded, and
 * tripped a bound calibrated for exactly that linear case.
 *
 * Deliberately NOT solved by raising WF_RATIO_MAX: the bound sits where it does
 * because linear (~20x) and quadratic (~128x) are each >=2x away from it, so
 * inflating it moves the test toward the very signal it exists to catch. This
 * keeps the threshold and removes the variance instead. */
static long extract_wide_flat_ms_best_of(int n, int reps, int *out_defs) {
    long best = -1;
    for (int i = 0; i < reps; i++) {
        int defs = 0;
        long ms = extract_wide_flat_ms(n, &defs);
        if (ms < 0) {
            return ms;
        }
        if (best < 0 || ms < best) {
            best = ms;
            *out_defs = defs;
        }
    }
    return best;
}

TEST(extract_wide_flat_file_is_linear) {
    /* SCALING-RATIO guard: assert the COMPLEXITY CLASS, not a wall-clock
     * bound. Index-based ts_node_child(i) child loops are O(i) per call —
     * quadratic per wide node — and hung a 580k-sibling file for hours
     * (ms-typescript reallyLargeFile.ts). An absolute time bound conflates
     * machine speed with complexity: the gcc-13-ARM ASan CI leg runs this
     * extraction ~200x slower than clang at the SAME (measured perfectly
     * linear: 27.1s/54.2s/108.3s for 50k/100k/200k) complexity, and flunked
     * a 30s bound on linear code. Growing the input 4x must grow the time
     * ~4x when linear and ~16x when quadratic; the 10x bound splits those
     * decisively on every toolchain. The 120ms floor keeps clock noise from
     * mattering on fast machines. */
    /* Growth and bound CALIBRATED FROM MEASUREMENT, not models. The ASan
     * test build carries a large LINEAR per-line baseline (~31us/line on
     * clang-macOS, ~540us/line on gcc-13-ARM) that dilutes small-growth
     * ratios: at 8x growth the measured quadratic ratio was 22.4 — a 24x
     * bound false-passed the known-quadratic pre-merge walk. At 20x growth
     * the measured ratios are ~20x for linear code (both toolchains) and
     * ~128x for the quadratic walk (clang-macOS) — bound 40 sits >=2x from
     * both. The 120ms floor keeps clock noise irrelevant on fast hosts. */
    enum { WF_SMALL = 20 * 1000, WF_BIG = 400 * 1000, WF_RATIO_MAX = 40, WF_FLOOR_MS = 120 };
    int defs_small = 0;
    int defs_big = 0;
    /* Small is cheap, so sample it more; big dominates runtime, so twice is the
     * affordable compromise that still discards one unlucky sample. */
    long t_small = extract_wide_flat_ms_best_of(WF_SMALL, 3, &defs_small);
    long t_big = extract_wide_flat_ms_best_of(WF_BIG, 2, &defs_big);
    ASSERT_GTE(t_small, 0);
    ASSERT_GTE(t_big, 0);
    /* Anti-vacuous guard: the breadth was actually walked at both sizes. */
    ASSERT_GTE(defs_small, 8);
    ASSERT_GTE(defs_big, 8);
    fprintf(stderr, "  [wide-flat] t(%d)=%ldms t(%d)=%ldms\n", WF_SMALL, t_small, WF_BIG, t_big);
    long base = t_small > WF_FLOOR_MS ? t_small : WF_FLOOR_MS;
    if (t_big > WF_RATIO_MAX * base) {
        char msg[160];
        snprintf(msg, sizeof(msg),
                 "wide-flat scaling 20x input: %ldms -> %ldms (> %dx base %ldms) — "
                 "quadratic child access",
                 t_small, t_big, WF_RATIO_MAX, base);
        FAIL(msg);
    }
    PASS();
}

#if defined(CBM_CALL_REFERENCE_LOOKUP_TEST_API) && CBM_CALL_REFERENCE_LOOKUP_TEST_API
/* A flat block of value-reference statements exercises occurrence-role
 * classification for every identifier. The old parent/child field lookup
 * restarts at the block's first child for each statement, so 8x more source
 * produces about 64x more lookup work. Count work instead of wall time: this
 * RED is deterministic, sanitizer-independent, and finishes quickly even on
 * the known-quadratic implementation. */
static uint64_t extract_wide_reference_field_work(int statement_count, int *out_usages,
                                                  uint64_t *out_slow_parent_fallbacks) {
    static const char prefix[] = "function target() {}\nfunction wide() {\n";
    static const char statement[] = "  target;\n";
    static const char suffix[] = "}\n";
    size_t capacity = sizeof(prefix) + (size_t)statement_count * sizeof(statement) + sizeof(suffix);
    char *source = malloc(capacity);
    if (!source) {
        return UINT64_MAX;
    }
    size_t offset = 0;
    memcpy(source + offset, prefix, sizeof(prefix) - 1U);
    offset += sizeof(prefix) - 1U;
    for (int i = 0; i < statement_count; i++) {
        memcpy(source + offset, statement, sizeof(statement) - 1U);
        offset += sizeof(statement) - 1U;
    }
    memcpy(source + offset, suffix, sizeof(suffix));
    offset += sizeof(suffix) - 1U;

    cbm_usage_field_lookup_test_reset();
    CBMFileResult *result = cbm_extract_file(source, (int)offset, CBM_LANG_JAVASCRIPT, "proj",
                                             "wide-references.js", 0, NULL, NULL);
    free(source);
    if (!result) {
        return UINT64_MAX;
    }
    int usages = 0;
    for (int i = 0; i < result->usages.count; i++) {
        if (result->usages.items[i].ref_name &&
            strcmp(result->usages.items[i].ref_name, "target") == 0) {
            usages++;
        }
    }
    uint64_t work = cbm_usage_field_lookup_test_work();
    *out_slow_parent_fallbacks = cbm_usage_slow_parent_fallback_test_count();
    cbm_free_result(result);
    *out_usages = usages;
    return work;
}

TEST(extract_wide_flat_reference_fields_are_linear) {
    enum { SMALL = 128, BIG = 1024, INPUT_GROWTH = 8, WORK_RATIO_MAX = 12 };
    int small_usages = 0;
    int big_usages = 0;
    uint64_t small_slow_parent_fallbacks = 0;
    uint64_t big_slow_parent_fallbacks = 0;
    uint64_t small_work =
        extract_wide_reference_field_work(SMALL, &small_usages, &small_slow_parent_fallbacks);
    uint64_t big_work =
        extract_wide_reference_field_work(BIG, &big_usages, &big_slow_parent_fallbacks);
    ASSERT_TRUE(small_work != UINT64_MAX);
    ASSERT_TRUE(big_work != UINT64_MAX);
    ASSERT_EQ(small_usages, SMALL);
    ASSERT_EQ(big_usages, BIG);
    ASSERT_EQ(small_slow_parent_fallbacks, 0);
    ASSERT_EQ(big_slow_parent_fallbacks, 0);
    ASSERT_GTE(small_work, (uint64_t)SMALL);
    fprintf(stderr, "  [wide-reference-fields] work(%d)=%llu work(%d)=%llu input_growth=%dx\n",
            SMALL, (unsigned long long)small_work, BIG, (unsigned long long)big_work, INPUT_GROWTH);
    uint64_t maximum = small_work * WORK_RATIO_MAX + 256U;
    if (big_work > maximum) {
        char message[192];
        snprintf(message, sizeof(message),
                 "wide-reference field lookup grew from %llu to %llu for %dx input "
                 "(maximum %dx + 256) -- quadratic sibling scan",
                 (unsigned long long)small_work, (unsigned long long)big_work, INPUT_GROWTH,
                 WORK_RATIO_MAX);
        FAIL(message);
    }
    PASS();
}
#endif

/* ===================================================================
 * Group H3: ObjectScript return type extraction
 * =================================================================== */

TEST(objectscript_udl_method_return_type) {
    CBMFileResult *r = extract("Class MyApp.Factory Extends %RegisteredObject\n"
                               "{\n"
                               "Method GetAdapter() As EnsLib.SQL.OutboundAdapter\n"
                               "{\n"
                               "    Quit ##class(EnsLib.SQL.OutboundAdapter).%New()\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Factory.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    bool found_rt = false;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "GetAdapter") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].return_type);
            ASSERT(strstr(r->defs.items[i].return_type, "EnsLib.SQL.OutboundAdapter") != NULL);
            found_rt = true;
        }
    }
    ASSERT(found_rt);
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_scalar_return_type_not_resolved) {
    CBMFileResult *r = extract("Class MyApp.Counter Extends %RegisteredObject\n"
                               "{\n"
                               "Method GetName() As %String\n"
                               "{\n"
                               "    Quit \"hello\"\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Counter.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "GetName") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].return_type);
            ASSERT(strstr(r->defs.items[i].return_type, "%String") != NULL);
        }
    }
    cbm_free_result(r);
    PASS();
}

/* ===================================================================
 * Group H2: ObjectScript macro expansion
 * =================================================================== */

TEST(objectscript_udl_class) {
    CBMFileResult *r = extract("Class MyApp.Patient Extends %Persistent\n{\n}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Patient.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Patient"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_methods_after_goto_label) {
    CBMFileResult *r = extract("Class Graph.KG.Test Extends %RegisteredObject\n"
                               "{\n"
                               "ClassMethod First() As %String\n"
                               "{\n"
                               "    If 1 { Goto Done }\n"
                               "Done\n"
                               "    Quit \"x\"\n"
                               "}\n"
                               "ClassMethod Second() As %String\n"
                               "{\n"
                               "    Quit \"y\"\n"
                               "}\n"
                               "ClassMethod Third() As %String\n"
                               "{\n"
                               "    Quit \"z\"\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Test.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "Graph.KG.Test"));
    ASSERT(has_def(r, "Method", "First"));
    ASSERT(has_def(r, "Method", "Second"));
    ASSERT(has_def(r, "Method", "Third"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_methods) {
    CBMFileResult *r = extract("Class MyApp.Utils Extends %RegisteredObject\n"
                               "{\n"
                               "ClassMethod Format(pVal As %String) As %String\n"
                               "{\n"
                               "    Quit pVal\n"
                               "}\n"
                               "Method Save() As %Status\n"
                               "{\n"
                               "    Quit ..%Save()\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Utils.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Utils"));
    ASSERT(has_def(r, "Method", "Format"));
    ASSERT(has_def(r, "Method", "Save"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_base_classes) {
    CBMFileResult *r = extract("Class MyApp.Patient Extends %Persistent\n"
                               "{\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Patient.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Patient"));
    int found = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "MyApp.Patient") == 0) {
            found = 1;
            ASSERT_NOT_NULL(r->defs.items[i].base_classes);
            ASSERT_NOT_NULL(r->defs.items[i].base_classes[0]);
            ASSERT_STR_EQ(r->defs.items[i].base_classes[0], "%Persistent");
        }
    }
    ASSERT_TRUE(found);
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_multiple_bases) {
    CBMFileResult *r = extract("Class MyApp.Dual Extends (MyApp.Base, %RegisteredObject)\n"
                               "{\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Dual.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    int found = 0;
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].name, "MyApp.Dual") == 0) {
            found = 1;
            ASSERT_NOT_NULL(r->defs.items[i].base_classes);
            ASSERT_NOT_NULL(r->defs.items[i].base_classes[0]);
            ASSERT_NOT_NULL(r->defs.items[i].base_classes[1]);
        }
    }
    ASSERT_TRUE(found);
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_properties) {
    CBMFileResult *r = extract("Class MyApp.Patient Extends %Persistent\n"
                               "{\n"
                               "Property Name As %String;\n"
                               "Property DOB As %Date;\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Patient.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Patient"));
    ASSERT(has_def(r, "Variable", "Name"));
    ASSERT(has_def(r, "Variable", "DOB"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_routine_tags) {
    CBMFileResult *r = extract("UTILS\n"
                               "    Quit\n"
                               "\n"
                               "Format(value,fmt)\n"
                               "    Set result = $ZDate(value, fmt)\n"
                               "    Quit result\n"
                               "\n"
                               "Log(msg)\n"
                               "    Write msg,!\n"
                               "    Quit\n",
                               CBM_LANG_OBJECTSCRIPT_ROUTINE, "t", "Utils.mac");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Function", "Format"));
    ASSERT(has_def(r, "Function", "Log"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_query_member) {
    CBMFileResult *r =
        extract("Class MyApp.Repo Extends %Persistent\n"
                "{\n"
                "Query FindAll(name As %String) As %SQLQuery { SELECT * FROM MyApp_Repo }\n"
                "}\n",
                CBM_LANG_OBJECTSCRIPT_UDL, "t", "Repo.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Class", "MyApp.Repo"));
    ASSERT(has_def(r, "Method", "FindAll"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_index_member) {
    CBMFileResult *r = extract("Class MyApp.Repo Extends %Persistent\n"
                               "{\n"
                               "Property Name As %String;\n"
                               "Index NameIdx On Name;\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Repo.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Index", "NameIdx"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_xdata_member) {
    CBMFileResult *r = extract("Class MyApp.Service Extends %CSP.REST\n"
                               "{\n"
                               "XData UrlMap { <Routes/> }\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Service.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "XData", "UrlMap"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_trigger_member) {
    CBMFileResult *r = extract("Class MyApp.Log Extends %Persistent\n"
                               "{\n"
                               "Trigger AfterInsert [ Event = INSERT ] { }\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Log.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Trigger", "AfterInsert"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_trigger_body_quit) {
    CBMFileResult *r = extract("Class MyApp.Patient Extends %Persistent\n"
                               "{\n"
                               "Trigger OnDeleteSQL [ Event = DELETE, Time = AFTER ] {\n"
                               "    Quit\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Patient.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Trigger", "OnDeleteSQL"));
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Trigger") == 0 &&
            strcmp(r->defs.items[i].name, "OnDeleteSQL") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].docstring);
            ASSERT(strstr(r->defs.items[i].docstring, "trigger_body") != NULL);
            ASSERT(strstr(r->defs.items[i].docstring, "Quit") != NULL);
            break;
        }
    }
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_trigger_body_tokens) {
    CBMFileResult *r = extract("Class MyApp.Order Extends %Persistent\n"
                               "{\n"
                               "Trigger AfterInsert [ Event = INSERT, Time = AFTER ] {\n"
                               "    Set id = ..%Id()\n"
                               "    Do ##class(MyApp.Audit).Log(id)\n"
                               "    Quit\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Order.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Trigger", "AfterInsert"));
    for (int i = 0; i < r->defs.count; i++) {
        if (strcmp(r->defs.items[i].label, "Trigger") == 0 &&
            strcmp(r->defs.items[i].name, "AfterInsert") == 0) {
            ASSERT_NOT_NULL(r->defs.items[i].docstring);
            ASSERT(strstr(r->defs.items[i].docstring, "trigger_body") != NULL);
            ASSERT_NOT_NULL(r->defs.items[i].body_tokens);
            ASSERT(strstr(r->defs.items[i].body_tokens, "Log") != NULL ||
                   strstr(r->defs.items[i].body_tokens, "Audit") != NULL ||
                   strstr(r->defs.items[i].body_tokens, "id") != NULL);
            break;
        }
    }
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_self_call_relative_dot_method) {
    CBMFileResult *r =
        extract("Class HS.Flash.UpdateManager Extends Ens.BusinessProcess\n"
                "{\n"
                "Method MakeMRNUpToDate(pRequest As HS.Message.FlashQueueUpdate) As %Status\n"
                "{\n"
                "    Set tSC = ..processStreamlet(pSession, pTS, tMPIID, tSourceMRN, ii)\n"
                "    Quit tSC\n"
                "}\n"
                "Method processStreamlet(pSession As %Integer) As %Status\n"
                "{\n"
                "    Quit $$$OK\n"
                "}\n"
                "}\n",
                CBM_LANG_OBJECTSCRIPT_UDL, "t", "UpdateManager.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "Method", "MakeMRNUpToDate"));
    ASSERT(has_call(r, "HS.Flash.UpdateManager.processStreamlet"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_calls_typed_new) {
    CBMFileResult *r = extract("Class MyApp.Caller Extends %RegisteredObject\n"
                               "{\n"
                               "Method Run() As %Status\n"
                               "{\n"
                               "    Set adapter = ##class(EnsLib.SQL.OutboundAdapter).%New()\n"
                               "    Do adapter.ExecuteQuery(\"SELECT 1\")\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "EnsLib.SQL.OutboundAdapter.ExecuteQuery"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_ensemble_production_def_parses_items) {
    CBMFileResult *r =
        extract("Class Sample.Production Extends Ens.Production\n"
                "{\n"
                "XData ProductionDefinition\n"
                "{\n"
                "<Production Name=\"Sample.Production\">\n"
                "  <Item Name=\"MyService\" ClassName=\"Sample.Service\" Enabled=\"true\">\n"
                "  </Item>\n"
                "  <Item Name=\"MyOperation\" ClassName=\"Sample.Operation\" Enabled=\"false\">\n"
                "  </Item>\n"
                "</Production>\n"
                "}\n"
                "}\n",
                CBM_LANG_OBJECTSCRIPT_UDL, "t", "Production.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "XData", "ProductionDefinition"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_ensemble_production_def_hs_settings) {
    CBMFileResult *r = extract(
        "Class HS.Flash.Production Extends Ens.Production\n"
        "{\n"
        "XData ProductionDefinition\n"
        "{\n"
        "<Production Name=\"HS.Flash.Production\">\n"
        "  <Item Name=\"FHIRService\" ClassName=\"HS.Flash.FHIRService\" Enabled=\"true\">\n"
        "    <Setting Target=\"Host\" Name=\"TargetConfigName\">FHIROps</Setting>\n"
        "    <Setting Target=\"Host\" Name=\"PatientHost\">PatientOps</Setting>\n"
        "    <Setting Target=\"Host\" Name=\"ConformanceOperation\">ConformOps</Setting>\n"
        "  </Item>\n"
        "</Production>\n"
        "}\n"
        "}\n",
        CBM_LANG_OBJECTSCRIPT_UDL, "t", "HSProduction.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_def(r, "XData", "ProductionDefinition"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_ensemble_production_def_absent_no_error) {
    CBMFileResult *r = extract("Class Sample.NonProduction Extends %Persistent\n"
                               "{\n"
                               "Method DoSomething() As %Status\n"
                               "{\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "NonProduction.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(!has_def(r, "XData", "ProductionDefinition"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_calls_typed_param) {
    CBMFileResult *r = extract("Class MyApp.Handler Extends %RegisteredObject\n"
                               "{\n"
                               "Method Process(req As Ens.Request) As %Status\n"
                               "{\n"
                               "    Do req.Send()\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Handler.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "Ens.Request.Send"));
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_udl_calls_typed_property) {
    CBMFileResult *r = extract("Class MyApp.Service Extends Ens.BusinessService\n"
                               "{\n"
                               "Property Adapter As EnsLib.SQL.InboundAdapter;\n"
                               "Method OnProcessInput() As %Status\n"
                               "{\n"
                               "    Do ..Adapter.ExecuteQuery(\"SELECT 1\")\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Service.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "EnsLib.SQL.InboundAdapter.ExecuteQuery"));
    cbm_free_result(r);
    PASS();
}

/* ===================================================================
 * Group H2: ObjectScript macro expansion
 * =================================================================== */

TEST(objectscript_macro_expand_system) {
    CBMMacroTable mt;
    cbm_macro_table_init_system(&mt);
    CBMFileResult *r = extract_with_macros("Class MyApp.Caller Extends %RegisteredObject\n"
                                           "{\n"
                                           "Method Run(sc As %Status) As %Status\n"
                                           "{\n"
                                           "    If $$$ISERR(sc) { Quit sc }\n"
                                           "    Quit $$$OK\n"
                                           "}\n"
                                           "}\n",
                                           CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls", &mt);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "%SYSTEM.Status.IsError"));
    cbm_free_result(r);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * Group H3: ObjectScript DATA_FLOWS argument extraction
 * ═══════════════════════════════════════════════════════════════════ */

static int find_call_args(const CBMFileResult *r, const char *callee, const char **out_arg0,
                          const char **out_arg1) {
    if (out_arg0)
        *out_arg0 = NULL;
    if (out_arg1)
        *out_arg1 = NULL;
    for (int i = 0; i < r->calls.count; i++) {
        if (strstr(r->calls.items[i].callee_name, callee)) {
            if (out_arg0 && r->calls.items[i].arg_count > 0)
                *out_arg0 = r->calls.items[i].args[0].expr;
            if (out_arg1 && r->calls.items[i].arg_count > 1)
                *out_arg1 = r->calls.items[i].args[1].expr;
            return r->calls.items[i].arg_count;
        }
    }
    return -1;
}

TEST(objectscript_data_flows_class_method_args) {
    CBMFileResult *r = extract("Class MyApp.Caller Extends %RegisteredObject\n"
                               "{\n"
                               "Method Run() As %Status\n"
                               "{\n"
                               "    Set sql = \"SELECT 1\"\n"
                               "    Do ##class(MyApp.Utils).Transform(sql, \"JSON\")\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "MyApp.Utils.Transform"));
    const char *arg0 = NULL;
    const char *arg1 = NULL;
    int argc = find_call_args(r, "MyApp.Utils.Transform", &arg0, &arg1);
    ASSERT(argc == 2);
    ASSERT_NOT_NULL(arg0);
    ASSERT(strstr(arg0, "sql") != NULL);
    cbm_free_result(r);
    PASS();
}

TEST(objectscript_macro_expand_local) {
    CBMMacroTable mt;
    cbm_macro_table_init_system(&mt);
    CBMArena arena;
    cbm_arena_init(&arena);
    const char *inc_content = "ROUTINE MyApp.Include [Type=INC]\n"
                              "#define MyCheck(%sc) ##class(MyApp.Utils).Validate(%sc)\n";
    cbm_parse_inc_file(&mt, &arena, inc_content);
    CBMFileResult *r = extract_with_macros("Class MyApp.Caller Extends %RegisteredObject\n"
                                           "{\n"
                                           "Method Run(sc As %Status) As %Status\n"
                                           "{\n"
                                           "    If $$$MyCheck(sc) { Quit $$$OK }\n"
                                           "    Quit $$$OK\n"
                                           "}\n"
                                           "}\n",
                                           CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls", &mt);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "MyApp.Utils.Validate"));
    cbm_free_result(r);
    cbm_arena_destroy(&arena);
    PASS();
}

TEST(objectscript_macro_constant_no_extra_call) {
    CBMMacroTable mt;
    cbm_macro_table_init_system(&mt);
    CBMArena arena;
    cbm_arena_init(&arena);
    const char *inc_content = "ROUTINE MyApp.Include [Type=INC]\n"
                              "#define MyConst 42\n";
    cbm_parse_inc_file(&mt, &arena, inc_content);
    CBMFileResult *r = extract_with_macros("Class MyApp.Caller Extends %RegisteredObject\n"
                                           "{\n"
                                           "Method Run() As %Integer\n"
                                           "{\n"
                                           "    Set x = $$$MyConst\n"
                                           "    Quit x\n"
                                           "}\n"
                                           "}\n",
                                           CBM_LANG_OBJECTSCRIPT_UDL, "t", "Caller.cls", &mt);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(!has_call(r, "$$$MyConst"));
    cbm_free_result(r);
    cbm_arena_destroy(&arena);
    PASS();
}

TEST(objectscript_data_flows_instance_method_args) {
    CBMFileResult *r = extract("Class MyApp.Service Extends %RegisteredObject\n"
                               "{\n"
                               "Method Run() As %Status\n"
                               "{\n"
                               "    Set adapter = ##class(EnsLib.SQL.OutboundAdapter).%New()\n"
                               "    Do adapter.ExecuteQuery(\"SELECT 1\")\n"
                               "    Quit $$$OK\n"
                               "}\n"
                               "}\n",
                               CBM_LANG_OBJECTSCRIPT_UDL, "t", "Service.cls");
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "EnsLib.SQL.OutboundAdapter.ExecuteQuery"));
    const char *arg0 = NULL;
    int argc = find_call_args(r, "EnsLib.SQL.OutboundAdapter.ExecuteQuery", &arg0, NULL);
    ASSERT(argc == 1);
    ASSERT_NOT_NULL(arg0);
    cbm_free_result(r);
    PASS();
}

/* ===================================================================
 * Group H4: IRIS Export XML → UDL transcoder
 * =================================================================== */

#define SIMPLE_EXPORT                               \
    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"  \
    "<Export generator=\"Cache\" version=\"25\">\n" \
    "<Class name=\"Test.Simple\">\n"                \
    "<Super>%RegisteredObject</Super>\n"            \
    "<Method name=\"Hello\">\n"                     \
    "<ReturnType>%String</ReturnType>\n"            \
    "<Implementation><![CDATA[\n"                   \
    "\tQuit \"hello\"\n"                            \
    "]]></Implementation>\n"                        \
    "</Method>\n"                                   \
    "</Class>\n"                                    \
    "</Export>\n"

TEST(iris_export_xml_simple_class) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl = cbm_iris_export_to_udl(&arena, SIMPLE_EXPORT, (int)strlen(SIMPLE_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 1);
    ASSERT_NOT_NULL(udl[0]);
    ASSERT(strstr(udl[0], "Test.Simple") != NULL);
    ASSERT(strstr(udl[0], "%RegisteredObject") != NULL);
    ASSERT(strstr(udl[0], "Hello") != NULL);
    ASSERT(strstr(udl[0], "Quit \"hello\"") != NULL);
    cbm_arena_destroy(&arena);
    PASS();
}

#define CLASSMETHOD_EXPORT                                     \
    "<?xml version=\"1.0\"?>\n"                                \
    "<Export generator=\"Cache\" version=\"25\">\n"            \
    "<Class name=\"Test.CM\">\n"                               \
    "<Method name=\"Run\">\n"                                  \
    "<ClassMethod>1</ClassMethod>\n"                           \
    "<FormalSpec>pArg:%String,pFlag:%Boolean=0</FormalSpec>\n" \
    "<ReturnType>%Status</ReturnType>\n"                       \
    "<Implementation><![CDATA[\n"                              \
    "\tQuit $$$OK\n"                                           \
    "]]></Implementation>\n"                                   \
    "</Method>\n"                                              \
    "</Class>\n"                                               \
    "</Export>\n"

TEST(iris_export_xml_classmethod) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl =
        cbm_iris_export_to_udl(&arena, CLASSMETHOD_EXPORT, (int)strlen(CLASSMETHOD_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 1);
    ASSERT(strstr(udl[0], "ClassMethod") != NULL);
    ASSERT(strstr(udl[0], "pArg") != NULL);
    ASSERT(strstr(udl[0], "pFlag") != NULL);
    ASSERT(strstr(udl[0], "%Status") != NULL);
    cbm_arena_destroy(&arena);
    PASS();
}

#define MEMBER_EXPORT                               \
    "<?xml version=\"1.0\"?>\n"                     \
    "<Export generator=\"Cache\" version=\"25\">\n" \
    "<Class name=\"Test.Members\">\n"               \
    "<Property name=\"Name\">\n"                    \
    "<Type>%String</Type>\n"                        \
    "<Parameter name=\"MAXLEN\" value=\"200\"/>\n"  \
    "</Property>\n"                                 \
    "<Parameter name=\"VERSION\">\n"                \
    "<Default>1</Default>\n"                        \
    "</Parameter>\n"                                \
    "<Index name=\"NameIdx\">\n"                    \
    "<Properties>Name</Properties>\n"               \
    "<Unique>1</Unique>\n"                          \
    "</Index>\n"                                    \
    "</Class>\n"                                    \
    "</Export>\n"

TEST(iris_export_xml_property_parameter_index) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl = cbm_iris_export_to_udl(&arena, MEMBER_EXPORT, (int)strlen(MEMBER_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 1);
    ASSERT(strstr(udl[0], "Property Name") != NULL);
    ASSERT(strstr(udl[0], "%String") != NULL);
    ASSERT(strstr(udl[0], "Parameter VERSION") != NULL);
    ASSERT(strstr(udl[0], "Index NameIdx") != NULL);
    cbm_arena_destroy(&arena);
    PASS();
}

#define CALLS_EXPORT                                \
    "<?xml version=\"1.0\"?>\n"                     \
    "<Export generator=\"Cache\" version=\"25\">\n" \
    "<Class name=\"Test.Caller\">\n"                \
    "<Super>%RegisteredObject</Super>\n"            \
    "<Method name=\"Run\">\n"                       \
    "<ClassMethod>1</ClassMethod>\n"                \
    "<ReturnType>%Status</ReturnType>\n"            \
    "<Implementation><![CDATA[\n"                   \
    "\tSet obj = ##class(Target.Worker).%New()\n"   \
    "\tDo obj.Execute()\n"                          \
    "\tQuit $$$OK\n"                                \
    "]]></Implementation>\n"                        \
    "</Method>\n"                                   \
    "</Class>\n"                                    \
    "</Export>\n"

TEST(iris_export_xml_calls_extracted) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl = cbm_iris_export_to_udl(&arena, CALLS_EXPORT, (int)strlen(CALLS_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 1);
    CBMFileResult *r = cbm_extract_file(udl[0], (int)strlen(udl[0]), CBM_LANG_OBJECTSCRIPT_UDL, "t",
                                        "Caller.cls", 0, NULL, NULL);
    ASSERT_NOT_NULL(r);
    ASSERT_FALSE(r->has_error);
    ASSERT(has_call(r, "Target.Worker.Execute"));
    cbm_free_result(r);
    cbm_arena_destroy(&arena);
    PASS();
}

#define MULTI_EXPORT                                                                          \
    "<?xml version=\"1.0\"?>\n"                                                               \
    "<Export generator=\"Cache\" version=\"25\">\n"                                           \
    "<Class name=\"Test.First\">\n"                                                           \
    "<Method name=\"One\"><Implementation><![CDATA[\tQuit 1\n]]></Implementation></Method>\n" \
    "</Class>\n"                                                                              \
    "<Class name=\"Test.Second\">\n"                                                          \
    "<Method name=\"Two\"><Implementation><![CDATA[\tQuit 2\n]]></Implementation></Method>\n" \
    "</Class>\n"                                                                              \
    "</Export>\n"

TEST(iris_export_xml_multi_class) {
    CBMArena arena;
    cbm_arena_init(&arena);
    int count = 0;
    char **udl = cbm_iris_export_to_udl(&arena, MULTI_EXPORT, (int)strlen(MULTI_EXPORT), &count);
    ASSERT_NOT_NULL(udl);
    ASSERT(count == 2);
    ASSERT(strstr(udl[0], "Test.First") != NULL || strstr(udl[1], "Test.First") != NULL);
    ASSERT(strstr(udl[0], "Test.Second") != NULL || strstr(udl[1], "Test.Second") != NULL);
    cbm_arena_destroy(&arena);
    PASS();
}

SUITE(extraction) {
    /* Initialize extraction library */
    cbm_init();

    /* Wide-flat-file linearity (ms-typescript hang) */
    RUN_TEST(extract_wide_flat_file_is_linear);
#if defined(CBM_CALL_REFERENCE_LOOKUP_TEST_API) && CBM_CALL_REFERENCE_LOOKUP_TEST_API
    RUN_TEST(extract_wide_flat_reference_fields_are_linear);
#endif

    /* Perl call-graph noise (#459 follow-up) */
    RUN_TEST(extract_perl_config_string_not_a_callee);
    RUN_TEST(extract_perl_builtin_call_is_function_not_method);
    RUN_TEST(extract_perl_method_call_flags_is_method);
    RUN_TEST(extract_flag_exempt_method_call_not_flagged_is_method);
    RUN_TEST(extract_ts_member_call_flags_is_method);
    RUN_TEST(extract_ts_this_super_receiver_not_flagged);
    RUN_TEST(extract_js_member_call_flags_is_method);

    /* InterSystems ObjectScript (UDL / routine / Export XML). */
    RUN_TEST(objectscript_udl_class);
    RUN_TEST(objectscript_udl_methods_after_goto_label);
    RUN_TEST(objectscript_udl_methods);
    RUN_TEST(objectscript_udl_base_classes);
    RUN_TEST(objectscript_udl_multiple_bases);
    RUN_TEST(objectscript_udl_properties);
    RUN_TEST(objectscript_routine_tags);
    RUN_TEST(objectscript_udl_query_member);
    RUN_TEST(objectscript_udl_index_member);
    RUN_TEST(objectscript_udl_xdata_member);
    RUN_TEST(objectscript_udl_trigger_member);
    RUN_TEST(objectscript_udl_trigger_body_quit);
    RUN_TEST(objectscript_udl_trigger_body_tokens);
    RUN_TEST(objectscript_udl_ensemble_production_def_parses_items);
    RUN_TEST(objectscript_udl_ensemble_production_def_hs_settings);
    RUN_TEST(objectscript_udl_ensemble_production_def_absent_no_error);
    RUN_TEST(objectscript_udl_self_call_relative_dot_method);
    RUN_TEST(objectscript_udl_calls_typed_new);
    RUN_TEST(objectscript_udl_calls_typed_param);
    RUN_TEST(objectscript_udl_calls_typed_property);
    RUN_TEST(objectscript_macro_expand_system);
    RUN_TEST(objectscript_macro_expand_local);
    RUN_TEST(objectscript_macro_constant_no_extra_call);
    RUN_TEST(objectscript_udl_method_return_type);
    RUN_TEST(objectscript_udl_scalar_return_type_not_resolved);
    RUN_TEST(objectscript_data_flows_class_method_args);
    RUN_TEST(objectscript_data_flows_instance_method_args);
    RUN_TEST(iris_export_xml_simple_class);
    RUN_TEST(iris_export_xml_classmethod);
    RUN_TEST(iris_export_xml_property_parameter_index);
    RUN_TEST(iris_export_xml_calls_extracted);
    RUN_TEST(iris_export_xml_multi_class);

    /* R box-module imports + member calls */
    RUN_TEST(extract_r_box_use_imports_issue218);
    RUN_TEST(extract_r_dollar_call_issue219);
    RUN_TEST(extract_ts_factory_object_methods_issue341);
    RUN_TEST(extract_c_macros_issue375);
    RUN_TEST(extract_cpp_macros_issue375);
    RUN_TEST(extract_cpp_functionlike_macro_type_arg_no_false_parse_partial_issue1071);
    RUN_TEST(extract_cpp_real_in_body_error_still_flagged_issue1071);
    RUN_TEST(extract_gdscript_issue186);
    RUN_TEST(extract_powershell_issue35);
    RUN_TEST(extract_luau_issue39);
    RUN_TEST(extract_qml_issue42);
    RUN_TEST(extract_cfscript_issue38);
    RUN_TEST(extract_cfml_tag_issue38);
    RUN_TEST(extract_helm_templates_issue338);
    RUN_TEST(extract_helm_values_toplevel_issue338);

    /* OOP */
    RUN_TEST(java_class);
    RUN_TEST(java_method);
    RUN_TEST(java_interface);
    RUN_TEST(java_interface_no_duplicate_function_issue1234);
    RUN_TEST(java_enum_dedup_preserves_calls_issue1234);
    RUN_TEST(java_class_extends_and_implements);
    RUN_TEST(python_class_base_extracted_bare);
    RUN_TEST(php_class);
    RUN_TEST(php_function);
    RUN_TEST(ruby_class);
    RUN_TEST(ruby_module);
    RUN_TEST(csharp_class);
    RUN_TEST(csharp_interface);
    RUN_TEST(swift_class);
    RUN_TEST(kotlin_function);
    RUN_TEST(kotlin_class);
    RUN_TEST(scala_function);
    RUN_TEST(scala_class);
    RUN_TEST(dart_class);
    RUN_TEST(groovy_class);

    /* Systems */
    RUN_TEST(rust_function);
    RUN_TEST(rust_struct);
    RUN_TEST(go_function);
    RUN_TEST(go_struct);
    RUN_TEST(go_interface);
    RUN_TEST(zig_function);
    RUN_TEST(c_function);
    RUN_TEST(c_struct);
    RUN_TEST(cpp_class);

    /* Scripting */
    RUN_TEST(python_function);
    RUN_TEST(python_class);
    RUN_TEST(js_function);
    RUN_TEST(js_class);
    RUN_TEST(ts_function);
    RUN_TEST(ts_class);
    RUN_TEST(body_tokens_type_identifier);
    RUN_TEST(lua_function);
    RUN_TEST(bash_function);
    RUN_TEST(perl_function);
    RUN_TEST(r_function);

    /* Functional */
    RUN_TEST(elixir_function);
    RUN_TEST(haskell_function);
    RUN_TEST(ocaml_function);
    RUN_TEST(erlang_function);

    /* Markup/Config */
    RUN_TEST(yaml_variables);
    RUN_TEST(hcl_blocks);
    RUN_TEST(sql_create_table);
    RUN_TEST(dockerfile_stages);

    /* Scientific */
    RUN_TEST(matlab_function);
    RUN_TEST(lean_function);
    RUN_TEST(form_procedure);
    RUN_TEST(wolfram_function);
    RUN_TEST(magma_function);

    /* v0.5 expansion */
    RUN_TEST(fsharp_function);
    RUN_TEST(julia_function);
    RUN_TEST(elm_function);
    RUN_TEST(nix_function);
    RUN_TEST(nix_defs_in_let_rooted_file);
    RUN_TEST(nix_defs_in_attrset_rooted_file);
    RUN_TEST(nix_defs_in_nested_let);
    RUN_TEST(nix_defs_survive_function_header_let);
    RUN_TEST(nix_defs_survive_function_header_attrset);
    RUN_TEST(nix_defs_survive_curried_header);
    RUN_TEST(nix_attrset_scope_disambiguates_leaf_names);
    RUN_TEST(nix_dotted_attrpath_qualifies_like_nested);
    RUN_TEST(nix_quoted_attr_name_strips_quotes);
    RUN_TEST(nix_interpolated_attr_mints_no_def);
    RUN_TEST(nix_module_level_bindings_mint_variables);
    RUN_TEST(nix_nested_bindings_are_not_module_level);
    RUN_TEST(nix_lambda_binding_is_function_not_variable);
    RUN_TEST(nix_curried_lambda_mints_one_def);
    RUN_TEST(fortran_function);

    /* OOP/Systems variants */
    RUN_TEST(swift_struct);
    RUN_TEST(swift_simple_call);
    RUN_TEST(swift_method_call);
    RUN_TEST(swift_constructor_call);
    RUN_TEST(swift_chained_call);
    RUN_TEST(objc_interface);
    RUN_TEST(objc_implementation);
    RUN_TEST(dart_top_level_function);
    RUN_TEST(rust_enum);
    RUN_TEST(zig_struct);
    RUN_TEST(cpp_function);
    RUN_TEST(cpp_gtest_same_name_collision_issue1266);
    RUN_TEST(cpp_gtest_f_unique_name_issue1266);
    RUN_TEST(cpp_out_of_line_method_issue428);
    RUN_TEST(cobol_paragraph);
    RUN_TEST(verilog_module);
    RUN_TEST(cuda_kernel);
    RUN_TEST(python_decorator);
    RUN_TEST(ts_interface);
    RUN_TEST(tsx_component);
    RUN_TEST(lua_table_method);
    RUN_TEST(emacs_lisp_defun);
    RUN_TEST(emacs_lisp_defvar);
    RUN_TEST(haskell_data_type);
    RUN_TEST(clojure_function);

    /* Config/Markup */
    RUN_TEST(html_elements);
    RUN_TEST(sql_function);
    RUN_TEST(meson_project);
    RUN_TEST(css_rules);
    RUN_TEST(scss_rules);
    RUN_TEST(toml_basic);
    RUN_TEST(cmake_function);
    RUN_TEST(json_object);
    RUN_TEST(protobuf_message);
    RUN_TEST(graphql_type);
    RUN_TEST(svelte_component);
    RUN_TEST(vue_component);
    RUN_TEST(glsl_shader);
    RUN_TEST(vimscript_function);

    /* Scientific extended */
    RUN_TEST(matlab_parse);
    RUN_TEST(matlab_call);
    RUN_TEST(lean_parse);
    RUN_TEST(lean_call);
    RUN_TEST(lean_type_annotation_not_call);
    RUN_TEST(form_parse);
    RUN_TEST(form_call);
    RUN_TEST(magma_procedure);
    RUN_TEST(magma_parse);
    RUN_TEST(magma_import);
    RUN_TEST(magma_call);
    RUN_TEST(magma_disambiguation);
    RUN_TEST(wolfram_function_extended);
    RUN_TEST(wolfram_call);
    RUN_TEST(wolfram_caller_attribution);
    RUN_TEST(c_caller_attribution);
    RUN_TEST(cpp_out_of_line_method_caller_attribution);
    RUN_TEST(cpp_out_of_line_ctor_dtor_caller_attribution);
    RUN_TEST(wolfram_parse);
    RUN_TEST(wolfram_import);
    RUN_TEST(wolfram_nested_def);

    /* cbm_test.go ports */
    RUN_TEST(python_docstring);
    RUN_TEST(go_function_extraction);
    RUN_TEST(js_arrow_function);

    /* language_failures_test.go ports */
    RUN_TEST(commonlisp_defun);
    RUN_TEST(commonlisp_multiple_functions);
    RUN_TEST(commonlisp_defmacro);
    RUN_TEST(makefile_rule_as_function);
    RUN_TEST(makefile_multiple_targets);
    RUN_TEST(makefile_variable_extraction);
    RUN_TEST(vimscript_function_extraction);
    RUN_TEST(vimscript_function_without_bang);
    RUN_TEST(julia_function_extraction);
    RUN_TEST(julia_function_with_args);

    /* Cross-cutting */
    RUN_TEST(python_calls);
    RUN_TEST(python_iris_classMethodValue);
    RUN_TEST(go_calls);
    RUN_TEST(python_imports);
    RUN_TEST(js_imports);
    RUN_TEST(go_imports);
    RUN_TEST(java_imports);
    RUN_TEST(rust_imports);
    RUN_TEST(c_imports);
    RUN_TEST(ruby_imports);
    RUN_TEST(lua_imports);
    RUN_TEST(import_stress_go);
    RUN_TEST(svelte_imports_basic);
    RUN_TEST(svelte_imports_no_script);
    RUN_TEST(vue_imports_basic);
    RUN_TEST(html_imports_basic);

    /* config_extraction_test.go ports */
    RUN_TEST(toml_basic_table_and_pair);
    RUN_TEST(toml_nested_table);
    RUN_TEST(toml_table_array_element);
    RUN_TEST(toml_dotted_key);
    RUN_TEST(toml_quoted_key);
    RUN_TEST(toml_empty_table);
    RUN_TEST(toml_comments_only);
    RUN_TEST(toml_boolean_and_integer_values);
    RUN_TEST(ini_basic_section_and_setting);
    RUN_TEST(ini_multiple_sections);
    RUN_TEST(ini_global_keys);
    RUN_TEST(ini_comments);
    RUN_TEST(json_basic_pair);
    RUN_TEST(json_nested_object);
    RUN_TEST(json_empty_object);
    RUN_TEST(json_boolean_null_values);
    RUN_TEST(json_package_json_deps);
    RUN_TEST(xml_basic_element);
    RUN_TEST(xml_self_closing_tag);
    RUN_TEST(xml_empty_document);
    RUN_TEST(xml_multiple_children);
    RUN_TEST(markdown_atx_headings);
    RUN_TEST(markdown_setext_headings);
    RUN_TEST(markdown_heading_content);
    RUN_TEST(markdown_no_headings);

    /* __init__.py / index.ts Module QN collision regression */
    RUN_TEST(python_init_module_qn_not_collide_with_folder);
    RUN_TEST(python_init_nested_module_qn);
    RUN_TEST(js_index_module_qn_not_collide_with_folder);
    RUN_TEST(python_regular_module_qn_unchanged);
    RUN_TEST(extract_java_method_annotations_issue382);
    RUN_TEST(extract_java_jaxrs_path_composition_issue1005);
    RUN_TEST(extract_ts_template_string_url_issue1006);
    RUN_TEST(extract_go_binary_concat_url_issue1249);
    RUN_TEST(extract_go_binary_concat_url_no_literal_suffix_issue1249);
    RUN_TEST(extract_java_no_double_class_qn);
    RUN_TEST(extract_go_no_filename_in_module_qn);
    RUN_TEST(extract_large_ts_has_functions_issue213);

    /* Per-function complexity metrics (Tier A) */
    RUN_TEST(complexity_nested_loops_depth);
    RUN_TEST(complexity_loop_with_branch);
    RUN_TEST(complexity_flat_no_loops);
    RUN_TEST(complexity_linear_scan_in_loop);
    RUN_TEST(complexity_recursion_in_loop_unguarded);
    RUN_TEST(complexity_guarded_recursion);
    RUN_TEST(complexity_super_only_not_recursive);
    RUN_TEST(complexity_same_name_other_receiver_not_recursive);
    RUN_TEST(complexity_self_receiver_still_recursive);
    RUN_TEST(complexity_chained_receiver_not_self);
    RUN_TEST(complexity_go_method_receiver_self_recursion);
    RUN_TEST(complexity_delegation_receivers_not_recursive_issue876);
    RUN_TEST(complexity_access_depth_and_params);
    RUN_TEST(extract_c_ifdef_split_brace_fn_recovered_issue961);
    RUN_TEST(extract_cpp_preproc_signature_gap_issue946);
    RUN_TEST(extract_cpp_preproc_macro_generated_callable_skipped_issue949);
    RUN_TEST(extract_c_ifdef_split_brace_after_include_remapped_issue949);
    RUN_TEST(extract_c_clean_file_no_recovery_duplicates_issue961);
    RUN_TEST(walk_defs_no_truncation_over_4096_issue668);
    RUN_TEST(extract_rust_test_attr_marks_is_test_issue855);
    RUN_TEST(docstring_utf8_truncation_boundary_issue1017);
    RUN_TEST(extract_ts_decorators_survive_interleaved_comment);

    cbm_shutdown();
}