quarb-csv 0.40.1

//! End-to-end tests: queries run through the engine against parsed
//! CSV tables.

use quarb_csv::CsvAdapter;

const DOC: &str = "\
name,dept,age,salary
Ada,eng,36,120000
Bo,sales,17,45000
Cy,eng,64,95000
Dee,\"ops, misc\",41,
";

fn nodes(query: &str) -> Vec<String> {
    let adapter = CsvAdapter::parse(DOC).unwrap();
    match quarb::run(query, &adapter).unwrap() {
        quarb::QueryResult::Nodes(ns) => ns.into_iter().map(|n| adapter.locator(n)).collect(),
        quarb::QueryResult::Values(_) => panic!("expected nodes"),
    }
}

fn values(query: &str) -> Vec<String> {
    let adapter = CsvAdapter::parse(DOC).unwrap();
    match quarb::run(query, &adapter).unwrap() {
        quarb::QueryResult::Values(vs) => vs.iter().map(|v| v.to_string()).collect(),
        quarb::QueryResult::Nodes(_) => panic!("expected values"),
    }
}

#[test]
fn rows_and_columns() {
    assert_eq!(nodes("/row").len(), 4);
    assert_eq!(values("//row @| count"), vec!["4"]);
    assert_eq!(nodes("/row[2]"), vec!["/row[2]"]);
    assert_eq!(nodes("/row[-1]"), vec!["/row[4]"]);
    assert_eq!(values("/row[1]::name"), vec!["Ada"]);
    // a quoted cell keeps its embedded comma
    assert_eq!(values("/row[4]::dept"), vec!["ops, misc"]);
    // table shape
    assert_eq!(values("^:::n-rows"), vec!["4"]);
    assert_eq!(values("^:::columns"), vec!["name, dept, age, salary"]);
}

