/*
 * test_extraction_inheritance.c — Reproduce-first suite for class-inheritance
 * base-class extraction across the 9 hybrid-LSP languages.
 *
 * DESIGN INTENT
 * ─────────────
 * Every row asserts the CORRECT behaviour: that `CBMDefinition.base_classes`
 * contains real type names, not keywords or punctuation.  For the three broken
 * languages the rows are EXPECTED RED until the extractors are fixed:
 *
 *   RED (broken extractors — rows FAIL until fixed):
 *     TypeScript / TSX — extractor stores the keyword "extends" / "implements"
 *                        instead of the following type name.
 *     PHP             — base_classes is never populated (always NULL / empty).
 *     Kotlin          — `:` supertype syntax is not parsed → base_classes empty.
 *
 *   GREEN (correct extractors — rows PASS as regression guards):
 *     Python  — NOTE: the simple `class Dog(Animal):` case is ALSO red because
 *               collect_bases_from_field does not yet match the plain `identifier`
 *               node used by tree-sitter-python (it grabs the argument_list text
 *               "(Animal)" with parens).  The reproduction for that root-cause is
 *               already in test_extraction.c (python_class_base_extracted_bare).
 *               This suite adds multi-base, generic-base, and qualified-base
 *               variants that share the same root bug — they are all RED until the
 *               identifier-node fix lands.  Python cases that use
 *               `type_identifier` nodes (not yet confirmed) are tentatively
 *               labelled RED.
 *     Java    — single-base and multi-interface extraction is correct (regression
 *               guard for the fix landed with #279).
 *     C#      — extraction is correct (regression guards).
 *     C++     — extraction is correct (regression guards).
 *     Rust    — impl_traits array (not base_classes) is the capture point; Rust
 *               rows verify impl_traits entries for `impl Trait for Struct`.
 *
 * STRUCTURE
 * ─────────
 * inherit_case_t   — one test row.
 * run_inherit_case — generic runner: extract → find def → check base_classes
 *                    (or impl_traits for Rust).
 * One TEST() per language group so failures are readable at the suite level.
 * SUITE(extraction_inheritance) wires them together via RUN_TEST().
 *
 * HOW TO ADD TO THE RUNNER
 * ─────────────────────────
 * In test_main.c add:
 *   extern void suite_extraction_inheritance(void);
 *   RUN_SUITE(extraction_inheritance);
 * (Do NOT do this here — another workstream owns test_main.c.)
 */

#include "test_framework.h"
#include "cbm.h"
#include <string.h>
#include <stdbool.h>
#include <stdio.h>

/* ── Shared helpers ─────────────────────────────────────────────── */

/* Find a definition by label+name; returns NULL if not found. */
static CBMDefinition *find_def(CBMFileResult *r, const char *label, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        CBMDefinition *d = &r->defs.items[i];
        if (d->label && strcmp(d->label, label) == 0 && d->name && strcmp(d->name, name) == 0)
            return d;
    }
    return NULL;
}

/* Find a definition by name alone (any label). */
static CBMDefinition *find_def_any(CBMFileResult *r, const char *name) {
    for (int i = 0; i < r->defs.count; i++) {
        CBMDefinition *d = &r->defs.items[i];
        if (d->name && strcmp(d->name, name) == 0)
            return d;
    }
    return NULL;
}

/* Return 1 if base_classes contains `want` exactly. */
static int bases_contain(CBMDefinition *d, const char *want) {
    if (!d->base_classes)
        return 0;
    for (const char **b = d->base_classes; *b; b++) {
        if (strcmp(*b, want) == 0)
            return 1;
    }
    return 0;
}

/* Return 1 if ANY base_classes entry contains `substr` as a substring.
 * Used to assert that keywords like "extends" / "implements" / ":" do NOT
 * appear inside any captured base name. */
static int bases_contain_substr(CBMDefinition *d, const char *substr) {
    if (!d->base_classes)
        return 0;
    for (const char **b = d->base_classes; *b; b++) {
        if (strstr(*b, substr))
            return 1;
    }
    return 0;
}

/* Count entries in a NULL-terminated base_classes array. */
static int bases_count(CBMDefinition *d) {
    if (!d->base_classes)
        return 0;
    int n = 0;
    for (const char **b = d->base_classes; *b; b++)
        n++;
    return n;
}

/* ── Table-driven case type ─────────────────────────────────────── */

/* Labels used to look up the class definition in the extraction result.
 * The extractor uses "Class", "Interface", "Struct" — we try all three in
 * find_def_flex() below. */
typedef struct {
    CBMLanguage lang;
    const char *path;              /* file path hint (sets language via extension too) */
    const char *src;               /* source snippet */
    const char *class_name;        /* name to look up */
    const char *expected_bases[8]; /* NULL-terminated list of real type names to find */
    /* bad_strings: substrings that must NOT appear inside any base_classes entry.
     * Used to catch keyword-capture bugs.  NULL-terminated, or {NULL} if unused. */
    const char *bad_strings[6];
    int min_base_count; /* >= this many entries expected (0 = don't check count) */
} inherit_case_t;

/* Find def trying Class / Interface / Struct / any-label fallback. */
static CBMDefinition *find_def_flex(CBMFileResult *r, const char *name) {
    CBMDefinition *d;
    if ((d = find_def(r, "Class", name)))
        return d;
    if ((d = find_def(r, "Interface", name)))
        return d;
    if ((d = find_def(r, "Struct", name)))
        return d;
    /* Fallback: any label — covers languages where the extractor uses custom labels */
    return find_def_any(r, name);
}

/*
 * Generic runner for one inherit_case_t row.
 * Returns 0 on pass, 1 on failure (sets FAIL path via printf + return).
 * Cannot use ASSERT macros directly here because they do `return 1` — which
 * is fine since this helper also returns int.  We use manual checks so we
 * can include the case description in the failure message.
 */
