test: cover external callgrind graph parser

Author: not-matthias

callgrind-utils/tests/data/example.out

@@ -0,0 +1,124 @@
+# callgrind format
+# Runner-style uncompressed output (--compress-strings=no): full fn=/fl=/ob=
+# names, blank-line separated function records, a single part: block. Fed
+# directly to the monorepo callgrind-parser with no local preprocessing. Every
+# callee also has its own fn= record, since build_call_graph only nodes
+# functions that appear as fn= and drops edges to otherwise-unknown callees.
+version: 1
+creator: callgrind-fixture
+pid: 1
+cmd: ./prog
+positions: line
+events: Ir
+part: 1
+
+# ===== main: object /path/to/clreq, file file1.c =====
+ob=/path/to/clreq
+fl=file1.c
+fn=main
+0 4
+# regular call: main -> func1; no cfi -> callee inherits file1.c.
+cfn=func1
+calls=1 50
+16 400
+# cfl= is the historical alias of cfi=; callee file resolves to cflfile.c.
+cfl=cflfile.c
+cfn=cflop
+calls=1 52
+18 30
+# omitted cfi/cfl: callee inherits the current file context (file1.c).
+cfn=nofile
+calls=1 53
+19 10
+# same function name in two different objects/files -> two distinct nodes.
+cob=liba
+cfi=fileA.c
+cfn=helper
+calls=1 60
+20 5
+cob=libb
+cfi=fileB.c
+cfn=helper
+calls=1 61
+21 5
+# cob= overrides the callee object; file inherited from context (file1.c).
+cob=extlib
+cfn=extfn
+calls=1 70
+22 3
+
+# ===== func1 =====
+fl=file1.c
+fn=func1
+ob=/path/to/clreq
+23 100
+cfn=func2
+calls=1 54
+24 50
+
+# ===== func2 =====
+fl=file1.c
+fn=func2
+ob=/path/to/clreq
+25 20
+cfn=rec
+calls=1 55
+26 50
+# a function name reused by a later call still yields a distinct edge.
+cfn=func1
+calls=1 62
+27 20
+
+# ===== rec: direct recursion -> self-edge (caller == callee) =====
+fl=file1.c
+fn=rec
+ob=/path/to/clreq
+28 7
+cfn=rec
+calls=1 56
+29 7
+
+# ===== callee functions (need their own fn= to become nodes) =====
+fl=cflfile.c
+fn=cflop
+ob=/path/to/clreq
+40 30
+
+fl=file1.c
+fn=nofile
+ob=/path/to/clreq
+41 10
+
+fl=fileA.c
+fn=helper
+ob=liba
+42 5
+
+fl=fileB.c
+fn=helper
+ob=libb
+43 5
+
+fl=file1.c
+fn=extfn
+ob=extlib
+44 3
+
+fl=inline.c
+fn=inltarget
+ob=/path/to/clreq
+45 4
+
+# ===== inlhost: inline fi=/fe= file transition =====
+# fi= moves the current file context to inline.c; a following call with no cfi
+# inherits inline.c for the callee. fe= restores file1.c before the function
+# terminates, so the caller keeps file1.c.
+fl=file1.c
+fn=inlhost
+ob=/path/to/clreq
+30 4
+fi=inline.c
+cfn=inltarget
+calls=1 57
+31 4
+fe=file1.c

callgrind-utils/tests/parser.rs

