wehub-resource-sync
1921 lines
71 KiB
C
1921 lines
71 KiB
C
/*
|
|
* test_grammar_probe_d.c — Remaining code-grammar node/import/inheritance probe.
|
|
*
|
|
* SCOPE
|
|
* ─────
|
|
* Probes 25 grammar-only code languages not yet covered by probes _a, _b, _c:
|
|
* agda, assembly, bicep, cfml, cfscript, cobol, elm, func, janet, lean,
|
|
* llvm_ir, magma, move, nasm, objc, pony, purescript, pine, qml, smali,
|
|
* tablegen, tlaplus, verilog, vhdl, wolfram.
|
|
*
|
|
* SKIPPED (with reason):
|
|
* systemverilog — CBM_LANG_SYSTEMVERILOG has no extension entry in the
|
|
* EXT_TABLE (language.c); the only SV extension ".sv" maps to
|
|
* CBM_LANG_VERILOG. File-based index_repository cannot route to
|
|
* CBM_LANG_SYSTEMVERILOG via extension alone. It is already exercised
|
|
* by the test_grammar_regression.c direct-language fixture and the
|
|
* grammar_labels histogram (Class:1,Function:1,Module:1).
|
|
*
|
|
* COLOUR LEGEND
|
|
* ─────────────
|
|
* GREEN = guard: pipeline already produces the correct result; a failure
|
|
* here is a real regression.
|
|
* RED = bug reproduction: pipeline does NOT yet produce the expected
|
|
* node/edge; test FAILS until fixed. Brief inline comment names
|
|
* root-cause class.
|
|
*
|
|
* CALLS dimensions are intentionally omitted (covered by P5 breadth).
|
|
* Do NOT register this suite in test_main.c.
|
|
*
|
|
* SUITE(grammar_probe_d)
|
|
*/
|
|
|
|
#include "../src/foundation/compat.h"
|
|
#include "test_framework.h"
|
|
#include "test_helpers.h"
|
|
#include "cbm.h"
|
|
#include <mcp/mcp.h>
|
|
#include <store/store.h>
|
|
#include <pipeline/pipeline.h>
|
|
#include <foundation/log.h>
|
|
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* Harness — mirrors test_grammar_probe_a.c exactly.
|
|
* Prefix "gpd_" to avoid symbol clashes with sibling probe files.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
typedef struct {
|
|
char tmpdir[256];
|
|
char dbpath[512];
|
|
char *project;
|
|
cbm_mcp_server_t *srv;
|
|
} GpdProj;
|
|
|
|
typedef struct {
|
|
const char *name; /* relative filename, may include '/' for subdirs */
|
|
const char *content;
|
|
} GpdFile;
|
|
|
|
static void gpd_to_fwd_slashes(char *p) {
|
|
for (; *p; p++) {
|
|
if (*p == '\\') *p = '/';
|
|
}
|
|
}
|
|
|
|
static cbm_store_t *gpd_open_indexed(GpdProj *lp) {
|
|
lp->project = cbm_project_name_from_path(lp->tmpdir);
|
|
if (!lp->project) return NULL;
|
|
const char *home = getenv("HOME");
|
|
if (!home) home = "/tmp";
|
|
char cache_dir[512];
|
|
snprintf(cache_dir, sizeof(cache_dir), "%s/.cache/codebase-memory-mcp", home);
|
|
cbm_mkdir(cache_dir);
|
|
snprintf(lp->dbpath, sizeof(lp->dbpath), "%s/%s.db", cache_dir, lp->project);
|
|
unlink(lp->dbpath);
|
|
lp->srv = cbm_mcp_server_new(NULL);
|
|
if (!lp->srv) return NULL;
|
|
char args[700];
|
|
snprintf(args, sizeof(args), "{\"repo_path\":\"%s\"}", lp->tmpdir);
|
|
char *resp = cbm_mcp_handle_tool(lp->srv, "index_repository", args);
|
|
if (resp) free(resp);
|
|
return cbm_store_open_path(lp->dbpath);
|
|
}
|
|
|
|
static cbm_store_t *gpd_index_files(GpdProj *lp, const GpdFile *files, int nfiles) {
|
|
memset(lp, 0, sizeof(*lp));
|
|
snprintf(lp->tmpdir, sizeof(lp->tmpdir), "/tmp/cbm_gpd_XXXXXX");
|
|
if (!cbm_mkdtemp(lp->tmpdir)) return NULL;
|
|
gpd_to_fwd_slashes(lp->tmpdir);
|
|
for (int i = 0; i < nfiles; i++) {
|
|
char path[700];
|
|
snprintf(path, sizeof(path), "%s/%s", lp->tmpdir, files[i].name);
|
|
char *slash = strrchr(path, '/');
|
|
if (slash && slash > path + strlen(lp->tmpdir)) {
|
|
*slash = '\0';
|
|
cbm_mkdir_p(path, 0755);
|
|
*slash = '/';
|
|
}
|
|
FILE *f = fopen(path, "wb");
|
|
if (!f) return NULL;
|
|
fputs(files[i].content, f);
|
|
fclose(f);
|
|
}
|
|
return gpd_open_indexed(lp);
|
|
}
|
|
|
|
static void gpd_cleanup(GpdProj *lp, cbm_store_t *store) {
|
|
if (store) cbm_store_close(store);
|
|
if (lp->srv) { cbm_mcp_server_free(lp->srv); lp->srv = NULL; }
|
|
free(lp->project);
|
|
lp->project = NULL;
|
|
th_rmtree(lp->tmpdir);
|
|
unlink(lp->dbpath);
|
|
char wal[600], shm[600];
|
|
snprintf(wal, sizeof(wal), "%s-wal", lp->dbpath);
|
|
unlink(wal);
|
|
snprintf(shm, sizeof(shm), "%s-shm", lp->dbpath);
|
|
unlink(shm);
|
|
}
|
|
|
|
/* ── Node-count helpers ─────────────────────────────────────────── */
|
|
|
|
static int gpd_count_label(cbm_store_t *store, const char *project, const char *label) {
|
|
cbm_node_t *nodes = NULL;
|
|
int count = 0;
|
|
if (cbm_store_find_nodes_by_label(store, project, label, &nodes, &count) != CBM_STORE_OK)
|
|
return -1;
|
|
cbm_store_free_nodes(nodes, count);
|
|
return count;
|
|
}
|
|
|
|
/* Sum of all type-like labels. */
|
|
static int gpd_type_nodes(cbm_store_t *store, const char *project) {
|
|
static const char *labels[] = {"Class","Struct","Interface","Enum","Trait","Type",NULL};
|
|
int total = 0;
|
|
for (int i = 0; labels[i]; i++) {
|
|
int n = gpd_count_label(store, project, labels[i]);
|
|
if (n > 0) total += n;
|
|
}
|
|
return total;
|
|
}
|
|
|
|
/* Metrics bundled per index pass. */
|
|
typedef struct {
|
|
int ok;
|
|
int total_nodes;
|
|
int functions;
|
|
int methods;
|
|
int types; /* type-like sum */
|
|
int imports; /* IMPORTS edges */
|
|
int inherits; /* INHERITS edges */
|
|
} GpdMetrics;
|
|
|
|
static GpdMetrics gpd_metrics_files(const GpdFile *files, int nfiles) {
|
|
GpdProj lp;
|
|
cbm_store_t *store = gpd_index_files(&lp, files, nfiles);
|
|
GpdMetrics m = {0};
|
|
if (store) {
|
|
m.ok = 1;
|
|
m.total_nodes = cbm_store_count_nodes(store, lp.project);
|
|
m.functions = gpd_count_label(store, lp.project, "Function");
|
|
m.methods = gpd_count_label(store, lp.project, "Method");
|
|
m.types = gpd_type_nodes(store, lp.project);
|
|
m.imports = cbm_store_count_edges_by_type(store, lp.project, "IMPORTS");
|
|
m.inherits = cbm_store_count_edges_by_type(store, lp.project, "INHERITS");
|
|
}
|
|
gpd_cleanup(&lp, store);
|
|
return m;
|
|
}
|
|
|
|
static GpdMetrics gpd_metrics(const char *filename, const char *content) {
|
|
GpdFile f = {filename, content};
|
|
return gpd_metrics_files(&f, 1);
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 1 — Agda (.agda)
|
|
*
|
|
* Agda label histogram: Function:1, Module:1 (grammar_labels histogram).
|
|
* Spec: agda_func_types = {"function"}, agda_class_types = {"data","record"},
|
|
* agda_import_types = {"import","open","import_directive","instance"}.
|
|
* Extension: .agda → CBM_LANG_AGDA.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Agda: function definition → Function node. */
|
|
TEST(probe_agda_function) {
|
|
GpdMetrics m = gpd_metrics("Nat.agda",
|
|
"module Nat where\n"
|
|
"\n"
|
|
"double : Nat -> Nat\n"
|
|
"double n = n + n\n"
|
|
"\n"
|
|
"triple : Nat -> Nat\n"
|
|
"triple n = n + n + n\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: function definitions must reach the graph as Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Agda: data type definition → type-like node.
|
|
* RED: histogram shows Function:1/Module:1 only; data/record types not
|
|
* extracted as Class/Type nodes despite agda_class_types spec. */
|
|
TEST(probe_agda_data_type) {
|
|
GpdMetrics m = gpd_metrics("Shape.agda",
|
|
"module Shape where\n"
|
|
"\n"
|
|
"data Shape : Set where\n"
|
|
" Circle : Shape\n"
|
|
" Square : Shape\n"
|
|
"\n"
|
|
"area : Shape -> Nat\n"
|
|
"area Circle = 1\n"
|
|
"area Square = 2\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Agda data/record type not extracted as type-like node (node-extraction gap). */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* Agda: `import` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only Agda has no module-import resolver in the pipeline. */
|
|
TEST(probe_agda_imports_edge) {
|
|
static const GpdFile files[] = {
|
|
{"Utils.agda",
|
|
"module Utils where\n"
|
|
"\n"
|
|
"double : Nat -> Nat\n"
|
|
"double n = n + n\n"},
|
|
{"Main.agda",
|
|
"module Main where\n"
|
|
"\n"
|
|
"import Utils\n"
|
|
"\n"
|
|
"quad : Nat -> Nat\n"
|
|
"quad n = Utils.double (Utils.double n)\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Agda `import` not resolved into IMPORTS edges by the pipeline. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 2 — Assembly (.s)
|
|
*
|
|
* Assembly label histogram: Function:1, Module:1.
|
|
* Spec: assembly_func_types = {"label"}, no class/import types.
|
|
* Extension: .s → CBM_LANG_ASSEMBLY.
|
|
* Assembly has no OOP, no imports — only labels extracted as Functions.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Assembly: global label → Function node. */
|
|
TEST(probe_assembly_label_function) {
|
|
GpdMetrics m = gpd_metrics("add.s",
|
|
".global add\n"
|
|
"add:\n"
|
|
" add x0, x0, x1\n"
|
|
" ret\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: global label must be extracted as a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Assembly: multiple labels → multiple Function nodes. */
|
|
TEST(probe_assembly_multiple_labels) {
|
|
GpdMetrics m = gpd_metrics("math.s",
|
|
".global square\n"
|
|
"square:\n"
|
|
" mul x0, x0, x0\n"
|
|
" ret\n"
|
|
"\n"
|
|
".global negate\n"
|
|
"negate:\n"
|
|
" neg x0, x0\n"
|
|
" ret\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both labels should produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Assembly: no OOP — no type-like nodes expected. */
|
|
TEST(probe_assembly_no_type_nodes) {
|
|
GpdMetrics m = gpd_metrics("noop.s",
|
|
".global noop\n"
|
|
"noop:\n"
|
|
" ret\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: assembly produces 0 type-like nodes. */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 3 — Bicep (.bicep)
|
|
*
|
|
* Bicep label histogram: Function:1, Module:1 (from grammar_labels).
|
|
* Spec: bicep_func_types = {"user_defined_function","lambda_expression"},
|
|
* bicep_class_types = {"resource_declaration","type_declaration","module_declaration"},
|
|
* bicep_import_types = {"import_statement","module_declaration","import","using_statement"}.
|
|
* Extension: .bicep → CBM_LANG_BICEP.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Bicep: user-defined function → Function node. */
|
|
TEST(probe_bicep_function) {
|
|
GpdMetrics m = gpd_metrics("funcs.bicep",
|
|
"func greet(name string) string => 'Hello, ${name}!'\n"
|
|
"\n"
|
|
"func square(n int) int => n * n\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both user-defined functions must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Bicep: resource declaration → type-like node.
|
|
* RED: histogram shows Function:1/Module:1 only; resource_declaration not
|
|
* extracted as Class/Type node despite bicep_class_types spec. */
|
|
TEST(probe_bicep_resource_node) {
|
|
GpdMetrics m = gpd_metrics("storage.bicep",
|
|
"resource storageAccount 'Microsoft.Storage/storageAccounts@2021-02-01' = {\n"
|
|
" name: 'mystorage'\n"
|
|
" location: 'eastus'\n"
|
|
" kind: 'StorageV2'\n"
|
|
" sku: {\n"
|
|
" name: 'Standard_LRS'\n"
|
|
" }\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Bicep resource_declaration not yet extracted as type-like node. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* Bicep: module declaration (cross-file reference) → IMPORTS edge.
|
|
* RED: grammar-only Bicep has no module-resolver in the pipeline. */
|
|
TEST(probe_bicep_module_import) {
|
|
static const GpdFile files[] = {
|
|
{"storage.bicep",
|
|
"param name string\n"
|
|
"resource sa 'Microsoft.Storage/storageAccounts@2021-02-01' = {\n"
|
|
" name: name\n"
|
|
" location: 'eastus'\n"
|
|
" kind: 'StorageV2'\n"
|
|
" sku: { name: 'Standard_LRS' }\n"
|
|
"}\n"},
|
|
{"main.bicep",
|
|
"module storage './storage.bicep' = {\n"
|
|
" name: 'storageDeploy'\n"
|
|
" params: { name: 'mystore' }\n"
|
|
"}\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Bicep module cross-reference not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 4 — CFML (.cfm — tag dialect)
|
|
*
|
|
* CFML label histogram: Function:1, Module:1.
|
|
* Spec: cfml_func_types = {"function_declaration","function_expression"};
|
|
* cffunction tags handled separately as cf_function_tag.
|
|
* Extension: .cfm → CBM_LANG_CFML.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* CFML: <cffunction> tag → Function node. */
|
|
TEST(probe_cfml_function_tag) {
|
|
GpdMetrics m = gpd_metrics("greet.cfm",
|
|
"<cffunction name=\"greet\" returntype=\"string\">\n"
|
|
" <cfargument name=\"name\" type=\"string\">\n"
|
|
" <cfreturn \"Hello, \" & name>\n"
|
|
"</cffunction>\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: <cffunction> tag must produce a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* CFML: two <cffunction> tags → at least 2 Function nodes. */
|
|
TEST(probe_cfml_two_functions) {
|
|
GpdMetrics m = gpd_metrics("utils.cfm",
|
|
"<cffunction name=\"double\" returntype=\"numeric\">\n"
|
|
" <cfargument name=\"n\" type=\"numeric\">\n"
|
|
" <cfreturn n * 2>\n"
|
|
"</cffunction>\n"
|
|
"\n"
|
|
"<cffunction name=\"triple\" returntype=\"numeric\">\n"
|
|
" <cfargument name=\"n\" type=\"numeric\">\n"
|
|
" <cfreturn n * 3>\n"
|
|
"</cffunction>\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both cffunction tags must be extracted as Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* CFML: no OOP class nodes expected (tag dialect has no class construct). */
|
|
TEST(probe_cfml_no_type_nodes) {
|
|
GpdMetrics m = gpd_metrics("simple.cfm",
|
|
"<cffunction name=\"noop\" returntype=\"void\">\n"
|
|
"</cffunction>\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: CFML tag dialect produces 0 type-like nodes. */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 5 — CFScript (.cfc — script dialect)
|
|
*
|
|
* CFScript label histogram: Function:2, Module:1 (from grammar_labels for cfscript).
|
|
* Spec: cfscript_func_types = {"function_declaration","function_expression",
|
|
* "arrow_function","method_definition"}.
|
|
* Extension: .cfc → CBM_LANG_CFSCRIPT.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* CFScript: component with two function declarations → 2 Function nodes. */
|
|
TEST(probe_cfscript_functions) {
|
|
GpdMetrics m = gpd_metrics("MathService.cfc",
|
|
"component {\n"
|
|
" function double(numeric n) {\n"
|
|
" return n * 2;\n"
|
|
" }\n"
|
|
"\n"
|
|
" function triple(numeric n) {\n"
|
|
" return n * 3;\n"
|
|
" }\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both function declarations must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* CFScript: no cross-file import syntax modeled — pipeline produces 0 IMPORTS. */
|
|
TEST(probe_cfscript_no_import_edges) {
|
|
GpdMetrics m = gpd_metrics("Single.cfc",
|
|
"component {\n"
|
|
" function greet(string name) {\n"
|
|
" return \"Hello, \" & name;\n"
|
|
" }\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: single-file CFScript produces 0 IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 6 — COBOL (.cob)
|
|
*
|
|
* COBOL label histogram: Class:1, Function:1 (from MUST_EXTRACT_DEFS fixture).
|
|
* Spec: cobol_func_types = {"program_definition"},
|
|
* cobol_import_types = {"open_statement","use_statement","with_clause"}.
|
|
* Extension: .cob → CBM_LANG_COBOL.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* COBOL: PROGRAM-ID → Function (program_definition) node. */
|
|
TEST(probe_cobol_program_node) {
|
|
GpdMetrics m = gpd_metrics("hello.cob",
|
|
" IDENTIFICATION DIVISION.\n"
|
|
" PROGRAM-ID. HELLO.\n"
|
|
" PROCEDURE DIVISION.\n"
|
|
" MAIN-PARA.\n"
|
|
" DISPLAY 'Hello, World!'.\n"
|
|
" STOP RUN.\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: PROGRAM-ID must produce a Function node (program_definition). */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* COBOL: pipeline indexes the file and produces at least 1 node. */
|
|
TEST(probe_cobol_no_crash) {
|
|
GpdMetrics m = gpd_metrics("calc.cob",
|
|
" IDENTIFICATION DIVISION.\n"
|
|
" PROGRAM-ID. CALC.\n"
|
|
" DATA DIVISION.\n"
|
|
" WORKING-STORAGE SECTION.\n"
|
|
" 01 NUM PIC 9(4) VALUE 0.\n"
|
|
" PROCEDURE DIVISION.\n"
|
|
" COMPUTE NUM = 2 + 2.\n"
|
|
" STOP RUN.\n");
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 7 — Elm (.elm)
|
|
*
|
|
* Elm label histogram: Class:1, Function:1, Module:1.
|
|
* Spec: elm_func_types = {"value_declaration","function_declaration"},
|
|
* elm_class_types = {"type_declaration","type_alias_declaration","module_declaration"},
|
|
* elm_import_types = {"import"}.
|
|
* Extension: .elm → CBM_LANG_ELM.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Elm: function definition → Function node. */
|
|
TEST(probe_elm_function) {
|
|
GpdMetrics m = gpd_metrics("Math.elm",
|
|
"module Math exposing (..)\n"
|
|
"\n"
|
|
"double : Int -> Int\n"
|
|
"double n = n * 2\n"
|
|
"\n"
|
|
"triple : Int -> Int\n"
|
|
"triple n = n * 3\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both function definitions must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Elm: type alias declaration → type-like node. */
|
|
TEST(probe_elm_type_alias) {
|
|
GpdMetrics m = gpd_metrics("Types.elm",
|
|
"module Types exposing (..)\n"
|
|
"\n"
|
|
"type alias Point = { x : Float, y : Float }\n"
|
|
"\n"
|
|
"type Shape\n"
|
|
" = Circle Float\n"
|
|
" | Rectangle Float Float\n"
|
|
"\n"
|
|
"area : Shape -> Float\n"
|
|
"area s =\n"
|
|
" case s of\n"
|
|
" Circle r -> 3.14159 * r * r\n"
|
|
" Rectangle w h -> w * h\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: type alias/type declaration must produce type-like node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Elm: `import` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only Elm has no import-resolver in the pipeline. */
|
|
TEST(probe_elm_imports_edge) {
|
|
static const GpdFile files[] = {
|
|
{"Utils.elm",
|
|
"module Utils exposing (..)\n"
|
|
"\n"
|
|
"double : Int -> Int\n"
|
|
"double n = n * 2\n"},
|
|
{"Main.elm",
|
|
"module Main exposing (..)\n"
|
|
"\n"
|
|
"import Utils\n"
|
|
"\n"
|
|
"quad : Int -> Int\n"
|
|
"quad n = Utils.double (Utils.double n)\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Elm `import` not resolved into IMPORTS edges by the pipeline. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 8 — FunC (.fc)
|
|
*
|
|
* FunC label histogram: Function:1, Module:1.
|
|
* Spec: func_func_types = {"function_definition"},
|
|
* func_import_types = {"include_directive"}.
|
|
* Extension: .fc → CBM_LANG_FUNC.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* FunC: function definition → Function node. */
|
|
TEST(probe_func_function) {
|
|
GpdMetrics m = gpd_metrics("math.fc",
|
|
"int square(int n) {\n"
|
|
" return n * n;\n"
|
|
"}\n"
|
|
"\n"
|
|
"int cube(int n) {\n"
|
|
" return n * square(n);\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both function definitions must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* FunC: `#include` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only FunC has no include-resolver in the pipeline. */
|
|
TEST(probe_func_imports_edge) {
|
|
static const GpdFile files[] = {
|
|
{"utils.fc",
|
|
"int double_val(int n) {\n"
|
|
" return n * 2;\n"
|
|
"}\n"},
|
|
{"main.fc",
|
|
"#include \"utils.fc\"\n"
|
|
"\n"
|
|
"int run(int n) {\n"
|
|
" return double_val(n);\n"
|
|
"}\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: FunC #include not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* FunC: no OOP — no type-like nodes expected. */
|
|
TEST(probe_func_no_type_nodes) {
|
|
GpdMetrics m = gpd_metrics("noop.fc",
|
|
"() noop() {\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: FunC produces 0 type-like nodes. */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 9 — Janet (.janet)
|
|
*
|
|
* Janet label histogram: Module:1 only (from grammar_labels MUST_EXTRACT_DEFS).
|
|
* Spec: CBM_LANG_JANET uses empty_types for all definition types — no function
|
|
* extraction is configured; the grammar emits only a source/Module node.
|
|
* Extension: .janet → CBM_LANG_JANET.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Janet: pipeline indexes the file without crashing — total_nodes >= 1. */
|
|
TEST(probe_janet_no_crash) {
|
|
GpdMetrics m = gpd_metrics("math.janet",
|
|
"(defn double [n] (* 2 n))\n"
|
|
"\n"
|
|
"(defn square [n] (* n n))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash; at least Module node expected. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Janet: functions NOT extracted — the spec has empty_types for func.
|
|
* RED: defn forms not configured in the lang spec; 0 Function nodes is the
|
|
* current behaviour and a known gap. */
|
|
TEST(probe_janet_function_extraction_gap) {
|
|
GpdMetrics m = gpd_metrics("ops.janet",
|
|
"(defn add [a b] (+ a b))\n"
|
|
"(defn sub [a b] (- a b))\n"
|
|
"(defn mul [a b] (* a b))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Janet defn forms not configured in lang_spec → 0 Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1); /* expected RED — empty func_types in spec */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 10 — Lean (.lean)
|
|
*
|
|
* Lean label histogram: Function:2, Module:1.
|
|
* Spec: lean_func_types = {"def","theorem","instance","abbrev"},
|
|
* lean_class_types = {"structure","class_inductive","inductive"},
|
|
* lean_import_types = {"import","extends","instance"}.
|
|
* Extension: .lean → CBM_LANG_LEAN.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Lean: two `def` definitions → 2 Function nodes. */
|
|
TEST(probe_lean_def_functions) {
|
|
GpdMetrics m = gpd_metrics("math.lean",
|
|
"def double (n : Nat) : Nat := n * 2\n"
|
|
"\n"
|
|
"def square (n : Nat) : Nat := n * n\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both def bindings must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Lean: theorem definition → Function node. */
|
|
TEST(probe_lean_theorem) {
|
|
GpdMetrics m = gpd_metrics("proofs.lean",
|
|
"theorem add_comm (a b : Nat) : a + b = b + a := by\n"
|
|
" omega\n"
|
|
"\n"
|
|
"theorem mul_comm (a b : Nat) : a * b = b * a := by\n"
|
|
" omega\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: theorem definitions must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Lean: structure definition → type-like node.
|
|
* RED: histogram shows Function/Module only; structure not yet extracted as
|
|
* type node despite lean_class_types having "structure". */
|
|
TEST(probe_lean_structure_type) {
|
|
GpdMetrics m = gpd_metrics("types.lean",
|
|
"structure Point where\n"
|
|
" x : Float\n"
|
|
" y : Float\n"
|
|
"\n"
|
|
"def origin : Point := { x := 0, y := 0 }\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Lean structure not extracted as type-like node (node-extraction gap). */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* Lean: `import` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only Lean has no import-resolver in the pipeline. */
|
|
TEST(probe_lean_imports_edge) {
|
|
static const GpdFile files[] = {
|
|
{"MathUtils.lean",
|
|
"def double (n : Nat) : Nat := n * 2\n"},
|
|
{"Main.lean",
|
|
"import MathUtils\n"
|
|
"\n"
|
|
"def quad (n : Nat) : Nat := double (double n)\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Lean `import` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 11 — LLVM IR (.ll)
|
|
*
|
|
* LLVM IR label histogram: Function:1, Module:1.
|
|
* Spec: llvm_func_types = {"function_header"}, no class/import types.
|
|
* Extension: .ll → CBM_LANG_LLVM_IR.
|
|
* LLVM IR has no OOP and no import mechanism at the IR level.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* LLVM IR: function definition → Function node. */
|
|
TEST(probe_llvmir_function) {
|
|
GpdMetrics m = gpd_metrics("add.ll",
|
|
"define i32 @add(i32 %a, i32 %b) {\n"
|
|
"entry:\n"
|
|
" %r = add i32 %a, %b\n"
|
|
" ret i32 %r\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: LLVM IR function definition must produce a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* LLVM IR: two function definitions → 2 Function nodes. */
|
|
TEST(probe_llvmir_two_functions) {
|
|
GpdMetrics m = gpd_metrics("math.ll",
|
|
"define i32 @square(i32 %n) {\n"
|
|
"entry:\n"
|
|
" %r = mul i32 %n, %n\n"
|
|
" ret i32 %r\n"
|
|
"}\n"
|
|
"\n"
|
|
"define i32 @negate(i32 %n) {\n"
|
|
"entry:\n"
|
|
" %r = sub i32 0, %n\n"
|
|
" ret i32 %r\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both function definitions must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* LLVM IR: no OOP — no type-like nodes expected. */
|
|
TEST(probe_llvmir_no_type_nodes) {
|
|
GpdMetrics m = gpd_metrics("noop.ll",
|
|
"define void @noop() {\n"
|
|
"entry:\n"
|
|
" ret void\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: LLVM IR produces 0 type-like nodes. */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 12 — Magma (.mag)
|
|
*
|
|
* Magma label histogram: Function:2, Module:1 (from grammar_labels).
|
|
* Spec: magma_func_types = {"function_definition","procedure_definition",
|
|
* "intrinsic_definition","anonymous_function"},
|
|
* magma_import_types = {"load_statement","require","require_statement"}.
|
|
* Extension: .mag → CBM_LANG_MAGMA.
|
|
* Note: .m also resolves to Magma if content has end function/procedure markers
|
|
* (via cbm_disambiguate_m), but .mag is unambiguous.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Magma: function definition → Function node. */
|
|
TEST(probe_magma_function) {
|
|
GpdMetrics m = gpd_metrics("arith.mag",
|
|
"function Square(n)\n"
|
|
" return n * n;\n"
|
|
"end function;\n"
|
|
"\n"
|
|
"function Cube(n)\n"
|
|
" return n * Square(n);\n"
|
|
"end function;\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both function definitions must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Magma: procedure definition → Function node (procedures are in func_types). */
|
|
TEST(probe_magma_procedure) {
|
|
GpdMetrics m = gpd_metrics("proc.mag",
|
|
"procedure PrintVal(n)\n"
|
|
" print n;\n"
|
|
"end procedure;\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: procedure must produce a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Magma: no OOP types — Magma is functional/mathematical. */
|
|
TEST(probe_magma_no_type_nodes) {
|
|
GpdMetrics m = gpd_metrics("simple.mag",
|
|
"function Id(x)\n"
|
|
" return x;\n"
|
|
"end function;\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: Magma produces 0 type-like nodes. */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 13 — Move (.move)
|
|
*
|
|
* Move label histogram: Function:1, Module:1.
|
|
* Spec: move_func_types = {"function_item"}, no class types (grammar comment:
|
|
* struct/enum exist only as anonymous keyword tokens, never as parent nodes),
|
|
* move_import_types = {"use_declaration"}.
|
|
* Extension: .move → CBM_LANG_MOVE.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Move: function inside module → Function node. */
|
|
TEST(probe_move_function) {
|
|
GpdMetrics m = gpd_metrics("math.move",
|
|
"module 0x1::math {\n"
|
|
" public fun double(n: u64): u64 {\n"
|
|
" n * 2\n"
|
|
" }\n"
|
|
"\n"
|
|
" public fun square(n: u64): u64 {\n"
|
|
" n * n\n"
|
|
" }\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both function_item nodes must reach the graph. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Move: `use` declaration in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only Move has no use-declaration resolver in the pipeline. */
|
|
TEST(probe_move_imports_edge) {
|
|
static const GpdFile files[] = {
|
|
{"utils.move",
|
|
"module 0x1::utils {\n"
|
|
" public fun double(n: u64): u64 { n * 2 }\n"
|
|
"}\n"},
|
|
{"main.move",
|
|
"module 0x1::main {\n"
|
|
" use 0x1::utils;\n"
|
|
"\n"
|
|
" public fun run(n: u64): u64 {\n"
|
|
" utils::double(n)\n"
|
|
" }\n"
|
|
"}\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Move `use` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* Move: struct definition — grammar models struct only as anonymous token, not
|
|
* as a named parent node. Verify no spurious type nodes are emitted. */
|
|
TEST(probe_move_struct_not_extracted) {
|
|
GpdMetrics m = gpd_metrics("types.move",
|
|
"module 0x1::types {\n"
|
|
" struct Point has copy, drop {\n"
|
|
" x: u64,\n"
|
|
" y: u64,\n"
|
|
" }\n"
|
|
"\n"
|
|
" public fun origin(): Point {\n"
|
|
" Point { x: 0, y: 0 }\n"
|
|
" }\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: Move grammar produces 0 type nodes (struct is anonymous token). */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 14 — NASM (.nasm)
|
|
*
|
|
* NASM label histogram: Function:1, Module:1.
|
|
* Spec: nasm_func_types = {"label","preproc_def","preproc_multiline_macro"},
|
|
* nasm_class_types = {"struc_declaration"},
|
|
* nasm_import_types = {"preproc_include"}.
|
|
* Extension: .nasm → CBM_LANG_NASM.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* NASM: label → Function node. */
|
|
TEST(probe_nasm_label_function) {
|
|
GpdMetrics m = gpd_metrics("add.nasm",
|
|
"global add\n"
|
|
"add:\n"
|
|
" mov eax, edi\n"
|
|
" add eax, esi\n"
|
|
" ret\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: label must be extracted as Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* NASM: struc declaration → type-like node.
|
|
* RED: histogram shows Function:1/Module:1 only; struc_declaration not
|
|
* extracted as a type node despite nasm_class_types spec. */
|
|
TEST(probe_nasm_struc_node) {
|
|
GpdMetrics m = gpd_metrics("point.nasm",
|
|
"struc Point\n"
|
|
" .x: resd 1\n"
|
|
" .y: resd 1\n"
|
|
"endstruc\n"
|
|
"\n"
|
|
"global get_x\n"
|
|
"get_x:\n"
|
|
" mov eax, [edi + Point.x]\n"
|
|
" ret\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: NASM struc_declaration not extracted as type-like node. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* NASM: %include in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only NASM has no include-resolver in the pipeline. */
|
|
TEST(probe_nasm_include_edge) {
|
|
static const GpdFile files[] = {
|
|
{"utils.nasm",
|
|
"global double\n"
|
|
"double:\n"
|
|
" shl edi, 1\n"
|
|
" mov eax, edi\n"
|
|
" ret\n"},
|
|
{"main.nasm",
|
|
"%include \"utils.nasm\"\n"
|
|
"\n"
|
|
"global run\n"
|
|
"run:\n"
|
|
" call double\n"
|
|
" ret\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: NASM %include not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 15 — Objective-C (.m with ObjC markers)
|
|
*
|
|
* ObjC label histogram: Class:1, Function:2, Module:1 (from grammar_labels).
|
|
* Spec: objc_func_types = {"function_definition","method_definition","method_declaration"},
|
|
* objc_class_types = {"class_interface","class_implementation","protocol_declaration",...},
|
|
* objc_import_types = {"preproc_import","preproc_include"}.
|
|
* Extension: .m → disambiguated to CBM_LANG_OBJC when @interface/@implementation
|
|
* markers are present (via cbm_disambiguate_m).
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* ObjC: @interface declaration → Class node. */
|
|
TEST(probe_objc_class_node) {
|
|
GpdMetrics m = gpd_metrics("Animal.m",
|
|
"#import <Foundation/Foundation.h>\n"
|
|
"\n"
|
|
"@interface Animal : NSObject\n"
|
|
"- (NSString *)speak;\n"
|
|
"- (NSString *)name;\n"
|
|
"@end\n"
|
|
"\n"
|
|
"@implementation Animal\n"
|
|
"- (NSString *)speak { return @\"...\"; }\n"
|
|
"- (NSString *)name { return @\"Animal\"; }\n"
|
|
"@end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: @interface must produce a Class/type-like node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* ObjC: methods → Function/Method nodes. */
|
|
TEST(probe_objc_method_nodes) {
|
|
GpdMetrics m = gpd_metrics("Calc.m",
|
|
"@interface Calc : NSObject\n"
|
|
"- (int)square:(int)n;\n"
|
|
"- (int)cube:(int)n;\n"
|
|
"@end\n"
|
|
"\n"
|
|
"@implementation Calc\n"
|
|
"- (int)square:(int)n { return n * n; }\n"
|
|
"- (int)cube:(int)n { return n * n * n; }\n"
|
|
"@end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: ObjC method_definition is labelled "Method" (extract_defs.c
|
|
* sets def.label = "Method" for CBM_LANG_OBJC method_definition),
|
|
* not "Function" — matches grammar_labels histogram objc=Method:1.
|
|
* Fixture fix: assert Method, not Function. */
|
|
ASSERT_TRUE(m.methods >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* ObjC: subclass via @interface Child : Parent → INHERITS edge.
|
|
* RED: grammar-only ObjC has no base-class resolver in the pipeline. */
|
|
TEST(probe_objc_inherits_edge) {
|
|
GpdMetrics m = gpd_metrics("Dog.m",
|
|
"@interface Animal : NSObject\n"
|
|
"- (NSString *)speak;\n"
|
|
"@end\n"
|
|
"\n"
|
|
"@interface Dog : Animal\n"
|
|
"- (void)bark;\n"
|
|
"@end\n"
|
|
"\n"
|
|
"@implementation Dog\n"
|
|
"- (NSString *)speak { return @\"Woof\"; }\n"
|
|
"- (void)bark { NSLog(@\"Woof!\"); }\n"
|
|
"@end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: ObjC @interface inheritance not yet resolved into INHERITS edges. */
|
|
ASSERT_TRUE(m.inherits >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ObjC: #import in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only ObjC has no #import resolver in the pipeline. */
|
|
TEST(probe_objc_import_edge) {
|
|
static const GpdFile files[] = {
|
|
{"Utils.m",
|
|
"@interface Utils : NSObject\n"
|
|
"+ (int)double:(int)n;\n"
|
|
"@end\n"
|
|
"@implementation Utils\n"
|
|
"+ (int)double:(int)n { return n * 2; }\n"
|
|
"@end\n"},
|
|
{"Main.m",
|
|
"#import \"Utils.m\"\n"
|
|
"\n"
|
|
"@interface Main : NSObject\n"
|
|
"+ (int)run:(int)n;\n"
|
|
"@end\n"
|
|
"@implementation Main\n"
|
|
"+ (int)run:(int)n { return [Utils double:n]; }\n"
|
|
"@end\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: ObjC #import not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 16 — Pony (.pony)
|
|
*
|
|
* Pony label histogram: Class:1, Function:1, Module:1 (from grammar_labels).
|
|
* Spec: pony_func_types = {"method","constructor","ffi_method","lambda_expression"},
|
|
* pony_class_types = {"actor_definition","class_definition","struct_definition",
|
|
* "trait_definition","interface_definition","primitive_definition",
|
|
* "type_alias"},
|
|
* pony_import_types = {"use_statement"}.
|
|
* Extension: .pony → CBM_LANG_PONY.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Pony: class definition → Class node. */
|
|
TEST(probe_pony_class_node) {
|
|
GpdMetrics m = gpd_metrics("Animal.pony",
|
|
"class Animal\n"
|
|
" let _name: String\n"
|
|
"\n"
|
|
" new create(name: String) =>\n"
|
|
" _name = name\n"
|
|
"\n"
|
|
" fun name(): String =>\n"
|
|
" _name\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: class_definition must produce a type-like node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Pony: actor definition → type-like node. */
|
|
TEST(probe_pony_actor_node) {
|
|
GpdMetrics m = gpd_metrics("Counter.pony",
|
|
"actor Counter\n"
|
|
" var _count: U64 = 0\n"
|
|
"\n"
|
|
" be increment() =>\n"
|
|
" _count = _count + 1\n"
|
|
"\n"
|
|
" be reset() =>\n"
|
|
" _count = 0\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: actor_definition must produce a type-like node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Pony: methods (fun/be/new) inside a type → Method nodes. */
|
|
TEST(probe_pony_method_nodes) {
|
|
GpdMetrics m = gpd_metrics("Math.pony",
|
|
"primitive Math\n"
|
|
" fun square(n: U64): U64 =>\n"
|
|
" n * n\n"
|
|
"\n"
|
|
" fun cube(n: U64): U64 =>\n"
|
|
" n * square(n)\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: fun methods inside a primitive/actor/class are promoted to Method
|
|
* nodes (extract_defs.c Pony method-promotion), so assert on m.methods. */
|
|
ASSERT_TRUE(m.methods >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Pony: trait with interface → type-like node. */
|
|
TEST(probe_pony_trait_node) {
|
|
GpdMetrics m = gpd_metrics("Speakable.pony",
|
|
"trait Speakable\n"
|
|
" fun speak(): String\n"
|
|
"\n"
|
|
"class Dog is Speakable\n"
|
|
" fun speak(): String =>\n"
|
|
" \"Woof!\"\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both trait and class must produce type-like nodes. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Pony: `use` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only Pony has no use-statement resolver in the pipeline. */
|
|
TEST(probe_pony_imports_edge) {
|
|
static const GpdFile files[] = {
|
|
{"util.pony",
|
|
"primitive MathUtil\n"
|
|
" fun double(n: U64): U64 =>\n"
|
|
" n * 2\n"},
|
|
{"main.pony",
|
|
"use \"./util\"\n"
|
|
"\n"
|
|
"actor Main\n"
|
|
" new create(env: Env) =>\n"
|
|
" let r = MathUtil.double(21)\n"
|
|
" env.out.print(r.string())\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Pony `use` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 17 — PureScript (.purs)
|
|
*
|
|
* PureScript label histogram: Class:1, Function:1, Module:1 (from grammar_labels).
|
|
* Spec: purescript_func_types = {"function"},
|
|
* purescript_class_types = {"class_declaration","data","newtype","type_alias"},
|
|
* purescript_import_types = {"import","import_item","instance"}.
|
|
* Extension: .purs → CBM_LANG_PURESCRIPT.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* PureScript: function definition → Function node. */
|
|
TEST(probe_purescript_function) {
|
|
GpdMetrics m = gpd_metrics("Math.purs",
|
|
"module Math where\n"
|
|
"\n"
|
|
"double :: Int -> Int\n"
|
|
"double n = n * 2\n"
|
|
"\n"
|
|
"square :: Int -> Int\n"
|
|
"square n = n * n\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: function definitions must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* PureScript: data/type declaration → type-like node. */
|
|
TEST(probe_purescript_data_type) {
|
|
GpdMetrics m = gpd_metrics("Types.purs",
|
|
"module Types where\n"
|
|
"\n"
|
|
"data Shape\n"
|
|
" = Circle Number\n"
|
|
" | Rectangle Number Number\n"
|
|
"\n"
|
|
"type Alias = Shape\n"
|
|
"\n"
|
|
"area :: Shape -> Number\n"
|
|
"area (Circle r) = 3.14159 * r * r\n"
|
|
"area (Rectangle w h) = w * h\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: data declaration must produce a type-like node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* PureScript: `import` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only PureScript has no import-resolver in the pipeline. */
|
|
TEST(probe_purescript_imports_edge) {
|
|
static const GpdFile files[] = {
|
|
{"Utils.purs",
|
|
"module Utils where\n"
|
|
"\n"
|
|
"double :: Int -> Int\n"
|
|
"double n = n * 2\n"},
|
|
{"Main.purs",
|
|
"module Main where\n"
|
|
"\n"
|
|
"import Utils (double)\n"
|
|
"\n"
|
|
"quad :: Int -> Int\n"
|
|
"quad n = double (double n)\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: PureScript `import` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 18 — Pine Script (.pine)
|
|
*
|
|
* Pine label histogram: Function:1, Module:1 (from grammar_labels).
|
|
* Spec: pine_func_types = {"function_declaration_statement"},
|
|
* pine_class_types = {"type_definition_statement"}.
|
|
* Extension: .pine → CBM_LANG_PINE.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Pine Script: function declaration → Function node. */
|
|
TEST(probe_pine_function) {
|
|
GpdMetrics m = gpd_metrics("indicator.pine",
|
|
"//@version=5\n"
|
|
"indicator('My Indicator')\n"
|
|
"\n"
|
|
"double(n) =>\n"
|
|
" n * 2\n"
|
|
"\n"
|
|
"square(n) =>\n"
|
|
" n * n\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: function_declaration_statement must produce a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Pine Script: type definition → type-like node.
|
|
* RED: histogram shows Function/Module only; type_definition_statement not
|
|
* extracted as type-like node despite pine_class_types spec. */
|
|
TEST(probe_pine_type_node) {
|
|
GpdMetrics m = gpd_metrics("types.pine",
|
|
"//@version=5\n"
|
|
"indicator('Types')\n"
|
|
"\n"
|
|
"type Point\n"
|
|
" float x = 0\n"
|
|
" float y = 0\n"
|
|
"\n"
|
|
"makePoint(x, y) =>\n"
|
|
" Point.new(x, y)\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Pine Script type_definition_statement not extracted as type-like node. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 19 — QML (.qml)
|
|
*
|
|
* QML label histogram: Class:1, Function:2, Module:1 (from grammar_labels).
|
|
* Spec: qml_class_types = {"class_declaration","class","abstract_class_declaration",
|
|
* "enum_declaration","interface_declaration","ui_inline_component"},
|
|
* qml_import_types = {"import_statement","import","ui_import"}.
|
|
* Function types reuse js_func_types (QMLJS is a TS/JS superset).
|
|
* Extension: .qml → CBM_LANG_QML.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* QML: JavaScript function inside a component → Function node. */
|
|
TEST(probe_qml_function) {
|
|
GpdMetrics m = gpd_metrics("Button.qml",
|
|
"import QtQuick 2.15\n"
|
|
"\n"
|
|
"Rectangle {\n"
|
|
" id: root\n"
|
|
" width: 100; height: 40\n"
|
|
"\n"
|
|
" function greet(name) {\n"
|
|
" return \"Hello, \" + name\n"
|
|
" }\n"
|
|
"\n"
|
|
" function dismiss() {\n"
|
|
" visible = false\n"
|
|
" }\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: JavaScript functions inside QML must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* QML: `import` → IMPORTS edge.
|
|
* RED: grammar-only QML has no import-resolver in the pipeline. */
|
|
TEST(probe_qml_imports_edge) {
|
|
static const GpdFile files[] = {
|
|
{"Utils.qml",
|
|
"import QtQuick 2.15\n"
|
|
"\n"
|
|
"Rectangle {\n"
|
|
" function double(n) { return n * 2 }\n"
|
|
"}\n"},
|
|
{"Main.qml",
|
|
"import QtQuick 2.15\n"
|
|
"import \"./Utils.qml\"\n"
|
|
"\n"
|
|
"Rectangle {\n"
|
|
" function run(n) { return n * 4 }\n"
|
|
"}\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: QML `import` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 20 — Smali (.smali)
|
|
*
|
|
* Smali label histogram: Class:1, Function:1, Module:1.
|
|
* Spec: smali_func_types = {"method_definition"},
|
|
* smali_class_types = {"class_definition"},
|
|
* smali_import_types = {"super_directive","implements_directive"}.
|
|
* Extension: .smali → CBM_LANG_SMALI.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Smali: class definition → Class node. */
|
|
TEST(probe_smali_class_node) {
|
|
GpdMetrics m = gpd_metrics("A.smali",
|
|
".class public LA;\n"
|
|
".super Ljava/lang/Object;\n"
|
|
"\n"
|
|
".method public constructor <init>()V\n"
|
|
" .registers 1\n"
|
|
" return-void\n"
|
|
".end method\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: class_definition must produce a type-like node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Smali: method definition → Function node. */
|
|
TEST(probe_smali_method_node) {
|
|
GpdMetrics m = gpd_metrics("Math.smali",
|
|
".class public LMath;\n"
|
|
".super Ljava/lang/Object;\n"
|
|
"\n"
|
|
".method public static square(I)I\n"
|
|
" .registers 2\n"
|
|
" mul-int v0, p0, p0\n"
|
|
" return v0\n"
|
|
".end method\n"
|
|
"\n"
|
|
".method public static cube(I)I\n"
|
|
" .registers 2\n"
|
|
" mul-int v0, p0, p0\n"
|
|
" mul-int v0, v0, p0\n"
|
|
" return v0\n"
|
|
".end method\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: method definitions must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Smali: .super and .implements directives → IMPORTS edges.
|
|
* RED: Smali super/implements directives not resolved into IMPORTS edges. */
|
|
TEST(probe_smali_super_import) {
|
|
static const GpdFile files[] = {
|
|
{"Base.smali",
|
|
".class public LBase;\n"
|
|
".super Ljava/lang/Object;\n"
|
|
"\n"
|
|
".method public doBase()V\n"
|
|
" return-void\n"
|
|
".end method\n"},
|
|
{"Child.smali",
|
|
".class public LChild;\n"
|
|
".super LBase;\n"
|
|
"\n"
|
|
".method public doChild()V\n"
|
|
" return-void\n"
|
|
".end method\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Smali .super directive not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 21 — TableGen (.td)
|
|
*
|
|
* TableGen label histogram: Function:1, Module:1.
|
|
* Spec: tablegen_func_types = {"def","multiclass","defm"},
|
|
* tablegen_class_types = {"class"},
|
|
* tablegen_import_types = {"include","include_directive"}.
|
|
* Extension: .td → CBM_LANG_TABLEGEN.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* TableGen: `def` record → Function node (def is in func_types). */
|
|
TEST(probe_tablegen_def_node) {
|
|
GpdMetrics m = gpd_metrics("regs.td",
|
|
"def R0 { int num = 0; }\n"
|
|
"def R1 { int num = 1; }\n"
|
|
"def R2 { int num = 2; }\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: def records must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* TableGen: `class` definition → type-like node.
|
|
* RED: histogram shows Function:1/Module:1 only; class not extracted as
|
|
* type-like node despite tablegen_class_types spec. */
|
|
TEST(probe_tablegen_class_node) {
|
|
GpdMetrics m = gpd_metrics("instrs.td",
|
|
"class Instruction {\n"
|
|
" string mnemonic = \"\";\n"
|
|
" int opcode = 0;\n"
|
|
"}\n"
|
|
"\n"
|
|
"def ADD : Instruction {\n"
|
|
" let mnemonic = \"add\";\n"
|
|
" let opcode = 1;\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: TableGen class not extracted as type-like node. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* TableGen: `include` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only TableGen has no include-resolver in the pipeline. */
|
|
TEST(probe_tablegen_include_edge) {
|
|
static const GpdFile files[] = {
|
|
{"base.td",
|
|
"class BaseInstr {\n"
|
|
" int opcode = 0;\n"
|
|
"}\n"},
|
|
{"derived.td",
|
|
"include \"base.td\"\n"
|
|
"\n"
|
|
"def ADD : BaseInstr {\n"
|
|
" let opcode = 1;\n"
|
|
"}\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: TableGen `include` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 22 — TLA+ (.tla)
|
|
*
|
|
* TLA+ label histogram: Function:1, Module:1.
|
|
* Spec: tlaplus_func_types = {"operator_definition","function_definition"},
|
|
* tlaplus_import_types = {"extends","instance"}.
|
|
* Extension: .tla → CBM_LANG_TLAPLUS.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* TLA+: operator definition → Function node. */
|
|
TEST(probe_tlaplus_operator) {
|
|
GpdMetrics m = gpd_metrics("counter.tla",
|
|
"---- MODULE counter ----\n"
|
|
"VARIABLE count\n"
|
|
"\n"
|
|
"Init == count = 0\n"
|
|
"\n"
|
|
"Increment == count' = count + 1\n"
|
|
"====\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: operator definitions (Init, Increment) must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* TLA+: EXTENDS in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only TLA+ has no EXTENDS resolver in the pipeline. */
|
|
TEST(probe_tlaplus_extends_edge) {
|
|
static const GpdFile files[] = {
|
|
{"Naturals.tla",
|
|
"---- MODULE Naturals ----\n"
|
|
"Max(a, b) == IF a > b THEN a ELSE b\n"
|
|
"====\n"},
|
|
{"Counter.tla",
|
|
"---- MODULE Counter ----\n"
|
|
"EXTENDS Naturals\n"
|
|
"\n"
|
|
"VARIABLE count\n"
|
|
"\n"
|
|
"Init == count = 0\n"
|
|
"Next == count' = Max(count + 1, count)\n"
|
|
"====\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: TLA+ EXTENDS not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* TLA+: no OOP — no type-like nodes expected. */
|
|
TEST(probe_tlaplus_no_type_nodes) {
|
|
GpdMetrics m = gpd_metrics("simple.tla",
|
|
"---- MODULE simple ----\n"
|
|
"VARIABLE x\n"
|
|
"Init == x = 0\n"
|
|
"====\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: TLA+ produces 0 type-like nodes. */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 23 — Verilog (.v)
|
|
*
|
|
* Verilog label histogram: Class:1, Module:1.
|
|
* Spec: verilog_func_types = {"function_declaration","task_declaration",...},
|
|
* verilog_class_types = {"module_declaration","class_declaration",...},
|
|
* verilog_import_types = {"extends","import","package_import_declaration"}.
|
|
* Extension: .v → CBM_LANG_VERILOG.
|
|
* Note: .sv also maps to CBM_LANG_VERILOG (not CBM_LANG_SYSTEMVERILOG).
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Verilog: module declaration → type-like node. */
|
|
TEST(probe_verilog_module_node) {
|
|
GpdMetrics m = gpd_metrics("counter.v",
|
|
"module counter(\n"
|
|
" input clk,\n"
|
|
" input rst,\n"
|
|
" output reg [7:0] count\n"
|
|
");\n"
|
|
"\n"
|
|
"always @(posedge clk or posedge rst) begin\n"
|
|
" if (rst)\n"
|
|
" count <= 0;\n"
|
|
" else\n"
|
|
" count <= count + 1;\n"
|
|
"end\n"
|
|
"\n"
|
|
"endmodule\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: module_declaration must produce a type-like node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Verilog: function declaration → Function node. */
|
|
TEST(probe_verilog_function) {
|
|
GpdMetrics m = gpd_metrics("math.v",
|
|
"module math_funcs;\n"
|
|
"\n"
|
|
"function [7:0] double;\n"
|
|
" input [7:0] n;\n"
|
|
" begin\n"
|
|
" double = n << 1;\n"
|
|
" end\n"
|
|
"endfunction\n"
|
|
"\n"
|
|
"endmodule\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: function declaration must produce a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Verilog: SystemVerilog-style file (.sv) — lands on CBM_LANG_VERILOG via EXT_TABLE.
|
|
* No separate CBM_LANG_SYSTEMVERILOG routing is available through file extension. */
|
|
TEST(probe_verilog_sv_extension) {
|
|
GpdMetrics m = gpd_metrics("adder.sv",
|
|
"module adder(\n"
|
|
" input logic [7:0] a,\n"
|
|
" input logic [7:0] b,\n"
|
|
" output logic [7:0] sum\n"
|
|
");\n"
|
|
" assign sum = a + b;\n"
|
|
"endmodule\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: .sv → CBM_LANG_VERILOG; module_declaration must produce type-like node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 24 — VHDL (.vhd)
|
|
*
|
|
* VHDL label histogram: Class:1, Module:1.
|
|
* Spec: vhdl_func_types = {"subprogram_declaration","subprogram_definition"},
|
|
* vhdl_class_types = {"entity_declaration","architecture_definition",
|
|
* "component_declaration","interface_declaration",
|
|
* "package_declaration","protected_type_declaration",
|
|
* "record_type_definition","type_declaration"},
|
|
* vhdl_import_types = {"library_clause","use_clause"}.
|
|
* Extension: .vhd / .vhdl → CBM_LANG_VHDL.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* VHDL: entity declaration → type-like node. */
|
|
TEST(probe_vhdl_entity_node) {
|
|
GpdMetrics m = gpd_metrics("counter.vhd",
|
|
"entity counter is\n"
|
|
" port (\n"
|
|
" clk : in bit;\n"
|
|
" rst : in bit;\n"
|
|
" count : out integer\n"
|
|
" );\n"
|
|
"end counter;\n"
|
|
"\n"
|
|
"architecture rtl of counter is\n"
|
|
"begin\n"
|
|
"end architecture;\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: entity_declaration must produce a type-like node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* VHDL: subprogram (function/procedure) definition → Function node. */
|
|
TEST(probe_vhdl_subprogram) {
|
|
GpdMetrics m = gpd_metrics("funcs.vhd",
|
|
"package math_pkg is\n"
|
|
" function double(n : integer) return integer;\n"
|
|
"end package;\n"
|
|
"\n"
|
|
"package body math_pkg is\n"
|
|
" function double(n : integer) return integer is\n"
|
|
" begin\n"
|
|
" return n * 2;\n"
|
|
" end function;\n"
|
|
"end package body;\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: subprogram_definition must produce a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* VHDL: library/use in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only VHDL has no library/use resolver in the pipeline. */
|
|
TEST(probe_vhdl_use_imports_edge) {
|
|
static const GpdFile files[] = {
|
|
{"math_pkg.vhd",
|
|
"package math_pkg is\n"
|
|
" function double(n : integer) return integer;\n"
|
|
"end package;\n"
|
|
"\n"
|
|
"package body math_pkg is\n"
|
|
" function double(n : integer) return integer is\n"
|
|
" begin return n * 2; end function;\n"
|
|
"end package body;\n"},
|
|
{"top.vhd",
|
|
"library work;\n"
|
|
"use work.math_pkg.all;\n"
|
|
"\n"
|
|
"entity top is end;\n"
|
|
"architecture rtl of top is\n"
|
|
"begin\n"
|
|
"end architecture;\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: VHDL library/use not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 25 — Wolfram (.wl)
|
|
*
|
|
* Wolfram label histogram: Function:2, Module:1.
|
|
* Spec: wolfram_func_types = {"set_delayed_top","set_top","set_delayed","set"},
|
|
* wolfram_import_types = {"get_top"}.
|
|
* Extension: .wl / .wls → CBM_LANG_WOLFRAM.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Wolfram: SetDelayed function definition → Function node. */
|
|
TEST(probe_wolfram_function) {
|
|
GpdMetrics m = gpd_metrics("math.wl",
|
|
"Square[n_] := n * n\n"
|
|
"\n"
|
|
"Cube[n_] := n * Square[n]\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* REAL BUG (class 16 node-extraction incompleteness): two top-level
|
|
* `f[x_] := ...` SetDelayed defs in one file yield only 1 Function node,
|
|
* not 2. The grammar_labels histogram only guarantees Function:1 for a
|
|
* single-def fixture; a 2-def file under-extracts. Root cause likely in
|
|
* extract_defs.c wolfram walk (resolve_wolfram_func_name / top-level
|
|
* statement iteration capturing only the first set_delayed_top). RED. */
|
|
ASSERT_TRUE(m.functions >= 2); /* REAL BUG — multi-def under-extraction */
|
|
PASS();
|
|
}
|
|
|
|
/* Wolfram: Set (=) definition → Function node. */
|
|
TEST(probe_wolfram_set_definition) {
|
|
GpdMetrics m = gpd_metrics("const.wl",
|
|
"Pi = 3.14159265\n"
|
|
"\n"
|
|
"E = 2.71828182\n"
|
|
"\n"
|
|
"Double[n_] := n * 2\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* REAL BUG (class 16 node-extraction incompleteness): a file whose first
|
|
* top-level statements are plain `Pi = 3.14` / `E = 2.71` (set_top with a
|
|
* non-`apply` LHS → resolve_wolfram_func_name returns null) followed by a
|
|
* real `Double[n_] := n*2` def yields 0 Function nodes — the trailing
|
|
* apply-LHS SetDelayed def is NOT extracted. A lone `f[x_] := ...`
|
|
* extracts fine (grammar_labels wolfram=Function:1), so the leading
|
|
* non-def set_top statements suppress later extraction. Root cause:
|
|
* extract_defs.c wolfram top-level walk. RED. */
|
|
ASSERT_TRUE(m.functions >= 1); /* REAL BUG — set_top prefix suppresses later def */
|
|
PASS();
|
|
}
|
|
|
|
/* Wolfram: << (Get) import in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only Wolfram has no << resolver in the pipeline. */
|
|
TEST(probe_wolfram_get_import) {
|
|
static const GpdFile files[] = {
|
|
{"utils.wl",
|
|
"Double[n_] := n * 2\n"
|
|
"Triple[n_] := n * 3\n"},
|
|
{"main.wls",
|
|
"<< \"utils.wl\"\n"
|
|
"\n"
|
|
"Quad[n_] := Double[Double[n]]\n"}
|
|
};
|
|
GpdMetrics m = gpd_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Wolfram << (get_top) not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* Wolfram: no OOP types — Wolfram is functional/symbolic. */
|
|
TEST(probe_wolfram_no_type_nodes) {
|
|
GpdMetrics m = gpd_metrics("simple.wl",
|
|
"Id[x_] := x\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: Wolfram produces 0 type-like nodes. */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* SUITE wiring
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
SUITE(grammar_probe_d) {
|
|
/* Agda (.agda) */
|
|
RUN_TEST(probe_agda_function);
|
|
RUN_TEST(probe_agda_data_type);
|
|
RUN_TEST(probe_agda_imports_edge);
|
|
|
|
/* Assembly (.s) */
|
|
RUN_TEST(probe_assembly_label_function);
|
|
RUN_TEST(probe_assembly_multiple_labels);
|
|
RUN_TEST(probe_assembly_no_type_nodes);
|
|
|
|
/* Bicep (.bicep) */
|
|
RUN_TEST(probe_bicep_function);
|
|
RUN_TEST(probe_bicep_resource_node);
|
|
RUN_TEST(probe_bicep_module_import);
|
|
|
|
/* CFML (.cfm) */
|
|
RUN_TEST(probe_cfml_function_tag);
|
|
RUN_TEST(probe_cfml_two_functions);
|
|
RUN_TEST(probe_cfml_no_type_nodes);
|
|
|
|
/* CFScript (.cfc) */
|
|
RUN_TEST(probe_cfscript_functions);
|
|
RUN_TEST(probe_cfscript_no_import_edges);
|
|
|
|
/* COBOL (.cob) */
|
|
RUN_TEST(probe_cobol_program_node);
|
|
RUN_TEST(probe_cobol_no_crash);
|
|
|
|
/* Elm (.elm) */
|
|
RUN_TEST(probe_elm_function);
|
|
RUN_TEST(probe_elm_type_alias);
|
|
RUN_TEST(probe_elm_imports_edge);
|
|
|
|
/* FunC (.fc) */
|
|
RUN_TEST(probe_func_function);
|
|
RUN_TEST(probe_func_imports_edge);
|
|
RUN_TEST(probe_func_no_type_nodes);
|
|
|
|
/* Janet (.janet) */
|
|
RUN_TEST(probe_janet_no_crash);
|
|
RUN_TEST(probe_janet_function_extraction_gap);
|
|
|
|
/* Lean (.lean) */
|
|
RUN_TEST(probe_lean_def_functions);
|
|
RUN_TEST(probe_lean_theorem);
|
|
RUN_TEST(probe_lean_structure_type);
|
|
RUN_TEST(probe_lean_imports_edge);
|
|
|
|
/* LLVM IR (.ll) */
|
|
RUN_TEST(probe_llvmir_function);
|
|
RUN_TEST(probe_llvmir_two_functions);
|
|
RUN_TEST(probe_llvmir_no_type_nodes);
|
|
|
|
/* Magma (.mag) */
|
|
RUN_TEST(probe_magma_function);
|
|
RUN_TEST(probe_magma_procedure);
|
|
RUN_TEST(probe_magma_no_type_nodes);
|
|
|
|
/* Move (.move) */
|
|
RUN_TEST(probe_move_function);
|
|
RUN_TEST(probe_move_imports_edge);
|
|
RUN_TEST(probe_move_struct_not_extracted);
|
|
|
|
/* NASM (.nasm) */
|
|
RUN_TEST(probe_nasm_label_function);
|
|
RUN_TEST(probe_nasm_struc_node);
|
|
RUN_TEST(probe_nasm_include_edge);
|
|
|
|
/* Objective-C (.m with ObjC markers) */
|
|
RUN_TEST(probe_objc_class_node);
|
|
RUN_TEST(probe_objc_method_nodes);
|
|
RUN_TEST(probe_objc_inherits_edge);
|
|
RUN_TEST(probe_objc_import_edge);
|
|
|
|
/* Pony (.pony) */
|
|
RUN_TEST(probe_pony_class_node);
|
|
RUN_TEST(probe_pony_actor_node);
|
|
RUN_TEST(probe_pony_method_nodes);
|
|
RUN_TEST(probe_pony_trait_node);
|
|
RUN_TEST(probe_pony_imports_edge);
|
|
|
|
/* PureScript (.purs) */
|
|
RUN_TEST(probe_purescript_function);
|
|
RUN_TEST(probe_purescript_data_type);
|
|
RUN_TEST(probe_purescript_imports_edge);
|
|
|
|
/* Pine Script (.pine) */
|
|
RUN_TEST(probe_pine_function);
|
|
RUN_TEST(probe_pine_type_node);
|
|
|
|
/* QML (.qml) */
|
|
RUN_TEST(probe_qml_function);
|
|
RUN_TEST(probe_qml_imports_edge);
|
|
|
|
/* Smali (.smali) */
|
|
RUN_TEST(probe_smali_class_node);
|
|
RUN_TEST(probe_smali_method_node);
|
|
RUN_TEST(probe_smali_super_import);
|
|
|
|
/* TableGen (.td) */
|
|
RUN_TEST(probe_tablegen_def_node);
|
|
RUN_TEST(probe_tablegen_class_node);
|
|
RUN_TEST(probe_tablegen_include_edge);
|
|
|
|
/* TLA+ (.tla) */
|
|
RUN_TEST(probe_tlaplus_operator);
|
|
RUN_TEST(probe_tlaplus_extends_edge);
|
|
RUN_TEST(probe_tlaplus_no_type_nodes);
|
|
|
|
/* Verilog (.v — also covers .sv routed as CBM_LANG_VERILOG) */
|
|
RUN_TEST(probe_verilog_module_node);
|
|
RUN_TEST(probe_verilog_function);
|
|
RUN_TEST(probe_verilog_sv_extension);
|
|
|
|
/* VHDL (.vhd) */
|
|
RUN_TEST(probe_vhdl_entity_node);
|
|
RUN_TEST(probe_vhdl_subprogram);
|
|
RUN_TEST(probe_vhdl_use_imports_edge);
|
|
|
|
/* Wolfram (.wl) */
|
|
RUN_TEST(probe_wolfram_function);
|
|
RUN_TEST(probe_wolfram_set_definition);
|
|
RUN_TEST(probe_wolfram_get_import);
|
|
RUN_TEST(probe_wolfram_no_type_nodes);
|
|
}
|