static int run_inherit_case(const inherit_case_t *tc) {
    CBMFileResult *r =
        cbm_extract_file(tc->src, (int)strlen(tc->src), tc->lang, "t", tc->path, 0, NULL, NULL);
    if (!r) {
        printf("  FAIL  [%s] cbm_extract_file returned NULL\n", tc->class_name);
        return 1;
    }

    CBMDefinition *cls = find_def_flex(r, tc->class_name);
    if (!cls) {
        printf("  FAIL  [%s] definition not found in extraction result\n", tc->class_name);
        cbm_free_result(r);
        return 1;
    }

    /* When no bases are expected and no min count is set, this is a
     * no-crash / sanity row — skip the rest of the checks. */
    if (!tc->expected_bases[0] && tc->min_base_count == 0) {
        cbm_free_result(r);
        return 0;
    }

    /* Assert base_classes is non-NULL (at least one base expected). */
    if (!cls->base_classes) {
        printf("  FAIL  [%s] base_classes is NULL (expected non-empty)\n", tc->class_name);
        cbm_free_result(r);
        return 1;
    }

    /* Assert each expected base name is present. */
    int ok = 1;
    for (int i = 0; tc->expected_bases[i]; i++) {
        if (!bases_contain(cls, tc->expected_bases[i])) {
            printf("  FAIL  [%s] expected base \"%s\" not found in base_classes\n", tc->class_name,
                   tc->expected_bases[i]);
            ok = 0;
        }
    }

    /* Assert no bad keyword strings appear inside any base name. */
    for (int i = 0; tc->bad_strings[i]; i++) {
        if (bases_contain_substr(cls, tc->bad_strings[i])) {
            printf("  FAIL  [%s] bad string \"%s\" found inside a base_classes entry\n",
                   tc->class_name, tc->bad_strings[i]);
            ok = 0;
        }
    }

    /* Assert minimum count. */
    if (tc->min_base_count > 0) {
        int cnt = bases_count(cls);
        if (cnt < tc->min_base_count) {
            printf("  FAIL  [%s] base_classes has %d entries, expected >= %d\n", tc->class_name,
                   cnt, tc->min_base_count);
            ok = 0;
        }
    }

    cbm_free_result(r);
    return ok ? 0 : 1;
}

/* Convenience macro: run a table of cases, accumulate failures. */
#define RUN_CASES(table)                                               \
    do {                                                               \
        int _fail = 0;                                                 \
        int _n = (int)(sizeof(table) / sizeof(table[0]));              \
        for (int _i = 0; _i < _n; _i++) {                              \
            if (run_inherit_case(&table[_i]) != 0)                     \
                _fail++;                                               \
        }                                                              \
        if (_fail > 0) {                                               \
            printf("  FAIL  %d / %d cases above failed\n", _fail, _n); \
            return 1;                                                  \
        }                                                              \
    } while (0)

/* ═══════════════════════════════════════════════════════════════════
 * PYTHON  (expected: RED until identifier-node fix in extract_defs.c)
 *
 * Root cause: collect_bases_from_field() does not match the plain
 * `identifier` node used by tree-sitter-python for unqualified base
 * names → raw argument_list text "(Base)" (with parens) is stored
 * instead of "Base". Fix: accept `identifier` as a valid child type.
 * ═══════════════════════════════════════════════════════════════════ */

static const inherit_case_t python_cases[] = {
    /* ── single base (bare identifier) ────────────────────────── */
    {CBM_LANG_PYTHON,
     "m.py",
     "class Animal:\n    pass\n\nclass Dog(Animal):\n    pass\n",
     "Dog",
     {"Animal", NULL},
     {"(", ")", NULL},
     1},
    /* ── multiple bases ─────────────────────────────────────────── */
    {CBM_LANG_PYTHON,
     "m.py",
     "class A: pass\nclass B: pass\nclass C(A, B): pass\n",
     "C",
     {"A", "B", NULL},
     {"(", ")", NULL},
     2},
    /* ── base + mixin ───────────────────────────────────────────── */
    {CBM_LANG_PYTHON,
     "m.py",
     "class Base: pass\nclass Mixin: pass\nclass Service(Base, Mixin): pass\n",
     "Service",
     {"Base", "Mixin", NULL},
     {"(", ")", NULL},
     2},
    /* ── generic base (subscript, e.g. Generic[T]) ──────────────── */
    {CBM_LANG_PYTHON,
     "m.py",
     "from typing import Generic, TypeVar\nT = TypeVar('T')\n"
     "class Stack(Generic[T]):\n    pass\n",
     "Stack",
     {"Generic", NULL},
     {"(", ")", NULL},
     1},
    /* ── qualified base (dotted: module.Base) ───────────────────── */
    {CBM_LANG_PYTHON,
     "m.py",
     "import django.db\nclass MyModel(django.db.Model):\n    pass\n",
     "MyModel",
     {"django.db.Model", NULL},
     {"(", ")", NULL},
     1},
    /* ── abstract base (abc.ABC) ────────────────────────────────── */
    {CBM_LANG_PYTHON,
     "m.py",
     "from abc import ABC, abstractmethod\nclass Shape(ABC):\n    @abstractmethod\n    def "
     "area(self): pass\n",
     "Shape",
     {"ABC", NULL},
     {"(", ")", NULL},
     1},
    /* ── dataclass with base ────────────────────────────────────── */
    {CBM_LANG_PYTHON,
     "m.py",
     "from dataclasses import dataclass\n@dataclass\nclass Point:\n    x: float\n\n"
     "@dataclass\nclass Point3D(Point):\n    z: float\n",
     "Point3D",
     {"Point", NULL},
     {"(", ")", NULL},
     1},
    /* ── exception subclass ─────────────────────────────────────── */
    {CBM_LANG_PYTHON,
     "m.py",
     "class AppError(Exception): pass\n",
     "AppError",
     {"Exception", NULL},
     {"(", ")", NULL},
     1},
    /* ── three bases ────────────────────────────────────────────── */
    {CBM_LANG_PYTHON,
     "m.py",
     "class X: pass\nclass Y: pass\nclass Z: pass\nclass Multi(X, Y, Z): pass\n",
     "Multi",
     {"X", "Y", "Z", NULL},
     {"(", ")", NULL},
     3},
    /* ── base with keyword argument (metaclass=) should not bleed ── */
    {CBM_LANG_PYTHON,
     "m.py",
     "class Meta: pass\nclass MyClass(object, metaclass=Meta): pass\n",
     "MyClass",
     {"object", NULL},
     {"(", ")", "metaclass", NULL},
     1},
};