#[test]
fn filtering_and_arithmetic() {
    assert_eq!(values("/row[::age > 35]::name"), vec!["Ada", "Cy", "Dee"]);
    assert_eq!(
        values(r#"/row[::dept = "eng" && ::age < 40]::name"#),
        vec!["Ada"]
    );
    // computed comparison over cells
    assert_eq!(values("/row[::salary div ::age > 3000]::name"), vec!["Ada"]);
    // computed column, aggregated
    assert_eq!(
        values("/row[::dept = \"eng\"] | .(::salary + 0) | $. @| sum"),
        vec!["215000"]
    );
}

#[test]
fn missing_values() {
    // Dee's salary cell is empty: the property is null
    assert_eq!(values("/row[::name = \"Dee\"]::salary"), vec![""]);
    // ... which numeric aggregates skip (pandas' NaN behavior)
    assert_eq!(values("/row::salary @| mean"), vec!["86666.66666666667"]);
    assert_eq!(values("/row::salary @| count"), vec!["4"]);
    // ... and truthiness filters (dropna)
    assert_eq!(values("/row[::salary]::name @| count"), vec!["3"]);
    // ... and null propagates through arithmetic
    assert_eq!(values("/row[::name = \"Dee\"] | ::salary * 2"), vec![""]);
    // default(v) fills the hole (pandas fillna); non-nulls pass
    assert_eq!(
        values("/row[::name = \"Dee\"] | ::salary | default(0)"),
        vec!["0"]
    );
    assert_eq!(values("/row[1] | ::salary | default(0)"), vec!["120000"]);
}

#[test]
fn aggregation() {
    assert_eq!(values("/row::age @| median"), vec!["38.5"]);
    assert_eq!(values("/row::age @| max"), vec!["64"]);
    assert_eq!(values("/row::name @| sort @| first"), vec!["Ada"]);
    assert_eq!(values("/row[::dept = \"eng\"]::age @| mean"), vec!["50"]);
}

/// Keyed aggregates over rows: node-preserving, with missing keys
/// not competing.
#[test]
fn keyed_aggregates() {
    assert_eq!(values("/row @| max_by(::salary) | ::name"), vec!["Ada"]);
    // Dee's missing salary does not compete for the minimum
    assert_eq!(values("/row @| min_by(::salary) | ::name"), vec!["Bo"]);
    assert_eq!(values("/row @| top(2, ::age) | ::name"), vec!["Cy", "Dee"]);
    assert_eq!(values("/row @| bottom(1, ::age) | ::name"), vec!["Bo"]);
    // sort_by sends missing keys last
    assert_eq!(
        values("/row @| sort_by(::salary) | ::name"),
        vec!["Bo", "Cy", "Ada", "Dee"]
    );
    assert_eq!(
        values("/row @| unique_by(::dept) | ::dept"),
        vec!["eng", "sales", "ops, misc"]
    );
    // keyed commands compose with positional selection and projection
    assert_eq!(
        values("/row @| sort_by(::age) @| [..2] | ::name"),
        vec!["Bo", "Ada"]
    );
    // ... and preserve node identity: a node result stays one
    assert_eq!(nodes("/row @| max_by(::age)"), vec!["/row[3]"]);
}

/// record(...) builds a record per row; records display as strict
/// JSON, so a stream of them is JSONL.
#[test]
fn records_and_json() {
    // auto-named projections plus a named computed field
    assert_eq!(
        values(r#"/row[::dept = "eng"] | %(::name; monthly = ::salary div 12)"#),
        vec![
            "%(name = \"Ada\"; monthly = 10000)",
            "%(name = \"Cy\"; monthly = 7916.666666666667)"
        ]
    );
    // | json serializes any topic: strings quote, null is literal
    assert_eq!(values("/row[1]::name | json"), vec![r#""Ada""#]);
    assert_eq!(values("/row[-1]::salary | json"), vec!["null"]);
    // composes with keyed aggregates: top earner as a record
    assert_eq!(
        values("/row @| max_by(::salary) | %(::name; ::salary)"),
        vec!["%(name = \"Ada\"; salary = \"120000\")"]
    );
}

/// Value-keyed grouping: list topics, keys as recallable regs,
/// reductions as separate per-capsa commands.
#[test]
fn grouping() {
    // value_counts
    assert_eq!(
        values("/row @| group(::dept) | count | %($.dept; n = $_)"),
        vec![
            "%(dept = \"eng\"; n = 2)",
            "%(dept = \"sales\"; n = 1)",
            "%(dept = \"ops, misc\"; n = 1)"
        ]
    );
    // groupby().mean() — and groups sort by their aggregate (the
    // null mean, per the missing-key rule, sorts last)
    assert_eq!(
        values(
            "/row::salary @| group(::dept) | mean | .m | %($.dept; mean = $.m) \
             @| sort_by($.m)"
        ),
        vec![
            "%(dept = \"sales\"; mean = 45000)",
            "%(dept = \"eng\"; mean = 107500)",
            "%(dept = \"ops, misc\"; mean = null)"
        ]
    );
    // computed group keys, record-convention named
    assert_eq!(
        values("/row @| group(\"senior\", ::age idiv 40) | count | %($.senior; n = $_)"),
        vec!["%(senior = 0; n = 2)", "%(senior = 1; n = 2)"]
    );
    // null keys form no group (pandas dropna): Dee's empty salary
    assert_eq!(
        values("/row @| group(::salary) | count @| count"),
        vec!["3"]
    );
}

/// A group carries its member capsae alongside the list topic:
/// keyed aggregates on `|` work per group, `@| ungroup` flattens
/// back with the group's key registers inherited.
#[test]
fn group_members() {
    // per-group top-1 by salary, flattened to rows
    assert_eq!(
        values(
            "/row @| group(::dept) | top(1, ::salary) @| ungroup \
             | %($.dept; ::name; ::salary)"
        ),
        vec![
            "%(dept = \"eng\"; name = \"Ada\"; salary = \"120000\")",
            "%(dept = \"sales\"; name = \"Bo\"; salary = \"45000\")",
            "%(dept = \"ops, misc\"; name = \"Dee\"; salary = null)"
        ]
    );
    // a keyed command on `|` rebuilds the list topic from the
    // surviving members, so reductions see the trimmed group
    assert_eq!(
        values("/row::salary @| group(::dept) | top(1, $_) | sum | %($.dept; max = $_)"),
        vec![
            "%(dept = \"eng\"; max = 120000)",
            "%(dept = \"sales\"; max = 45000)",
            "%(dept = \"ops, misc\"; max = null)"
        ]
    );
    // ungroup restores the pre-group typing: an unprojected
    // context comes back as nodes
    assert_eq!(
        nodes("/row @| group(::dept) | top(1, ::age) @| ungroup"),
        vec!["/row[3]", "/row[2]", "/row[4]"]
    );
    // ... and a projected one as its values
    assert_eq!(
        values("/row::name @| group(::dept) | top(1, ::age) @| ungroup"),
        vec!["Cy", "Bo", "Dee"]
    );
    // a keyed command on the plain pipe with no group before it is
    // refused with a pointer (2026-08-27): it would rank each
    // capsa's single value against itself and pass everything
    // through, silently.
    let adapter = CsvAdapter::parse(DOC).unwrap();
    let e = quarb::run("/row | top(1, ::age) @| ungroup @| count", &adapter).unwrap_err();
    assert!(e.to_string().contains("ranks a context"), "{e}");
}

/// `$ordinal` / `$ord` — the capsa's 1-based position in the
/// current context: ephemeral order, unlike the tree fact
/// `:index`.
#[test]
fn ordinal() {
    // a computed rank column after a sort
    assert_eq!(
        values("/row @| sort_by(::age) | %($ord; ::name)"),
        vec![
            "%(ordinal = 1; name = \"Bo\")",
            "%(ordinal = 2; name = \"Ada\")",
            "%(ordinal = 3; name = \"Dee\")",
            "%(ordinal = 4; name = \"Cy\")"
        ]
    );
    // positional sampling in a per-capsa filter
    assert_eq!(
        values("/row | [$ord mod 2 = 1] | ::name"),
        vec!["Ada", "Cy"]
    );
    // the ordinal is the position in the context at that command:
    // after a filter, survivors renumber
    assert_eq!(
        values("/row | [::dept = \"eng\"] | $ord + 0"),
        vec!["1", "2"]
    );
    // outside a capsa context (navigation predicates) it is null
    assert_eq!(values("/row[$ord = 1] @| count"), vec!["0"]);
}

/// `@| window(span[, key])` — each capsa gains its neighbors at
/// ordinal offsets within the span as members (partial near the
/// edges), so the per-capsa aggregate machinery rolls. Ages in
/// context order: 36, 17, 64, 41.
#[test]
fn windows() {
    // rolling sum of 2 (self + predecessor); partial at row 1
    assert_eq!(
        values("/row | ::age @| window(-1..0) | sum"),
        vec!["36", "53", "81", "105"]
    );
    // `window(n)` is the trailing-count sugar
    assert_eq!(
        values("/row | ::age @| window(2) | sum"),
        vec!["36", "53", "81", "105"]
    );
    // expanding window: cumulative sum
    assert_eq!(
        values("/row | ::age @| window(..0) | sum"),
        vec!["36", "53", "117", "158"]
    );
    // centered window: partial at both edges
    assert_eq!(
        values("/row @| window(-1..1) | count"),
        vec!["2", "3", "3", "2"]
    );
    // leading window
    assert_eq!(
        values("/row | ::age @| window(0..1) | max"),
        vec!["36", "64", "64", "41"]
    );
    // a span past the edge leaves an empty window
    assert_eq!(
        values("/row @| window(..-1) | count"),
        vec!["0", "1", "2", "3"]
    );
    // keyed: neighbors are the nearest same-key capsae, original
    // order preserved (eng, sales, eng, ops)
    assert_eq!(
        values("/row | ::age @| window(-1..0, ::dept) | sum"),
        vec!["36", "17", "100", "41"]
    );
    // members ride the keyed `|` machinery: rolling max
    assert_eq!(
        values("/row | ::age @| window(-1..0) | top(1, $_) | sum"),
        vec!["36", "36", "64", "64"]
    );
    // window is capsa-preserving: registers stay the capsa's own
    assert_eq!(
        values("/row | ::age | .a @| window(-1..0) | sum | $_ - $.a"),
        vec!["0", "36", "17", "64"]
    );
}

/// `@| shift(n[, key])` — the topic becomes the effective topic of
/// the capsa `n` positions back in its partition (negative looks
/// forward; null past the edge).
#[test]
fn shift() {
    assert_eq!(
        values("/row | ::age @| shift(1)"),
        vec!["", "36", "17", "64"]
    );
    assert_eq!(
        values("/row | ::age @| shift(-1)"),
        vec!["17", "64", "41", ""]
    );
    // the diff idiom: row-over-row delta (null at the edge)
    assert_eq!(
        values("/row | ::age | .now @| shift(1) | $.now - $_"),
        vec!["", "-19", "47", "-23"]
    );
    // keyed: the previous same-key capsa (eng, sales, eng, ops)
    assert_eq!(
        values("/row | ::age @| shift(1, ::dept)"),
        vec!["", "", "36", ""]
    );
}

/// `"text ${expr} text"` — interpolated strings: holes evaluate in
/// the current scope and splice as text; null splices as empty; a
/// hole-free double-quoted string stays a plain literal.
#[test]
fn interpolation() {
    assert_eq!(
        values(r#"/row[..2] | "${::name} is ${::age}""#),
        vec!["Ada is 36", "Bo is 17"]
    );
    // full expressions in holes; register recall; \$ escapes
    assert_eq!(
        values(r#"/row[1] | ::salary | .s | "\$${$.s}, monthly \$${$_ idiv 12}""#),
        vec!["$120000, monthly $10000"]
    );
    // null splices as empty (Dee's salary is missing)
    assert_eq!(values(r#"/row[-1] | "[${::salary}]""#), vec!["[]"]);
    // a hole-free double-quoted string is an ordinary literal
    assert_eq!(values(r#"/row[::dept = "eng"] @| count"#), vec!["2"]);
    // interpolations work as function arguments
    assert_eq!(
        values(r#"/row[1] | %(who = "${::name}/${::dept}")"#),
        vec!["%(who = \"Ada/eng\")"]
    );
}

/// The `^` anchor is semantic: inside a subcontext body it reaches
/// back to the arbor root, so a per-capsa computation can consult
/// the whole table (a share-of-total column).
#[test]
fn root_anchor_in_subcontexts() {
    assert_eq!(
        values("/row @| group(::dept) | count | .n | .t(^/row @| count) | $.n * 100 idiv $.t"),
        vec!["50", "25", "25"]
    );
    // at the top level the anchor is inert (root is already the
    // start), and it round-trips through the unparser
    assert_eq!(values("^/row @| count"), vec!["4"]);
}

/// Procedural macros end to end: the body computes over argument
/// forms at expansion time, and the spliced text runs against the
/// table.
#[test]
fn macros_end_to_end() {
    // describe: one stanza per column argument, auto-joined
    assert_eq!(
        values(
            r#"macro &describe(@cols):
                 /cols/* | .k(/projection::key)
                         | "| .${$.k}-mean(/row${::form} @| mean)";
               ^ | &describe(::age, ::salary) | %."#
        ),
        vec!["%(\"age-mean\" = 39.5; \"salary-mean\" = 86666.66666666667)"]
    );
    // a computed splice parameterizes a filter at expansion time
    assert_eq!(
        values(r#"macro &odd($n): ^ | "| [\$ord mod ${$n} = 1]"; /row | &odd(2) | ::name"#),
        vec!["Ada", "Cy"]
    );
}

/// Data-aware macros (`&name!`): the body reads the dataset —
/// mounted as `/data` — at expansion time. Outside a hole a
/// parameter is the argument form (`| $col` projects the data by
/// it); inside a hole it splices as text.
#[test]
fn data_aware_macros() {
    // the pivot: distinct key values, read from the data, become
    // one generated count column each
    assert_eq!(
        values(
            r#"macro &pivot!($col):
                 /data/row[::age < 40] | $col @| unique
                   | "| .n-${$_}(/row[${$col} = \"${$_}\"] @| count)";
               ^ | &pivot!(::dept) | %."#
        ),
        vec!["%(\"n-eng\" = 2; \"n-sales\" = 1)"]
    );
    // the form binding also filters the data at expansion time
    assert_eq!(
        values(
            r#"macro &max!($col):
                 /data/row | $col @| max | "| \"${$_}\"";
               ^ | &max!(::age)"#
        ),
        vec!["64"]
    );
}

/// `window` / `shift` argument and pipe shapes are checked at parse
/// time.
#[test]
fn window_shapes() {
    let err = |q: &str| {
        let adapter = CsvAdapter::parse(DOC).unwrap();
        quarb::run(q, &adapter).unwrap_err().to_string()
    };
    // whole-context only: they read neighbors
    assert!(err("/row | ::age | window(-1..0)").contains("'window' uses '@|'"));
    assert!(err("/row | ::age | shift(1)").contains("'shift' uses '@|'"));
    // an empty span, a zero count, a missing distance
    assert!(err("/row @| window(2..1)").contains("start <= end"));
    assert!(err("/row @| window(0)").contains("offset range or a count"));
    assert!(err("/row @| shift()").contains("integer distance"));
    // a range argument is window's span or a rank band on the
    // commands that select by rank; a reduction takes none
    assert!(err("/row @| sum(1..2)").contains("no range argument"));
    let adapter = CsvAdapter::parse(DOC).unwrap();
    assert!(quarb::run("/row @| top(1..2; ::age)", &adapter).is_ok());
}

/// `%.` — the register as a record: the named view, one field per
/// name in first-push order, latest value per name; unnamed regs
/// are invisible to it.
#[test]
fn the_fields_push_takes_a_record() {
    let adapter = CsvAdapter::parse(DOC).unwrap();
    let err = quarb::run("/row | ::age | .% | %.", &adapter)
        .unwrap_err()
        .to_string();
    assert!(
        err.contains("the fields push '| .%' takes a record topic, not text"),
        "{err}"
    );
    let err = quarb::run("/row | .% | %.", &adapter)
        .unwrap_err()
        .to_string();
    assert!(err.contains("not a node with no topic"), "{err}");
}

#[test]
fn register_record_view() {
    // multi-column output: pushes become fields
    assert_eq!(
        values("/row[::age > 35] | .name(::name) | .age(::age) | %."),
        vec![
            "%(name = \"Ada\"; age = \"36\")",
            "%(name = \"Cy\"; age = \"64\")",
            "%(name = \"Dee\"; age = \"41\")"
        ]
    );
    // a group's key regs are already named: %. after a reduction
    // labels the row without %()
    assert_eq!(
        values("/row @| group(::dept) | count | .n | %."),
        vec![
            "%(dept = \"eng\"; n = 2)",
            "%(dept = \"sales\"; n = 1)",
            "%(dept = \"ops, misc\"; n = 1)"
        ]
    );
    // unnamed regs are skipped; a repointed name keeps its place
    // and carries the latest value
    assert_eq!(
        values("/row[1] | .a(::name) | ::dept | . | .b(::age) | .a(::salary) | %."),
        vec!["%(a = \"120000\"; b = \"36\")"]
    );
    // an empty register is an empty record
    assert_eq!(values("/row[1] | %."), vec!["%()"]);
}

/// Fragment definitions expand at parse time: query fragments,
/// parameterized fragments, pipeline fragments, and defs files.
#[test]
fn fragments() {
    assert_eq!(
        values("def &grown: /row[::age >= 18]; &grown @| count"),
        vec!["3"]
    );
    assert_eq!(
        values("def &above($col, $min): /row[$col >= $min]; &above(::salary, 100000) | ::name"),
        vec!["Ada"]
    );
    assert_eq!(
        values(
            "def &cols: | .name(::name) | .dept(::dept) | %.; \
             /row @| top(1, ::salary) | &cols"
        ),
        vec!["%(name = \"Ada\"; dept = \"eng\")"]
    );
    // a def building on an earlier def
    assert_eq!(
        values(
            "def &grown: /row[::age >= 18]; \
             def &grown-eng: &grown | [::dept = \"eng\"]; \
             &grown-eng | ::name"
        ),
        vec!["Ada", "Cy"]
    );
    // arguments are forms, evaluated per capsa at the splice site
    assert_eq!(
        values("def &col($c): | .v($c) | $.v; /row | &col(::age * 2) @| max"),
        vec!["128"]
    );
    // a preloaded defs table (the --defs path)
    let defs = quarb::parse_defs("def &grown: /row[::age >= 18];").unwrap();
    let adapter = CsvAdapter::parse(DOC).unwrap();
    match quarb::run_with_defs("&grown @| count", &defs, &adapter).unwrap() {
        quarb::QueryResult::Values(vs) => assert_eq!(vs[0].to_string(), "3"),
        _ => panic!("expected values"),
    }
}

/// `$1` … `$9` — regex captures: a successful `=~` in a filter
/// command binds its groups for the rest of the pipeline.
#[test]
fn captures() {
    // extract, then use as fields (Perl's match-then-harvest)
    assert_eq!(
        values(r#"/row | [::dept == (/^(\w+)s$/)] | %(stem = $1; ::name)"#),
        vec!["%(stem = \"sale\"; name = \"Bo\")"]
    );
    // captures reach pushes, %., and later filters
    assert_eq!(
        values(r#"/row | [::name == (/^(\w)/)] | .initial($1) | .age(::age) | %. @| [1..2]"#),
        vec![
            "%(initial = \"A\"; age = \"36\")",
            "%(initial = \"B\"; age = \"17\")"
        ]
    );
    // ... and group keys
    assert_eq!(
        values(r#"/row | [::dept == (/^(\w)/)] @| group("initial", $1) | count | .n | %."#),
        vec![
            "%(initial = \"e\"; n = 2)",
            "%(initial = \"s\"; n = 1)",
            "%(initial = \"o\"; n = 1)"
        ]
    );
    // a later filter without == keeps earlier captures; an
    // unreferenced group index is null
    assert_eq!(
        values(r#"/row | [::name == (/^(\w+)$/)] | [::age > 30] | %(who = $1; g2 = $2)"#),
        vec![
            "%(who = \"Ada\"; g2 = null)",
            "%(who = \"Cy\"; g2 = null)",
            "%(who = \"Dee\"; g2 = null)"
        ]
    );
    // outside any match, captures are null (and falsy)
    assert_eq!(values("/row[1] | %(c = $1)"), vec!["%(c = null)"]);
}

/// Regression: a property projection evaluated at the arbor root
/// (NodeId 0) must not underflow the 1-based cell index. The root
/// has no cells, so the property is simply null.
#[test]
fn property_at_root_is_null() {
    use quarb::{AstAdapter, NodeId};
    let adapter = CsvAdapter::parse(DOC).unwrap();
    // Used to panic with 'attempt to subtract with overflow'
    // (debug) / silently wrap (release) in CsvAdapter::cell.
    assert!(adapter.property(NodeId(0), "age").is_none());
}

#[test]
fn tsv_and_errors() {
    let tsv = "a\tb\n1\t2\n";
    let adapter = CsvAdapter::parse_with_delimiter(tsv, b'\t').unwrap();
    match quarb::run("/row::b", &adapter).unwrap() {
        quarb::QueryResult::Values(vs) => assert_eq!(vs.len(), 1),
        _ => panic!("expected values"),
    }
    // a ragged record is an error
    assert!(CsvAdapter::parse("a,b\n1,2,3\n").is_err());
}

/// Correlated subqueries: `$$` steps a capsa-scope operand out to
/// the invoking capsa, so a subcontext body can mention "this
/// row's" values — the wide crosstab, groupwise transforms, and
/// share-of-group columns.
#[test]
fn correlated_subqueries() {
    // wide crosstab: one row per dept, one generated cell per
    // condition, each cell counting with THIS group's key
    assert_eq!(
        values(
            "/row @| group(::dept) \
             | .adults(^/row[::dept = $.dept][::age >= 18] @| count) | %."
        ),
        vec![
            "%(dept = \"eng\"; adults = 2)",
            "%(dept = \"sales\"; adults = 0)",
            "%(dept = \"ops, misc\"; adults = 1)"
        ]
    );
    // groupwise transform: each row paired with its group's mean
    assert_eq!(
        values(
            "/row @| [..2] | .d(::dept) \
             | .m(^/row[::dept = $.d]::salary @| mean) | $.m"
        ),
        vec!["107500", "45000"]
    );
    // `_` is the served node inside the body — its core metadata too
    assert_eq!(
        values("/row @| [..2] | ::age | .t(^/row[:index = $$__:index]::name) | $.t"),
        vec!["Ada", "Bo"]
    );
    // an unset recall is null at any level
    assert_eq!(values("/row[1] | $.x"), vec![""]);
    // the capsa is shared through nested bodies: `$.a` two bodies
    // down is the push the top-level pipeline made
    assert_eq!(
        values(
            "/row[1] | .a(::age) | .x(^/row[1] | .b(::dept) | .y(^/row[::age = $.a] @| count) | $.y) | $.x"
        ),
        vec!["1"]
    );
}

// A table of text defines no references: both arrows are refused
// with the value match as the remedy, never answered with nothing.
#[test]
fn arrows_are_refused_where_nothing_refers() {
    let adapter = CsvAdapter::parse(DOC).unwrap();
    for q in ["/*[1]::dept-->", "/*[1]<--(/*::dept)", "/*[1]<--"] {
        let err = quarb::run(q, &adapter).unwrap_err().to_string();
        assert!(err.contains("defines none"), "{q}: {err}");
    }
    // the value match is the working spelling
    assert_eq!(values("/*[1]::dept=>(/*::dept)::name"), ["Ada", "Cy"]);
}