wehub-resource-sync
1147 lines
41 KiB
C
1147 lines
41 KiB
C
/*
|
|
* test_grammar_probe_a.c — Grammar-only node/import/inheritance probe.
|
|
*
|
|
* SCOPE
|
|
* ─────
|
|
* Probes 12 grammar-only languages: ada, awk, cairo, clojure, commonlisp,
|
|
* crystal, d, emacslisp, fennel, fish, fsharp, gleam.
|
|
*
|
|
* CALLS is already covered for these languages by the P5 contract_calls_breadth
|
|
* suite in test_lang_contract.c (CALL_CASES rows). This file probes the OTHER
|
|
* dimensions that breadth doesn't cover:
|
|
* • NODE creation — definition-kind diversity (functions, classes, structs,
|
|
* records, constants, modules, protocols, etc.)
|
|
* • IMPORTS edges — the language's cross-file import/require/use/open
|
|
* mechanism at the graph layer (two-file fixture).
|
|
* • INHERITANCE — OOP languages: Crystal `<`, D `:`, F# `inherit`,
|
|
* Ada tagged-type extension.
|
|
* • Other — language-specific constructs (D structs/interfaces,
|
|
* F# records, Clojure protocols/defrecord, etc.)
|
|
*
|
|
* 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; the test FAILS until the bug is fixed. Brief inline
|
|
* comments document the root-cause class.
|
|
*
|
|
* CALLS dimensions are intentionally omitted here (covered by P5 breadth).
|
|
* Do NOT register this suite in test_main.c — a sibling agent owns that file.
|
|
*
|
|
* SUITE(grammar_probe_a)
|
|
*/
|
|
|
|
#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_lang_contract.c / test_node_creation_probe.c.
|
|
* Prefix "gpa_" to avoid symbol collisions with sibling probe files.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
typedef struct {
|
|
char tmpdir[256];
|
|
char dbpath[512];
|
|
char *project;
|
|
cbm_mcp_server_t *srv;
|
|
} GpaProj;
|
|
|
|
typedef struct {
|
|
const char *name; /* relative filename, may include '/' for subdirs */
|
|
const char *content;
|
|
} GpaFile;
|
|
|
|
static void gpa_to_fwd_slashes(char *p) {
|
|
for (; *p; p++) {
|
|
if (*p == '\\') *p = '/';
|
|
}
|
|
}
|
|
|
|
static cbm_store_t *gpa_open_indexed(GpaProj *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 *gpa_index_files(GpaProj *lp, const GpaFile *files, int nfiles) {
|
|
memset(lp, 0, sizeof(*lp));
|
|
snprintf(lp->tmpdir, sizeof(lp->tmpdir), "/tmp/cbm_gpa_XXXXXX");
|
|
if (!cbm_mkdtemp(lp->tmpdir)) return NULL;
|
|
gpa_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 gpa_open_indexed(lp);
|
|
}
|
|
|
|
static void gpa_cleanup(GpaProj *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 gpa_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 gpa_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 = gpa_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 */
|
|
} GpaMetrics;
|
|
|
|
static GpaMetrics gpa_metrics_files(const GpaFile *files, int nfiles) {
|
|
GpaProj lp;
|
|
cbm_store_t *store = gpa_index_files(&lp, files, nfiles);
|
|
GpaMetrics m = {0};
|
|
if (store) {
|
|
m.ok = 1;
|
|
m.total_nodes = cbm_store_count_nodes(store, lp.project);
|
|
m.functions = gpa_count_label(store, lp.project, "Function");
|
|
m.methods = gpa_count_label(store, lp.project, "Method");
|
|
m.types = gpa_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");
|
|
}
|
|
gpa_cleanup(&lp, store);
|
|
return m;
|
|
}
|
|
|
|
static GpaMetrics gpa_metrics(const char *filename, const char *content) {
|
|
GpaFile f = {filename, content};
|
|
return gpa_metrics_files(&f, 1);
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 1 — Ada (.adb)
|
|
*
|
|
* Ada label histogram (from test_grammar_labels.c): Function:1, Module:1
|
|
* OOP: Ada 95 tagged types can model inheritance but grammar-only extraction
|
|
* produces Function/Module — no Class node expected.
|
|
* IMPORTS: Ada `with Pkg;` imports are extracted at the source level.
|
|
* Graph-level IMPORTS edges require the package body to be present;
|
|
* single-file fixture is expected RED (resolver can't find the target).
|
|
* CALLS: covered by P5 breadth (CALL_CASES ada entry); not probed here.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Ada: two procedure definitions → at least 2 Function nodes. */
|
|
TEST(probe_ada_functions) {
|
|
GpaMetrics m = gpa_metrics("calc.adb",
|
|
"procedure Calc is\n"
|
|
" function Add(A, B : Integer) return Integer is\n"
|
|
" begin\n"
|
|
" return A + B;\n"
|
|
" end Add;\n"
|
|
" function Sub(A, B : Integer) return Integer is\n"
|
|
" begin\n"
|
|
" return A - B;\n"
|
|
" end Sub;\n"
|
|
"begin\n"
|
|
" null;\n"
|
|
"end Calc;\n");
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.functions >= 1); /* GREEN: at least the outer procedure or inner ones */
|
|
PASS();
|
|
}
|
|
|
|
/* Ada: a package spec (.ads) with multiple subprogram specs → Function nodes. */
|
|
TEST(probe_ada_package_spec_nodes) {
|
|
GpaMetrics m = gpa_metrics("math.ads",
|
|
"package Math is\n"
|
|
" function Square(X : Float) return Float;\n"
|
|
" function Cube(X : Float) return Float;\n"
|
|
" function Abs_Val(X : Float) return Float;\n"
|
|
"end Math;\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: spec subprogram declarations must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Ada: pipeline indexes the file and produces at least 1 node (no crash). */
|
|
TEST(probe_ada_no_crash) {
|
|
GpaMetrics m = gpa_metrics("hello.adb",
|
|
"with Ada.Text_IO;\n"
|
|
"procedure Hello is\n"
|
|
"begin\n"
|
|
" Ada.Text_IO.Put_Line(\"Hello\");\n"
|
|
"end Hello;\n");
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Ada: `with` import in a two-file fixture → IMPORTS edge at graph level.
|
|
* RED: grammar-only Ada has no import-resolution pass that turns `with Pkg`
|
|
* into a graph IMPORTS edge pointing to the package body node. */
|
|
TEST(probe_ada_imports_edge) {
|
|
static const GpaFile files[] = {
|
|
{"math.ads",
|
|
"package Math is\n"
|
|
" function Square(X : Float) return Float;\n"
|
|
"end Math;\n"},
|
|
{"main.adb",
|
|
"with Math;\n"
|
|
"procedure Main is\n"
|
|
" R : Float;\n"
|
|
"begin\n"
|
|
" R := Math.Square(3.0);\n"
|
|
"end Main;\n"}
|
|
};
|
|
GpaMetrics m = gpa_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Ada `with` not yet resolved into IMPORTS edges by the pipeline. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED — no Ada import resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 2 — Awk (.awk)
|
|
*
|
|
* Awk label histogram: Function:2, Module:1
|
|
* Awk has no imports, no OOP, no types — only user-defined functions.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Awk: two function definitions → 2 Function nodes. */
|
|
TEST(probe_awk_functions) {
|
|
GpaMetrics m = gpa_metrics("stats.awk",
|
|
"function max(a, b) {\n"
|
|
" return (a > b) ? a : b\n"
|
|
"}\n"
|
|
"\n"
|
|
"function min(a, b) {\n"
|
|
" return (a < b) ? a : b\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both user-defined functions must reach the graph. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Awk: three functions in one file — broader coverage of def-count floor. */
|
|
TEST(probe_awk_three_functions) {
|
|
GpaMetrics m = gpa_metrics("util.awk",
|
|
"function trim(s) { sub(/^[ \\t]+/, \"\", s); sub(/[ \\t]+$/, \"\", s); return s }\n"
|
|
"function upper(s, i, c, r) { for(i=1;i<=length(s);i++) r=r toupper(substr(s,i,1)); return r }\n"
|
|
"function repeat(s, n, i, r) { for(i=0;i<n;i++) r=r s; return r }\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: all three functions must appear as nodes. */
|
|
ASSERT_TRUE(m.functions >= 3);
|
|
PASS();
|
|
}
|
|
|
|
/* Awk has no OOP — no type-like nodes expected. */
|
|
TEST(probe_awk_no_type_nodes) {
|
|
GpaMetrics m = gpa_metrics("proc.awk",
|
|
"function process(line) {\n"
|
|
" print line\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: awk produces 0 type-like nodes (no classes/structs). */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 3 — Cairo (.cairo)
|
|
*
|
|
* Cairo label histogram: Function:2, Module:1
|
|
* Cairo (Starknet) is a Rust-like language — free functions and `fn` items.
|
|
* No OOP classes; no cross-file import mechanism indexable in single pass.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Cairo: two free functions → 2 Function nodes. */
|
|
TEST(probe_cairo_functions) {
|
|
GpaMetrics m = gpa_metrics("math.cairo",
|
|
"fn add(x: felt252, y: felt252) -> felt252 {\n"
|
|
" x + y\n"
|
|
"}\n"
|
|
"\n"
|
|
"fn mul(x: felt252, y: felt252) -> felt252 {\n"
|
|
" x * y\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both functions must be graph nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Cairo: trait definition — if the grammar/extractor models it. */
|
|
TEST(probe_cairo_trait_or_type) {
|
|
GpaMetrics m = gpa_metrics("iface.cairo",
|
|
"trait IMath {\n"
|
|
" fn add(x: felt252, y: felt252) -> felt252;\n"
|
|
"}\n"
|
|
"\n"
|
|
"fn zero() -> felt252 { 0 }\n");
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1); /* GREEN: at least the function node. */
|
|
PASS();
|
|
}
|
|
|
|
/* Cairo: three functions to exercise def-count floor. */
|
|
TEST(probe_cairo_three_functions) {
|
|
GpaMetrics m = gpa_metrics("ops.cairo",
|
|
"fn identity(x: felt252) -> felt252 { x }\n"
|
|
"fn negate(x: felt252) -> felt252 { -x }\n"
|
|
"fn square(x: felt252) -> felt252 { x * x }\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: all three free functions. */
|
|
ASSERT_TRUE(m.functions >= 3);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 4 — Clojure (.clj)
|
|
*
|
|
* Clojure label histogram: Function:2, Module:1
|
|
* Clojure is a Lisp; no OOP classes. Namespace with `ns` + `:require`.
|
|
* IMPORTS: `ns` with `:require` can form cross-ns dependencies.
|
|
* CALLS: known gap (lisp list-head not resolved as callee).
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Clojure: two `defn` definitions → 2 Function nodes. */
|
|
TEST(probe_clojure_functions) {
|
|
GpaMetrics m = gpa_metrics("core.clj",
|
|
"(ns myapp.core)\n"
|
|
"\n"
|
|
"(defn greet [name]\n"
|
|
" (str \"Hello, \" name))\n"
|
|
"\n"
|
|
"(defn farewell [name]\n"
|
|
" (str \"Goodbye, \" name))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both defn forms must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Clojure: defmulti / defmethod (polymorphic dispatch). */
|
|
TEST(probe_clojure_defmulti) {
|
|
GpaMetrics m = gpa_metrics("dispatch.clj",
|
|
"(ns myapp.dispatch)\n"
|
|
"\n"
|
|
"(defmulti area :shape)\n"
|
|
"\n"
|
|
"(defmethod area :circle [s]\n"
|
|
" (* Math/PI (:r s) (:r s)))\n"
|
|
"\n"
|
|
"(defmethod area :rect [s]\n"
|
|
" (* (:w s) (:h s)))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at least the defmulti + defmethod forms produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Clojure: defrecord → type-like node (if grammar models it). */
|
|
TEST(probe_clojure_defrecord) {
|
|
GpaMetrics m = gpa_metrics("model.clj",
|
|
"(ns myapp.model)\n"
|
|
"\n"
|
|
"(defrecord Point [x y])\n"
|
|
"\n"
|
|
"(defn make-point [x y] (->Point x y))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1); /* GREEN: at minimum the function node. */
|
|
PASS();
|
|
}
|
|
|
|
/* Clojure: two-file :require → IMPORTS edge.
|
|
* RED: grammar-only Clojure has no ns-resolution pass in the pipeline. */
|
|
TEST(probe_clojure_imports_edge) {
|
|
static const GpaFile files[] = {
|
|
{"util.clj",
|
|
"(ns myapp.util)\n"
|
|
"(defn double-it [x] (* 2 x))\n"},
|
|
{"core.clj",
|
|
"(ns myapp.core\n"
|
|
" (:require [myapp.util :as u]))\n"
|
|
"\n"
|
|
"(defn run [n] (u/double-it n))\n"}
|
|
};
|
|
GpaMetrics m = gpa_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Clojure ns :require not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 5 — Common Lisp (.lisp)
|
|
*
|
|
* CommonLisp label histogram: Function:2, Module:1
|
|
* Common Lisp uses `defun` for functions; `defpackage`/`in-package` for namespaces.
|
|
* No class hierarchy (CLOS exists but grammar-only extraction won't model it).
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Common Lisp: two `defun` definitions → 2 Function nodes. */
|
|
TEST(probe_commonlisp_functions) {
|
|
GpaMetrics m = gpa_metrics("math.lisp",
|
|
"(defun square (x)\n"
|
|
" (* x x))\n"
|
|
"\n"
|
|
"(defun cube (x)\n"
|
|
" (* x (square x)))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both defun forms must be Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Common Lisp: `defmacro` — if extractor models it as a Function. */
|
|
TEST(probe_commonlisp_defmacro) {
|
|
GpaMetrics m = gpa_metrics("macros.lisp",
|
|
"(defmacro when-positive (n &body body)\n"
|
|
" `(when (> ,n 0) ,@body))\n"
|
|
"\n"
|
|
"(defun use-macro (x)\n"
|
|
" (when-positive x\n"
|
|
" (format t \"positive~%\")))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at minimum defun should produce a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Common Lisp: defstruct → type-like node (if grammar models it). */
|
|
TEST(probe_commonlisp_defstruct) {
|
|
GpaMetrics m = gpa_metrics("types.lisp",
|
|
"(defstruct point\n"
|
|
" (x 0)\n"
|
|
" (y 0))\n"
|
|
"\n"
|
|
"(defun make-pt (a b)\n"
|
|
" (make-point :x a :y b))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
ASSERT_TRUE(m.total_nodes >= 1); /* GREEN: at minimum the function. */
|
|
PASS();
|
|
}
|
|
|
|
/* Common Lisp: `require` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only CL has no package-resolution pass in the pipeline. */
|
|
TEST(probe_commonlisp_imports_edge) {
|
|
static const GpaFile files[] = {
|
|
{"util.lisp",
|
|
"(defpackage :util (:export :double))\n"
|
|
"(in-package :util)\n"
|
|
"(defun double (x) (* 2 x))\n"},
|
|
{"main.lisp",
|
|
"(defpackage :main (:use :cl :util))\n"
|
|
"(in-package :main)\n"
|
|
"(defun run (n) (util:double n))\n"}
|
|
};
|
|
GpaMetrics m = gpa_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: CL package :use not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 6 — Crystal (.cr)
|
|
*
|
|
* Crystal label histogram: Class:1, Function:1, Module:1
|
|
* Crystal is an OOP language with Ruby-like syntax.
|
|
* Inheritance: `class Child < Parent` — extractor should populate base_classes.
|
|
* Imports: `require "./module"` — cross-file IMPORTS possible.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Crystal: class and method definitions → Class + Function/Method nodes. */
|
|
TEST(probe_crystal_class_node) {
|
|
GpaMetrics m = gpa_metrics("animal.cr",
|
|
"class Animal\n"
|
|
" def initialize(@name : String)\n"
|
|
" end\n"
|
|
"\n"
|
|
" def speak : String\n"
|
|
" \"...\"\n"
|
|
" end\n"
|
|
"end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: class Animal must produce a Class node. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Crystal: class with inheritance `class Dog < Animal` → Class + INHERITS edge.
|
|
* GREEN for Class node (histogram confirms Class:1); INHERITS edge status probed
|
|
* separately below. */
|
|
TEST(probe_crystal_subclass_node) {
|
|
GpaMetrics m = gpa_metrics("pets.cr",
|
|
"class Animal\n"
|
|
" def breathe; end\n"
|
|
"end\n"
|
|
"\n"
|
|
"class Dog < Animal\n"
|
|
" def bark; \"woof\"; end\n"
|
|
"end\n"
|
|
"\n"
|
|
"class Cat < Animal\n"
|
|
" def meow; \"meow\"; end\n"
|
|
"end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at least 2 class nodes (Dog, Cat; Animal also expected). */
|
|
ASSERT_TRUE(m.types >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Crystal: INHERITS edge via `class Dog < Animal`.
|
|
* RED: grammar-only Crystal pipeline does not yet resolve base_classes into
|
|
* INHERITS graph edges (no Crystal branch in pass_semantic.c resolver). */
|
|
TEST(probe_crystal_inherits_edge) {
|
|
GpaMetrics m = gpa_metrics("inherit.cr",
|
|
"class Base\n"
|
|
" def do_base; end\n"
|
|
"end\n"
|
|
"\n"
|
|
"class Derived < Base\n"
|
|
" def do_derived; end\n"
|
|
"end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Crystal INHERITS edge not yet produced by the pipeline. */
|
|
ASSERT_TRUE(m.inherits >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* Crystal: module definition → type-like node. */
|
|
TEST(probe_crystal_module_node) {
|
|
GpaMetrics m = gpa_metrics("mixin.cr",
|
|
"module Greetable\n"
|
|
" def greet\n"
|
|
" puts \"Hello!\"\n"
|
|
" end\n"
|
|
"end\n"
|
|
"\n"
|
|
"class Person\n"
|
|
" include Greetable\n"
|
|
"end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both the module and class should yield type-like nodes. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Crystal: require in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only Crystal has no `require` resolver in the pipeline. */
|
|
TEST(probe_crystal_imports_edge) {
|
|
static const GpaFile files[] = {
|
|
{"util.cr",
|
|
"def double(x : Int32) : Int32\n"
|
|
" x * 2\n"
|
|
"end\n"},
|
|
{"main.cr",
|
|
"require \"./util\"\n"
|
|
"\n"
|
|
"def run(n : Int32) : Int32\n"
|
|
" double(n)\n"
|
|
"end\n"}
|
|
};
|
|
GpaMetrics m = gpa_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Crystal `require` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 7 — D (.d) — CBM_LANG_DLANG
|
|
*
|
|
* D label histogram: Function:2, Module:1
|
|
* D has `import`, structs, classes with `:` inheritance, interfaces.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* D: two free functions → 2 Function nodes. */
|
|
TEST(probe_d_functions) {
|
|
GpaMetrics m = gpa_metrics("math.d",
|
|
"int square(int x)\n"
|
|
"{\n"
|
|
" return x * x;\n"
|
|
"}\n"
|
|
"\n"
|
|
"int cube(int x)\n"
|
|
"{\n"
|
|
" return x * square(x);\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both functions must be Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* D: struct definition → Struct/type-like node.
|
|
* RED: the grammar-only D extractor produces Function:2/Module:1 (histogram);
|
|
* structs may not yet be extracted as distinct Struct nodes. */
|
|
TEST(probe_d_struct_node) {
|
|
GpaMetrics m = gpa_metrics("point.d",
|
|
"struct Point\n"
|
|
"{\n"
|
|
" double x;\n"
|
|
" double y;\n"
|
|
"}\n"
|
|
"\n"
|
|
"double dist(Point a, Point b)\n"
|
|
"{\n"
|
|
" import std.math : sqrt;\n"
|
|
" return sqrt((a.x-b.x)^^2 + (a.y-b.y)^^2);\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* REAL BUG (NEW-16, node-extraction incompleteness): d_class_types DOES list
|
|
* "struct_declaration" (lang_specs.c:943-950), so the spec is configured, yet 0
|
|
* type nodes reach the graph. D struct/class/interface defs are not being
|
|
* extracted despite the spec — root cause is in the D def-extraction path. */
|
|
ASSERT_TRUE(m.types >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* D: class with inheritance `class Dog : Animal`.
|
|
* RED: D OOP classes not expected in the current histogram (only Function/Module). */
|
|
TEST(probe_d_class_inherits) {
|
|
GpaMetrics m = gpa_metrics("pets.d",
|
|
"class Animal\n"
|
|
"{\n"
|
|
" void breathe() {}\n"
|
|
"}\n"
|
|
"\n"
|
|
"class Dog : Animal\n"
|
|
"{\n"
|
|
" void bark() {}\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: D class not yet extracted as Class node nor INHERITS edge produced. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED — no D class extractor */
|
|
ASSERT_TRUE(m.inherits >= 1); /* expected RED — no D INHERITS resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* D: interface definition.
|
|
* RED: D interfaces not expected in current grammar histogram. */
|
|
TEST(probe_d_interface_node) {
|
|
GpaMetrics m = gpa_metrics("iface.d",
|
|
"interface IWriter\n"
|
|
"{\n"
|
|
" void write(string s);\n"
|
|
" void flush();\n"
|
|
"}\n"
|
|
"\n"
|
|
"void noop() {}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: D interface not yet yielding Interface node. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* D: import in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only D has no import resolver in the pipeline. */
|
|
TEST(probe_d_imports_edge) {
|
|
static const GpaFile files[] = {
|
|
{"util.d",
|
|
"module util;\n"
|
|
"\n"
|
|
"int double_val(int x) { return x * 2; }\n"},
|
|
{"main.d",
|
|
"module main;\n"
|
|
"\n"
|
|
"import util;\n"
|
|
"\n"
|
|
"void run() {\n"
|
|
" int y = double_val(21);\n"
|
|
"}\n"}
|
|
};
|
|
GpaMetrics m = gpa_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: D `import` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 8 — Emacs Lisp (.el)
|
|
*
|
|
* EmacsLisp label histogram: Function:2, Module:1
|
|
* Emacs Lisp uses `defun`; `require`/`provide` for modules; no OOP classes.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Emacs Lisp: two `defun` definitions → 2 Function nodes. */
|
|
TEST(probe_emacslisp_functions) {
|
|
GpaMetrics m = gpa_metrics("util.el",
|
|
"(defun el-square (x)\n"
|
|
" \"Return X squared.\"\n"
|
|
" (* x x))\n"
|
|
"\n"
|
|
"(defun el-cube (x)\n"
|
|
" \"Return X cubed.\"\n"
|
|
" (* x (el-square x)))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both defun forms must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Emacs Lisp: defvar / defconst — global variable definitions. */
|
|
TEST(probe_emacslisp_defvar) {
|
|
GpaMetrics m = gpa_metrics("config.el",
|
|
"(defvar my-config-max 100\n"
|
|
" \"Maximum value for config.\")\n"
|
|
"\n"
|
|
"(defconst my-version \"1.0\"\n"
|
|
" \"Package version.\")\n"
|
|
"\n"
|
|
"(defun my-get-max () my-config-max)\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: at minimum the defun should produce a Function node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Emacs Lisp: `require` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only EmacsLisp has no require-resolver in the pipeline. */
|
|
TEST(probe_emacslisp_imports_edge) {
|
|
static const GpaFile files[] = {
|
|
{"math-util.el",
|
|
"(provide 'math-util)\n"
|
|
"\n"
|
|
"(defun math-util-double (x) (* 2 x))\n"},
|
|
{"main.el",
|
|
"(require 'math-util)\n"
|
|
"\n"
|
|
"(defun main-run (n) (math-util-double n))\n"}
|
|
};
|
|
GpaMetrics m = gpa_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: EmacsLisp `require` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 9 — Fennel (.fnl)
|
|
*
|
|
* Fennel label histogram: Function:2, Module:1
|
|
* Fennel is a Lisp that compiles to Lua; `require` for imports; no OOP classes.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Fennel: two `fn` definitions → 2 Function nodes. */
|
|
TEST(probe_fennel_functions) {
|
|
GpaMetrics m = gpa_metrics("ops.fnl",
|
|
"(fn add [a b]\n"
|
|
" (+ a b))\n"
|
|
"\n"
|
|
"(fn mul [a b]\n"
|
|
" (* a b))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both fn forms must be Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Fennel: `lambda` (shorthand fn) definition. */
|
|
TEST(probe_fennel_lambda) {
|
|
GpaMetrics m = gpa_metrics("lambdas.fnl",
|
|
"(fn double [x] (* 2 x))\n"
|
|
"(fn square [x] (* x x))\n"
|
|
"(fn cube [x] (* x x x))\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: all three fn forms must be Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 3);
|
|
PASS();
|
|
}
|
|
|
|
/* Fennel: `require` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only Fennel has no require-resolver in the pipeline. */
|
|
TEST(probe_fennel_imports_edge) {
|
|
static const GpaFile files[] = {
|
|
{"util.fnl",
|
|
"(fn double [x] (* 2 x))\n"
|
|
"{:double double}\n"},
|
|
{"main.fnl",
|
|
"(local util (require :util))\n"
|
|
"\n"
|
|
"(fn run [n]\n"
|
|
" (util.double n))\n"}
|
|
};
|
|
GpaMetrics m = gpa_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Fennel `require` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 10 — Fish (.fish)
|
|
*
|
|
* Fish label histogram: Function:1, Module:1
|
|
* Fish shell scripting: `function` keyword; no imports, no OOP.
|
|
* The histogram shows only 1 function extracted (CALL_CASES fixture has 2 fns
|
|
* but only 1 reaches the graph — possible extraction gap for the second fn).
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Fish: single function definition → at least 1 Function node. */
|
|
TEST(probe_fish_function_node) {
|
|
GpaMetrics m = gpa_metrics("greet.fish",
|
|
"function greet\n"
|
|
" set name $argv[1]\n"
|
|
" echo \"Hello, $name!\"\n"
|
|
"end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: the function must appear as a node. */
|
|
ASSERT_TRUE(m.functions >= 1);
|
|
PASS();
|
|
}
|
|
|
|
/* Fish: two function definitions — exercises the known histogram gap.
|
|
* The P5 CALL_CASES fixture has 2 fns but histogram shows Function:1.
|
|
* RED: second fish function not extracted (possible grammar gap in extractor). */
|
|
TEST(probe_fish_two_functions) {
|
|
GpaMetrics m = gpa_metrics("funcs.fish",
|
|
"function say_hello\n"
|
|
" echo \"Hello!\"\n"
|
|
"end\n"
|
|
"\n"
|
|
"function say_bye\n"
|
|
" echo \"Bye!\"\n"
|
|
"end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: only 1 of the 2 fish functions appears to be extracted (histogram gap). */
|
|
ASSERT_TRUE(m.functions >= 2); /* expected RED — second fn not extracted */
|
|
PASS();
|
|
}
|
|
|
|
/* Fish has no OOP and no import mechanism; verify no spurious type nodes. */
|
|
TEST(probe_fish_no_type_nodes) {
|
|
GpaMetrics m = gpa_metrics("noop.fish",
|
|
"function noop\n"
|
|
" true\n"
|
|
"end\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: fish produces 0 type-like nodes. */
|
|
ASSERT_TRUE(m.types == 0);
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 11 — F# (.fs)
|
|
*
|
|
* F# label histogram: Function:2, Module:1
|
|
* F# is a functional-first .NET language: `let` functions, `type` records/unions,
|
|
* `open` for imports, `type Child() = inherit Parent()` for OOP.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* F#: two `let` function bindings → 2 Function nodes. */
|
|
TEST(probe_fsharp_functions) {
|
|
GpaMetrics m = gpa_metrics("calc.fs",
|
|
"let square x = x * x\n"
|
|
"\n"
|
|
"let cube x = x * square x\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both let-bindings must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* F#: record type definition → type-like node.
|
|
* RED: the grammar histogram shows only Function/Module; record types not yet
|
|
* extracted as Type/Struct nodes. */
|
|
TEST(probe_fsharp_record_type) {
|
|
GpaMetrics m = gpa_metrics("model.fs",
|
|
"type Point = { X: float; Y: float }\n"
|
|
"\n"
|
|
"let origin = { X = 0.0; Y = 0.0 }\n"
|
|
"\n"
|
|
"let dist (a: Point) (b: Point) =\n"
|
|
" let dx = a.X - b.X\n"
|
|
" let dy = a.Y - b.Y\n"
|
|
" sqrt (dx*dx + dy*dy)\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: F# record type not yet extracted as a Type/Struct node. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* F#: discriminated union → type-like node.
|
|
* RED: same root cause as record types. */
|
|
TEST(probe_fsharp_discriminated_union) {
|
|
GpaMetrics m = gpa_metrics("shape.fs",
|
|
"type Shape =\n"
|
|
" | Circle of float\n"
|
|
" | Rectangle of float * float\n"
|
|
"\n"
|
|
"let area shape =\n"
|
|
" match shape with\n"
|
|
" | Circle r -> System.Math.PI * r * r\n"
|
|
" | Rectangle (w, h) -> w * h\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: F# discriminated union not yet extracted as a Type node. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* F#: class with `inherit` → Class node + INHERITS edge.
|
|
* RED: class nodes not in histogram; no F# INHERITS resolver. */
|
|
TEST(probe_fsharp_class_inherits) {
|
|
GpaMetrics m = gpa_metrics("oop.fs",
|
|
"type Animal(name: string) =\n"
|
|
" member _.Name = name\n"
|
|
" abstract member Speak: unit -> string\n"
|
|
" default _.Speak() = \"...\"\n"
|
|
"\n"
|
|
"type Dog(name: string) =\n"
|
|
" inherit Animal(name)\n"
|
|
" override _.Speak() = \"Woof!\"\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: F# OOP class/inherit not yet modeled by the extractor. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED — no F# class extraction */
|
|
ASSERT_TRUE(m.inherits >= 1); /* expected RED — no F# INHERITS resolver */
|
|
PASS();
|
|
}
|
|
|
|
/* F#: `open` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only F# has no `open`-resolver in the pipeline. */
|
|
TEST(probe_fsharp_imports_edge) {
|
|
static const GpaFile files[] = {
|
|
{"MathUtils.fs",
|
|
"module MathUtils\n"
|
|
"\n"
|
|
"let double x = x * 2\n"
|
|
"let triple x = x * 3\n"},
|
|
{"Main.fs",
|
|
"module Main\n"
|
|
"\n"
|
|
"open MathUtils\n"
|
|
"\n"
|
|
"let run n = double n + triple n\n"}
|
|
};
|
|
GpaMetrics m = gpa_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: F# `open` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* GROUP 12 — Gleam (.gleam)
|
|
*
|
|
* Gleam label histogram: Function:2, Module:1
|
|
* Gleam is a statically-typed functional language on the BEAM (Erlang VM).
|
|
* `pub fn` for public functions, `import` for modules; no OOP classes.
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
/* Gleam: two `pub fn` definitions → 2 Function nodes. */
|
|
TEST(probe_gleam_functions) {
|
|
GpaMetrics m = gpa_metrics("math.gleam",
|
|
"pub fn square(x: Int) -> Int {\n"
|
|
" x * x\n"
|
|
"}\n"
|
|
"\n"
|
|
"pub fn cube(x: Int) -> Int {\n"
|
|
" x * square(x)\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both pub fn definitions must produce Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Gleam: private (non-pub) function — must also produce a Function node. */
|
|
TEST(probe_gleam_private_function) {
|
|
GpaMetrics m = gpa_metrics("util.gleam",
|
|
"fn internal_double(x: Int) -> Int {\n"
|
|
" x * 2\n"
|
|
"}\n"
|
|
"\n"
|
|
"pub fn double(x: Int) -> Int {\n"
|
|
" internal_double(x)\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* GREEN: both the private and public fn must become Function nodes. */
|
|
ASSERT_TRUE(m.functions >= 2);
|
|
PASS();
|
|
}
|
|
|
|
/* Gleam: custom type definition → type-like node.
|
|
* RED: histogram shows Function/Module only; custom types not yet extracted. */
|
|
TEST(probe_gleam_custom_type) {
|
|
GpaMetrics m = gpa_metrics("types.gleam",
|
|
"pub type Shape {\n"
|
|
" Circle(Float)\n"
|
|
" Rectangle(Float, Float)\n"
|
|
"}\n"
|
|
"\n"
|
|
"pub fn area(s: Shape) -> Float {\n"
|
|
" case s {\n"
|
|
" Circle(r) -> 3.14159 *. r *. r\n"
|
|
" Rectangle(w, h) -> w *. h\n"
|
|
" }\n"
|
|
"}\n");
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Gleam custom type not yet extracted as a Type node. */
|
|
ASSERT_TRUE(m.types >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* Gleam: `import` in two-file fixture → IMPORTS edge.
|
|
* RED: grammar-only Gleam has no import-resolver in the pipeline. */
|
|
TEST(probe_gleam_imports_edge) {
|
|
static const GpaFile files[] = {
|
|
{"math_utils.gleam",
|
|
"pub fn double(x: Int) -> Int {\n"
|
|
" x * 2\n"
|
|
"}\n"},
|
|
{"main.gleam",
|
|
"import math_utils\n"
|
|
"\n"
|
|
"pub fn run(n: Int) -> Int {\n"
|
|
" math_utils.double(n)\n"
|
|
"}\n"}
|
|
};
|
|
GpaMetrics m = gpa_metrics_files(files, 2);
|
|
ASSERT_TRUE(m.ok);
|
|
/* RED: Gleam `import` not resolved into IMPORTS edges. */
|
|
ASSERT_TRUE(m.imports >= 1); /* expected RED */
|
|
PASS();
|
|
}
|
|
|
|
/* ══════════════════════════════════════════════════════════════════
|
|
* SUITE wiring
|
|
* ══════════════════════════════════════════════════════════════════ */
|
|
|
|
SUITE(grammar_probe_a) {
|
|
/* Ada */
|
|
RUN_TEST(probe_ada_functions);
|
|
RUN_TEST(probe_ada_package_spec_nodes);
|
|
RUN_TEST(probe_ada_no_crash);
|
|
RUN_TEST(probe_ada_imports_edge);
|
|
|
|
/* Awk */
|
|
RUN_TEST(probe_awk_functions);
|
|
RUN_TEST(probe_awk_three_functions);
|
|
RUN_TEST(probe_awk_no_type_nodes);
|
|
|
|
/* Cairo */
|
|
RUN_TEST(probe_cairo_functions);
|
|
RUN_TEST(probe_cairo_trait_or_type);
|
|
RUN_TEST(probe_cairo_three_functions);
|
|
|
|
/* Clojure */
|
|
RUN_TEST(probe_clojure_functions);
|
|
RUN_TEST(probe_clojure_defmulti);
|
|
RUN_TEST(probe_clojure_defrecord);
|
|
RUN_TEST(probe_clojure_imports_edge);
|
|
|
|
/* Common Lisp */
|
|
RUN_TEST(probe_commonlisp_functions);
|
|
RUN_TEST(probe_commonlisp_defmacro);
|
|
RUN_TEST(probe_commonlisp_defstruct);
|
|
RUN_TEST(probe_commonlisp_imports_edge);
|
|
|
|
/* Crystal */
|
|
RUN_TEST(probe_crystal_class_node);
|
|
RUN_TEST(probe_crystal_subclass_node);
|
|
RUN_TEST(probe_crystal_inherits_edge);
|
|
RUN_TEST(probe_crystal_module_node);
|
|
RUN_TEST(probe_crystal_imports_edge);
|
|
|
|
/* D */
|
|
RUN_TEST(probe_d_functions);
|
|
RUN_TEST(probe_d_struct_node);
|
|
RUN_TEST(probe_d_class_inherits);
|
|
RUN_TEST(probe_d_interface_node);
|
|
RUN_TEST(probe_d_imports_edge);
|
|
|
|
/* Emacs Lisp */
|
|
RUN_TEST(probe_emacslisp_functions);
|
|
RUN_TEST(probe_emacslisp_defvar);
|
|
RUN_TEST(probe_emacslisp_imports_edge);
|
|
|
|
/* Fennel */
|
|
RUN_TEST(probe_fennel_functions);
|
|
RUN_TEST(probe_fennel_lambda);
|
|
RUN_TEST(probe_fennel_imports_edge);
|
|
|
|
/* Fish */
|
|
RUN_TEST(probe_fish_function_node);
|
|
RUN_TEST(probe_fish_two_functions);
|
|
RUN_TEST(probe_fish_no_type_nodes);
|
|
|
|
/* F# */
|
|
RUN_TEST(probe_fsharp_functions);
|
|
RUN_TEST(probe_fsharp_record_type);
|
|
RUN_TEST(probe_fsharp_discriminated_union);
|
|
RUN_TEST(probe_fsharp_class_inherits);
|
|
RUN_TEST(probe_fsharp_imports_edge);
|
|
|
|
/* Gleam */
|
|
RUN_TEST(probe_gleam_functions);
|
|
RUN_TEST(probe_gleam_private_function);
|
|
RUN_TEST(probe_gleam_custom_type);
|
|
RUN_TEST(probe_gleam_imports_edge);
|
|
}
|