TEST(inherit_python) {
    RUN_CASES(python_cases);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * JAVA  (expected: GREEN — regression guards for #279 fix)
 * ═══════════════════════════════════════════════════════════════════ */

static const inherit_case_t java_cases[] = {
    /* ── extends only ───────────────────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class Dog extends Animal { }",
     "Dog",
     {"Animal", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── implements single interface ─────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class ConcreteList implements List { }",
     "ConcreteList",
     {"List", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── extends + implements one ────────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class MyThread extends Thread implements Runnable { }",
     "MyThread",
     {"Thread", "Runnable", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── extends + implements two (regression for #279) ─────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class DefaultLinkTool extends DefaultDiagramTool implements ILinkTool, Closeable { }",
     "DefaultLinkTool",
     {"DefaultDiagramTool", "ILinkTool", "Closeable", NULL},
     {"extends", "implements", NULL},
     3},
    /* ── implements three interfaces ─────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class Svc implements A, B, C { }",
     "Svc",
     {"A", "B", "C", NULL},
     {"extends", "implements", NULL},
     3},
    /* ── generic base (extends List<String>) ─────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "import java.util.*; public class MyList extends ArrayList<String> { }",
     "MyList",
     {"ArrayList", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── generic implements (Comparable<T>) ──────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class Box<T> implements Comparable<Box<T>> { public int compareTo(Box<T> o) { return "
     "0; } }",
     "Box",
     {"Comparable", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── abstract class extends ──────────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public abstract class AbstractSvc extends BaseService { protected abstract void run(); }",
     "AbstractSvc",
     {"BaseService", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── interface extends interface ─────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public interface ReadWriteRepo extends ReadRepo, WriteRepo { }",
     "ReadWriteRepo",
     {"ReadRepo", "WriteRepo", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── enum implements interface ───────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public enum Status implements Displayable { OPEN, CLOSED; public String display() { return "
     "name(); } }",
     "Status",
     {"Displayable", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── qualified (imported) type name ─────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class Handler extends java.net.ServerSocket { }",
     "Handler",
     {"java.net.ServerSocket", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── extends + implements four ───────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class Mega extends Base implements A, B, C, D { }",
     "Mega",
     {"Base", "A", "B", "C", "D", NULL},
     {"extends", "implements", NULL},
     5},
    /* ── nested class with base ──────────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class Outer { public static class Inner extends Outer { } }",
     "Inner",
     {"Outer", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── record implements interface (Java 16+) ──────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public record Point(int x, int y) implements Comparable<Point> { "
     "public int compareTo(Point o) { return Integer.compare(x, o.x); } }",
     "Point",
     {"Comparable", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── sealed class (Java 17+) ─────────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public sealed class Shape permits Circle, Rectangle { }",
     "Shape",
     {NULL}, /* permitted-types are not base_classes of Shape; no bases to assert */
     {NULL},
     0},
    /* ── class implements Serializable ──────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "import java.io.*; public class Data extends BaseData implements Serializable, Cloneable { }",
     "Data",
     {"BaseData", "Serializable", "Cloneable", NULL},
     {"extends", "implements", NULL},
     3},
    /* ── generic class extends generic base ──────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class Pair<A, B> extends AbstractPair<A, B> implements Iterable<A> { "
     "public java.util.Iterator<A> iterator() { return null; } }",
     "Pair",
     {"AbstractPair", "Iterable", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── class extending Exception ───────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class AppException extends RuntimeException { "
     "public AppException(String msg) { super(msg); } }",
     "AppException",
     {"RuntimeException", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── multiple interfaces no extends ──────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "public class Codec implements Encoder, Decoder, Closeable { }",
     "Codec",
     {"Encoder", "Decoder", "Closeable", NULL},
     {"extends", "implements", NULL},
     3},
    /* ── annotated class with base ───────────────────────────────── */
    {CBM_LANG_JAVA,
     "Svc.java",
     "@Override public class AnnotatedSvc extends BaseSvc { }",
     "AnnotatedSvc",
     {"BaseSvc", NULL},
     {"extends", "implements", NULL},
     1},
};

TEST(inherit_java) {
    RUN_CASES(java_cases);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * C#  (expected: GREEN — regression guards)
 * ═══════════════════════════════════════════════════════════════════ */

static const inherit_case_t csharp_cases[] = {
    /* ── single base class ──────────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class Dog : Animal { }",
     "Dog",
     {"Animal", NULL},
     {":", NULL},
     1},
    /* ── implements single interface ─────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class Repo : IRepository { }",
     "Repo",
     {"IRepository", NULL},
     {":", NULL},
     1},
    /* ── base + interface ────────────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class Service : BaseService, IService { }",
     "Service",
     {"BaseService", "IService", NULL},
     {":", NULL},
     2},
    /* ── base + two interfaces ───────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class Worker : BackgroundService, IWorker, IDisposable { }",
     "Worker",
     {"BackgroundService", "IWorker", "IDisposable", NULL},
     {":", NULL},
     3},
    /* ── generic base ────────────────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class OrderList : List<Order> { }",
     "OrderList",
     {"List", NULL},
     {":", NULL},
     1},
    /* ── generic base + interface ────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class Stack<T> : Collection<T>, IStack<T> { }",
     "Stack",
     {"Collection", "IStack", NULL},
     {":", NULL},
     2},
    /* ── interface extends two interfaces ────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public interface ICrud : IRead, IWrite { }",
     "ICrud",
     {"IRead", "IWrite", NULL},
     {":", NULL},
     2},
    /* ── abstract class with base ────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public abstract class AbstractHandler : BaseHandler { protected abstract void Handle(); }",
     "AbstractHandler",
     {"BaseHandler", NULL},
     {":", NULL},
     1},
    /* ── sealed class ────────────────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public sealed class SingletonService : BaseService { }",
     "SingletonService",
     {"BaseService", NULL},
     {":", NULL},
     1},
    /* ── namespace-qualified base ────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "namespace App { public class Handler : System.Net.Http.HttpMessageHandler { "
     "protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> "
     "SendAsync(System.Net.Http.HttpRequestMessage r, System.Threading.CancellationToken c) "
     "{ return null; } } }",
     "Handler",
     {"System.Net.Http.HttpMessageHandler", NULL},
     {":", NULL},
     1},
    /* ── partial class with base ─────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public partial class PartialSvc : BaseSvc, IPartial { }",
     "PartialSvc",
     {"BaseSvc", "IPartial", NULL},
     {":", NULL},
     2},
    /* ── record with base ────────────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public record OrderRecord(int Id) : BaseRecord(Id), IRecord { }",
     "OrderRecord",
     {"BaseRecord", "IRecord", NULL},
     {":", NULL},
     2},
    /* ── struct implements interface ─────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public struct Point : IEquatable<Point> { public bool Equals(Point other) => true; }",
     "Point",
     {"IEquatable", NULL},
     {":", NULL},
     1},
    /* ── class with four interfaces ──────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class Mega : Base, IA, IB, IC, ID { }",
     "Mega",
     {"Base", "IA", "IB", "IC", "ID", NULL},
     {":", NULL},
     5},
    /* ── exception subclass ─────────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class AppException : Exception { public AppException(string msg) : base(msg) {} }",
     "AppException",
     {"Exception", NULL},
     {":", NULL},
     1},
    /* ── nested class with base ──────────────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class Outer { public class Inner : Outer { } }",
     "Inner",
     {"Outer", NULL},
     {":", NULL},
     1},
    /* ── class in namespace with base ───────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "namespace MyApp.Services { public class OrderSvc : BaseOrderSvc, IOrderSvc { } }",
     "OrderSvc",
     {"BaseOrderSvc", "IOrderSvc", NULL},
     {":", NULL},
     2},
    /* ── interface with single parent ───────────────────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public interface IAdvancedService : IBasicService { void AdvancedOp(); }",
     "IAdvancedService",
     {"IBasicService", NULL},
     {":", NULL},
     1},
    /* ── generic class implements generic interface ───────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class Repo<T> : BaseRepo<T>, IRepo<T> where T : class { }",
     "Repo",
     {"BaseRepo", "IRepo", NULL},
     {":", "where", NULL},
     2},
    /* ── class with IDisposable + IAsyncDisposable ───────────────── */
    {CBM_LANG_CSHARP,
     "Svc.cs",
     "public class Resource : IDisposable, IAsyncDisposable { "
     "public void Dispose() {} "
     "public System.Threading.Tasks.ValueTask DisposeAsync() => default; }",
     "Resource",
     {"IDisposable", "IAsyncDisposable", NULL},
     {":", NULL},
     2},
};

TEST(inherit_csharp) {
    RUN_CASES(csharp_cases);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * C++  (expected: GREEN — regression guards)
 * ═══════════════════════════════════════════════════════════════════ */

static const inherit_case_t cpp_cases[] = {
    /* ── public single base ─────────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class Dog : public Animal { };",
     "Dog",
     {"Animal", NULL},
     {"public", "private", "protected", ":", NULL},
     1},
    /* ── private base ────────────────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class Impl : private Base { };",
     "Impl",
     {"Base", NULL},
     {"public", "private", "protected", ":", NULL},
     1},
    /* ── multiple inheritance ────────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class C : public A, public B { };",
     "C",
     {"A", "B", NULL},
     {"public", "private", "protected", ":", NULL},
     2},
    /* ── struct with base ────────────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "struct Derived : Base { int x; };",
     "Derived",
     {"Base", NULL},
     {":", NULL},
     1},
    /* ── virtual inheritance ─────────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class D : public virtual B1, public virtual B2 { };",
     "D",
     {"B1", "B2", NULL},
     {"virtual", "public", ":", NULL},
     2},
    /* ── template base ───────────────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "template<typename T> class Stack : public std::vector<T> { };",
     "Stack",
     {"std::vector", NULL},
     /* qualified base: `::` is legitimate, so the bare-`:` separator-leak
      * guard does not apply here (it would match inside `std::vector`). */
     {"public", "template", NULL},
     1},
    /* ── CRTP pattern ────────────────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "template<typename Derived> class Base { };\n"
     "class Concrete : public Base<Concrete> { };",
     "Concrete",
     {"Base", NULL},
     {"public", ":", NULL},
     1},
    /* ── abstract class (pure virtual) with public base ──────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class AbstractLogger : public ILogger { public: virtual void log(const char*) = 0; };",
     "AbstractLogger",
     {"ILogger", NULL},
     {"public", ":", NULL},
     1},
    /* ── class in namespace ──────────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "namespace net { class Socket : public BaseSocket { }; }",
     "Socket",
     {"BaseSocket", NULL},
     {"public", ":", NULL},
     1},
    /* ── three-way diamond inheritance ──────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class A { }; class B : public A { }; class C : public A { };\n"
     "class D : public B, public C { };",
     "D",
     {"B", "C", NULL},
     {"public", ":", NULL},
     2},
    /* ── fully qualified base name ───────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class MyStream : public std::ostream { public: MyStream() : std::ostream(nullptr) {} };",
     "MyStream",
     {"std::ostream", NULL},
     /* qualified base: bare-`:` guard omitted (matches inside `std::ostream`). */
     {"public", NULL},
     1},
    /* ── protected base ──────────────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class Node : protected TreeNode { };",
     "Node",
     {"TreeNode", NULL},
     {"protected", ":", NULL},
     1},
    /* ── multiple bases with mixed access ────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class Widget : public Drawable, private EventHandler, protected Serializable { };",
     "Widget",
     {"Drawable", "EventHandler", "Serializable", NULL},
     {"public", "private", "protected", ":", NULL},
     3},
    /* ── exception class from std::exception ─────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "#include <stdexcept>\nclass AppError : public std::runtime_error { "
     "public: AppError(const char* m) : std::runtime_error(m) {} };",
     "AppError",
     {"std::runtime_error", NULL},
     /* qualified base: bare-`:` guard omitted (matches inside `std::runtime_error`). */
     {"public", NULL},
     1},
    /* ── template class with multiple template base types ────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "template<typename K, typename V>\n"
     "class LruCache : public Cache<K,V>, public Observable { };",
     "LruCache",
     {"Cache", "Observable", NULL},
     {"public", ":", NULL},
     2},
    /* ── nested class with base ──────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class Outer { public: class Inner : public Base { }; };",
     "Inner",
     {"Base", NULL},
     {"public", ":", NULL},
     1},
    /* ── class using final specifier ─────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class Leaf final : public Node { };",
     "Leaf",
     {"Node", NULL},
     {"public", "final", ":", NULL},
     1},
    /* ── struct with scoped base ─────────────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "struct MyVisitor : public boost::static_visitor<int> { int operator()(int x) { return x; } "
     "};",
     "MyVisitor",
     {"boost::static_visitor", NULL},
     /* qualified base: bare-`:` guard omitted (matches inside `boost::static_visitor`). */
     {"public", NULL},
     1},
    /* ── policy-based design (two template base policies) ────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "template<class StoragePolicy, class LogPolicy>\n"
     "class Engine : public StoragePolicy, public LogPolicy { };",
     "Engine",
     {"StoragePolicy", "LogPolicy", NULL},
     {"public", ":", NULL},
     2},
    /* ── empty base optimization (EBO) ──────────────────────────── */
    {CBM_LANG_CPP,
     "svc.cpp",
     "class EboContainer : private Allocator, public ContainerBase { };",
     "EboContainer",
     {"Allocator", "ContainerBase", NULL},
     {"private", "public", ":", NULL},
     2},
};

