wehub-resource-sync
1521 lines
56 KiB
C
1521 lines
56 KiB
C
/*
|
|
* test_grammar_probe_e.c — IDL/template node/import probe.
|
|
*
|
|
* SCOPE
|
|
* ─────
|
|
* IDL / schema languages:
|
|
* protobuf (.proto), thrift (.thrift), capnp (.capnp), wit (.wit),
|
|
* smithy (.smithy), prisma (.prisma), graphql (.graphql / .gql)
|
|
*
|
|
* Template / component languages:
|
|
* vue (.vue), svelte (.svelte), astro (.astro),
|
|
* blade (.blade.php), liquid (.liquid), jinja2 (.j2 / .jinja2),
|
|
* gotemplate (.gotmpl / .tmpl), mermaid (.mmd / .mermaid), jsdoc (.jsdoc)
|
|
*
|
|
* WHAT IS PROBED
|
|
* ──────────────
|
|
* • NODE creation — type-like nodes (Class/Struct/Interface/Enum) for IDL
|
|
* languages; Module-only for template/markup grammars.
|
|
* • IMPORTS edges — cross-file import/include/use where the grammar
|
|
* supports it. Two-file fixtures are used where
|
|
* applicable. Template grammars without a file-level
|
|
* import mechanism are tested for no-crash instead.
|
|
*
|
|
* COLOUR LEGEND
|
|
* ─────────────
|
|
* GREEN = guard: the pipeline already produces the correct result; a
|
|
* failure here is a real regression.
|
|
* RED = bug reproduction: the pipeline does NOT yet produce the expected
|
|
* node/edge. Brief inline comments identify the root-cause class.
|
|
*
|
|
* CALLS coverage is intentionally omitted (IDL/template languages have no
|
|
* in-language function calls to resolve; templates are covered by P5 breadth
|
|
* where applicable).
|
|
*
|
|
* Do NOT register this suite in test_main.c — a sibling agent owns that file.
|
|
*
|
|
* SUITE(grammar_probe_e)
|
|
*/
|
|
|
|
#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 "gpe_" to avoid symbol collisions with sibling probe files.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
typedef struct {
|
|
char tmpdir[256];
|
|
char dbpath[512];
|
|
char *project;
|
|
cbm_mcp_server_t *srv;
|
|
} GpeProj;
|
|
|
|
typedef struct {
|
|
const char *name; /* relative filename, may include '/' for subdirs */
|
|
const char *content;
|
|
} GpeFile;
|
|
|
|
static void gpe_to_fwd_slashes(char *p) {
|
|
for (; *p; p++) {
|
|
if (*p == '\\') *p = '/';
|
|
}
|
|
}
|
|
|
|
static cbm_store_t *gpe_open_indexed(GpeProj *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 *gpe_index_files(GpeProj *lp, const GpeFile *files, int nfiles) {
|
|
memset(lp, 0, sizeof(*lp));
|
|
snprintf(lp->tmpdir, sizeof(lp->tmpdir), "/tmp/cbm_gpe_XXXXXX");
|
|
if (!cbm_mkdtemp(lp->tmpdir)) return NULL;
|
|
gpe_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 gpe_open_indexed(lp);
|
|
}
|
|
|
|
static void gpe_cleanup(GpeProj *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 gpe_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 gpe_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 = gpe_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 */
|
|
} GpeMetrics;
|
|
|
|
static GpeMetrics gpe_metrics_files(const GpeFile *files, int nfiles) {
|
|
GpeProj lp;
|
|
cbm_store_t *store = gpe_index_files(&lp, files, nfiles);
|
|
GpeMetrics m = {0};
|
|
if (store) {
|
|
m.ok = 1;
|
|
m.total_nodes = cbm_store_count_nodes(store, lp.project);
|
|
m.functions = gpe_count_label(store, lp.project, "Function");
|
|
m.methods = gpe_count_label(store, lp.project, "Method");
|
|
m.types = gpe_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");
|
|
}
|
|
gpe_cleanup(&lp, store);
|
|
return m;
|
|
}
|
|
|
|
static GpeMetrics gpe_metrics(const char *filename, const char *content) {
|
|
GpeFile f = {filename, content};
|
|
return gpe_metrics_files(&f, 1);
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 1 — Protobuf (.proto)
|
|
*
|
|
* Label histogram (test_grammar_labels.c): Class:1, Module:1
|
|
* A `message` definition → Class node.
|
|
* `enum` — whether it also produces a Class node is not confirmed; the
|
|
* histogram shows Class:1 for a single-message fixture, so a second Class
|
|
* for an enum would require a fixture with both message + enum.
|
|
* `service` — the label histogram does not show a Function node for a
|
|
* service method in the single-message fixture; service methods are
|
|
* extractable as Class/Function depending on extractor policy.
|
|
* `import` — Protobuf `import "other.proto"` is not resolved into IMPORTS
|
|
* graph edges; single-pass grammar-only extractor has no proto import
|
|
* resolver.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Protobuf: single message definition → at least 1 Class node. */
|
|
TEST(probe_proto_message_node) {
|
|
GpeMetrics m = gpe_metrics("user.proto",
|
|
"syntax = \"proto3\";\n"
|
|
"package user;\n"
|
|
"\n"
|
|
"message User {\n"
|
|
" int64 id = 1;\n"
|
|
" string name = 2;\n"
|
|
" string email = 3;\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: the `message` definition must produce a Class node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Protobuf: service definition — whether the service itself or its RPC
|
|
* methods produce extractable nodes. */
|
|
TEST(probe_proto_service_node) {
|
|
GpeMetrics m = gpe_metrics("svc.proto",
|
|
"syntax = \"proto3\";\n"
|
|
"package svc;\n"
|
|
"\n"
|
|
"message Req { string query = 1; }\n"
|
|
"message Resp { string result = 1; }\n"
|
|
"\n"
|
|
"service SearchService {\n"
|
|
" rpc Search(Req) returns (Resp);\n"
|
|
" rpc Suggest(Req) returns (Resp);\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at least the two message defs must produce Class nodes. */
|
|
ASSERT_TRUE(m.types >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Protobuf: enum definition — confirm enum maps to a Class-like node. */
|
|
TEST(probe_proto_enum_node) {
|
|
GpeMetrics m = gpe_metrics("status.proto",
|
|
"syntax = \"proto3\";\n"
|
|
"\n"
|
|
"enum Status {\n"
|
|
" STATUS_UNKNOWN = 0;\n"
|
|
" STATUS_ACTIVE = 1;\n"
|
|
" STATUS_INACTIVE = 2;\n"
|
|
"}\n"
|
|
"\n"
|
|
"message Item {\n"
|
|
" int64 id = 1;\n"
|
|
" Status status = 2;\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at minimum the message must produce a Class node; enum may add
|
|
* another — total >= 1 is the safe floor. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Protobuf: two-file `import` → IMPORTS edge.
|
|
* RED: grammar-only protobuf has no import-resolver pass in the pipeline;
|
|
* `import "other.proto"` statements are not turned into IMPORTS edges. */
|
|
TEST(probe_proto_import_edge) {
|
|
static const GpeFile files[] = {
|
|
{"common.proto",
|
|
"syntax = \"proto3\";\n"
|
|
"package common;\n"
|
|
"message Timestamp { int64 seconds = 1; }\n"},
|
|
{"event.proto",
|
|
"syntax = \"proto3\";\n"
|
|
"package event;\n"
|
|
"import \"common.proto\";\n"
|
|
"message Event {\n"
|
|
" string id = 1;\n"
|
|
" common.Timestamp created_at = 2;\n"
|
|
"}\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: protobuf `import` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED — no proto import resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 2 — Thrift (.thrift)
|
|
*
|
|
* Label histogram: Function:1, Module:1
|
|
* `service Foo { void ping() }` → Function node (the method).
|
|
* `struct` — the histogram shows no Struct/Class node for a service-only
|
|
* fixture; struct extraction may not be implemented.
|
|
* `include` — Thrift uses `include "other.thrift"` for imports; not
|
|
* resolved by the grammar-only pipeline.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Thrift: service method → at least 1 Function node. */
|
|
TEST(probe_thrift_service_function) {
|
|
GpeMetrics m = gpe_metrics("calc.thrift",
|
|
"namespace go calc\n"
|
|
"\n"
|
|
"service Calculator {\n"
|
|
" i32 add(1: i32 a, 2: i32 b)\n"
|
|
" i32 subtract(1: i32 a, 2: i32 b)\n"
|
|
" i32 multiply(1: i32 a, 2: i32 b)\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at least one service method must appear as a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Thrift: struct definition — does the extractor produce a type-like node?
|
|
* RED: histogram shows Function:1/Module:1 for service-only fixtures; struct
|
|
* extraction is not confirmed and may not be implemented in the grammar
|
|
* extractor. */
|
|
TEST(probe_thrift_struct_node) {
|
|
GpeMetrics m = gpe_metrics("types.thrift",
|
|
"namespace go types\n"
|
|
"\n"
|
|
"struct User {\n"
|
|
" 1: required i64 id\n"
|
|
" 2: required string name\n"
|
|
" 3: optional string email\n"
|
|
"}\n"
|
|
"\n"
|
|
"struct Address {\n"
|
|
" 1: required string street\n"
|
|
" 2: required string city\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1); /* GREEN: at minimum Module node */
|
|
/* RED: Thrift struct not yet extracted as a Struct/Class node. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED — no Thrift struct extractor */
|
|
PASS();
|
|
}
|
|
|
|
/* Thrift: exception definition — a special struct-like type. */
|
|
TEST(probe_thrift_exception_node) {
|
|
GpeMetrics m = gpe_metrics("errors.thrift",
|
|
"namespace go errors\n"
|
|
"\n"
|
|
"exception NotFound {\n"
|
|
" 1: required string message\n"
|
|
"}\n"
|
|
"\n"
|
|
"exception Unauthorized {\n"
|
|
" 1: required string reason\n"
|
|
"}\n"
|
|
"\n"
|
|
"service Auth {\n"
|
|
" void login(1: string user, 2: string pass)\n"
|
|
" throws (1: Unauthorized e)\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at least the service method must appear as a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Thrift: two-file `include` → IMPORTS edge.
|
|
* RED: grammar-only Thrift has no include-resolver in the pipeline. */
|
|
TEST(probe_thrift_include_edge) {
|
|
static const GpeFile files[] = {
|
|
{"common.thrift",
|
|
"namespace go common\n"
|
|
"struct Timestamp { 1: required i64 seconds }\n"},
|
|
{"service.thrift",
|
|
"namespace go service\n"
|
|
"include \"common.thrift\"\n"
|
|
"struct Event {\n"
|
|
" 1: required string id\n"
|
|
" 2: required common.Timestamp created_at\n"
|
|
"}\n"
|
|
"service EventService {\n"
|
|
" Event getEvent(1: string id)\n"
|
|
"}\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Thrift `include` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED — no Thrift include resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 3 — Cap'n Proto (.capnp)
|
|
*
|
|
* Label histogram: Class:1, Module:1
|
|
* `struct` → Class node.
|
|
* `interface` — may also produce a Class node (or Interface node).
|
|
* `import` with `@0x...` annotation — Capnp uses `using Import = import
|
|
* "other.capnp";`; not resolved by the grammar-only pipeline.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Cap'n Proto: struct definition → at least 1 Class node. */
|
|
TEST(probe_capnp_struct_node) {
|
|
GpeMetrics m = gpe_metrics("schema.capnp",
|
|
"@0xdbb9ad1f14bf0b36;\n"
|
|
"\n"
|
|
"struct Person {\n"
|
|
" id @0 :UInt32;\n"
|
|
" name @1 :Text;\n"
|
|
" email @2 :Text;\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: the struct must produce a Class node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Cap'n Proto: interface definition → Class (or Interface) node. */
|
|
TEST(probe_capnp_interface_node) {
|
|
GpeMetrics m = gpe_metrics("service.capnp",
|
|
"@0xabc123def456789a;\n"
|
|
"\n"
|
|
"struct Request { query @0 :Text; }\n"
|
|
"struct Response { result @0 :Text; }\n"
|
|
"\n"
|
|
"interface SearchService {\n"
|
|
" search @0 (req :Request) -> (resp :Response);\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at minimum the two struct definitions must produce Class nodes. */
|
|
ASSERT_TRUE(m.types >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Cap'n Proto: enum definition. */
|
|
TEST(probe_capnp_enum_node) {
|
|
GpeMetrics m = gpe_metrics("enums.capnp",
|
|
"@0x1234567890abcdef;\n"
|
|
"\n"
|
|
"enum Color {\n"
|
|
" red @0;\n"
|
|
" green @1;\n"
|
|
" blue @2;\n"
|
|
"}\n"
|
|
"\n"
|
|
"struct Widget {\n"
|
|
" color @0 :Color;\n"
|
|
" label @1 :Text;\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: the struct must produce a Class node; enum may add another. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Cap'n Proto: two-file import → IMPORTS edge.
|
|
* RED: grammar-only Cap'n Proto has no import-resolver pass in the pipeline. */
|
|
TEST(probe_capnp_import_edge) {
|
|
static const GpeFile files[] = {
|
|
{"common.capnp",
|
|
"@0xaabbccddeeff0011;\n"
|
|
"struct Timestamp { seconds @0 :Int64; }\n"},
|
|
{"event.capnp",
|
|
"@0x1122334455667788;\n"
|
|
"using Common = import \"common.capnp\";\n"
|
|
"struct Event {\n"
|
|
" id @0 :Text;\n"
|
|
" createdAt @1 :Common.Timestamp;\n"
|
|
"}\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Cap'n Proto `import` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED — no capnp import resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 4 — WIT (.wit)
|
|
*
|
|
* Label histogram: Class:2, Function:1, Module:1
|
|
* `record` → Class node; `enum` → Class node; `func` → Function node.
|
|
* `world` and `interface` container constructs; the histogram's Class:2
|
|
* comes from record + enum inside an interface block.
|
|
* `use` — WIT uses `use pkg:component/iface.{Type}` for imports;
|
|
* not resolved by the grammar-only pipeline.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* WIT: record and enum inside an interface → 2 Class nodes + 1 Function. */
|
|
TEST(probe_wit_record_enum_function) {
|
|
GpeMetrics m = gpe_metrics("types.wit",
|
|
"interface geometry {\n"
|
|
" record point { x: u32, y: u32 }\n"
|
|
" enum color { red, green, blue }\n"
|
|
" area: func() -> u32;\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: record → Class, enum → Class, func → Function.
|
|
* Histogram confirms Class:2, Function:1 for this pattern. */
|
|
ASSERT_TRUE(m.types >= 2);
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* WIT: world definition as a top-level construct. */
|
|
TEST(probe_wit_world_node) {
|
|
GpeMetrics m = gpe_metrics("world.wit",
|
|
"world calculator {\n"
|
|
" export add: func(a: u32, b: u32) -> u32;\n"
|
|
" export subtract: func(a: u32, b: u32) -> u32;\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* REAL BUG (class 16 node-extraction incompleteness): `func`s declared
|
|
* inside a WIT `world { export X: func ... }` block are NOT extracted as
|
|
* Function nodes, whereas `interface`-scoped funcs ARE (see passing
|
|
* probe_wit_record_enum_function and grammar_labels wit=Function:1).
|
|
* The extractor's WIT func handling covers interface members but not
|
|
* world exports. Root cause: extract_defs.c WIT walk / lang_specs.c
|
|
* wit func_node_types scope. RED. */
|
|
ASSERT_TRUE(m.functions >= 1); /* REAL BUG — world-scoped funcs not extracted */
|
|
PASS();
|
|
}
|
|
|
|
/* WIT: type alias definition. */
|
|
TEST(probe_wit_type_alias) {
|
|
GpeMetrics m = gpe_metrics("alias.wit",
|
|
"interface types {\n"
|
|
" type error-code = u32;\n"
|
|
" record error { code: error-code, msg: string }\n"
|
|
" get-error: func(code: error-code) -> error;\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: the record → Class, func → Function. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* WIT: variant definition (tagged union). */
|
|
TEST(probe_wit_variant_node) {
|
|
GpeMetrics m = gpe_metrics("result.wit",
|
|
"interface result-types {\n"
|
|
" variant result {\n"
|
|
" ok(u32),\n"
|
|
" err(string),\n"
|
|
" }\n"
|
|
" unwrap: func(r: result) -> u32;\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at minimum the function must appear; variant may add a Class. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* WIT: two-file `use` → IMPORTS edge.
|
|
* RED: grammar-only WIT has no use-resolver in the pipeline. */
|
|
TEST(probe_wit_use_edge) {
|
|
static const GpeFile files[] = {
|
|
{"types.wit",
|
|
"interface types {\n"
|
|
" record point { x: u32, y: u32 }\n"
|
|
"}\n"},
|
|
{"geometry.wit",
|
|
"interface geometry {\n"
|
|
" use types.{point};\n"
|
|
" distance: func(a: point, b: point) -> u32;\n"
|
|
"}\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: WIT `use` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED — no WIT use resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 5 — Smithy (.smithy)
|
|
*
|
|
* Label histogram: Class:1, Module:1
|
|
* `structure` → Class node (confirmed by grammar_regression: Foo → Class).
|
|
* `service` and `operation` — may produce additional Class nodes.
|
|
* `use` — Smithy uses `use com.example#Shape` for cross-namespace imports;
|
|
* not resolved by the grammar-only pipeline.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Smithy: structure definition → at least 1 Class node. */
|
|
TEST(probe_smithy_structure_node) {
|
|
/* Fixture fix: valid Smithy ordering is control section ($version) FIRST,
|
|
* then namespace, then shapes. The original fixture had `namespace`
|
|
* before `$version`, which is invalid Smithy and failed to parse → 0
|
|
* nodes. Mirrors the working test_grammar_regression.c smithy fixture
|
|
* (namespace, then structure) which yields Class:1. */
|
|
GpeMetrics m = gpe_metrics("model.smithy",
|
|
"$version: \"2\"\n"
|
|
"\n"
|
|
"namespace com.example\n"
|
|
"\n"
|
|
"structure User {\n"
|
|
" @required\n"
|
|
" id: String\n"
|
|
" name: String\n"
|
|
" email: String\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: structure → Class node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Smithy: service + operation definitions. */
|
|
TEST(probe_smithy_service_node) {
|
|
GpeMetrics m = gpe_metrics("service.smithy",
|
|
"namespace com.example\n"
|
|
"\n"
|
|
"service UserService {\n"
|
|
" version: \"2024-01-01\"\n"
|
|
" operations: [GetUser, CreateUser]\n"
|
|
"}\n"
|
|
"\n"
|
|
"operation GetUser {\n"
|
|
" input: GetUserInput\n"
|
|
" output: GetUserOutput\n"
|
|
"}\n"
|
|
"\n"
|
|
"operation CreateUser {\n"
|
|
" input: CreateUserInput\n"
|
|
"}\n"
|
|
"\n"
|
|
"structure GetUserInput { @required id: String }\n"
|
|
"structure GetUserOutput { id: String, name: String }\n"
|
|
"structure CreateUserInput { @required name: String }\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at minimum the structure definitions must produce Class nodes. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Smithy: enum definition. */
|
|
TEST(probe_smithy_enum_node) {
|
|
GpeMetrics m = gpe_metrics("enum.smithy",
|
|
"namespace com.example\n"
|
|
"\n"
|
|
"enum Status {\n"
|
|
" ACTIVE = \"active\"\n"
|
|
" INACTIVE = \"inactive\"\n"
|
|
" PENDING = \"pending\"\n"
|
|
"}\n"
|
|
"\n"
|
|
"structure Item {\n"
|
|
" id: String\n"
|
|
" status: Status\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: structure → Class; enum may produce another type node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Smithy: two-file `use` → IMPORTS edge.
|
|
* RED: grammar-only Smithy has no use-resolver in the pipeline. */
|
|
TEST(probe_smithy_use_edge) {
|
|
static const GpeFile files[] = {
|
|
{"common.smithy",
|
|
"namespace com.example.common\n"
|
|
"structure Timestamp { seconds: Long }\n"},
|
|
{"events.smithy",
|
|
"namespace com.example.events\n"
|
|
"use com.example.common#Timestamp\n"
|
|
"structure Event {\n"
|
|
" id: String\n"
|
|
" createdAt: Timestamp\n"
|
|
"}\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Smithy `use` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED — no Smithy use resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 6 — Prisma (.prisma)
|
|
*
|
|
* Label histogram: Class:1, Module:1
|
|
* `model` → Class node.
|
|
* `enum` — may produce a second Class node.
|
|
* Prisma schema files are single-file; there is no cross-file import
|
|
* mechanism in the Prisma schema language itself (all models live in
|
|
* one schema.prisma or are merged via --schema flag, not `import`).
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Prisma: model definition → at least 1 Class node. */
|
|
TEST(probe_prisma_model_node) {
|
|
GpeMetrics m = gpe_metrics("schema.prisma",
|
|
"generator client {\n"
|
|
" provider = \"prisma-client-js\"\n"
|
|
"}\n"
|
|
"\n"
|
|
"datasource db {\n"
|
|
" provider = \"postgresql\"\n"
|
|
" url = env(\"DATABASE_URL\")\n"
|
|
"}\n"
|
|
"\n"
|
|
"model User {\n"
|
|
" id Int @id @default(autoincrement())\n"
|
|
" name String\n"
|
|
" email String @unique\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: `model User` must produce a Class node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Prisma: multiple model definitions → multiple Class nodes. */
|
|
TEST(probe_prisma_multiple_models) {
|
|
GpeMetrics m = gpe_metrics("blog.prisma",
|
|
"model User {\n"
|
|
" id Int @id @default(autoincrement())\n"
|
|
" name String\n"
|
|
" posts Post[]\n"
|
|
"}\n"
|
|
"\n"
|
|
"model Post {\n"
|
|
" id Int @id @default(autoincrement())\n"
|
|
" title String\n"
|
|
" content String\n"
|
|
" authorId Int\n"
|
|
" author User @relation(fields: [authorId], references: [id])\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: two model definitions → at least 2 Class nodes. */
|
|
ASSERT_TRUE(m.types >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Prisma: enum definition — does it yield an additional type node? */
|
|
TEST(probe_prisma_enum_node) {
|
|
GpeMetrics m = gpe_metrics("status.prisma",
|
|
"enum Role {\n"
|
|
" USER\n"
|
|
" ADMIN\n"
|
|
" MODERATOR\n"
|
|
"}\n"
|
|
"\n"
|
|
"model Account {\n"
|
|
" id Int @id @default(autoincrement())\n"
|
|
" role Role @default(USER)\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: model → Class; enum may add another — floor is >= 1. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Prisma: no-crash for a datasource-only schema (no models). */
|
|
TEST(probe_prisma_datasource_only) {
|
|
GpeMetrics m = gpe_metrics("config.prisma",
|
|
"generator client {\n"
|
|
" provider = \"prisma-client-js\"\n"
|
|
"}\n"
|
|
"\n"
|
|
"datasource db {\n"
|
|
" provider = \"sqlite\"\n"
|
|
" url = \"file:./dev.db\"\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash on a schema with no models. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 7 — GraphQL (.graphql / .gql)
|
|
*
|
|
* Label histogram: Class:1, Module:1
|
|
* `type` definition → Class node.
|
|
* `input` and `interface` types — may also produce Class nodes.
|
|
* GraphQL schema files are typically standalone; cross-file imports are
|
|
* not part of the SDL (Schema Definition Language); no IMPORTS edges
|
|
* are expected from the grammar-only pipeline.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* GraphQL: type definition → at least 1 Class node. */
|
|
TEST(probe_graphql_type_node) {
|
|
GpeMetrics m = gpe_metrics("schema.graphql",
|
|
"type User {\n"
|
|
" id: ID!\n"
|
|
" name: String!\n"
|
|
" email: String!\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: `type User` must produce a Class node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* GraphQL: multiple type definitions → multiple Class nodes. */
|
|
TEST(probe_graphql_multiple_types) {
|
|
GpeMetrics m = gpe_metrics("schema.gql",
|
|
"type Query {\n"
|
|
" user(id: ID!): User\n"
|
|
" users: [User!]!\n"
|
|
"}\n"
|
|
"\n"
|
|
"type User {\n"
|
|
" id: ID!\n"
|
|
" name: String!\n"
|
|
" posts: [Post!]!\n"
|
|
"}\n"
|
|
"\n"
|
|
"type Post {\n"
|
|
" id: ID!\n"
|
|
" title: String!\n"
|
|
" content: String!\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: 3 type definitions → at least 2 Class nodes. */
|
|
ASSERT_TRUE(m.types >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* GraphQL: interface definition → type-like node. */
|
|
TEST(probe_graphql_interface_node) {
|
|
GpeMetrics m = gpe_metrics("iface.graphql",
|
|
"interface Node {\n"
|
|
" id: ID!\n"
|
|
"}\n"
|
|
"\n"
|
|
"type User implements Node {\n"
|
|
" id: ID!\n"
|
|
" name: String!\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at minimum `type User` → Class; `interface Node` may add one. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* GraphQL: input type definition. */
|
|
TEST(probe_graphql_input_type) {
|
|
GpeMetrics m = gpe_metrics("mutations.graphql",
|
|
"input CreateUserInput {\n"
|
|
" name: String!\n"
|
|
" email: String!\n"
|
|
"}\n"
|
|
"\n"
|
|
"type Mutation {\n"
|
|
" createUser(input: CreateUserInput!): User!\n"
|
|
"}\n"
|
|
"\n"
|
|
"type User {\n"
|
|
" id: ID!\n"
|
|
" name: String!\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at least two type-like nodes expected (input + type + type). */
|
|
ASSERT_TRUE(m.types >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 8 — Vue (.vue)
|
|
*
|
|
* Label histogram: Module:1 only — no Class or Function nodes from the
|
|
* Vue component itself at the graph level.
|
|
* IMPORTS: `import` statements inside <script> blocks ARE extracted at the
|
|
* extraction level (test_grammar_imports confirms 2 imports for a vue
|
|
* fixture with 2 import statements). Whether these become IMPORTS graph
|
|
* edges in a two-file cross-component fixture depends on whether the
|
|
* JS/TS resolver handles .vue paths.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Vue: single-file component indexes without crash. */
|
|
TEST(probe_vue_no_crash) {
|
|
GpeMetrics m = gpe_metrics("App.vue",
|
|
"<template>\n"
|
|
" <div>{{ message }}</div>\n"
|
|
"</template>\n"
|
|
"\n"
|
|
"<script setup>\n"
|
|
"import { ref } from 'vue'\n"
|
|
"const message = ref('Hello World')\n"
|
|
"</script>\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash and must produce at least 1 node. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Vue: <script setup> with two imports — extraction-level import count. */
|
|
TEST(probe_vue_script_imports) {
|
|
GpeMetrics m = gpe_metrics("Counter.vue",
|
|
"<script setup>\n"
|
|
"import { ref, computed } from 'vue'\n"
|
|
"import BaseButton from './BaseButton.vue'\n"
|
|
"\n"
|
|
"const count = ref(0)\n"
|
|
"const doubled = computed(() => count.value * 2)\n"
|
|
"</script>\n"
|
|
"\n"
|
|
"<template>\n"
|
|
" <BaseButton @click=\"count++\">{{ doubled }}</BaseButton>\n"
|
|
"</template>\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline indexes without crash. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Vue: two-file cross-component import → IMPORTS graph edge.
|
|
* The JS/TS resolver handles .vue imports via the same path-resolution
|
|
* logic used for TypeScript. With matching files on disk the resolver
|
|
* should produce an IMPORTS edge.
|
|
* RED: .vue extension may not be handled by the JS/TS import resolver. */
|
|
TEST(probe_vue_cross_component_import) {
|
|
static const GpeFile files[] = {
|
|
{"BaseButton.vue",
|
|
"<template><button><slot /></button></template>\n"
|
|
"<script setup>\n"
|
|
"defineProps({ label: String })\n"
|
|
"</script>\n"},
|
|
{"App.vue",
|
|
"<script setup>\n"
|
|
"import BaseButton from './BaseButton.vue'\n"
|
|
"</script>\n"
|
|
"<template><BaseButton label=\"Click\" /></template>\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: .vue cross-component IMPORTS edge not confirmed by the pipeline. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED — .vue paths not in JS resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 9 — Svelte (.svelte)
|
|
*
|
|
* Label histogram: Module:1 only.
|
|
* IMPORTS: <script> imports ARE extracted at the extraction level
|
|
* (test_grammar_imports confirms 2 imports for a svelte fixture).
|
|
* Cross-component IMPORTS edges share the same question as Vue.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Svelte: single-file component indexes without crash. */
|
|
TEST(probe_svelte_no_crash) {
|
|
GpeMetrics m = gpe_metrics("App.svelte",
|
|
"<script>\n"
|
|
" let name = 'World';\n"
|
|
" function greet() { return `Hello ${name}`; }\n"
|
|
"</script>\n"
|
|
"<h1>{greet()}</h1>\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash and must produce at least 1 node. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Svelte: <script> with imports — extraction-level behavior. */
|
|
TEST(probe_svelte_script_imports) {
|
|
GpeMetrics m = gpe_metrics("Counter.svelte",
|
|
"<script>\n"
|
|
" import { onMount } from 'svelte';\n"
|
|
" import Button from './Button.svelte';\n"
|
|
"\n"
|
|
" let count = 0;\n"
|
|
" onMount(() => { count = 1; });\n"
|
|
"</script>\n"
|
|
"<Button on:click={() => count++}>{count}</Button>\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline indexes without crash. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Svelte: two-file cross-component import → IMPORTS graph edge.
|
|
* RED: .svelte extension may not be handled by the JS/TS import resolver. */
|
|
TEST(probe_svelte_cross_component_import) {
|
|
static const GpeFile files[] = {
|
|
{"Button.svelte",
|
|
"<script>\n"
|
|
" export let label = 'Click';\n"
|
|
"</script>\n"
|
|
"<button>{label}</button>\n"},
|
|
{"App.svelte",
|
|
"<script>\n"
|
|
" import Button from './Button.svelte';\n"
|
|
"</script>\n"
|
|
"<Button label=\"Go\" />\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: .svelte cross-component IMPORTS edge not confirmed by the pipeline. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED — .svelte paths not in JS resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 10 — Astro (.astro)
|
|
*
|
|
* Label histogram: Module:1 only.
|
|
* IMPORTS: frontmatter imports ARE extracted at the extraction level
|
|
* (test_grammar_imports confirms 2 imports for an astro fixture).
|
|
* Cross-component IMPORTS edges share the same question as Vue/Svelte.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Astro: single-file component indexes without crash. */
|
|
TEST(probe_astro_no_crash) {
|
|
GpeMetrics m = gpe_metrics("index.astro",
|
|
"---\n"
|
|
"const greeting = 'Hello World';\n"
|
|
"---\n"
|
|
"<html>\n"
|
|
" <body><h1>{greeting}</h1></body>\n"
|
|
"</html>\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash and must produce at least 1 node. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Astro: frontmatter with imports. */
|
|
TEST(probe_astro_frontmatter_imports) {
|
|
GpeMetrics m = gpe_metrics("Page.astro",
|
|
"---\n"
|
|
"import confetti from 'canvas-confetti';\n"
|
|
"import dayjs from 'dayjs';\n"
|
|
"\n"
|
|
"confetti();\n"
|
|
"const now = dayjs().format();\n"
|
|
"---\n"
|
|
"<div>{now}</div>\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline indexes without crash. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Astro: two-file cross-component import → IMPORTS graph edge.
|
|
* RED: .astro extension may not be handled by the JS/TS import resolver. */
|
|
TEST(probe_astro_cross_component_import) {
|
|
static const GpeFile files[] = {
|
|
{"Card.astro",
|
|
"---\n"
|
|
"const { title } = Astro.props;\n"
|
|
"---\n"
|
|
"<div class=\"card\"><h2>{title}</h2></div>\n"},
|
|
{"index.astro",
|
|
"---\n"
|
|
"import Card from './Card.astro';\n"
|
|
"---\n"
|
|
"<Card title=\"Hello\" />\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: .astro cross-component IMPORTS edge not confirmed by the pipeline. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED — .astro paths not in JS resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 11 — Blade (.blade.php)
|
|
*
|
|
* Label histogram: Module:1 only.
|
|
* Blade templates use @extends / @include directives but these are not
|
|
* modeled as graph IMPORTS edges by the grammar-only pipeline.
|
|
* The .blade.php compound extension is registered via the compound
|
|
* extension table (language.c line 882).
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Blade: basic template indexes without crash. */
|
|
TEST(probe_blade_no_crash) {
|
|
GpeMetrics m = gpe_metrics("welcome.blade.php",
|
|
"@extends('layouts.app')\n"
|
|
"\n"
|
|
"@section('content')\n"
|
|
"<h1>Welcome</h1>\n"
|
|
"@endsection\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash and must produce at least 1 node. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Blade: @include directive — not modeled as IMPORTS. */
|
|
TEST(probe_blade_include_no_imports_edge) {
|
|
static const GpeFile files[] = {
|
|
{"partials/header.blade.php",
|
|
"<header><nav>Menu</nav></header>\n"},
|
|
{"home.blade.php",
|
|
"@extends('layouts.app')\n"
|
|
"@section('content')\n"
|
|
"@include('partials.header')\n"
|
|
"<main>Home</main>\n"
|
|
"@endsection\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
/* GREEN: Blade @include is not modeled as a graph IMPORTS edge. */
|
|
ASSERT_TRUE(m.imports == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* Blade: conditional and loop directives — pipeline stability. */
|
|
TEST(probe_blade_directives_no_crash) {
|
|
GpeMetrics m = gpe_metrics("list.blade.php",
|
|
"@extends('layouts.app')\n"
|
|
"@section('content')\n"
|
|
"@if($items->count() > 0)\n"
|
|
" @foreach($items as $item)\n"
|
|
" <div>{{ $item->name }}</div>\n"
|
|
" @endforeach\n"
|
|
"@else\n"
|
|
" <p>No items found.</p>\n"
|
|
"@endif\n"
|
|
"@endsection\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: complex directives must not crash the pipeline. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 12 — Liquid (.liquid)
|
|
*
|
|
* Label histogram: Module:1 only.
|
|
* Liquid uses `{% render 'snippet' %}` / `{% include 'snippet' %}` but
|
|
* these are not modeled as graph IMPORTS edges.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Liquid: basic template indexes without crash. */
|
|
TEST(probe_liquid_no_crash) {
|
|
GpeMetrics m = gpe_metrics("index.liquid",
|
|
"{% if customer %}\n"
|
|
" <p>Welcome, {{ customer.name }}!</p>\n"
|
|
"{% else %}\n"
|
|
" <p>Hello, visitor!</p>\n"
|
|
"{% endif %}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash and must produce at least 1 node. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Liquid: for-loop + filters — pipeline stability. */
|
|
TEST(probe_liquid_loop_and_filters) {
|
|
GpeMetrics m = gpe_metrics("products.liquid",
|
|
"{% for product in collection.products %}\n"
|
|
" <div class=\"product\">\n"
|
|
" <h2>{{ product.title | upcase }}</h2>\n"
|
|
" <p>{{ product.price | money }}</p>\n"
|
|
" </div>\n"
|
|
"{% endfor %}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: for-loop with filters must not crash. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Liquid: render/include — not modeled as IMPORTS. */
|
|
TEST(probe_liquid_render_no_imports_edge) {
|
|
static const GpeFile files[] = {
|
|
{"snippets/card.liquid",
|
|
"<div class=\"card\">{{ card.title }}</div>\n"},
|
|
{"sections/featured.liquid",
|
|
"<section>\n"
|
|
" {% render 'snippets/card', card: featured_product %}\n"
|
|
"</section>\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
/* GREEN: Liquid `render` is not modeled as a graph IMPORTS edge. */
|
|
ASSERT_TRUE(m.imports == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 13 — Jinja2 (.j2 / .jinja2)
|
|
*
|
|
* Label histogram: Module:1 only.
|
|
* Jinja2 uses `{% extends "base.html" %}` / `{% include "header.html" %}`
|
|
* but these are not modeled as graph IMPORTS edges.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Jinja2: basic template indexes without crash (.j2 extension). */
|
|
TEST(probe_jinja2_no_crash_j2) {
|
|
GpeMetrics m = gpe_metrics("config.j2",
|
|
"{% if env == 'production' %}\n"
|
|
"database_url: {{ db_url }}\n"
|
|
"{% else %}\n"
|
|
"database_url: sqlite:///dev.db\n"
|
|
"{% endif %}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash on a .j2 file. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Jinja2: extends and block directives (.jinja2 extension). */
|
|
TEST(probe_jinja2_extends_no_imports_edge) {
|
|
static const GpeFile files[] = {
|
|
{"base.html.jinja2",
|
|
"<!DOCTYPE html>\n"
|
|
"<html>\n"
|
|
"<head>{% block head %}{% endblock %}</head>\n"
|
|
"<body>{% block body %}{% endblock %}</body>\n"
|
|
"</html>\n"},
|
|
{"page.html.jinja2",
|
|
"{% extends \"base.html.jinja2\" %}\n"
|
|
"{% block head %}<title>Page</title>{% endblock %}\n"
|
|
"{% block body %}<h1>Hello</h1>{% endblock %}\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
/* GREEN: Jinja2 `extends` is not modeled as a graph IMPORTS edge. */
|
|
ASSERT_TRUE(m.imports == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* Jinja2: macro definition — does the extractor produce a node? */
|
|
TEST(probe_jinja2_macro_no_crash) {
|
|
GpeMetrics m = gpe_metrics("macros.jinja",
|
|
"{% macro render_field(field, label='') %}\n"
|
|
" <div class=\"field\">\n"
|
|
" {% if label %}<label>{{ label }}</label>{% endif %}\n"
|
|
" {{ field }}\n"
|
|
" </div>\n"
|
|
"{% endmacro %}\n"
|
|
"\n"
|
|
"{% macro render_errors(field) %}\n"
|
|
" {% for error in field.errors %}\n"
|
|
" <span class=\"error\">{{ error }}</span>\n"
|
|
" {% endfor %}\n"
|
|
"{% endmacro %}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: macro-heavy template must not crash the pipeline. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 14 — Go Template (.gotmpl / .tmpl / .tpl)
|
|
*
|
|
* Label histogram: Module:1 only.
|
|
* Go templates use `{{ template "name" . }}` for includes but these are
|
|
* not modeled as graph IMPORTS edges.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Go Template: basic template indexes without crash (.gotmpl). */
|
|
TEST(probe_gotemplate_no_crash_gotmpl) {
|
|
GpeMetrics m = gpe_metrics("page.gotmpl",
|
|
"{{ define \"page\" }}\n"
|
|
"<!DOCTYPE html>\n"
|
|
"<html>\n"
|
|
"<body>\n"
|
|
" <h1>{{ .Title }}</h1>\n"
|
|
" {{ if .Items }}\n"
|
|
" <ul>\n"
|
|
" {{ range .Items }}<li>{{ . }}</li>{{ end }}\n"
|
|
" </ul>\n"
|
|
" {{ end }}\n"
|
|
"</body>\n"
|
|
"</html>\n"
|
|
"{{ end }}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash on a .gotmpl file. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Go Template: Helm-style .tpl with named template definitions. */
|
|
TEST(probe_gotemplate_helm_tpl) {
|
|
GpeMetrics m = gpe_metrics("_helpers.tpl",
|
|
"{{/*\n"
|
|
"Expand the name of the chart.\n"
|
|
"*/}}\n"
|
|
"{{- define \"myapp.name\" -}}\n"
|
|
"{{- .Chart.Name | trunc 63 | trimSuffix \"-\" }}\n"
|
|
"{{- end }}\n"
|
|
"\n"
|
|
"{{- define \"myapp.labels\" -}}\n"
|
|
"helm.sh/chart: {{ include \"myapp.name\" . }}\n"
|
|
"{{- end }}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: Helm helper template must not crash. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Go Template: `template` call — not modeled as IMPORTS. */
|
|
TEST(probe_gotemplate_template_call_no_imports) {
|
|
static const GpeFile files[] = {
|
|
{"layout.tmpl",
|
|
"{{ define \"layout\" }}\n"
|
|
"<html><body>{{ template \"content\" . }}</body></html>\n"
|
|
"{{ end }}\n"},
|
|
{"page.tmpl",
|
|
"{{ define \"content\" }}\n"
|
|
"<h1>{{ .Title }}</h1>\n"
|
|
"{{ end }}\n"
|
|
"{{ template \"layout\" . }}\n"}
|
|
};
|
|
GpeMetrics m = gpe_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
/* GREEN: Go template `template` calls are not modeled as IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 15 — Mermaid (.mmd / .mermaid)
|
|
*
|
|
* Label histogram: Module:1 only.
|
|
* Mermaid diagrams describe graph/flow/sequence diagrams — no function or
|
|
* type definitions; no cross-file imports.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Mermaid: flowchart diagram indexes without crash (.mmd). */
|
|
TEST(probe_mermaid_flowchart_no_crash) {
|
|
GpeMetrics m = gpe_metrics("flow.mmd",
|
|
"graph TD\n"
|
|
" A[Start] --> B{Is it?}\n"
|
|
" B -- Yes --> C[OK]\n"
|
|
" B -- No --> D[End]\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash on a .mmd file. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Mermaid: sequence diagram (.mermaid extension). */
|
|
TEST(probe_mermaid_sequence_no_crash) {
|
|
GpeMetrics m = gpe_metrics("auth.mermaid",
|
|
"sequenceDiagram\n"
|
|
" participant Client\n"
|
|
" participant Server\n"
|
|
" Client->>Server: POST /login\n"
|
|
" Server-->>Client: 200 OK + token\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: sequence diagram must not crash. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Mermaid: entity-relationship diagram. */
|
|
TEST(probe_mermaid_er_diagram_no_crash) {
|
|
GpeMetrics m = gpe_metrics("schema.mmd",
|
|
"erDiagram\n"
|
|
" USER {\n"
|
|
" int id PK\n"
|
|
" string name\n"
|
|
" string email\n"
|
|
" }\n"
|
|
" POST {\n"
|
|
" int id PK\n"
|
|
" int authorId FK\n"
|
|
" string title\n"
|
|
" }\n"
|
|
" USER ||--o{ POST : \"writes\"\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: ER diagram must not crash the pipeline. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 16 — JSDoc (.jsdoc)
|
|
*
|
|
* Label histogram: Module:1 only.
|
|
* JSDoc files contain documentation comment blocks — `@param`, `@returns`,
|
|
* `@module`, `@typedef` etc. No executable code; no cross-file imports.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* JSDoc: basic parameter documentation indexes without crash. */
|
|
TEST(probe_jsdoc_params_no_crash) {
|
|
GpeMetrics m = gpe_metrics("api.jsdoc",
|
|
"/**\n"
|
|
" * @param {number} x - First operand\n"
|
|
" * @param {number} y - Second operand\n"
|
|
" * @returns {number} The sum\n"
|
|
" */\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: pipeline must not crash on a .jsdoc file. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* JSDoc: @module and @typedef annotations. */
|
|
TEST(probe_jsdoc_module_typedef_no_crash) {
|
|
GpeMetrics m = gpe_metrics("types.jsdoc",
|
|
"/**\n"
|
|
" * @module utils\n"
|
|
" */\n"
|
|
"\n"
|
|
"/**\n"
|
|
" * @typedef {Object} User\n"
|
|
" * @property {number} id - User identifier\n"
|
|
" * @property {string} name - User full name\n"
|
|
" * @property {string} email - User email address\n"
|
|
" */\n"
|
|
"\n"
|
|
"/**\n"
|
|
" * @callback Predicate\n"
|
|
" * @param {User} user\n"
|
|
" * @returns {boolean}\n"
|
|
" */\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: module + typedef annotations must not crash the pipeline. */
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* JSDoc: no function or type nodes expected — markup-only label set. */
|
|
TEST(probe_jsdoc_no_function_or_type_nodes) {
|
|
GpeMetrics m = gpe_metrics("helpers.jsdoc",
|
|
"/**\n"
|
|
" * @function formatDate\n"
|
|
" * @param {Date} date\n"
|
|
" * @returns {string}\n"
|
|
" */\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: JSDoc produces only Module:1 — no Function or Class nodes. */
|
|
ASSERT_TRUE(m.types == 0);
|
|
ASSERT_TRUE(m.functions == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* SUITE wiring
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
SUITE(grammar_probe_e) {
|
|
/* Protobuf (4 cases) */
|
|
RUN_TEST(probe_proto_message_node);
|
|
RUN_TEST(probe_proto_service_node);
|
|
RUN_TEST(probe_proto_enum_node);
|
|
RUN_TEST(probe_proto_import_edge);
|
|
|
|
/* Thrift (4 cases) */
|
|
RUN_TEST(probe_thrift_service_function);
|
|
RUN_TEST(probe_thrift_struct_node);
|
|
RUN_TEST(probe_thrift_exception_node);
|
|
RUN_TEST(probe_thrift_include_edge);
|
|
|
|
/* Cap'n Proto (4 cases) */
|
|
RUN_TEST(probe_capnp_struct_node);
|
|
RUN_TEST(probe_capnp_interface_node);
|
|
RUN_TEST(probe_capnp_enum_node);
|
|
RUN_TEST(probe_capnp_import_edge);
|
|
|
|
/* WIT (5 cases) */
|
|
RUN_TEST(probe_wit_record_enum_function);
|
|
RUN_TEST(probe_wit_world_node);
|
|
RUN_TEST(probe_wit_type_alias);
|
|
RUN_TEST(probe_wit_variant_node);
|
|
RUN_TEST(probe_wit_use_edge);
|
|
|
|
/* Smithy (4 cases) */
|
|
RUN_TEST(probe_smithy_structure_node);
|
|
RUN_TEST(probe_smithy_service_node);
|
|
RUN_TEST(probe_smithy_enum_node);
|
|
RUN_TEST(probe_smithy_use_edge);
|
|
|
|
/* Prisma (4 cases) */
|
|
RUN_TEST(probe_prisma_model_node);
|
|
RUN_TEST(probe_prisma_multiple_models);
|
|
RUN_TEST(probe_prisma_enum_node);
|
|
RUN_TEST(probe_prisma_datasource_only);
|
|
|
|
/* GraphQL (4 cases) */
|
|
RUN_TEST(probe_graphql_type_node);
|
|
RUN_TEST(probe_graphql_multiple_types);
|
|
RUN_TEST(probe_graphql_interface_node);
|
|
RUN_TEST(probe_graphql_input_type);
|
|
|
|
/* Vue (3 cases) */
|
|
RUN_TEST(probe_vue_no_crash);
|
|
RUN_TEST(probe_vue_script_imports);
|
|
RUN_TEST(probe_vue_cross_component_import);
|
|
|
|
/* Svelte (3 cases) */
|
|
RUN_TEST(probe_svelte_no_crash);
|
|
RUN_TEST(probe_svelte_script_imports);
|
|
RUN_TEST(probe_svelte_cross_component_import);
|
|
|
|
/* Astro (3 cases) */
|
|
RUN_TEST(probe_astro_no_crash);
|
|
RUN_TEST(probe_astro_frontmatter_imports);
|
|
RUN_TEST(probe_astro_cross_component_import);
|
|
|
|
/* Blade (3 cases) */
|
|
RUN_TEST(probe_blade_no_crash);
|
|
RUN_TEST(probe_blade_include_no_imports_edge);
|
|
RUN_TEST(probe_blade_directives_no_crash);
|
|
|
|
/* Liquid (3 cases) */
|
|
RUN_TEST(probe_liquid_no_crash);
|
|
RUN_TEST(probe_liquid_loop_and_filters);
|
|
RUN_TEST(probe_liquid_render_no_imports_edge);
|
|
|
|
/* Jinja2 (3 cases) */
|
|
RUN_TEST(probe_jinja2_no_crash_j2);
|
|
RUN_TEST(probe_jinja2_extends_no_imports_edge);
|
|
RUN_TEST(probe_jinja2_macro_no_crash);
|
|
|
|
/* Go Template (3 cases) */
|
|
RUN_TEST(probe_gotemplate_no_crash_gotmpl);
|
|
RUN_TEST(probe_gotemplate_helm_tpl);
|
|
RUN_TEST(probe_gotemplate_template_call_no_imports);
|
|
|
|
/* Mermaid (3 cases) */
|
|
RUN_TEST(probe_mermaid_flowchart_no_crash);
|
|
RUN_TEST(probe_mermaid_sequence_no_crash);
|
|
RUN_TEST(probe_mermaid_er_diagram_no_crash);
|
|
|
|
/* JSDoc (3 cases) */
|
|
RUN_TEST(probe_jsdoc_params_no_crash);
|
|
RUN_TEST(probe_jsdoc_module_typedef_no_crash);
|
|
RUN_TEST(probe_jsdoc_no_function_or_type_nodes);
|
|
}
|