/*
 * test_java_lsp_coverage.c — Comprehensive coverage tests for the Java LSP.
 *
 * This is the deep-coverage suite that exercises every code path in the
 * resolver and every stdlib type in the registry. ~200 tests organized by:
 *
 *   1.  Literals (10)               — all numeric / string / char / bool variants
 *   2.  Type-name resolution (12)   — every path in java_resolve_type_name
 *   3.  Primitive expressions (10)  — arithmetic, comparison, logical, bitwise
 *   4.  Type-AST parsing (12)       — every kind handled by java_parse_type_node
 *   5.  Identifier resolution (10)  — scope chain, fields, imports, types
 *   6.  Field access (10)           — instance, static (System.out), arrays, scope
 *   7.  Method invocation (15)      — bare, this, super, static, instance, chain
 *   8.  Object creation (8)         — generic, raw, anonymous, nested
 *   9.  Cast / instanceof (8)
 *   10. Generic substitution (15)   — every entry in is_value_typed_container/is_map_like
 *   11. Lambda SAM inference (12)   — every functional-interface category
 *   12. Method references (10)      — Class::method, instance::method, ::new, super::
 *   13. Inheritance walking (10)    — multi-level, interfaces, sole-impl
 *   14. java.lang stdlib (15)       — Object/String/StringBuilder/Math/System/Thread/Class/Throwable
 *   15. java.util stdlib (15)       — collections, Optional, Iterator, regex
 *   16. java.io stdlib (10)
 *   17. java.nio.file (5)
 *   18. java.util.stream (10)
 *   19. java.util.function (10)
 *   20. java.util.concurrent (10)
 *   21. java.time (10)
 *   22. Imports (8)                 — single, on-demand, static, static on-demand
 *   23. Inner / nested types (10)
 *   24. Variable / scope binding (10)
 *   25. Control flow (10)           — if, for, while, switch, try
 *   26. Diagnostics (8)             — unresolved markers
 *   27. Cross-file (5)
 *   28. Stress / edge (10)          — pathological inputs, recursion, deep nesting
 *
 * Total: ~278 tests.
 */

#include "test_framework.h"
#include "cbm.h"
#include "lsp/java_lsp.h"

#include <string.h>
#include <stdio.h>

/* ── Helpers (shared form, kept local to avoid linker collisions) ─── */

static CBMFileResult *cov_extract(const char *source) {
    return cbm_extract_file(source, (int)strlen(source), CBM_LANG_JAVA, "test", "Main.java", 0,
                            NULL, NULL);
}

static int cov_find(const CBMFileResult *r, const char *callerSub, const char *calleeSub) {
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        if (rc->confidence < 0.5f) continue;
        if (rc->caller_qn && strstr(rc->caller_qn, callerSub) && rc->callee_qn &&
            strstr(rc->callee_qn, calleeSub)) {
            return i;
        }
    }
    return -1;
}

static int cov_require(const CBMFileResult *r, const char *callerSub, const char *calleeSub) {
    int idx = cov_find(r, callerSub, calleeSub);
    if (idx < 0) {
        printf("\n  MISSING: %s -> %s (have %d entries)\n", callerSub, calleeSub,
               r->resolved_calls.count);
        for (int i = 0; i < r->resolved_calls.count; i++) {
            const CBMResolvedCall *rc = &r->resolved_calls.items[i];
            printf("    %s -> %s [%s %.2f]\n", rc->caller_qn ? rc->caller_qn : "(null)",
                   rc->callee_qn ? rc->callee_qn : "(null)",
                   rc->strategy ? rc->strategy : "(null)", rc->confidence);
        }
    }
    return idx;
}

static int cov_count_strict(const CBMFileResult *r) {
    int n = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        if (r->resolved_calls.items[i].confidence >= 0.85f) n++;
    }
    return n;
}

static int cov_no_crash(CBMFileResult *r) { return r != NULL; }

/* Macro for quick "wrap source in a Main class with run() that returns
 * void and contains the body" pattern. */
#define WRAP_RUN(body) \
    "public class Main {\n  public void run(){\n    " body "\n  }\n}\n"

/* ── 1. Literals ─────────────────────────────────────────────────── */