TEST(inherit_cpp) {
    RUN_CASES(cpp_cases);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * TYPESCRIPT  (expected: RED — keyword-capture bug)
 *
 * Bug: the TS extractor stores "extends" / "implements" as the base
 * name instead of the following type name.
 * ═══════════════════════════════════════════════════════════════════ */

static const inherit_case_t typescript_cases[] = {
    /* ── extends single class ────────────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class Dog extends Animal { bark(): void {} }",
     "Dog",
     {"Animal", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── implements single interface ─────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class Repo implements IRepository { save(x: any) {} }",
     "Repo",
     {"IRepository", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── extends + implements ────────────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class Service extends BaseService implements IService { run() {} }",
     "Service",
     {"BaseService", "IService", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── implements two interfaces ───────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class Codec implements Encoder, Decoder { encode(x: any) {} decode(x: any) {} }",
     "Codec",
     {"Encoder", "Decoder", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── extends + implements three ──────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class Mega extends Base implements A, B, C { }",
     "Mega",
     {"Base", "A", "B", "C", NULL},
     {"extends", "implements", NULL},
     4},
    /* ── generic base ────────────────────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class Stack<T> extends Array<T> implements IStack<T> { push(x: T) { return 0; } }",
     "Stack",
     {"Array", "IStack", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── interface extends interface ─────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "interface ReadWriteRepo extends ReadRepo, WriteRepo { }",
     "ReadWriteRepo",
     {"ReadRepo", "WriteRepo", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── abstract class ──────────────────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "abstract class AbstractSvc extends BaseService { abstract run(): void; }",
     "AbstractSvc",
     {"BaseService", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── class extends Error ─────────────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class AppError extends Error { constructor(msg: string) { super(msg); } }",
     "AppError",
     {"Error", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── class extends EventEmitter ──────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "import { EventEmitter } from 'events';\n"
     "class Bus extends EventEmitter { emit(ev: string) { return super.emit(ev); } }",
     "Bus",
     {"EventEmitter", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── generic class extends generic base ──────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class Pair<A, B> extends AbstractPair<A, B> implements Iterable<A> { "
     "[Symbol.iterator]() { return this as any; } }",
     "Pair",
     {"AbstractPair", "Iterable", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── class implements multiple generic interfaces ─────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class Handler implements Middleware<Request, Response>, Disposable { "
     "handle(req: Request): Response { return null as any; } dispose() {} }",
     "Handler",
     {"Middleware", "Disposable", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── class in module namespace ───────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "export class OrderService extends BaseOrderService implements IOrderService { }",
     "OrderService",
     {"BaseOrderService", "IOrderService", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── mixin target class (concrete class consuming a mixin) ──────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class Loggable { log(msg: string) { console.log(msg); } }\n"
     "class Logger extends Loggable implements ILogger { info(msg: string) { this.log(msg); } }",
     "Logger",
     {"Loggable", "ILogger", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── decorator + extends ─────────────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "function Injectable() { return (c: any) => c; }\n"
     "@Injectable()\nclass UserService extends BaseUserService { }",
     "UserService",
     {"BaseUserService", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── class implementing multiple inferred generics ───────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class BinaryTree<T> extends Tree<T> implements Traversable<T>, Serializable { "
     "traverse() {} serialize() { return ''; } }",
     "BinaryTree",
     {"Tree", "Traversable", "Serializable", NULL},
     {"extends", "implements", NULL},
     3},
    /* ── React component extends ──────────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "import React from 'react';\n"
     "class MyComponent extends React.Component<{}, {}> { render() { return null; } }",
     "MyComponent",
     {"React.Component", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── exception hierarchy ─────────────────────────────────────── */
    {CBM_LANG_TYPESCRIPT,
     "svc.ts",
     "class NetworkError extends AppError implements Retryable { retry() {} }",
     "NetworkError",
     {"AppError", "Retryable", NULL},
     {"extends", "implements", NULL},
     2},
};

TEST(inherit_typescript) {
    RUN_CASES(typescript_cases);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * TSX  (expected: RED — same keyword-capture bug as TypeScript)
 * ═══════════════════════════════════════════════════════════════════ */

static const inherit_case_t tsx_cases[] = {
    /* ── React.Component subclass ────────────────────────────────── */
    {CBM_LANG_TSX,
     "App.tsx",
     "import React from 'react';\n"
     "class App extends React.Component<{}, {}> { render() { return <div/>; } }",
     "App",
     {"React.Component", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── PureComponent subclass ──────────────────────────────────── */
    {CBM_LANG_TSX,
     "Widget.tsx",
     "import { PureComponent } from 'react';\n"
     "class Widget extends PureComponent { render() { return null; } }",
     "Widget",
     {"PureComponent", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── component + interface ───────────────────────────────────── */
    {CBM_LANG_TSX,
     "Form.tsx",
     "import { Component } from 'react';\n"
     "class Form extends Component<FormProps, FormState> implements IForm { "
     "render() { return <form/>; } submit() {} }",
     "Form",
     {"Component", "IForm", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── abstract component ──────────────────────────────────────── */
    {CBM_LANG_TSX,
     "Base.tsx",
     "import { Component } from 'react';\n"
     "abstract class BaseView extends Component { abstract renderContent(): JSX.Element; }",
     "BaseView",
     {"Component", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── non-React class in .tsx ─────────────────────────────────── */
    {CBM_LANG_TSX,
     "store.tsx",
     "class UserStore extends BaseStore implements IStore { load() {} }",
     "UserStore",
     {"BaseStore", "IStore", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── generic component ───────────────────────────────────────── */
    {CBM_LANG_TSX,
     "List.tsx",
     "import { Component } from 'react';\n"
     "class List<T> extends Component<{ items: T[] }> { render() { return <ul/>; } }",
     "List",
     {"Component", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── interface extends in tsx file ───────────────────────────── */
    {CBM_LANG_TSX,
     "types.tsx",
     "interface IAdvanced extends IBasic, IExtended { doAdvanced(): void; }",
     "IAdvanced",
     {"IBasic", "IExtended", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── multiple interfaces + base ──────────────────────────────── */
    {CBM_LANG_TSX,
     "Mega.tsx",
     "class MegaComponent extends React.Component implements Serializable, Disposable { "
     "render() { return null; } }",
     "MegaComponent",
     {"React.Component", "Serializable", "Disposable", NULL},
     {"extends", "implements", NULL},
     3},
    /* ── error boundary component ────────────────────────────────── */
    {CBM_LANG_TSX,
     "ErrorBoundary.tsx",
     "import { Component, ReactNode, ErrorInfo } from 'react';\n"
     "class ErrorBoundary extends Component<{ children: ReactNode }, { hasError: boolean }> { "
     "componentDidCatch(err: Error, info: ErrorInfo) {} render() { return null; } }",
     "ErrorBoundary",
     {"Component", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── class extending custom hook class ───────────────────────── */
    {CBM_LANG_TSX,
     "hook.tsx",
     "class AdvancedHook extends BaseHook implements IHook { use() {} }",
     "AdvancedHook",
     {"BaseHook", "IHook", NULL},
     {"extends", "implements", NULL},
     2},
};

TEST(inherit_tsx) {
    RUN_CASES(tsx_cases);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * PHP  (expected: RED — base_classes never populated)
 *
 * Bug: the PHP extractor does not populate base_classes for `extends`
 * or `implements`.  All rows assert the class is found and base_classes
 * is non-NULL, which fails immediately.
 * ═══════════════════════════════════════════════════════════════════ */

static const inherit_case_t php_cases[] = {
    /* ── extends single class ────────────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nclass Dog extends Animal { public function bark(): void {} }",
     "Dog",
     {"Animal", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── implements single interface ─────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nclass Repo implements IRepository { public function save($x) {} }",
     "Repo",
     {"IRepository", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── extends + implements ────────────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nclass Service extends BaseService implements IService { public function run() {} }",
     "Service",
     {"BaseService", "IService", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── implements two interfaces ───────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nclass Codec implements Encoder, Decoder { "
     "public function encode($x) {} public function decode($x) {} }",
     "Codec",
     {"Encoder", "Decoder", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── extends + implements three ──────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nclass Mega extends Base implements A, B, C { }",
     "Mega",
     {"Base", "A", "B", "C", NULL},
     {"extends", "implements", NULL},
     4},
    /* ── abstract class ──────────────────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nabstract class AbstractSvc extends BaseService { abstract public function run(): "
     "void; }",
     "AbstractSvc",
     {"BaseService", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── final class ─────────────────────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nfinal class FinalSvc extends BaseSvc { }",
     "FinalSvc",
     {"BaseSvc", NULL},
     {"extends", "implements", NULL},
     1},
    /* ── namespace-qualified base ────────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nnamespace App\\Services;\nuse App\\Base\\BaseService;\n"
     "class OrderService extends BaseService implements IOrderService { }",
     "OrderService",
     {"BaseService", "IOrderService", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── interface extends interface ─────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\ninterface IAdvanced extends IBasic, IExtended { public function doAdvanced(): void; }",
     "IAdvanced",
     {"IBasic", "IExtended", NULL},
     {"extends", NULL},
     2},
    /* ── backslash-prefixed fully qualified base ──────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nclass MyException extends \\RuntimeException { }",
     "MyException",
     {"RuntimeException", NULL},
     {"extends", "\\\\", NULL},
     1},
    /* ── class extending Exception ───────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nclass AppException extends \\Exception { "
     "public function __construct(string $msg) { parent::__construct($msg); } }",
     "AppException",
     {"Exception", NULL},
     {"extends", NULL},
     1},
    /* ── implements four interfaces ──────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nclass Adapter implements IA, IB, IC, ID { "
     "public function a() {} public function b() {} "
     "public function c() {} public function d() {} }",
     "Adapter",
     {"IA", "IB", "IC", "ID", NULL},
     {"implements", NULL},
     4},
    /* ── trait-using class also extends ──────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\ntrait Logging { public function log() {} }\n"
     "class MyService extends BaseService { use Logging; }",
     "MyService",
     {"BaseService", NULL},
     {"extends", NULL},
     1},
    /* ── nested namespace with extends ───────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nnamespace App\\Http\\Controllers;\n"
     "class UserController extends Controller { }",
     "UserController",
     {"Controller", NULL},
     {"extends", NULL},
     1},
    /* ── multiple namespaced interfaces ──────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nuse Psr\\Http\\Server\\RequestHandlerInterface;\n"
     "use Psr\\Http\\Message\\ResponseInterface;\n"
     "class PsrHandler extends BaseHandler implements RequestHandlerInterface { "
     "public function handle($req): ResponseInterface { return null; } }",
     "PsrHandler",
     {"BaseHandler", "RequestHandlerInterface", NULL},
     {"extends", "implements", NULL},
     2},
    /* ── readonly class (PHP 8.2) ────────────────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nreadonly class ValueObject extends BaseValue { public function __construct("
     "public readonly string $value) {} }",
     "ValueObject",
     {"BaseValue", NULL},
     {"extends", NULL},
     1},
    /* ── enum implements interface (PHP 8.1) ─────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\ninterface HasLabel { public function label(): string; }\n"
     "enum Status: string implements HasLabel { "
     "case Active = 'active'; public function label(): string { return $this->value; } }",
     "Status",
     {"HasLabel", NULL},
     {"implements", NULL},
     1},
    /* ── extends with constructor promotion ──────────────────────── */
    {CBM_LANG_PHP,
     "Svc.php",
     "<?php\nclass PromotedDto extends BaseDto { "
     "public function __construct(public readonly string $name) { parent::__construct(); } }",
     "PromotedDto",
     {"BaseDto", NULL},
     {"extends", NULL},
     1},
};

TEST(inherit_php) {
    RUN_CASES(php_cases);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * KOTLIN  (expected: RED — `:` supertype syntax not parsed)
 *
 * Bug: the Kotlin extractor does not parse the `: SuperType` syntax,
 * leaving base_classes empty for all Kotlin classes with supertypes.
 * ═══════════════════════════════════════════════════════════════════ */

static const inherit_case_t kotlin_cases[] = {
    /* ── extends single class ────────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "open class Animal(val name: String)\nclass Dog(name: String) : Animal(name)",
     "Dog",
     {"Animal", NULL},
     {":", NULL},
     1},
    /* ── implements single interface ─────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "interface IRepo { fun save(x: Any) }\nclass Repo : IRepo { override fun save(x: Any) {} }",
     "Repo",
     {"IRepo", NULL},
     {":", NULL},
     1},
    /* ── extends + implements ────────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "open class BaseService\ninterface IService { fun run() }\n"
     "class Service : BaseService(), IService { override fun run() {} }",
     "Service",
     {"BaseService", "IService", NULL},
     {":", NULL},
     2},
    /* ── implements two interfaces ───────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "interface Encoder { fun encode(x: Any): String }\n"
     "interface Decoder { fun decode(s: String): Any }\n"
     "class Codec : Encoder, Decoder { "
     "override fun encode(x: Any) = x.toString() "
     "override fun decode(s: String): Any = s }",
     "Codec",
     {"Encoder", "Decoder", NULL},
     {":", NULL},
     2},
    /* ── abstract class ──────────────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "abstract class AbstractSvc : BaseService() { abstract fun run() }",
     "AbstractSvc",
     {"BaseService", NULL},
     {":", NULL},
     1},
    /* ── data class with base ────────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "open class BaseEntity(val id: Long)\n"
     "data class User(val name: String, override val id: Long) : BaseEntity(id)",
     "User",
     {"BaseEntity", NULL},
     {":", NULL},
     1},
    /* ── sealed class with base ──────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "sealed class Result\nclass Success(val value: Any) : Result()\nclass Failure(val err: "
     "Throwable) : Result()",
     "Success",
     {"Result", NULL},
     {":", NULL},
     1},
    /* ── object (singleton) implementing interface ───────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "interface Logger { fun log(msg: String) }\nobject ConsoleLogger : Logger { override fun "
     "log(msg: String) = println(msg) }",
     "ConsoleLogger",
     {"Logger", NULL},
     {":", NULL},
     1},
    /* ── generic class with bound ────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "open class Container<T>\nclass Box<T : Comparable<T>> : Container<T>()",
     "Box",
     {"Container", NULL},
     {":", NULL},
     1},
    /* ── companion object (no base — sanity check, no crash) ─────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "class MyClass { companion object : Factory<MyClass>() { override fun create() = MyClass() } "
     "}",
     "MyClass",
     {NULL}, /* outer class has no base; we just want no crash */
     {NULL},
     0},
    /* ── enum class implementing interface ───────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "interface Displayable { fun display(): String }\n"
     "enum class Status : Displayable { OPEN, CLOSED; override fun display() = name }",
     "Status",
     {"Displayable", NULL},
     {":", NULL},
     1},
    /* ── class extending Exception ───────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "class AppException(message: String) : Exception(message)",
     "AppException",
     {"Exception", NULL},
     {":", NULL},
     1},
    /* ── implements Comparable ───────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "class Version(val major: Int, val minor: Int) : Comparable<Version> { "
     "override fun compareTo(other: Version) = compareValuesBy(this, other, { it.major }, { "
     "it.minor }) }",
     "Version",
     {"Comparable", NULL},
     {":", NULL},
     1},
    /* ── open class hierarchy ────────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "open class Vehicle(val speed: Int)\nopen class MotorVehicle(speed: Int) : Vehicle(speed)\n"
     "class Car(speed: Int) : MotorVehicle(speed)",
     "Car",
     {"MotorVehicle", NULL},
     {":", NULL},
     1},
    /* ── inner class with base ───────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "open class BaseNode\nclass Tree { inner class Node : BaseNode() { var value: Int = 0 } }",
     "Node",
     {"BaseNode", NULL},
     {":", NULL},
     1},
    /* ── fun interface (SAM) ─────────────────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "fun interface Transformer { fun transform(input: String): String }\n"
     "class UpperTransformer : Transformer { override fun transform(input: String) = "
     "input.uppercase() }",
     "UpperTransformer",
     {"Transformer", NULL},
     {":", NULL},
     1},
    /* ── three bases (base + two interfaces) ─────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "open class BaseWorker\ninterface Runnable { fun run() }\ninterface Stoppable { fun stop() }\n"
     "class Worker : BaseWorker(), Runnable, Stoppable { override fun run() {} override fun stop() "
     "{} }",
     "Worker",
     {"BaseWorker", "Runnable", "Stoppable", NULL},
     {":", NULL},
     3},
    /* ── annotation class with base ─────────────────────────────────*/
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "annotation class MyAnnotation\nclass AnnotatedClass : BaseClass() { @MyAnnotation fun "
     "doWork() {} }",
     "AnnotatedClass",
     {"BaseClass", NULL},
     {":", NULL},
     1},
    /* ── value class (inline, Kotlin 1.5+) ──────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "interface Printable { fun print() }\n"
     "@JvmInline value class UserId(val id: String) : Printable { override fun print() = "
     "println(id) }",
     "UserId",
     {"Printable", NULL},
     {":", NULL},
     1},
    /* ── class with type-projected bound ─────────────────────────── */
    {CBM_LANG_KOTLIN,
     "Svc.kt",
     "open class Repository<T : Any>\nclass UserRepository : Repository<User>()",
     "UserRepository",
     {"Repository", NULL},
     {":", NULL},
     1},
};

TEST(inherit_kotlin) {
    RUN_CASES(kotlin_cases);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * RUST — impl Trait for Struct  (expected: GREEN — regression guards)
 *
 * Rust does not use `base_classes` on the Struct def.  Instead the
 * extractor populates CBMFileResult.impl_traits (CBMImplTrait array)
 * with {trait_name, struct_name} pairs.
 * ═══════════════════════════════════════════════════════════════════ */

/* Rust helper: check impl_traits array. */
static int rust_has_impl(CBMFileResult *r, const char *trait_name, const char *struct_name) {
    for (int i = 0; i < r->impl_traits.count; i++) {
        CBMImplTrait *it = &r->impl_traits.items[i];
        if (it->trait_name && strcmp(it->trait_name, trait_name) == 0 && it->struct_name &&
            strcmp(it->struct_name, struct_name) == 0)
            return 1;
    }
    return 0;
}

typedef struct {
    const char *src;
    const char *trait_name;
    const char *struct_name;
} rust_impl_case_t;

static int run_rust_impl(const rust_impl_case_t *tc) {
    CBMFileResult *r = cbm_extract_file(tc->src, (int)strlen(tc->src), CBM_LANG_RUST, "t", "lib.rs",
                                        0, NULL, NULL);
    if (!r) {
        printf("  FAIL  [impl %s for %s] extract returned NULL\n", tc->trait_name, tc->struct_name);
        return 1;
    }
    int found = rust_has_impl(r, tc->trait_name, tc->struct_name);
    if (!found) {
        printf("  FAIL  [impl %s for %s] not found in impl_traits\n", tc->trait_name,
               tc->struct_name);
        cbm_free_result(r);
        return 1;
    }
    cbm_free_result(r);
    return 0;
}

#define RUN_RUST_CASES(table)                                                    \
    do {                                                                         \
        int _fail = 0;                                                           \
        int _n = (int)(sizeof(table) / sizeof(table[0]));                        \
        for (int _i = 0; _i < _n; _i++) {                                        \
            if (run_rust_impl(&table[_i]) != 0)                                  \
                _fail++;                                                         \
        }                                                                        \
        if (_fail > 0) {                                                         \
            printf("  FAIL  %d / %d Rust impl cases above failed\n", _fail, _n); \
            return 1;                                                            \
        }                                                                        \
    } while (0)

static const rust_impl_case_t rust_cases[] = {
    /* ── basic trait impl ───────────────────────────────────────── */
    {"trait Greet { fn greet(&self) -> String; }\n"
     "struct Dog;\nimpl Greet for Dog { fn greet(&self) -> String { \"Woof\".into() } }",
     "Greet", "Dog"},
    /* ── Display trait ───────────────────────────────────────────── */
    {"use std::fmt;\nstruct Point { x: f64, y: f64 }\n"
     "impl fmt::Display for Point { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { "
     "write!(f, \"({},{})\", self.x, self.y) } }",
     "fmt::Display", "Point"},
    /* ── Iterator trait ──────────────────────────────────────────── */
    {"struct Counter { count: u32 }\n"
     "impl Iterator for Counter { type Item = u32; fn next(&mut self) -> Option<u32> { if "
     "self.count < 5 { self.count += 1; Some(self.count) } else { None } } }",
     "Iterator", "Counter"},
    /* ── From trait ──────────────────────────────────────────────── */
    {"struct Meters(f64);\nstruct Feet(f64);\n"
     "impl From<Feet> for Meters { fn from(f: Feet) -> Self { Meters(f.0 * 0.3048) } }",
     "From", "Meters"},
    /* ── Default trait ───────────────────────────────────────────── */
    {"struct Config { debug: bool, level: u32 }\n"
     "impl Default for Config { fn default() -> Self { Config { debug: false, level: 0 } } }",
     "Default", "Config"},
    /* ── PartialEq + Eq ──────────────────────────────────────────── */
    {"struct Id(u64);\nimpl PartialEq for Id { fn eq(&self, other: &Self) -> bool { self.0 == "
     "other.0 } }\nimpl Eq for Id {}",
     "PartialEq", "Id"},
    /* ── Clone + Copy ────────────────────────────────────────────── */
    {"#[derive(Copy)]\nstruct Tag(u8);\nimpl Clone for Tag { fn clone(&self) -> Self { *self } }",
     "Clone", "Tag"},
    /* ── custom trait for generic struct ─────────────────────────── */
    {"trait Serializable { fn serialize(&self) -> Vec<u8>; }\n"
     "struct Buffer<T> { data: Vec<T> }\n"
     "impl<T: Clone> Serializable for Buffer<T> { fn serialize(&self) -> Vec<u8> { vec![] } }",
     "Serializable", "Buffer"},
    /* ── Drop trait ──────────────────────────────────────────────── */
    {"struct Resource { name: String }\n"
     "impl Drop for Resource { fn drop(&mut self) { println!(\"drop {}\", self.name); } }",
     "Drop", "Resource"},
    /* ── crate-qualified trait ───────────────────────────────────── */
    {"mod io { pub trait Write { fn write(&mut self, buf: &[u8]) -> usize; } }\n"
     "struct Socket;\nimpl io::Write for Socket { fn write(&mut self, buf: &[u8]) -> usize { "
     "buf.len() } }",
     "io::Write", "Socket"},
    /* ── trait impl with associated type ────────────────────────── */
    {"trait Producer { type Item; fn produce(&self) -> Self::Item; }\n"
     "struct Factory;\nimpl Producer for Factory { type Item = u32; fn produce(&self) -> u32 { 42 "
     "} }",
     "Producer", "Factory"},
    /* ── Error trait ─────────────────────────────────────────────── */
    {"use std::fmt;\n"
     "#[derive(Debug)]\nstruct AppError { msg: String }\n"
     "impl fmt::Display for AppError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { "
     "write!(f, \"{}\", self.msg) } }\n"
     "impl std::error::Error for AppError {}",
     "std::error::Error", "AppError"},
    /* ── Ord trait for newtype ────────────────────────────────────── */
    {"use std::cmp::Ordering;\n#[derive(Eq, PartialEq)]\nstruct Priority(u8);\n"
     "impl PartialOrd for Priority { fn partial_cmp(&self, other: &Self) -> Option<Ordering> { "
     "Some(self.cmp(other)) } }\n"
     "impl Ord for Priority { fn cmp(&self, other: &Self) -> Ordering { self.0.cmp(&other.0) } }",
     "Ord", "Priority"},
    /* ── Index trait ─────────────────────────────────────────────── */
    {"use std::ops::Index;\nstruct Matrix { data: Vec<f64>, cols: usize }\n"
     "impl Index<(usize, usize)> for Matrix { type Output = f64; fn index(&self, idx: (usize, "
     "usize)) -> &f64 { &self.data[idx.0 * self.cols + idx.1] } }",
     "Index", "Matrix"},
    /* ── Add operator overload ───────────────────────────────────── */
    {"use std::ops::Add;\n#[derive(Clone, Copy)]\nstruct Vec2 { x: f32, y: f32 }\n"
     "impl Add for Vec2 { type Output = Vec2; fn add(self, rhs: Vec2) -> Vec2 { Vec2 { x: self.x + "
     "rhs.x, y: self.y + rhs.y } } }",
     "Add", "Vec2"},
    /* ── Send + Sync safety impls ─────────────────────────────────── */
    {"struct SharedState { data: std::sync::Mutex<Vec<u8>> }\n"
     "unsafe impl Send for SharedState {}\nunsafe impl Sync for SharedState {}",
     "Send", "SharedState"},
    /* ── Deref coercion ──────────────────────────────────────────── */
    {"use std::ops::Deref;\nstruct Wrapper<T>(T);\n"
     "impl<T> Deref for Wrapper<T> { type Target = T; fn deref(&self) -> &T { &self.0 } }",
     "Deref", "Wrapper"},
    /* ── AsRef trait ─────────────────────────────────────────────── */
    {"struct Path(String);\nimpl AsRef<str> for Path { fn as_ref(&self) -> &str { &self.0 } }",
     "AsRef", "Path"},
    /* ── Hash trait ──────────────────────────────────────────────── */
    {"use std::hash::{Hash, Hasher};\n#[derive(Eq, PartialEq)]\nstruct Key(String);\n"
     "impl Hash for Key { fn hash<H: Hasher>(&self, state: &mut H) { self.0.hash(state); } }",
     "Hash", "Key"},
    /* ── serde Serialize / Deserialize (external crate trait) ────── */
    {"trait Serialize { fn serialize(&self) -> String; }\n"
     "trait Deserialize { fn deserialize(s: &str) -> Self; }\n"
     "struct JsonRecord { id: u64 }\n"
     "impl Serialize for JsonRecord { fn serialize(&self) -> String { "
     "format!(\"{{\\\"id\\\":{}}}\", self.id) } }\n"
     "impl Deserialize for JsonRecord { fn deserialize(_s: &str) -> Self { JsonRecord { id: 0 } } "
     "}",
     "Serialize", "JsonRecord"},
};

TEST(inherit_rust_impls) {
    RUN_RUST_CASES(rust_cases);
    PASS();
}

/* ═══════════════════════════════════════════════════════════════════
 * SUITE declaration
 * ═══════════════════════════════════════════════════════════════════ */

SUITE(extraction_inheritance) {
    /* Languages expected GREEN (correct extractors — regression guards) */
    RUN_TEST(inherit_java);
    RUN_TEST(inherit_csharp);
    RUN_TEST(inherit_cpp);
    RUN_TEST(inherit_rust_impls);

    /* Languages expected RED (broken extractors — reproduce-first) */
    RUN_TEST(inherit_python); /* RED: identifier-node not matched in collect_bases_from_field */
    RUN_TEST(
        inherit_typescript); /* RED: keyword "extends"/"implements" captured instead of type name */
    RUN_TEST(inherit_tsx);   /* RED: same keyword-capture bug as TypeScript */
    RUN_TEST(inherit_php);   /* RED: base_classes never populated */
    RUN_TEST(inherit_kotlin); /* RED: `:` supertype syntax not parsed */
}