@@ -0,0 +1,220 @@
+//! Integration tests for the Callgrind `.out` -> call-graph parser.
+//!
+//! The fixture (`data/example.out`) uses runner-style uncompressed Callgrind
+//! syntax (`--compress-strings=no`): full `fn=`/`fl=`/`ob=` names, blank-line
+//! separated function records, and a single `part:` block, fed directly to the
+//! monorepo `callgrind-parser` with no local preprocessing. Every callee also
+//! has its own `fn=` record, since `build_call_graph` only nodes functions that
+//! appear as `fn=` and drops edges to otherwise-unknown callees.
+//!
+//! Topology is asserted through the canonical JSON projection (`to_json`),
+//! which exposes node identity (`name`/`object`/`file`) and indexed edges with
+//! per-thread call counts. Path normalization is exercised through `redact`,
+//! which basenames `file`/`object` before serialization.
+
+use callgrind_utils::model::CallGraph;
+use serde_json::Value;
+use std::io::Cursor;
+
+const FIXTURE: &str = include_str!("data/example.out");
+
+fn parse_default() -> CallGraph {
+    CallGraph::parse(Cursor::new(FIXTURE)).expect("parse fixture")
+}
+
+fn json(g: &CallGraph) -> Value {
+    serde_json::from_str(&g.to_json().expect("to_json")).expect("valid json")
+}
+
+/// The first node named `name` (unique names only).
+fn node<'a>(v: &'a Value, name: &str) -> &'a Value {
+    v["nodes"]
+        .as_array()
+        .expect("nodes array")
+        .iter()
+        .find(|n| n["name"].as_str() == Some(name))
+        .unwrap_or_else(|| panic!("node {name} not found"))
+}
+
+/// All nodes named `name` (distinct by object/file).
+fn nodes_named<'a>(v: &'a Value, name: &str) -> Vec<&'a Value> {
+    v["nodes"]
+        .as_array()
+        .expect("nodes array")
+        .iter()
+        .filter(|n| n["name"].as_str() == Some(name))
+        .collect()
+}
+
+/// All edges whose source/target nodes (looked up by name) are `caller`/`callee`.
+fn edges_between<'a>(v: &'a Value, caller: &str, callee: &str) -> Vec<&'a Value> {
+    let names: Vec<&str> = v["nodes"]
+        .as_array()
+        .expect("nodes array")
+        .iter()
+        .map(|n| n["name"].as_str().unwrap())
+        .collect();
+    v["edges"]
+        .as_array()
+        .expect("edges array")
+        .iter()
+        .filter(|e| {
+            let s = e["source"].as_u64().unwrap() as usize;
+            let t = e["target"].as_u64().unwrap() as usize;
+            names.get(s).copied() == Some(caller) && names.get(t).copied() == Some(callee)
+        })
+        .collect()
+}
+
+/// Call count of an edge: `counts` is `[[{pid,tid}, count], ...]`; take the
+/// single (pid,tid) entry the fixture produces.
+fn call_count(e: &Value) -> u64 {
+    e["counts"]
+        .as_array()
+        .expect("counts array")
+        .first()
+        .expect("at least one count entry")
+        .as_array()
+        .expect("count pair")[1]
+        .as_u64()
+        .unwrap()
+}
+
+#[test]
+fn parses_basic_callgraph() {
+    let v = json(&parse_default());
+    assert_eq!(v["nodes"].as_array().unwrap().len(), 11, "nodes: {v:#?}");
+    assert_eq!(v["edges"].as_array().unwrap().len(), 11, "edges: {v:#?}");
+
+    let e = &edges_between(&v, "main", "func1");
+    assert_eq!(e.len(), 1);
+    assert_eq!(call_count(e[0]), 1);
+    // No cfi on this call -> callee inherits the caller's file.
+    assert_eq!(node(&v, "main")["file"].as_str(), Some("file1.c"));
+    assert_eq!(node(&v, "func1")["file"].as_str(), Some("file1.c"));
+}
+
+#[test]
+fn cfl_alias_equals_cfi() {
+    // `cfl=cflfile.c` is the historical alias of `cfi=`; the callee node's file
+    // must resolve to cflfile.c while the object inherits the caller's.
+    let v = json(&parse_default());
+    let cflop = node(&v, "cflop");
+    assert_eq!(cflop["file"].as_str(), Some("cflfile.c"));
+    assert_eq!(cflop["object"].as_str(), Some("/path/to/clreq"));
+    assert_eq!(edges_between(&v, "main", "cflop").len(), 1);
+}
+
+#[test]
+fn omitted_cfi_inherits_current_file_context() {
+    // No `cfi`/`cfl`: the callee inherits the current file context (file1.c).
+    let v = json(&parse_default());
+    let nofile = node(&v, "nofile");
+    assert_eq!(nofile["file"].as_str(), Some("file1.c"));
+    assert_eq!(edges_between(&v, "main", "nofile").len(), 1);
+}
+
+#[test]
+fn inline_fi_fe_changes_callee_context_not_caller() {
+    // `fi=inline.c` moves the current file context, so the callee (inltarget)
+    // inherits inline.c. `fe=file1.c` restores the context before the function
+    // terminates, so the caller (inlhost) keeps file1.c.
+    let v = json(&parse_default());
+    assert_eq!(node(&v, "inlhost")["file"].as_str(), Some("file1.c"));
+    assert_eq!(node(&v, "inltarget")["file"].as_str(), Some("inline.c"));
+    assert_eq!(edges_between(&v, "inlhost", "inltarget").len(), 1);
+}
+
+#[test]
+fn same_name_different_object_are_distinct() {
+    // `helper` exists in liba/fileA.c AND libb/fileB.c -> two distinct nodes,
+    // two distinct edges from main.
+    let v = json(&parse_default());
+    let helpers = nodes_named(&v, "helper");
+    assert_eq!(helpers.len(), 2, "helpers: {helpers:#?}");
+
+    let mut keys: Vec<(&str, &str)> = helpers
+        .iter()
+        .map(|n| (n["object"].as_str().unwrap(), n["file"].as_str().unwrap()))
+        .collect();
+    keys.sort();
+    assert_eq!(keys, vec![("liba", "fileA.c"), ("libb", "fileB.c")]);
+
+    assert_eq!(edges_between(&v, "main", "helper").len(), 2);
+}
+
+#[test]
+fn recursion_becomes_self_edge() {
+    let v = json(&parse_default());
+    let rec = edges_between(&v, "rec", "rec");
+    assert_eq!(rec.len(), 1);
+    assert_eq!(rec[0]["source"], rec[0]["target"]);
+}
+
+#[test]
+fn cob_overrides_caller_object() {
+    // `cob=extlib` with no `cfi`: callee object is extlib, file inherited from
+    // the caller context (file1.c); the caller keeps its own object.
+    let v = json(&parse_default());
+    let extfn = node(&v, "extfn");
+    assert_eq!(extfn["object"].as_str(), Some("extlib"));
+    assert_eq!(extfn["file"].as_str(), Some("file1.c"));
+    assert_eq!(node(&v, "main")["object"].as_str(), Some("/path/to/clreq"));
+    assert_eq!(edges_between(&v, "main", "extfn").len(), 1);
+}
+
+#[test]
+fn redact_basenames_object_and_file_paths() {
+    // Raw JSON keeps the full object path verbatim; `redact` basenames it.
+    let raw = json(&parse_default());
+    assert!(raw["nodes"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|n| n["object"].as_str() == Some("/path/to/clreq")));
+
+    let redacted = json(&parse_default().redact());
+    assert!(redacted["nodes"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|n| n["object"].as_str() == Some("clreq")));
+    assert!(
+        !redacted["nodes"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|n| n["object"].as_str().unwrap().contains('/')),
+        "no object should retain a path separator after redaction"
+    );
+}
+
+#[test]
+fn to_json_is_canonical() {
+    let g = parse_default();
+    let v = json(&g);
+
+    assert_eq!(v["version"].as_u64(), Some(3));
+    let nodes = v["nodes"].as_array().unwrap();
+    let edges = v["edges"].as_array().unwrap();
+    assert_eq!(nodes.len(), 11);
+    assert_eq!(edges.len(), 11);
+
+    // Edges reference valid node indices.
+    for e in edges {
+        let s = e["source"].as_u64().unwrap() as usize;
+        let t = e["target"].as_u64().unwrap() as usize;
+        assert!(s < nodes.len() && t < nodes.len(), "edge index out of range");
+    }
+
+    // Edges are sorted by source index (the serializer's canonical order).
+    let sources: Vec<u64> = edges.iter().map(|e| e["source"].as_u64().unwrap()).collect();
+    let mut sorted = sources.clone();
+    sorted.sort();
+    assert_eq!(sources, sorted, "edges must be sorted by source");
+
+    // Output is deterministic: re-parsing yields byte-identical JSON.
+    let j1 = parse_default().to_json().unwrap();
+    let j2 = parse_default().to_json().unwrap();
+    assert_eq!(j1, j2, "JSON must be deterministic across parses");
+}