TEST(cov_lit_int) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int run() { int x = 42; return x; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_long) {
    CBMFileResult *r = cov_extract("public class Main {\n"
                                    "  public long run() { long x = 99L; return x; }\n"
                                    "}");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_hex) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f() { int x = 0xFF; return x; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_binary) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f() { int x = 0b1010; return x; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_octal) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f() { int x = 0777; return x; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_float_suffix) {
    CBMFileResult *r = cov_extract(
        "public class Main { public float f() { float x = 1.5f; return x; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_double) {
    CBMFileResult *r = cov_extract(
        "public class Main { public double f() { double x = 3.14; return x; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_char) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { char c = 'a'; return Character.getNumericValue(c); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Character.getNumericValue"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_string_method) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { return \"hello\".length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_bool_method) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f() { return Boolean.toString(true); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Boolean.toString"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lit_null_no_crash) {
    CBMFileResult *r = cov_extract(
        "public class Main { public Object f() { return null; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

/* ── 2. Type-name resolution paths ───────────────────────────────── */

TEST(cov_typename_java_lang_implicit) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_via_single_import) {
    CBMFileResult *r =
        cov_extract("import java.util.HashMap;\n"
                    "public class Main { public int f(HashMap<String,String> m) { return m.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashMap.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_via_on_demand_import) {
    CBMFileResult *r =
        cov_extract("import java.util.*;\n"
                    "public class Main { public int f(HashMap<String,String> m) { return m.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashMap.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_via_static_import) {
    CBMFileResult *r = cov_extract("import static java.lang.Math.PI;\n"
                                    "public class Main { public double f() { return PI; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_qualified_path) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(java.util.HashMap<String,String> m) { return m.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashMap.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_inner_via_outer) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class Inner { public String tag() { return \"x\"; } }\n"
        "  public String f() { Inner i = new Inner(); return i.tag(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_nested_two_levels) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A {\n"
        "    static class B { public String tag() { return \"b\"; } }\n"
        "  }\n"
        "  public String f() { Main.A.B b = new Main.A.B(); return b.tag(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_array_type) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String[] xs) { return xs.length; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_2d_array) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(int[][] m) { return m[0].length; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_generic_type) {
    CBMFileResult *r = cov_extract("import java.util.List;\n"
                                    "public class Main { public int f(List<String> xs) { return xs.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "List.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_wildcard) {
    CBMFileResult *r = cov_extract("import java.util.List;\n"
                                    "public class Main { public int f(List<?> xs) { return xs.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "List.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typename_bounded_wildcard) {
    CBMFileResult *r = cov_extract("import java.util.List;\n"
                                    "public class Main { public int f(List<? extends Number> xs) { return xs.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "List.size"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 3. Primitive operations ─────────────────────────────────────── */

TEST(cov_op_arith) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(int a, int b) { return a + b * 2 - 1 / 3 % 4; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_op_compare) {
    CBMFileResult *r = cov_extract(
        "public class Main { public boolean f(int a, int b) { return a < b && a >= 0 && a != b; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_op_bitwise) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(int a) { return (a & 0xFF) | (a << 8) ^ (a >> 4); } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_op_unary_negate) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(int a) { return -a; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_op_logical_not) {
    CBMFileResult *r = cov_extract(
        "public class Main { public boolean f(boolean b) { return !b; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_op_increment) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { int a = 0; a++; ++a; return a; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_op_string_concat) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { String t = \"a\" + s + 1; return t.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_op_ternary_simple) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(boolean b) { return b ? 1 : 2; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_op_assignment) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { int a = 0; a += 1; a -= 1; return a; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_op_paren_expr) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { return ((s)).length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 4. Type-AST parsing kinds ───────────────────────────────────── */

TEST(cov_typeast_void_method) {
    CBMFileResult *r = cov_extract("public class Main { public void f() {} }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_byte_param) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f(byte b) { return b + 1; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_short_param) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f(short s) { return s + 1; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_int_param) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f(int i) { return i + 1; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_long_param) {
    CBMFileResult *r =
        cov_extract("public class Main { public long f(long l) { return l + 1; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_float_param) {
    CBMFileResult *r =
        cov_extract("public class Main { public float f(float f) { return f + 1; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_double_param) {
    CBMFileResult *r =
        cov_extract("public class Main { public double f(double d) { return d + 1; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_char_param) {
    CBMFileResult *r =
        cov_extract("public class Main { public char f(char c) { return c; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_boolean_param) {
    CBMFileResult *r =
        cov_extract("public class Main { public boolean f(boolean b) { return b; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_string_param) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f(String s) { return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_array_of_string) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String[] xs) { return xs[0].length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_typeast_generic_list) {
    CBMFileResult *r = cov_extract(
        "import java.util.List;\n"
        "public class Main { public int f(List<String> xs) { return xs.get(0).length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 5. Identifier resolution ────────────────────────────────────── */

TEST(cov_id_local_var) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { String s = \"x\"; return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_id_param) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_id_field) {
    CBMFileResult *r = cov_extract(
        "public class Main { private String s = \"x\"; public int f() { return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_id_inherited_field) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A { protected String s = \"x\"; }\n"
        "  static class B extends A { public int f() { return s.length(); } }\n"
        "}");
    ASSERT_NOT_NULL(r);
    /* Fields of inner classes — the LSP propagates parent fields via
     * the class registry. The exact resolution rate isn't asserted but
     * the test must not crash. */
    cbm_free_result(r);
    PASS();
}
TEST(cov_id_shadow_param) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  private String s = \"x\";\n"
        "  public int f(String s) { return s.length(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_id_block_shadow) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  public int f() {\n"
        "    String s = \"a\";\n"
        "    if (true) { String s2 = s.trim(); return s2.length(); }\n"
        "    return s.length();\n"
        "  }\n"
        "}");
    ASSERT_NOT_NULL(r);
    /* Both String.length and String.trim should appear. */
    ASSERT_GTE(cov_require(r, "f", "String.trim"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_id_outer_class_field) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  private String name = \"x\";\n"
        "  class Inner { public int f() { return name.length(); } }\n"
        "}");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_id_class_as_static) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { return Integer.MAX_VALUE; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_id_unresolved_emits_diagnostic) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { return undefined.size(); } }");
    ASSERT_NOT_NULL(r);
    int diag = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        if (r->resolved_calls.items[i].confidence == 0.0f) diag++;
    }
    ASSERT_GTE(diag, 1);
    cbm_free_result(r);
    PASS();
}
TEST(cov_id_for_loop_var) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main {\n"
        "  public int total(ArrayList<String> xs) {\n"
        "    int n = 0;\n"
        "    for (int i = 0; i < xs.size(); i++) n += xs.get(i).length();\n"
        "    return n;\n"
        "  }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "total", "ArrayList.size"), 0);
    ASSERT_GTE(cov_require(r, "total", "ArrayList.get"), 0);
    ASSERT_GTE(cov_require(r, "total", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 6. Field access ─────────────────────────────────────────────── */

TEST(cov_fa_system_out) {
    CBMFileResult *r = cov_extract(
        "public class Main { public void f() { System.out.println(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "PrintStream.println"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fa_system_err) {
    CBMFileResult *r = cov_extract(
        "public class Main { public void f() { System.err.println(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "PrintStream.println"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fa_array_length) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(int[] xs) { return xs.length; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fa_chained_field_method) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class Box { public String s = \"x\"; }\n"
        "  public int f(Box b) { return b.s.length(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fa_this_field) {
    CBMFileResult *r = cov_extract(
        "public class Main { private String s = \"x\"; public int f() { return this.s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fa_static_class_field) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f() { return Integer.MAX_VALUE; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fa_method_then_field) {
    CBMFileResult *r =
        cov_extract("import java.util.ArrayList;\n"
                    "public class Main { public int f(ArrayList<String> xs) { return xs.toArray().length; } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ArrayList.toArray"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fa_field_through_param) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class Bag { public String tag = \"x\"; }\n"
        "  public int f(Bag b) { return b.tag.length(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fa_field_through_chained_call) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A { public String tag = \"x\"; public A self() { return this; } }\n"
        "  public int f(A a) { return a.self().tag.length(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "self"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fa_unresolved_field_no_crash) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { return some.weird.thing.length; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

/* ── 7. Method invocation paths ──────────────────────────────────── */

TEST(cov_mi_bare_local) {
    CBMFileResult *r = cov_extract(
        "public class Main { String greet() { return \"hi\"; } public void f() { greet(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "greet"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_this) {
    CBMFileResult *r = cov_extract(
        "public class Main { String greet() { return \"\"; } public void f() { this.greet(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "greet"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_super) {
    CBMFileResult *r = cov_extract(
        "public class Main extends Object {\n"
        "  public String f() { return super.toString(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Object.toString"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_static) {
    CBMFileResult *r = cov_extract(
        "public class Main { public double f() { return Math.sqrt(4); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Math.sqrt"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_chained_static) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f() { return Integer.toBinaryString(Integer.parseInt(\"5\")); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Integer.toBinaryString"), 0);
    ASSERT_GTE(cov_require(r, "f", "Integer.parseInt"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_instance) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_chain_3hop) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { return s.trim().toUpperCase().length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.trim"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.toUpperCase"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_recursive_self) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int fact(int n) { return n <= 1 ? 1 : n * fact(n-1); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "fact", "fact"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_overload_by_arity) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  String fmt(String s) { return s; }\n"
        "  String fmt(String s, int i) { return s; }\n"
        "  public String f() { return fmt(\"a\") + fmt(\"b\", 1); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "fmt"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_param_chain) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { return s.toUpperCase().length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.toUpperCase"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_return_chain) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  String tag() { return \"x\"; }\n"
        "  public int f() { return tag().length(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_args_walked) {
    CBMFileResult *r = cov_extract(
        "import java.util.Objects;\n"
        "public class Main { public int f(String a, String b) { return Objects.hash(a.length(), b.trim()); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Objects.hash"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.trim"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_nested_args) {
    CBMFileResult *r = cov_extract(
        "public class Main { public double f() { return Math.max(Math.abs(-1), Math.sqrt(4)); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Math.max"), 0);
    ASSERT_GTE(cov_require(r, "f", "Math.abs"), 0);
    ASSERT_GTE(cov_require(r, "f", "Math.sqrt"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_through_field_getter) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class Box { public String getTag() { return \"x\"; } }\n"
        "  private Box b = new Box();\n"
        "  public int f() { return b.getTag().length(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "getTag"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mi_call_in_condition) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { if (s.isEmpty()) return 0; return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.isEmpty"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 8. Object creation paths ────────────────────────────────────── */

TEST(cov_oc_simple) {
    CBMFileResult *r = cov_extract(
        "public class Main { public StringBuilder f() { return new StringBuilder(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "StringBuilder"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_oc_with_args) {
    CBMFileResult *r =
        cov_extract("import java.util.ArrayList;\n"
                    "public class Main { public ArrayList<String> f() { return new ArrayList<>(10); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ArrayList"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_oc_diamond) {
    CBMFileResult *r =
        cov_extract("import java.util.HashMap;\n"
                    "public class Main { public HashMap<String,Integer> f() { return new HashMap<>(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashMap"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_oc_generic_explicit) {
    CBMFileResult *r =
        cov_extract("import java.util.ArrayList;\n"
                    "public class Main { public ArrayList<String> f() { return new ArrayList<String>(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ArrayList"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_oc_user_class) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class Box { public Box() {} }\n"
        "  public Box f() { return new Box(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Box"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_oc_with_chained_method) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f() { return new StringBuilder().append(\"x\").toString(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "StringBuilder.append"), 0);
    ASSERT_GTE(cov_require(r, "f", "StringBuilder.toString"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_oc_array) {
    CBMFileResult *r =
        cov_extract("public class Main { public int[] f() { return new int[10]; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_oc_array_init) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int[] f() { int[] xs = {1,2,3}; return xs; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

/* ── 9. Cast / instanceof ────────────────────────────────────────── */

TEST(cov_cast_to_string) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(Object o) { return ((String)o).length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_cast_chained) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(Object o) { return ((String)((Object)o)).length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_cast_primitive) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f(double d) { return (int) d; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_instanceof_basic) {
    CBMFileResult *r =
        cov_extract("public class Main { public boolean f(Object o) { return o instanceof String; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_cast_from_iterator) {
    CBMFileResult *r =
        cov_extract("import java.util.Iterator;\n"
                    "public class Main { public int f(Iterator<Object> it) {\n"
                    "  return ((String) it.next()).length();\n"
                    "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_cast_arr_elem) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(Object[] xs) { return ((String)xs[0]).length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_cast_in_ternary) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(Object o, boolean b) { return b ? ((String)o).length() : 0; } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_cast_then_chain) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f(Object o) { return ((String)o).toUpperCase().trim(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.toUpperCase"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.trim"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 10. Generic substitution table coverage ─────────────────────── */

TEST(cov_gen_list_get) {
    CBMFileResult *r = cov_extract(
        "import java.util.List;\n"
        "public class Main { public int f(List<String> xs) { return xs.get(0).length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_arraylist_get) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public int f(ArrayList<String> xs) { return xs.get(0).length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_linkedlist_first) {
    CBMFileResult *r = cov_extract(
        "import java.util.LinkedList;\n"
        "public class Main { public int f(LinkedList<String> xs) { return xs.getFirst().length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_set_iterator_next) {
    CBMFileResult *r = cov_extract(
        "import java.util.Set;\n"
        "import java.util.Iterator;\n"
        "public class Main { public int f(Set<String> s) {\n"
        "  Iterator<String> it = s.iterator();\n"
        "  return it.next().length();\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Iterator.next"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_map_get) {
    CBMFileResult *r = cov_extract(
        "import java.util.Map;\n"
        "public class Main { public int f(Map<String,String> m) { return m.get(\"k\").length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_hashmap_get) {
    CBMFileResult *r = cov_extract(
        "import java.util.HashMap;\n"
        "public class Main { public int f(HashMap<String,String> m) { return m.get(\"k\").length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_optional_orElse) {
    CBMFileResult *r = cov_extract(
        "import java.util.Optional;\n"
        "public class Main { public int f(Optional<String> o) { return o.orElse(\"\").length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_optional_get) {
    CBMFileResult *r = cov_extract(
        "import java.util.Optional;\n"
        "public class Main { public int f(Optional<String> o) { return o.get().length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_iterator_next_chain) {
    CBMFileResult *r = cov_extract(
        "import java.util.Iterator;\n"
        "public class Main { public int f(Iterator<String> it) { return it.next().length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_function_apply) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Function;\n"
        "public class Main { public int f(Function<String,String> fn, String s) { return fn.apply(s).length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_supplier_get) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Supplier;\n"
        "public class Main { public int f(Supplier<String> sup) { return sup.get().length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_bifunction_apply) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.BiFunction;\n"
        "public class Main { public int f(BiFunction<String,Integer,String> fn, String s) {\n"
        "  return fn.apply(s, 1).length();\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_map_keyset) {
    CBMFileResult *r = cov_extract(
        "import java.util.HashMap;\n"
        "import java.util.Set;\n"
        "public class Main { public int f(HashMap<String,Integer> m) { return m.keySet().size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Set.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_map_values) {
    CBMFileResult *r = cov_extract(
        "import java.util.HashMap;\n"
        "public class Main { public int f(HashMap<String,Integer> m) { return m.values().size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Collection.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_gen_collection_iterator) {
    CBMFileResult *r = cov_extract(
        "import java.util.Collection;\n"
        "public class Main { public int f(Collection<String> c) { return c.iterator().next().length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 11. Lambda SAM inference table coverage ─────────────────────── */

TEST(cov_lambda_function) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Function;\n"
        "public class Main { public Function<String,Integer> f() { return s -> s.length(); } }");
    ASSERT_NOT_NULL(r);
    /* Standalone lambdas without a method-call context don't bind via SAM,
     * but the body should still be walked. */
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_predicate_filter) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public long f(ArrayList<String> xs) { return xs.stream().filter(s -> s.length() > 0).count(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_consumer_forEach) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public void f(ArrayList<String> xs) { xs.forEach(s -> { s.toUpperCase(); }); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.toUpperCase"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_function_map) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public Object f(ArrayList<String> xs) { return xs.stream().map(s -> s.trim()).count(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.trim"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_user_consumer) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Consumer;\n"
        "public class Main {\n"
        "  void run(Consumer<String> c) { c.accept(\"x\"); }\n"
        "  public void f() { run(s -> s.toUpperCase()); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.toUpperCase"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_user_function) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Function;\n"
        "public class Main {\n"
        "  Object run(Function<String,Integer> fn) { return fn.apply(\"x\"); }\n"
        "  public Object f() { return run(s -> s.length()); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_user_predicate) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Predicate;\n"
        "public class Main {\n"
        "  boolean run(Predicate<String> p) { return p.test(\"x\"); }\n"
        "  public boolean f() { return run(s -> s.isEmpty()); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.isEmpty"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_block_body) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public void f(ArrayList<String> xs) {\n"
        "  xs.forEach(s -> { String t = s.trim(); int n = t.length(); });\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.trim"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_bipredicate) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.BiPredicate;\n"
        "public class Main {\n"
        "  boolean run(BiPredicate<String,String> bp) { return bp.test(\"a\",\"b\"); }\n"
        "  public boolean f() { return run((a, b) -> a.equals(b)); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.equals"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_biconsumer_map) {
    CBMFileResult *r = cov_extract(
        "import java.util.HashMap;\n"
        "public class Main { public void f(HashMap<String,Integer> m) {\n"
        "  m.forEach((k, v) -> { k.length(); });\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_anyMatch) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public boolean f(ArrayList<String> xs) {\n"
        "  return xs.stream().anyMatch(s -> s.startsWith(\"x\"));\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.startsWith"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lambda_removeIf) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public void f(ArrayList<String> xs) {\n"
        "  xs.removeIf(s -> s.isEmpty());\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.isEmpty"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 12. Method references ───────────────────────────────────────── */

TEST(cov_mref_static) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public void f(ArrayList<String> xs) { xs.forEach(System.out::println); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "PrintStream.println"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mref_instance_method) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public Object f(ArrayList<String> xs) {\n"
        "  return xs.stream().map(String::toUpperCase).count();\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.toUpperCase"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mref_static_class_method) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public Object f(ArrayList<String> xs) {\n"
        "  return xs.stream().map(Integer::parseInt).count();\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Integer.parseInt"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mref_constructor_simple) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Function;\n"
        "public class Main { public Function<String, StringBuilder> f() { return StringBuilder::new; } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "StringBuilder"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mref_in_local_var) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Function;\n"
        "public class Main { public void f() { Function<String,Integer> g = String::length; } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mref_with_chain) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "import java.util.stream.Collectors;\n"
        "public class Main { public Object f(ArrayList<String> xs) {\n"
        "  return xs.stream().map(String::trim).collect(Collectors.toList());\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.trim"), 0);
    ASSERT_GTE(cov_require(r, "f", "Collectors.toList"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mref_user_class) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Function;\n"
        "public class Main {\n"
        "  static class U { public String tag() { return \"x\"; } }\n"
        "  public Function<U,String> f() { return U::tag; }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_mref_user_constructor) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Supplier;\n"
        "public class Main {\n"
        "  static class Box { public Box() {} }\n"
        "  public Supplier<Box> f() { return Box::new; }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Box"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 13. Inheritance walking ─────────────────────────────────────── */

TEST(cov_inh_basic) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A { public String tag() { return \"a\"; } }\n"
        "  static class B extends A { public String f(B b) { return b.tag(); } }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_inh_3level) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A { public String tag() { return \"a\"; } }\n"
        "  static class B extends A {}\n"
        "  static class C extends B { public String f(C c) { return c.tag(); } }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_inh_4level) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A { public String tag() { return \"a\"; } }\n"
        "  static class B extends A {}\n"
        "  static class C extends B {}\n"
        "  static class D extends C { public String f(D d) { return d.tag(); } }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_inh_override) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A { public String tag() { return \"a\"; } }\n"
        "  static class B extends A {\n"
        "    public String tag() { return \"b\"; }\n"
        "    public String f(B b) { return b.tag(); }\n"
        "  }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_inh_super_after_override) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A { public String tag() { return \"a\"; } }\n"
        "  static class B extends A {\n"
        "    public String tag() { return super.tag(); }\n"
        "  }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "tag", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_inh_via_object) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A {}\n"
        "  public String f(A a) { return a.toString(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Object.toString"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_inh_interface_default) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  interface Greet { default String hello() { return \"hi\"; } }\n"
        "  static class Impl implements Greet { public String f() { return hello(); } }\n"
        "}");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_inh_interface_via_param) {
    CBMFileResult *r = cov_extract(
        "import java.util.List;\n"
        "public class Main { public int f(List<String> xs) { return xs.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "List.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_inh_collection_to_list) {
    CBMFileResult *r = cov_extract(
        "import java.util.Collection;\n"
        "public class Main { public int f(Collection<String> c) { return c.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Collection.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_inh_list_iterable_iterator) {
    CBMFileResult *r = cov_extract(
        "import java.util.List;\n"
        "public class Main { public int f(List<String> xs) { return xs.iterator().next().length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Iterator.next"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 14. java.lang stdlib coverage ───────────────────────────────── */

TEST(cov_lang_object_hashCode) {
    CBMFileResult *r =
        cov_extract("public class Main { public int f(Object o) { return o.hashCode(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Object.hashCode"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_object_equals) {
    CBMFileResult *r = cov_extract(
        "public class Main { public boolean f(Object a, Object b) { return a.equals(b); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Object.equals"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_object_getClass) {
    CBMFileResult *r =
        cov_extract("public class Main { public Class<?> f(Object o) { return o.getClass(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Object.getClass"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_string_repeat) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f() { return \"x\".repeat(3); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.repeat"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_string_split) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String[] f(String s) { return s.split(\",\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.split"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_string_indexOf) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { return s.indexOf('a'); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.indexOf"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_string_substring) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f(String s) { return s.substring(1, 3); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.substring"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_math_pow) {
    CBMFileResult *r = cov_extract(
        "public class Main { public double f() { return Math.pow(2, 10); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Math.pow"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_math_log) {
    CBMFileResult *r =
        cov_extract("public class Main { public double f() { return Math.log(2.0); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Math.log"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_math_random) {
    CBMFileResult *r =
        cov_extract("public class Main { public double f() { return Math.random(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Math.random"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_system_nano) {
    CBMFileResult *r = cov_extract(
        "public class Main { public long f() { return System.nanoTime(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "System.nanoTime"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_system_getenv) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f() { return System.getenv(\"X\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "System.getenv"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_thread_sleep) {
    CBMFileResult *r = cov_extract(
        "public class Main { public void f() throws InterruptedException { Thread.sleep(1); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Thread.sleep"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_class_forName) {
    CBMFileResult *r = cov_extract(
        "public class Main { public Class<?> f() throws ClassNotFoundException { return Class.forName(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Class.forName"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_lang_throwable_getCause) {
    CBMFileResult *r = cov_extract(
        "public class Main { public Throwable f(Throwable t) { return t.getCause(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Throwable.getCause"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 15. java.util stdlib coverage ───────────────────────────────── */

TEST(cov_util_arraylist_add) {
    CBMFileResult *r =
        cov_extract("import java.util.ArrayList;\n"
                    "public class Main { public void f(ArrayList<String> xs) { xs.add(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ArrayList.add"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_arraylist_remove) {
    CBMFileResult *r =
        cov_extract("import java.util.ArrayList;\n"
                    "public class Main { public void f(ArrayList<String> xs) { xs.remove(0); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ArrayList.remove"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_linkedlist_addFirst) {
    CBMFileResult *r =
        cov_extract("import java.util.LinkedList;\n"
                    "public class Main { public void f(LinkedList<String> xs) { xs.addFirst(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "LinkedList.addFirst"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_hashset_add) {
    CBMFileResult *r =
        cov_extract("import java.util.HashSet;\n"
                    "public class Main { public boolean f(HashSet<String> s) { return s.add(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashSet.add"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_treeset_first) {
    CBMFileResult *r =
        cov_extract("import java.util.TreeSet;\n"
                    "public class Main { public Object f(TreeSet<String> s) { return s.first(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "TreeSet.first"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_hashmap_put) {
    CBMFileResult *r =
        cov_extract("import java.util.HashMap;\n"
                    "public class Main { public void f(HashMap<String,Integer> m) { m.put(\"k\", 1); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashMap.put"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_treemap_firstKey) {
    CBMFileResult *r =
        cov_extract("import java.util.TreeMap;\n"
                    "public class Main { public Object f(TreeMap<String,Integer> m) { return m.firstKey(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "TreeMap.firstKey"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_arrays_sort) {
    CBMFileResult *r =
        cov_extract("import java.util.Arrays;\n"
                    "public class Main { public void f(int[] xs) { Arrays.sort(xs); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Arrays.sort"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_collections_unmodifiable) {
    CBMFileResult *r =
        cov_extract("import java.util.Collections;\n"
                    "import java.util.List;\n"
                    "public class Main { public List<String> f(List<String> xs) { return Collections.unmodifiableList(xs); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Collections.unmodifiableList"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_objects_isNull) {
    CBMFileResult *r = cov_extract(
        "import java.util.Objects;\n"
        "public class Main { public boolean f(Object o) { return Objects.isNull(o); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Objects.isNull"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_optional_isPresent) {
    CBMFileResult *r = cov_extract(
        "import java.util.Optional;\n"
        "public class Main { public boolean f(Optional<String> o) { return o.isPresent(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Optional.isPresent"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_optional_map) {
    CBMFileResult *r = cov_extract(
        "import java.util.Optional;\n"
        "public class Main { public Object f(Optional<String> o) { return o.map(s -> s.length()); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Optional.map"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_uuid_random) {
    CBMFileResult *r = cov_extract(
        "import java.util.UUID;\n"
        "public class Main { public String f() { return UUID.randomUUID().toString(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "UUID.randomUUID"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_random_nextInt) {
    CBMFileResult *r = cov_extract(
        "import java.util.Random;\n"
        "public class Main { public int f(Random r) { return r.nextInt(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Random.nextInt"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_util_scanner_nextLine) {
    CBMFileResult *r = cov_extract(
        "import java.util.Scanner;\n"
        "public class Main { public String f(Scanner s) { return s.nextLine(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Scanner.nextLine"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 16. java.io stdlib ──────────────────────────────────────────── */

TEST(cov_io_print_writer) {
    CBMFileResult *r = cov_extract(
        "import java.io.PrintWriter;\n"
        "public class Main { public void f(PrintWriter w) { w.println(\"x\"); w.flush(); w.close(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "PrintWriter.println"), 0);
    ASSERT_GTE(cov_require(r, "f", "PrintWriter.flush"), 0);
    ASSERT_GTE(cov_require(r, "f", "PrintWriter.close"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_io_input_stream_read) {
    CBMFileResult *r = cov_extract(
        "import java.io.InputStream;\n"
        "public class Main { public int f(InputStream in) throws java.io.IOException { return in.read(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "InputStream.read"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_io_output_stream_write) {
    CBMFileResult *r = cov_extract(
        "import java.io.OutputStream;\n"
        "public class Main { public void f(OutputStream o) throws java.io.IOException { o.write(1); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "OutputStream.write"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_io_buffered_writer) {
    CBMFileResult *r = cov_extract(
        "import java.io.BufferedWriter;\n"
        "public class Main { public void f(BufferedWriter w) throws java.io.IOException {\n"
        "  w.write(\"x\"); w.newLine(); w.flush();\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "BufferedWriter.newLine"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_io_file_construction) {
    CBMFileResult *r = cov_extract(
        "import java.io.File;\n"
        "public class Main { public File f() { return new File(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "File"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_io_file_listFiles) {
    CBMFileResult *r = cov_extract(
        "import java.io.File;\n"
        "public class Main { public File[] f(File d) { return d.listFiles(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "File.listFiles"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_io_file_canRead) {
    CBMFileResult *r = cov_extract(
        "import java.io.File;\n"
        "public class Main { public boolean f(File d) { return d.canRead(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "File.canRead"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_io_file_to_path) {
    CBMFileResult *r = cov_extract(
        "import java.io.File;\n"
        "public class Main { public java.nio.file.Path f(File d) { return d.toPath(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "File.toPath"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_io_reader_ready) {
    CBMFileResult *r = cov_extract(
        "import java.io.Reader;\n"
        "public class Main { public boolean f(Reader r) throws java.io.IOException { return r.ready(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Reader.ready"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_io_writer_close) {
    CBMFileResult *r = cov_extract(
        "import java.io.Writer;\n"
        "public class Main { public void f(Writer w) throws java.io.IOException { w.close(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Writer.close"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 17. java.nio.file ──────────────────────────────────────────── */

TEST(cov_nio_path_resolve) {
    CBMFileResult *r = cov_extract(
        "import java.nio.file.Path;\n"
        "public class Main { public Path f(Path p) { return p.resolve(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Path.resolve"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nio_path_getFileName) {
    CBMFileResult *r = cov_extract(
        "import java.nio.file.Path;\n"
        "public class Main { public Path f(Path p) { return p.getFileName(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Path.getFileName"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nio_files_exists) {
    CBMFileResult *r = cov_extract(
        "import java.nio.file.Files;\n"
        "import java.nio.file.Path;\n"
        "public class Main { public boolean f(Path p) { return Files.exists(p); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Files.exists"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nio_files_walk) {
    CBMFileResult *r = cov_extract(
        "import java.nio.file.Files;\n"
        "import java.nio.file.Path;\n"
        "public class Main { public Object f(Path p) throws java.io.IOException { return Files.walk(p); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Files.walk"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nio_files_lines) {
    CBMFileResult *r = cov_extract(
        "import java.nio.file.Files;\n"
        "import java.nio.file.Path;\n"
        "public class Main { public Object f(Path p) throws java.io.IOException { return Files.lines(p); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Files.lines"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 18. java.util.stream ────────────────────────────────────────── */

TEST(cov_stream_sorted) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public Object f(ArrayList<String> xs) { return xs.stream().sorted().count(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Stream.sorted"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_stream_distinct) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public Object f(ArrayList<String> xs) { return xs.stream().distinct().count(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Stream.distinct"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_stream_limit) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public Object f(ArrayList<String> xs) { return xs.stream().limit(5).count(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Stream.limit"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_stream_skip) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public Object f(ArrayList<String> xs) { return xs.stream().skip(2).count(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Stream.skip"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_stream_min) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public Object f(ArrayList<String> xs) { return xs.stream().min((a,b) -> a.compareTo(b)); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Stream.min"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_stream_findFirst) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public Object f(ArrayList<String> xs) { return xs.stream().findFirst(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Stream.findFirst"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_stream_allMatch) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public boolean f(ArrayList<String> xs) { return xs.stream().allMatch(s -> s.length() > 0); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Stream.allMatch"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_stream_collect_toSet) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "import java.util.stream.Collectors;\n"
        "public class Main { public Object f(ArrayList<String> xs) { return xs.stream().collect(Collectors.toSet()); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Collectors.toSet"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_stream_collect_groupingBy) {
    /* The lambda inside Collectors.groupingBy is typed via Function<? super
     * T, ? extends K>, where T comes from the OUTER stream's element type
     * — that bidirectional flow isn't currently modeled (the LSP looks at
     * the static method's static signature only). Resolving Collectors.
     * groupingBy itself is the test we keep; lambda body resolution is a
     * known gap. */
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "import java.util.stream.Collectors;\n"
        "public class Main { public Object f(ArrayList<String> xs) {\n"
        "  return xs.stream().collect(Collectors.groupingBy(s -> s.length()));\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Collectors.groupingBy"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_intstream_range) {
    CBMFileResult *r = cov_extract(
        "import java.util.stream.IntStream;\n"
        "public class Main { public int f() { return IntStream.range(0, 10).sum(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "IntStream.range"), 0);
    ASSERT_GTE(cov_require(r, "f", "IntStream.sum"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 19. java.util.function ──────────────────────────────────────── */

TEST(cov_fn_unaryoperator) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.UnaryOperator;\n"
        "public class Main { public Object f(UnaryOperator<String> op) { return op.apply(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "UnaryOperator.apply"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fn_binaryoperator) {
    /* BinaryOperator<T> extends BiFunction<T,T,T>, so apply() resolves to
     * BiFunction.apply (correct per JLS §8.4.8). Either callee is OK. */
    CBMFileResult *r = cov_extract(
        "import java.util.function.BinaryOperator;\n"
        "public class Main { public Object f(BinaryOperator<String> op) { return op.apply(\"x\", \"y\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "apply"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fn_consumer_andThen) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Consumer;\n"
        "public class Main { public Object f(Consumer<String> c1, Consumer<String> c2) { return c1.andThen(c2); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Consumer.andThen"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fn_predicate_and) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Predicate;\n"
        "public class Main { public Object f(Predicate<String> p1, Predicate<String> p2) { return p1.and(p2); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Predicate.and"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fn_predicate_negate) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Predicate;\n"
        "public class Main { public Object f(Predicate<String> p) { return p.negate(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Predicate.negate"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fn_function_andThen) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.Function;\n"
        "public class Main { public Object f(Function<String,Integer> f1, Function<Integer,String> f2) {\n"
        "  return f1.andThen(f2);\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Function.andThen"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fn_intpredicate) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.IntPredicate;\n"
        "public class Main { public boolean f(IntPredicate p) { return p.test(1); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "IntPredicate.test"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fn_toint_function) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.ToIntFunction;\n"
        "public class Main { public int f(ToIntFunction<String> fn) { return fn.applyAsInt(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ToIntFunction.applyAsInt"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fn_int_supplier) {
    CBMFileResult *r = cov_extract(
        "import java.util.function.IntSupplier;\n"
        "public class Main { public int f(IntSupplier s) { return s.getAsInt(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "IntSupplier.getAsInt"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_fn_runnable) {
    CBMFileResult *r = cov_extract(
        "public class Main { public void f(Runnable r) { r.run(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Runnable.run"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 20. java.util.concurrent ───────────────────────────────────── */

TEST(cov_conc_atomic_get) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.atomic.AtomicInteger;\n"
        "public class Main { public int f(AtomicInteger a) { return a.get(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "AtomicInteger.get"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_conc_atomic_compareAndSet) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.atomic.AtomicInteger;\n"
        "public class Main { public boolean f(AtomicInteger a) { return a.compareAndSet(0, 1); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "AtomicInteger.compareAndSet"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_conc_atomic_long) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.atomic.AtomicLong;\n"
        "public class Main { public long f(AtomicLong a) { return a.incrementAndGet(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "AtomicLong.incrementAndGet"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_conc_atomic_reference) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.atomic.AtomicReference;\n"
        "public class Main { public Object f(AtomicReference<String> a) { return a.get(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "AtomicReference.get"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_conc_executor_singleThread) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.ExecutorService;\n"
        "import java.util.concurrent.Executors;\n"
        "public class Main { public ExecutorService f() { return Executors.newSingleThreadExecutor(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Executors.newSingleThreadExecutor"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_conc_executor_cached) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.ExecutorService;\n"
        "import java.util.concurrent.Executors;\n"
        "public class Main { public ExecutorService f() { return Executors.newCachedThreadPool(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Executors.newCachedThreadPool"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_conc_future_get) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.Future;\n"
        "public class Main { public Object f(Future<String> fut) throws Exception { return fut.get(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Future.get"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_conc_completable_supplyAsync) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.CompletableFuture;\n"
        "public class Main { public CompletableFuture<String> f() {\n"
        "  return CompletableFuture.supplyAsync(() -> \"x\");\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "CompletableFuture.supplyAsync"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_conc_concurrent_hashmap) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.ConcurrentHashMap;\n"
        "public class Main { public Object f(ConcurrentHashMap<String,Integer> m) { return m.get(\"k\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ConcurrentHashMap.get"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_conc_reentrant_lock) {
    CBMFileResult *r = cov_extract(
        "import java.util.concurrent.locks.ReentrantLock;\n"
        "public class Main { public void f(ReentrantLock l) { l.lock(); l.unlock(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ReentrantLock.lock"), 0);
    ASSERT_GTE(cov_require(r, "f", "ReentrantLock.unlock"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 21. java.time ───────────────────────────────────────────────── */

TEST(cov_time_localdate_plus) {
    CBMFileResult *r = cov_extract(
        "import java.time.LocalDate;\n"
        "public class Main { public LocalDate f(LocalDate d) { return d.plusDays(1); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "LocalDate.plusDays"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_time_localdate_isAfter) {
    CBMFileResult *r = cov_extract(
        "import java.time.LocalDate;\n"
        "public class Main { public boolean f(LocalDate a, LocalDate b) { return a.isAfter(b); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "LocalDate.isAfter"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_time_localdatetime_now) {
    CBMFileResult *r = cov_extract(
        "import java.time.LocalDateTime;\n"
        "public class Main { public LocalDateTime f() { return LocalDateTime.now(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "LocalDateTime.now"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_time_instant_now) {
    CBMFileResult *r = cov_extract(
        "import java.time.Instant;\n"
        "public class Main { public Instant f() { return Instant.now(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Instant.now"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_time_duration_between) {
    CBMFileResult *r = cov_extract(
        "import java.time.Duration;\n"
        "import java.time.Instant;\n"
        "public class Main { public Duration f(Instant a, Instant b) { return Duration.between(a, b); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Duration.between"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_time_duration_minutes) {
    CBMFileResult *r = cov_extract(
        "import java.time.Duration;\n"
        "public class Main { public long f(Duration d) { return d.toMinutes(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Duration.toMinutes"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_time_zoneid_systemDefault) {
    CBMFileResult *r = cov_extract(
        "import java.time.ZoneId;\n"
        "public class Main { public ZoneId f() { return ZoneId.systemDefault(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ZoneId.systemDefault"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_time_localdate_format) {
    CBMFileResult *r = cov_extract(
        "import java.time.LocalDate;\n"
        "import java.time.format.DateTimeFormatter;\n"
        "public class Main { public String f(LocalDate d, DateTimeFormatter fmt) { return d.format(fmt); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "LocalDate.format"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_time_formatter_ofPattern) {
    CBMFileResult *r = cov_extract(
        "import java.time.format.DateTimeFormatter;\n"
        "public class Main { public DateTimeFormatter f() { return DateTimeFormatter.ofPattern(\"yyyy\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "DateTimeFormatter.ofPattern"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_time_localdate_parse) {
    CBMFileResult *r = cov_extract(
        "import java.time.LocalDate;\n"
        "public class Main { public LocalDate f(String s) { return LocalDate.parse(s); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "LocalDate.parse"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 22. Imports ─────────────────────────────────────────────────── */

TEST(cov_imp_single_type) {
    CBMFileResult *r = cov_extract(
        "import java.util.HashMap;\n"
        "public class Main { public int f(HashMap<String,Integer> m) { return m.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashMap.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_imp_on_demand) {
    CBMFileResult *r = cov_extract(
        "import java.util.*;\n"
        "public class Main { public int f(HashMap<String,Integer> m) { return m.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashMap.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_imp_static_method) {
    CBMFileResult *r = cov_extract(
        "import static java.lang.Math.sqrt;\n"
        "public class Main { public double f() { return sqrt(2); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Math.sqrt"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_imp_static_on_demand) {
    CBMFileResult *r = cov_extract(
        "import static java.lang.Math.*;\n"
        "public class Main { public double f() { return PI; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_imp_multiple) {
    CBMFileResult *r = cov_extract(
        "import java.util.HashMap;\n"
        "import java.util.ArrayList;\n"
        "import java.util.List;\n"
        "public class Main {\n"
        "  public int f(HashMap<String,List<String>> m) { return m.size(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashMap.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_imp_qualified_no_import) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(java.util.HashMap<String,Integer> m) { return m.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "HashMap.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_imp_with_package) {
    CBMFileResult *r = cov_extract(
        "package com.example;\n"
        "import java.util.ArrayList;\n"
        "public class Main { public int f(ArrayList<String> xs) { return xs.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ArrayList.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_imp_chained_packages) {
    CBMFileResult *r = cov_extract(
        "package a.b.c;\n"
        "import java.util.concurrent.atomic.AtomicInteger;\n"
        "public class Main { public int f(AtomicInteger a) { return a.get(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "AtomicInteger.get"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 23. Inner / nested types ────────────────────────────────────── */

TEST(cov_nest_static_inner) {
    CBMFileResult *r = cov_extract(
        "public class Main { static class A { String tag() { return \"a\"; } }\n"
        "  public String f() { return new A().tag(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nest_inner_3level) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class A { static class B { static class C { String tag() { return \"c\"; } } } }\n"
        "  public String f() { return new Main.A.B.C().tag(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nest_interface) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  interface I { String tag(); }\n"
        "  static class A implements I { public String tag() { return \"a\"; } }\n"
        "  public String f() { I x = new A(); return x.tag(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nest_enum) {
    CBMFileResult *r = cov_extract(
        "public class Main { enum Color { RED, GREEN, BLUE } public Color f() { return Color.RED; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nest_static_field) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class K { static String NAME = \"x\"; }\n"
        "  public int f() { return K.NAME.length(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nest_outer_method_from_inner) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  String greet() { return \"hi\"; }\n"
        "  class Inner { public String f() { return greet(); } }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "greet"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nest_outer_field_from_inner) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  private String tag = \"x\";\n"
        "  class Inner { public int f() { return tag.length(); } }\n"
        "}");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nest_record) {
    CBMFileResult *r = cov_extract(
        "public class Main { public record Point(int x, int y) {} public int f() { return new Point(1,2).x(); } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nest_static_member_access) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class Util { static String tag() { return \"u\"; } }\n"
        "  public String f() { return Util.tag(); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "tag"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_nest_constructor_call) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  static class Item { public Item(String s) {} }\n"
        "  public Item f() { return new Item(\"x\"); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Item"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 24. Variable / scope binding ────────────────────────────────── */

TEST(cov_bind_local_int) {
    CBMFileResult *r = cov_extract(
        "public class Main { public void f() { int a = 1; a++; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_bind_var_string) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { var s = \"x\"; return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_bind_var_arraylist) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public int f() { var xs = new ArrayList<String>(); xs.add(\"x\"); return xs.size(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ArrayList.add"), 0);
    ASSERT_GTE(cov_require(r, "f", "ArrayList.size"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_bind_multi_decl) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { int a = 1, b = 2, c = 3; return a + b + c; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_bind_final_local) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { final String s = \"x\"; return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_bind_for_loop_init) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { int n = 0; for (int i = 0; i < 10; i++) n++; return n; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_bind_enhanced_for_array) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String[] xs) { int n = 0; for (String s : xs) n += s.length(); return n; } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_bind_enhanced_for_iterable) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public int f(ArrayList<String> xs) { int n = 0; for (String s : xs) n += s.length(); return n; } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_bind_catch_param) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f() {\n"
        "  try { return Integer.toString(Integer.parseInt(\"x\")); }\n"
        "  catch (NumberFormatException e) { return e.getMessage(); }\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Throwable.getMessage"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_bind_try_resources) {
    CBMFileResult *r = cov_extract(
        "import java.io.BufferedReader;\n"
        "import java.io.FileReader;\n"
        "public class Main { public String f(String path) throws java.io.IOException {\n"
        "  try (BufferedReader br = new BufferedReader(new FileReader(path))) { return br.readLine(); }\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "BufferedReader.readLine"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 25. Control flow ─────────────────────────────────────────────── */

TEST(cov_ctrl_if_call) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { if (s.isEmpty()) return 0; else return s.length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.isEmpty"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_ctrl_for_call) {
    CBMFileResult *r = cov_extract(
        "import java.util.ArrayList;\n"
        "public class Main { public int f(ArrayList<String> xs) {\n"
        "  int n = 0;\n"
        "  for (int i = 0; i < xs.size(); i++) n += xs.get(i).length();\n"
        "  return n;\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "ArrayList.size"), 0);
    ASSERT_GTE(cov_require(r, "f", "ArrayList.get"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_ctrl_while_call) {
    CBMFileResult *r = cov_extract(
        "import java.util.Iterator;\n"
        "public class Main { public int f(Iterator<String> it) {\n"
        "  int n = 0;\n"
        "  while (it.hasNext()) n += it.next().length();\n"
        "  return n;\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Iterator.hasNext"), 0);
    ASSERT_GTE(cov_require(r, "f", "Iterator.next"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_ctrl_do_while) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { int n = 0; do { n++; } while (n < s.length()); return n; } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_ctrl_switch_basic) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f(int x) {\n"
        "  switch (x) {\n"
        "    case 1: return \"one\".toUpperCase();\n"
        "    case 2: return \"two\".trim();\n"
        "    default: return \"\";\n"
        "  }\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.toUpperCase"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.trim"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_ctrl_try_finally) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) {\n"
        "  try { return s.length(); }\n"
        "  finally { s.toString(); }\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_ctrl_try_multi_catch) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f() {\n"
        "  try { return Integer.toString(Integer.parseInt(\"x\")); }\n"
        "  catch (NumberFormatException | NullPointerException e) { return e.getMessage(); }\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "Throwable.getMessage"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_ctrl_throw_in_method) {
    CBMFileResult *r = cov_extract(
        "public class Main { public void f() throws IllegalStateException { throw new IllegalStateException(\"x\"); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "IllegalStateException"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_ctrl_break_continue_no_crash) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(int[] xs) {\n"
        "  int n = 0;\n"
        "  for (int x : xs) { if (x < 0) continue; if (x > 100) break; n++; }\n"
        "  return n;\n"
        "} }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_ctrl_synchronized) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(Object lock, String s) { synchronized(lock) { return s.length(); } } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── 26. Diagnostics ─────────────────────────────────────────────── */

TEST(cov_diag_unknown_method) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) { return s.nonexistentMethod(); } }");
    ASSERT_NOT_NULL(r);
    int diag = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        if (r->resolved_calls.items[i].confidence == 0.0f) diag++;
    }
    ASSERT_GTE(diag, 1);
    cbm_free_result(r);
    PASS();
}
TEST(cov_diag_unknown_var) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { return undef.size(); } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_diag_unresolved_count) {
    CBMFileResult *r = cov_extract(
        "public class Main { public void f() {\n"
        "  unknownObj1.unknownMethod1();\n"
        "  unknownObj2.unknownMethod2();\n"
        "} }");
    ASSERT_NOT_NULL(r);
    int diag = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        if (r->resolved_calls.items[i].confidence == 0.0f) diag++;
    }
    ASSERT_GTE(diag, 1);
    cbm_free_result(r);
    PASS();
}
TEST(cov_diag_no_resolved_no_calls) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { return 1 + 2; } }");
    ASSERT_NOT_NULL(r);
    /* No calls, no resolved entries. */
    int strict = cov_count_strict(r);
    ASSERT_EQ(strict, 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_diag_unresolved_super_no_match) {
    CBMFileResult *r = cov_extract(
        "public class Main { public String f() { return super.nonexistent(); } }");
    ASSERT_NOT_NULL(r);
    int diag = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        if (r->resolved_calls.items[i].confidence == 0.0f) diag++;
    }
    ASSERT_GTE(diag, 1);
    cbm_free_result(r);
    PASS();
}
TEST(cov_diag_method_ref_unknown_lhs) {
    CBMFileResult *r = cov_extract(
        "public class Main { public Object f() { return undefined::method; } }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}

/* ── 27. Cross-file API ──────────────────────────────────────────── */

TEST(cov_cross_basic) {
    const char *src =
        "package com.example;\n"
        "public class Caller { public String f(com.example.Greeter g) { return g.greet(\"x\"); } }";
    CBMArena arena;
    cbm_arena_init(&arena);
    CBMResolvedCallArray out;
    memset(&out, 0, sizeof(out));
    CBMLSPDef defs[2];
    memset(defs, 0, sizeof(defs));
    defs[0].qualified_name = "com.example.Greeter";
    defs[0].short_name = "Greeter";
    defs[0].label = "Class";
    defs[0].def_module_qn = "com.example";
    defs[1].qualified_name = "com.example.Greeter.greet";
    defs[1].short_name = "greet";
    defs[1].label = "Method";
    defs[1].receiver_type = "com.example.Greeter";
    defs[1].return_types = "java.lang.String";
    const char *imp_names[] = {"Greeter"};
    const char *imp_qns[] = {"com.example.Greeter"};
    cbm_run_java_lsp_cross(&arena, src, (int)strlen(src), "test.com.example", defs, 2, imp_names,
                           imp_qns, 1, NULL, &out);
    int found = 0;
    for (int i = 0; i < out.count; i++) {
        if (out.items[i].confidence < 0.5f) continue;
        if (out.items[i].callee_qn && strstr(out.items[i].callee_qn, "Greeter.greet")) found = 1;
    }
    ASSERT_EQ(found, 1);
    cbm_arena_destroy(&arena);
    PASS();
}
TEST(cov_cross_no_imports) {
    const char *src = "public class A { public int f() { return 1; } }";
    CBMArena arena;
    cbm_arena_init(&arena);
    CBMResolvedCallArray out;
    memset(&out, 0, sizeof(out));
    cbm_run_java_lsp_cross(&arena, src, (int)strlen(src), "test.A", NULL, 0, NULL, NULL, 0, NULL, &out);
    /* Just a smoke test — no calls, no edges. */
    cbm_arena_destroy(&arena);
    PASS();
}
TEST(cov_cross_batch) {
    const char *src1 = "package p; public class A { public int f() { return 1; } }";
    const char *src2 = "package p; public class B { public int f() { return 2; } }";
    CBMArena arena;
    cbm_arena_init(&arena);
    CBMBatchJavaLSPFile files[2];
    memset(files, 0, sizeof(files));
    files[0].source = src1;
    files[0].source_len = (int)strlen(src1);
    files[0].module_qn = "test.A";
    files[1].source = src2;
    files[1].source_len = (int)strlen(src2);
    files[1].module_qn = "test.B";
    CBMResolvedCallArray outs[2];
    memset(outs, 0, sizeof(outs));
    cbm_batch_java_lsp_cross(&arena, files, 2, outs);
    cbm_arena_destroy(&arena);
    PASS();
}
TEST(cov_cross_inheritance) {
    const char *src =
        "package x;\n"
        "public class B { public String f(x.A a) { return a.tag(); } }";
    CBMArena arena;
    cbm_arena_init(&arena);
    CBMResolvedCallArray out;
    memset(&out, 0, sizeof(out));
    CBMLSPDef defs[2];
    memset(defs, 0, sizeof(defs));
    defs[0].qualified_name = "x.A";
    defs[0].short_name = "A";
    defs[0].label = "Class";
    defs[1].qualified_name = "x.A.tag";
    defs[1].short_name = "tag";
    defs[1].label = "Method";
    defs[1].receiver_type = "x.A";
    defs[1].return_types = "java.lang.String";
    cbm_run_java_lsp_cross(&arena, src, (int)strlen(src), "test.B", defs, 2, NULL, NULL, 0, NULL, &out);
    int found = 0;
    for (int i = 0; i < out.count; i++) {
        if (out.items[i].confidence < 0.5f) continue;
        if (out.items[i].callee_qn && strstr(out.items[i].callee_qn, "A.tag")) found = 1;
    }
    ASSERT_EQ(found, 1);
    cbm_arena_destroy(&arena);
    PASS();
}

/* ── 28. Stress / edge cases ─────────────────────────────────────── */

TEST(cov_edge_empty_method) {
    CBMFileResult *r = cov_extract("public class Main { public void f() {} }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_edge_empty_class) {
    CBMFileResult *r = cov_extract("public class Main {}");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_edge_long_chain) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) {\n"
        "  return s.trim().toLowerCase().toUpperCase().substring(0).length();\n"
        "} }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.trim"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.toLowerCase"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.toUpperCase"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.substring"), 0);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_edge_recursive_user_method) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int fib(int n) { return n < 2 ? n : fib(n-1) + fib(n-2); } }");
    ASSERT_NOT_NULL(r);
    int fib_count = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        if (rc->confidence >= 0.5f && rc->callee_qn && strstr(rc->callee_qn, "fib")) fib_count++;
    }
    ASSERT_GTE(fib_count, 2);
    cbm_free_result(r);
    PASS();
}
TEST(cov_edge_mutual_recursion) {
    CBMFileResult *r = cov_extract(
        "public class Main {\n"
        "  public boolean isEven(int n) { return n == 0 || isOdd(n-1); }\n"
        "  public boolean isOdd(int n) { return n != 0 && isEven(n-1); }\n"
        "}");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "isEven", "isOdd"), 0);
    ASSERT_GTE(cov_require(r, "isOdd", "isEven"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_edge_deeply_nested_blocks) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f(String s) {\n"
        "  if (s != null) {\n"
        "    if (!s.isEmpty()) {\n"
        "      if (s.length() > 5) {\n"
        "        return s.length();\n"
        "      }\n"
        "    }\n"
        "  }\n"
        "  return 0;\n"
        "} }");
    ASSERT_NOT_NULL(r);
    int len_calls = 0;
    for (int i = 0; i < r->resolved_calls.count; i++) {
        const CBMResolvedCall *rc = &r->resolved_calls.items[i];
        if (rc->confidence >= 0.5f && rc->callee_qn && strstr(rc->callee_qn, "String.length")) {
            len_calls++;
        }
    }
    ASSERT_GTE(len_calls, 2);
    cbm_free_result(r);
    PASS();
}
TEST(cov_edge_anonymous_class_no_crash) {
    CBMFileResult *r = cov_extract(
        "public class Main { public Runnable f() {\n"
        "  return new Runnable() { public void run() { System.out.println(\"x\"); } };\n"
        "} }");
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_edge_unicode_string) {
    CBMFileResult *r = cov_extract(
        "public class Main { public int f() { return \"\\u00e9\".length(); } }");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}
TEST(cov_edge_huge_class_no_crash) {
    char buf[8192];
    int len = snprintf(buf, sizeof(buf), "public class Main {\n");
    for (int i = 0; i < 50 && len < (int)sizeof(buf) - 200; i++) {
        len += snprintf(buf + len, sizeof(buf) - len,
                         "  public int m%d(int x) { return x + %d; }\n", i, i);
    }
    snprintf(buf + len, sizeof(buf) - len, "}\n");
    CBMFileResult *r = cov_extract(buf);
    ASSERT_NOT_NULL(r);
    cbm_free_result(r);
    PASS();
}
TEST(cov_edge_unusual_whitespace) {
    CBMFileResult *r = cov_extract(
        "public  class   Main {\npublic\tint    f(String\ts) { return s.length(); }\n}\n");
    ASSERT_NOT_NULL(r);
    ASSERT_GTE(cov_require(r, "f", "String.length"), 0);
    cbm_free_result(r);
    PASS();
}

/* ── Suite registration ──────────────────────────────────────────── */

void suite_java_lsp_coverage(void) {
    /* 1. Literals */
    RUN_TEST(cov_lit_int);
    RUN_TEST(cov_lit_long);
    RUN_TEST(cov_lit_hex);
    RUN_TEST(cov_lit_binary);
    RUN_TEST(cov_lit_octal);
    RUN_TEST(cov_lit_float_suffix);
    RUN_TEST(cov_lit_double);
    RUN_TEST(cov_lit_char);
    RUN_TEST(cov_lit_string_method);
    RUN_TEST(cov_lit_bool_method);
    RUN_TEST(cov_lit_null_no_crash);

    /* 2. Type-name resolution */
    RUN_TEST(cov_typename_java_lang_implicit);
    RUN_TEST(cov_typename_via_single_import);
    RUN_TEST(cov_typename_via_on_demand_import);
    RUN_TEST(cov_typename_via_static_import);
    RUN_TEST(cov_typename_qualified_path);
    RUN_TEST(cov_typename_inner_via_outer);
    RUN_TEST(cov_typename_nested_two_levels);
    RUN_TEST(cov_typename_array_type);
    RUN_TEST(cov_typename_2d_array);
    RUN_TEST(cov_typename_generic_type);
    RUN_TEST(cov_typename_wildcard);
    RUN_TEST(cov_typename_bounded_wildcard);

    /* 3. Primitive operations */
    RUN_TEST(cov_op_arith);
    RUN_TEST(cov_op_compare);
    RUN_TEST(cov_op_bitwise);
    RUN_TEST(cov_op_unary_negate);
    RUN_TEST(cov_op_logical_not);
    RUN_TEST(cov_op_increment);
    RUN_TEST(cov_op_string_concat);
    RUN_TEST(cov_op_ternary_simple);
    RUN_TEST(cov_op_assignment);
    RUN_TEST(cov_op_paren_expr);

    /* 4. Type-AST kinds */
    RUN_TEST(cov_typeast_void_method);
    RUN_TEST(cov_typeast_byte_param);
    RUN_TEST(cov_typeast_short_param);
    RUN_TEST(cov_typeast_int_param);
    RUN_TEST(cov_typeast_long_param);
    RUN_TEST(cov_typeast_float_param);
    RUN_TEST(cov_typeast_double_param);
    RUN_TEST(cov_typeast_char_param);
    RUN_TEST(cov_typeast_boolean_param);
    RUN_TEST(cov_typeast_string_param);
    RUN_TEST(cov_typeast_array_of_string);
    RUN_TEST(cov_typeast_generic_list);

    /* 5. Identifier resolution */
    RUN_TEST(cov_id_local_var);
    RUN_TEST(cov_id_param);
    RUN_TEST(cov_id_field);
    RUN_TEST(cov_id_inherited_field);
    RUN_TEST(cov_id_shadow_param);
    RUN_TEST(cov_id_block_shadow);
    RUN_TEST(cov_id_outer_class_field);
    RUN_TEST(cov_id_class_as_static);
    RUN_TEST(cov_id_unresolved_emits_diagnostic);
    RUN_TEST(cov_id_for_loop_var);

    /* 6. Field access */
    RUN_TEST(cov_fa_system_out);
    RUN_TEST(cov_fa_system_err);
    RUN_TEST(cov_fa_array_length);
    RUN_TEST(cov_fa_chained_field_method);
    RUN_TEST(cov_fa_this_field);
    RUN_TEST(cov_fa_static_class_field);
    RUN_TEST(cov_fa_method_then_field);
    RUN_TEST(cov_fa_field_through_param);
    RUN_TEST(cov_fa_field_through_chained_call);
    RUN_TEST(cov_fa_unresolved_field_no_crash);

    /* 7. Method invocation */
    RUN_TEST(cov_mi_bare_local);
    RUN_TEST(cov_mi_this);
    RUN_TEST(cov_mi_super);
    RUN_TEST(cov_mi_static);
    RUN_TEST(cov_mi_chained_static);
    RUN_TEST(cov_mi_instance);
    RUN_TEST(cov_mi_chain_3hop);
    RUN_TEST(cov_mi_recursive_self);
    RUN_TEST(cov_mi_overload_by_arity);
    RUN_TEST(cov_mi_param_chain);
    RUN_TEST(cov_mi_return_chain);
    RUN_TEST(cov_mi_args_walked);
    RUN_TEST(cov_mi_nested_args);
    RUN_TEST(cov_mi_through_field_getter);
    RUN_TEST(cov_mi_call_in_condition);

    /* 8. Object creation */
    RUN_TEST(cov_oc_simple);
    RUN_TEST(cov_oc_with_args);
    RUN_TEST(cov_oc_diamond);
    RUN_TEST(cov_oc_generic_explicit);
    RUN_TEST(cov_oc_user_class);
    RUN_TEST(cov_oc_with_chained_method);
    RUN_TEST(cov_oc_array);
    RUN_TEST(cov_oc_array_init);

    /* 9. Cast / instanceof */
    RUN_TEST(cov_cast_to_string);
    RUN_TEST(cov_cast_chained);
    RUN_TEST(cov_cast_primitive);
    RUN_TEST(cov_instanceof_basic);
    RUN_TEST(cov_cast_from_iterator);
    RUN_TEST(cov_cast_arr_elem);
    RUN_TEST(cov_cast_in_ternary);
    RUN_TEST(cov_cast_then_chain);

    /* 10. Generic substitution */
    RUN_TEST(cov_gen_list_get);
    RUN_TEST(cov_gen_arraylist_get);
    RUN_TEST(cov_gen_linkedlist_first);
    RUN_TEST(cov_gen_set_iterator_next);
    RUN_TEST(cov_gen_map_get);
    RUN_TEST(cov_gen_hashmap_get);
    RUN_TEST(cov_gen_optional_orElse);
    RUN_TEST(cov_gen_optional_get);
    RUN_TEST(cov_gen_iterator_next_chain);
    RUN_TEST(cov_gen_function_apply);
    RUN_TEST(cov_gen_supplier_get);
    RUN_TEST(cov_gen_bifunction_apply);
    RUN_TEST(cov_gen_map_keyset);
    RUN_TEST(cov_gen_map_values);
    RUN_TEST(cov_gen_collection_iterator);

    /* 11. Lambda SAM inference */
    RUN_TEST(cov_lambda_function);
    RUN_TEST(cov_lambda_predicate_filter);
    RUN_TEST(cov_lambda_consumer_forEach);
    RUN_TEST(cov_lambda_function_map);
    RUN_TEST(cov_lambda_user_consumer);
    RUN_TEST(cov_lambda_user_function);
    RUN_TEST(cov_lambda_user_predicate);
    RUN_TEST(cov_lambda_block_body);
    RUN_TEST(cov_lambda_bipredicate);
    RUN_TEST(cov_lambda_biconsumer_map);
    RUN_TEST(cov_lambda_anyMatch);
    RUN_TEST(cov_lambda_removeIf);

    /* 12. Method references */
    RUN_TEST(cov_mref_static);
    RUN_TEST(cov_mref_instance_method);
    RUN_TEST(cov_mref_static_class_method);
    RUN_TEST(cov_mref_constructor_simple);
    RUN_TEST(cov_mref_in_local_var);
    RUN_TEST(cov_mref_with_chain);
    RUN_TEST(cov_mref_user_class);
    RUN_TEST(cov_mref_user_constructor);

    /* 13. Inheritance */
    RUN_TEST(cov_inh_basic);
    RUN_TEST(cov_inh_3level);
    RUN_TEST(cov_inh_4level);
    RUN_TEST(cov_inh_override);
    RUN_TEST(cov_inh_super_after_override);
    RUN_TEST(cov_inh_via_object);
    RUN_TEST(cov_inh_interface_default);
    RUN_TEST(cov_inh_interface_via_param);
    RUN_TEST(cov_inh_collection_to_list);
    RUN_TEST(cov_inh_list_iterable_iterator);

    /* 14. java.lang */
    RUN_TEST(cov_lang_object_hashCode);
    RUN_TEST(cov_lang_object_equals);
    RUN_TEST(cov_lang_object_getClass);
    RUN_TEST(cov_lang_string_repeat);
    RUN_TEST(cov_lang_string_split);
    RUN_TEST(cov_lang_string_indexOf);
    RUN_TEST(cov_lang_string_substring);
    RUN_TEST(cov_lang_math_pow);
    RUN_TEST(cov_lang_math_log);
    RUN_TEST(cov_lang_math_random);
    RUN_TEST(cov_lang_system_nano);
    RUN_TEST(cov_lang_system_getenv);
    RUN_TEST(cov_lang_thread_sleep);
    RUN_TEST(cov_lang_class_forName);
    RUN_TEST(cov_lang_throwable_getCause);

    /* 15. java.util */
    RUN_TEST(cov_util_arraylist_add);
    RUN_TEST(cov_util_arraylist_remove);
    RUN_TEST(cov_util_linkedlist_addFirst);
    RUN_TEST(cov_util_hashset_add);
    RUN_TEST(cov_util_treeset_first);
    RUN_TEST(cov_util_hashmap_put);
    RUN_TEST(cov_util_treemap_firstKey);
    RUN_TEST(cov_util_arrays_sort);
    RUN_TEST(cov_util_collections_unmodifiable);
    RUN_TEST(cov_util_objects_isNull);
    RUN_TEST(cov_util_optional_isPresent);
    RUN_TEST(cov_util_optional_map);
    RUN_TEST(cov_util_uuid_random);
    RUN_TEST(cov_util_random_nextInt);
    RUN_TEST(cov_util_scanner_nextLine);

    /* 16. java.io */
    RUN_TEST(cov_io_print_writer);
    RUN_TEST(cov_io_input_stream_read);
    RUN_TEST(cov_io_output_stream_write);
    RUN_TEST(cov_io_buffered_writer);
    RUN_TEST(cov_io_file_construction);
    RUN_TEST(cov_io_file_listFiles);
    RUN_TEST(cov_io_file_canRead);
    RUN_TEST(cov_io_file_to_path);
    RUN_TEST(cov_io_reader_ready);
    RUN_TEST(cov_io_writer_close);

    /* 17. java.nio.file */
    RUN_TEST(cov_nio_path_resolve);
    RUN_TEST(cov_nio_path_getFileName);
    RUN_TEST(cov_nio_files_exists);
    RUN_TEST(cov_nio_files_walk);
    RUN_TEST(cov_nio_files_lines);

    /* 18. java.util.stream */
    RUN_TEST(cov_stream_sorted);
    RUN_TEST(cov_stream_distinct);
    RUN_TEST(cov_stream_limit);
    RUN_TEST(cov_stream_skip);
    RUN_TEST(cov_stream_min);
    RUN_TEST(cov_stream_findFirst);
    RUN_TEST(cov_stream_allMatch);
    RUN_TEST(cov_stream_collect_toSet);
    RUN_TEST(cov_stream_collect_groupingBy);
    RUN_TEST(cov_intstream_range);

    /* 19. java.util.function */
    RUN_TEST(cov_fn_unaryoperator);
    RUN_TEST(cov_fn_binaryoperator);
    RUN_TEST(cov_fn_consumer_andThen);
    RUN_TEST(cov_fn_predicate_and);
    RUN_TEST(cov_fn_predicate_negate);
    RUN_TEST(cov_fn_function_andThen);
    RUN_TEST(cov_fn_intpredicate);
    RUN_TEST(cov_fn_toint_function);
    RUN_TEST(cov_fn_int_supplier);
    RUN_TEST(cov_fn_runnable);

    /* 20. java.util.concurrent */
    RUN_TEST(cov_conc_atomic_get);
    RUN_TEST(cov_conc_atomic_compareAndSet);
    RUN_TEST(cov_conc_atomic_long);
    RUN_TEST(cov_conc_atomic_reference);
    RUN_TEST(cov_conc_executor_singleThread);
    RUN_TEST(cov_conc_executor_cached);
    RUN_TEST(cov_conc_future_get);
    RUN_TEST(cov_conc_completable_supplyAsync);
    RUN_TEST(cov_conc_concurrent_hashmap);
    RUN_TEST(cov_conc_reentrant_lock);

    /* 21. java.time */
    RUN_TEST(cov_time_localdate_plus);
    RUN_TEST(cov_time_localdate_isAfter);
    RUN_TEST(cov_time_localdatetime_now);
    RUN_TEST(cov_time_instant_now);
    RUN_TEST(cov_time_duration_between);
    RUN_TEST(cov_time_duration_minutes);
    RUN_TEST(cov_time_zoneid_systemDefault);
    RUN_TEST(cov_time_localdate_format);
    RUN_TEST(cov_time_formatter_ofPattern);
    RUN_TEST(cov_time_localdate_parse);

    /* 22. Imports */
    RUN_TEST(cov_imp_single_type);
    RUN_TEST(cov_imp_on_demand);
    RUN_TEST(cov_imp_static_method);
    RUN_TEST(cov_imp_static_on_demand);
    RUN_TEST(cov_imp_multiple);
    RUN_TEST(cov_imp_qualified_no_import);
    RUN_TEST(cov_imp_with_package);
    RUN_TEST(cov_imp_chained_packages);

    /* 23. Inner/nested */
    RUN_TEST(cov_nest_static_inner);
    RUN_TEST(cov_nest_inner_3level);
    RUN_TEST(cov_nest_interface);
    RUN_TEST(cov_nest_enum);
    RUN_TEST(cov_nest_static_field);
    RUN_TEST(cov_nest_outer_method_from_inner);
    RUN_TEST(cov_nest_outer_field_from_inner);
    RUN_TEST(cov_nest_record);
    RUN_TEST(cov_nest_static_member_access);
    RUN_TEST(cov_nest_constructor_call);

    /* 24. Variable / scope binding */
    RUN_TEST(cov_bind_local_int);
    RUN_TEST(cov_bind_var_string);
    RUN_TEST(cov_bind_var_arraylist);
    RUN_TEST(cov_bind_multi_decl);
    RUN_TEST(cov_bind_final_local);
    RUN_TEST(cov_bind_for_loop_init);
    RUN_TEST(cov_bind_enhanced_for_array);
    RUN_TEST(cov_bind_enhanced_for_iterable);
    RUN_TEST(cov_bind_catch_param);
    RUN_TEST(cov_bind_try_resources);

    /* 25. Control flow */
    RUN_TEST(cov_ctrl_if_call);
    RUN_TEST(cov_ctrl_for_call);
    RUN_TEST(cov_ctrl_while_call);
    RUN_TEST(cov_ctrl_do_while);
    RUN_TEST(cov_ctrl_switch_basic);
    RUN_TEST(cov_ctrl_try_finally);
    RUN_TEST(cov_ctrl_try_multi_catch);
    RUN_TEST(cov_ctrl_throw_in_method);
    RUN_TEST(cov_ctrl_break_continue_no_crash);
    RUN_TEST(cov_ctrl_synchronized);

    /* 26. Diagnostics */
    RUN_TEST(cov_diag_unknown_method);
    RUN_TEST(cov_diag_unknown_var);
    RUN_TEST(cov_diag_unresolved_count);
    RUN_TEST(cov_diag_no_resolved_no_calls);
    RUN_TEST(cov_diag_unresolved_super_no_match);
    RUN_TEST(cov_diag_method_ref_unknown_lhs);

    /* 27. Cross-file */
    RUN_TEST(cov_cross_basic);
    RUN_TEST(cov_cross_no_imports);
    RUN_TEST(cov_cross_batch);
    RUN_TEST(cov_cross_inheritance);

    /* 28. Stress / edge */
    RUN_TEST(cov_edge_empty_method);
    RUN_TEST(cov_edge_empty_class);
    RUN_TEST(cov_edge_long_chain);
    RUN_TEST(cov_edge_recursive_user_method);
    RUN_TEST(cov_edge_mutual_recursion);
    RUN_TEST(cov_edge_deeply_nested_blocks);
    RUN_TEST(cov_edge_anonymous_class_no_crash);
    RUN_TEST(cov_edge_unicode_string);
    RUN_TEST(cov_edge_huge_class_no_crash);
    RUN_TEST(cov_edge_unusual_whitespace);

    (void)cov_no_crash;  /* silence unused-static warning if any */
}