import t, c
from t import CInt, CExport, CPtr
from stdio import printf
import memhub
import stdlib
import string
from ast import (
    AST, ASTKind, Module, FunctionDef, Assign, If, For, While, With,
    Return, Expr, Name, Constant, BinOp, UnaryOp, Call, Compare,
    Import, ImportFrom, Expression,
    CONST_INT, CONST_STR, CONST_BOOL, CONST_NONE,
    OpKind, ASTCtx,
    FLAG_IS_ASYNC,
    parse, parse_expression, dump,
)


ARENA_SIZE: CInt = 16777216


def main() -> CInt | CExport:
    printf("=== NewAstTest Start ===\n")

    # 初始化分配器
    arena: bytes = stdlib.malloc(ARENA_SIZE)
    if arena is None:
        printf("FAIL: arena alloc failed\n")
        return 1
    pool: memhub.MemBuddy | CPtr = memhub.MemBuddy(arena, ARENA_SIZE)
    if pool is None:
        printf("FAIL: pool init failed\n")
        return 1

    passed: CInt = 0
    failed: CInt = 0

    # --- 分配 dump 缓冲区（用于 AST 反向输出测试） ---
    DUMP_BUF_SIZE: t.CSizeT = 8192
    dump_buf: t.CChar | CPtr = stdlib.malloc(DUMP_BUF_SIZE)
    if dump_buf is None:
        printf("FAIL: dump_buf alloc failed\n")
        stdlib.free(arena)
        return 1

    # --- Test 0: Match 语句 ---
    match_src: str = """match x:
    case 1:
        pass
    case _:
        pass
"""
    match_mod: Module | CPtr = parse(match_src, pool)
    if match_mod is not None and match_mod.kind() == ASTKind.Module:
        passed += 1
        printf("PASS: parse('match x: case 1: ... case _: ...') -> Module\n")
    else:
        failed += 1
        printf("FAIL: parse match with cases failed\n")

    # --- Test 1: Name 节点创建 ---
    name_x: Name | CPtr = Name(pool, "x", ASTCtx.Load)
    if name_x is None:
        printf("FAIL: Name creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: Name('x'), kind=%d\n", name_x.kind())

    # --- Test 2: ConstantInt 节点 ---
    int_42: Constant | CPtr = Constant(pool, CONST_INT, 42, 0.0, None, 1, 0)
    if int_42 is None:
        printf("FAIL: ConstantInt creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: ConstantInt(42), kind=%d, val=%lld\n",
               int_42.kind(), int_42.int_val)

    # --- Test 3: ConstantStr 节点 ---
    str_hello: Constant | CPtr = Constant(pool, CONST_STR, 0, 0.0, "hello", 2, 0)
    if str_hello is None:
        printf("FAIL: ConstantStr creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: ConstantStr('hello'), kind=%d\n", str_hello.kind())

    # --- Test 4: ConstantNone 节点 ---
    const_none: Constant | CPtr = Constant(pool, CONST_NONE, 0, 0.0, None, 3, 0)
    if const_none is None:
        printf("FAIL: ConstantNone creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: ConstantNone, kind=%d\n", const_none.kind())

    # --- Test 5: BinOp 节点 (x + 42) ---
    binop: BinOp | CPtr = BinOp(pool, name_x, OpKind.Add, int_42)
    if binop is None:
        printf("FAIL: BinOp creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: BinOp(Add), kind=%d\n", binop.kind())

    # --- Test 6: UnaryOp 节点 (-x) ---
    unary: UnaryOp | CPtr = UnaryOp(pool, OpKind.USub, name_x)
    if unary is None:
        printf("FAIL: UnaryOp creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: UnaryOp(USub), kind=%d\n", unary.kind())

    # --- Test 7: list[AST | CPtr] 容器 ---
    body: list[AST | CPtr] | CPtr = list[AST | CPtr](pool, 8)
    if body is None:
        printf("FAIL: list creation\n")
        failed += 1
    else:
        body.append(binop)
        body.append(unary)
        cnt: t.CSizeT = body.__len__()
        if cnt == 2:
            passed += 1
            printf("PASS: list append x2, count=%zu\n", cnt)
        else:
            failed += 1
            printf("FAIL: list count=%zu (expected 2)\n", cnt)

    # --- Test 8: list get + kind 分派 ---
    if body is not None:
        item0: AST | CPtr = body.get(0)
        if item0 is not None:
            k: CInt = item0.kind()
            if k == ASTKind.BinOp:
                passed += 1
                printf("PASS: list get(0).kind()=%d (BinOp)\n", k)
            else:
                failed += 1
                printf("FAIL: list get(0).kind()=%d (expected %d)\n", k, ASTKind.BinOp)
        else:
            failed += 1
            printf("FAIL: list get(0) returned None\n")

    # --- Test 9: Module 节点 (新签名：Module(pool) + append) ---
    mod: Module | CPtr = Module(pool)
    if mod is None:
        printf("FAIL: Module creation\n")
        failed += 1
    else:
        mod.append(binop)
        mod.append(unary)
        passed += 1
        printf("PASS: Module, kind=%d\n", mod.kind())

    # --- Test 10: 多态分派 — 通过 AST 基类指针调用 kind() ---
    ast_ptr: AST | CPtr = mod
    poly_kind: CInt = ast_ptr.kind()
    if poly_kind == ASTKind.Module:
        passed += 1
        printf("PASS: polymorphic kind()=%d (Module via AST ptr)\n", poly_kind)
    else:
        failed += 1
        printf("FAIL: polymorphic kind()=%d (expected %d)\n", poly_kind, ASTKind.Module)

    # --- Test 11: 多态分派 — list 中的节点 ---
    if body is not None:
        ast_item: AST | CPtr = body.get(1)
        if ast_item is not None:
            pk2: CInt = ast_item.kind()
            if pk2 == ASTKind.UnaryOp:
                passed += 1
                printf("PASS: polymorphic kind()=%d (UnaryOp via AST ptr)\n", pk2)
            else:
                failed += 1
                printf("FAIL: polymorphic kind()=%d (expected %d)\n", pk2, ASTKind.UnaryOp)
        else:
            failed += 1
            printf("FAIL: list get(1) returned None\n")

    # --- Test 12: Return 节点 ---
    ret: Return | CPtr = Return(pool, binop)
    if ret is None:
        printf("FAIL: Return creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: Return, kind=%d\n", ret.kind())

    # --- Test 13: Expr 语句节点 ---
    expr_stmt: Expr | CPtr = Expr(pool, binop)
    if expr_stmt is None:
        printf("FAIL: Expr creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: Expr, kind=%d\n", expr_stmt.kind())

    # --- Test 14: If 节点 (新签名：If(pool, test, orelse)，body=children) ---
    empty_else: list[AST | CPtr] | CPtr = list[AST | CPtr](pool, 8)
    if_stmt: If | CPtr = If(pool, binop, empty_else)
    if if_stmt is None:
        printf("FAIL: If creation\n")
        failed += 1
    else:
        if_stmt.append(ret)
        if_stmt.append(expr_stmt)
        passed += 1
        printf("PASS: If, kind=%d\n", if_stmt.kind())

    # --- Test 15: Compare 节点 ---
    cmp_ops: list[t.CInt] | CPtr = list[t.CInt](pool)
    cmp_ops.append(OpKind.Lt)
    cmp_comparators: list[AST | CPtr] | CPtr = list[AST | CPtr](pool, 8)
    cmp_comparators.append(int_42)
    cmp_node: Compare | CPtr = Compare(pool, name_x, cmp_ops, cmp_comparators)
    if cmp_node is None:
        printf("FAIL: Compare creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: Compare, kind=%d\n", cmp_node.kind())

    # --- Test 16: Assign 节点 ---
    assign_targets: list[AST | CPtr] | CPtr = list[AST | CPtr](pool, 8)
    assign_targets.append(name_x)
    assign_node: Assign | CPtr = Assign(pool, assign_targets, int_42)
    if assign_node is None:
        printf("FAIL: Assign creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: Assign, kind=%d\n", assign_node.kind())

    # --- Test 17: Call 节点 ---
    call_args: list[AST | CPtr] | CPtr = list[AST | CPtr](pool, 8)
    call_args.append(int_42)
    call_kwargs: list[AST | CPtr] | CPtr = list[AST | CPtr](pool, 8)
    call_node: Call | CPtr = Call(pool, name_x, call_args, call_kwargs)
    if call_node is None:
        printf("FAIL: Call creation\n")
        failed += 1
    else:
        passed += 1
        printf("PASS: Call, kind=%d\n", call_node.kind())

    # --- Test 18: 字段访问验证 ---
    if name_x is not None:
        nm: str = name_x.id
        if nm is not None:
            if string.strcmp(nm, "x") == 0:
                passed += 1
                printf("PASS: Name.id == 'x'\n")
            else:
                failed += 1
                printf("FAIL: Name.id != 'x'\n")
        else:
            failed += 1
            printf("FAIL: Name.id is None\n")

    # --- Test 19: parent 指针验证 (binop 被 append 到 mod) ---
    if binop is not None and binop.parent is mod:
        passed += 1
        printf("PASS: BinOp.parent == Module (via append)\n")
    else:
        failed += 1
        printf("FAIL: BinOp.parent != Module\n")

    # --- Test 20: Module.children 遍历 ---
    if mod is not None and mod.children is not None:
        mod_cnt: t.CSizeT = mod.children.__len__()
        if mod_cnt == 2:
            passed += 1
            printf("PASS: Module.children count=%zu (expected 2)\n", mod_cnt)
        else:
            failed += 1
            printf("FAIL: Module.children count=%zu (expected 2)\n", mod_cnt)
    else:
        failed += 1
        printf("FAIL: Module.children is None\n")

    # --- Test 21: Module.children 多态分派 ---
    if mod is not None and mod.children is not None:
        c0: AST | CPtr = mod.children.get(0)
        c1: AST | CPtr = mod.children.get(1)
        if c0 is not None and c1 is not None:
            k0: CInt = c0.kind()
            k1: CInt = c1.kind()
            if k0 == ASTKind.BinOp and k1 == ASTKind.UnaryOp:
                passed += 1
                printf("PASS: Module.children[0]=BinOp, [1]=UnaryOp\n")
            else:
                failed += 1
                printf("FAIL: Module.children kinds=%d,%d\n", k0, k1)
        else:
            failed += 1
            printf("FAIL: Module.children get returned None\n")
    else:
        failed += 1
        printf("FAIL: Module.children unavailable\n")

    # --- Test 22: If.children 遍历 (ret + expr_stmt) ---
    if if_stmt is not None and if_stmt.children is not None:
        if_cnt: t.CSizeT = if_stmt.children.__len__()
        if if_cnt == 2:
            passed += 1
            printf("PASS: If.children count=%zu (expected 2)\n", if_cnt)
        else:
            failed += 1
            printf("FAIL: If.children count=%zu (expected 2)\n", if_cnt)
    else:
        failed += 1
        printf("FAIL: If.children is None\n")

    # --- Test 23: parent 向上遍历 (if_stmt.children[0].parent == if_stmt) ---
    if if_stmt is not None and if_stmt.children is not None:
        first_child: AST | CPtr = if_stmt.children.get(0)
        if first_child is not None and first_child.parent is if_stmt:
            passed += 1
            printf("PASS: If.children[0].parent == If\n")
        else:
            failed += 1
            printf("FAIL: If.children[0].parent != If\n")
    else:
        failed += 1
        printf("FAIL: If.children unavailable for parent test\n")

    # --- Test 24: parse_expression 解析 "x + 42" ---
    expr_src: str = "x + 42"
    expr_tree: AST | CPtr = parse_expression(expr_src, pool)
    if expr_tree is not None:
        passed += 1
        printf("PASS: parse_expression('x + 42') -> kind=%d\n", expr_tree.kind())
    else:
        failed += 1
        printf("FAIL: parse_expression returned None\n")

    # --- Test 25: parse 解析简单模块 "x = 42\n" ---
    mod_src: str = "x = 42\n"
    parsed_mod: Module | CPtr = parse(mod_src, pool)
    if parsed_mod is not None and parsed_mod.kind() == ASTKind.Module:
        passed += 1
        printf("PASS: parse('x = 42') -> Module, kind=%d\n", parsed_mod.kind())
    else:
        failed += 1
        printf("FAIL: parse('x = 42') failed\n")

    # --- Test 26: parse 模块的 children 验证 ---
    if parsed_mod is not None and parsed_mod.children is not None:
        pmod_cnt: t.CSizeT = parsed_mod.children.__len__()
        if pmod_cnt == 1:
            passed += 1
            printf("PASS: parsed Module.children count=%zu (expected 1)\n", pmod_cnt)
        else:
            failed += 1
            printf("FAIL: parsed Module.children count=%zu (expected 1)\n", pmod_cnt)
    else:
        failed += 1
        printf("FAIL: parsed Module.children is None\n")

    # --- Test 27: parse 模块子节点类型验证 (Assign) ---
    if parsed_mod is not None and parsed_mod.children is not None:
        pmod_child: AST | CPtr = parsed_mod.children.get(0)
        if pmod_child is not None:
            pmod_k: CInt = pmod_child.kind()
            if pmod_k == ASTKind.Assign:
                passed += 1
                printf("PASS: parsed Module.children[0].kind()=%d (Assign)\n", pmod_k)
            else:
                failed += 1
                printf("FAIL: parsed Module.children[0].kind()=%d (expected %d)\n",
                       pmod_k, ASTKind.Assign)
        else:
            failed += 1
            printf("FAIL: parsed Module.children.get(0) returned None\n")
    else:
        failed += 1
        printf("FAIL: parsed Module.children unavailable for kind test\n")

    # --- Test 28: parse 多语句模块 ---
    multi_src: str = """a = 1
b = 2
c = a + b
"""
    multi_mod: Module | CPtr = parse(multi_src, pool)
    if multi_mod is not None and multi_mod.children is not None:
        multi_cnt: t.CSizeT = multi_mod.children.__len__()
        if multi_cnt == 3:
            passed += 1
            printf("PASS: parse multi-stmt, children=%zu (expected 3)\n", multi_cnt)
        else:
            failed += 1
            printf("FAIL: parse multi-stmt, children=%zu (expected 3)\n", multi_cnt)
    else:
        failed += 1
        printf("FAIL: parse multi-stmt failed\n")

    # --- Test 29: parse if 语句 ---
    if_src: str = """if x > 0:
    y = 1
"""
    if_mod: Module | CPtr = parse(if_src, pool)
    if if_mod is not None and if_mod.children is not None:
        if_cnt2: t.CSizeT = if_mod.children.__len__()
        if_k: CInt = if_mod.children.get(0).kind()
        if if_cnt2 == 1 and if_k == ASTKind.If:
            passed += 1
            printf("PASS: parse if, children=%zu kind=%d (If)\n", if_cnt2, if_k)
        else:
            failed += 1
            printf("FAIL: parse if, children=%zu kind=%d\n", if_cnt2, if_k)
    else:
        failed += 1
        printf("FAIL: parse if failed\n")

    # --- Test 30: parse for 循环 ---
    for_src: str = """for i in range(10):
    pass
"""
    for_mod: Module | CPtr = parse(for_src, pool)
    if for_mod is not None and for_mod.children is not None:
        for_cnt: t.CSizeT = for_mod.children.__len__()
        for_k: CInt = for_mod.children.get(0).kind()
        if for_cnt == 1 and for_k == ASTKind.For:
            passed += 1
            printf("PASS: parse for, children=%zu kind=%d (For)\n", for_cnt, for_k)
        else:
            failed += 1
            printf("FAIL: parse for, children=%zu kind=%d\n", for_cnt, for_k)
    else:
        failed += 1
        printf("FAIL: parse for failed\n")

    # --- Test 31: parse while 循环 ---
    while_src: str = """while x < 100:
    x = x + 1
"""
    while_mod: Module | CPtr = parse(while_src, pool)
    if while_mod is not None and while_mod.children is not None:
        while_cnt: t.CSizeT = while_mod.children.__len__()
        while_k: CInt = while_mod.children.get(0).kind()
        if while_cnt == 1 and while_k == ASTKind.While:
            passed += 1
            printf("PASS: parse while, children=%zu kind=%d (While)\n", while_cnt, while_k)
        else:
            failed += 1
            printf("FAIL: parse while, children=%zu kind=%d\n", while_cnt, while_k)
    else:
        failed += 1
        printf("FAIL: parse while failed\n")

    # --- Test 32: parse 函数定义 ---
    def_src: str = """def foo(a, b):
    return a + b
"""
    def_mod: Module | CPtr = parse(def_src, pool)
    if def_mod is not None and def_mod.children is not None:
        def_cnt: t.CSizeT = def_mod.children.__len__()
        def_k: CInt = def_mod.children.get(0).kind()
        if def_cnt == 1 and def_k == ASTKind.FunctionDef:
            passed += 1
            printf("PASS: parse def, children=%zu kind=%d (FunctionDef)\n", def_cnt, def_k)
        else:
            failed += 1
            printf("FAIL: parse def, children=%zu kind=%d\n", def_cnt, def_k)
    else:
        failed += 1
        printf("FAIL: parse def failed\n")

    # --- Test 33: parse 复杂表达式 (a + b * c - 1) ---
    complex_expr_src: str = "a + b * c - 1"
    complex_expr: AST | CPtr = parse_expression(complex_expr_src, pool)
    if complex_expr is not None:
        ce_k: CInt = complex_expr.kind()
        if ce_k == ASTKind.Expression:
            passed += 1
            printf("PASS: parse complex expr, kind=%d (Expression)\n", ce_k)
        else:
            failed += 1
            printf("FAIL: parse complex expr, kind=%d\n", ce_k)
    else:
        failed += 1
        printf("FAIL: parse complex expr failed\n")

    # --- Test 34: parse 嵌套语句 (for 内 if) ---
    nested_src: str = """for i in range(10):
    if i > 5:
        x = 1
"""
    nested_mod: Module | CPtr = parse(nested_src, pool)
    if nested_mod is not None and nested_mod.children is not None:
        nested_cnt: t.CSizeT = nested_mod.children.__len__()
        nested_k: CInt = nested_mod.children.get(0).kind()
        if nested_cnt == 1 and nested_k == ASTKind.For:
            passed += 1
            printf("PASS: parse nested for-if, children=%zu kind=%d (For)\n", nested_cnt, nested_k)
        else:
            failed += 1
            printf("FAIL: parse nested for-if, children=%zu kind=%d\n", nested_cnt, nested_k)
    else:
        failed += 1
        printf("FAIL: parse nested for-if failed\n")

    # --- Test 35: parse 混合多语句模块 ---
    mixed_src: str = """x = 1
y = 2
if x < y:
    z = x + y
else:
    z = 0
w = z * 2
"""
    mixed_mod: Module | CPtr = parse(mixed_src, pool)
    if mixed_mod is not None and mixed_mod.children is not None:
        mixed_cnt: t.CSizeT = mixed_mod.children.__len__()
        if mixed_cnt == 4:
            passed += 1
            printf("PASS: parse mixed module, children=%zu (expected 4)\n", mixed_cnt)
        else:
            failed += 1
            printf("FAIL: parse mixed module, children=%zu (expected 4)\n", mixed_cnt)
    else:
        failed += 1
        printf("FAIL: parse mixed module failed\n")

    # --- Test 36: dump 反向 - parse("x = 42") → dump → strstr 验证 ---
    if parsed_mod is not None:
        dump(parsed_mod, dump_buf, DUMP_BUF_SIZE)
        has_assign: str = string.strstr(dump_buf, "Assign")
        has_42: str = string.strstr(dump_buf, "42")
        if has_assign is not None and has_42 is not None:
            passed += 1
            printf("PASS: dump parse('x = 42') contains 'Assign' and '42'\n")
        else:
            failed += 1
            printf("FAIL: dump parse('x = 42') missing tokens\n")
    else:
        failed += 1
        printf("FAIL: parsed_mod unavailable for dump test\n")

    # --- Test 37: dump 反向 - parse_expression("x + 42 * 2") → dump → strstr BinOp ---
    if complex_expr is not None:
        dump(complex_expr, dump_buf, DUMP_BUF_SIZE)
        has_binop: str = string.strstr(dump_buf, "BinOp")
        if has_binop is not None:
            passed += 1
            printf("PASS: dump complex expr contains 'BinOp'\n")
        else:
            failed += 1
            printf("FAIL: dump complex expr missing 'BinOp'\n")
    else:
        failed += 1
        printf("FAIL: complex_expr unavailable for dump test\n")

    # --- Test 38: dump 反向 - parse if → dump → strstr "If" + "Compare" ---
    if if_mod is not None:
        dump(if_mod, dump_buf, DUMP_BUF_SIZE)
        has_if: str = string.strstr(dump_buf, "If(")
        has_cmp: str = string.strstr(dump_buf, "Compare")
        if has_if is not None and has_cmp is not None:
            passed += 1
            printf("PASS: dump parse if contains 'If(' and 'Compare'\n")
        else:
            failed += 1
            printf("FAIL: dump parse if missing tokens\n")
    else:
        failed += 1
        printf("FAIL: if_mod unavailable for dump test\n")

    # --- Test 39: dump 反向 - parse def → dump → strstr "FunctionDef" ---
    if def_mod is not None:
        dump(def_mod, dump_buf, DUMP_BUF_SIZE)
        has_fdef: str = string.strstr(dump_buf, "FunctionDef")
        if has_fdef is not None:
            passed += 1
            printf("PASS: dump parse def contains 'FunctionDef'\n")
        else:
            failed += 1
            printf("FAIL: dump parse def missing 'FunctionDef'\n")
    else:
        failed += 1
        printf("FAIL: def_mod unavailable for dump test\n")

    # --- Test 40: AST 结构化输出 - dump 多语句模块完整输出 ---
    if mixed_mod is not None:
        dump(mixed_mod, dump_buf, DUMP_BUF_SIZE)
        printf("--- AST dump of mixed module ---\n%s\n--- end dump ---\n", dump_buf)
        # 验证包含多种节点
        has_m_assign: str = string.strstr(dump_buf, "Assign")
        has_m_if: str = string.strstr(dump_buf, "If(")
        if has_m_assign is not None and has_m_if is not None:
            passed += 1
            printf("PASS: structured dump of mixed module contains Assign + If\n")
        else:
            failed += 1
            printf("FAIL: structured dump of mixed module missing nodes\n")
    else:
        failed += 1
        printf("FAIL: mixed_mod unavailable for structured dump\n")

    # --- Test 41: AST 结构化输出 - dump for 循环完整输出 ---
    if for_mod is not None:
        dump(for_mod, dump_buf, DUMP_BUF_SIZE)
        printf("--- AST dump of for loop ---\n%s\n--- end dump ---\n", dump_buf)
        has_for: str = string.strstr(dump_buf, "For(")
        if has_for is not None:
            passed += 1
            printf("PASS: structured dump of for loop contains 'For('\n")
        else:
            failed += 1
            printf("FAIL: structured dump of for loop missing 'For('\n")
    else:
        failed += 1
        printf("FAIL: for_mod unavailable for structured dump\n")

    # --- Test 42: type_name 多态分派验证 ---
    if parsed_mod is not None and parsed_mod.children is not None:
        tn_node: AST | CPtr = parsed_mod.children.get(0)
        if tn_node is not None:
            tn: str = tn_node.type_name()
            if tn is not None and string.strcmp(tn, "Assign") == 0:
                passed += 1
                printf("PASS: type_name() = 'Assign' (polymorphic)\n")
            else:
                failed += 1
                printf("FAIL: type_name() != 'Assign'\n")
        else:
            failed += 1
            printf("FAIL: type_name test node None\n")
    else:
        failed += 1
        printf("FAIL: parsed_mod unavailable for type_name test\n")

    # --- Test 43: parse 类定义 ---
    class_src: str = """class Foo(Base):
    x = 1
    def bar(self):
        return self.x
"""
    class_mod: Module | CPtr = parse(class_src, pool)
    if class_mod is not None and class_mod.children is not None:
        class_cnt: t.CSizeT = class_mod.children.__len__()
        class_k: CInt = class_mod.children.get(0).kind()
        if class_cnt == 1 and class_k == ASTKind.ClassDef:
            passed += 1
            printf("PASS: parse class, children=%zu kind=%d (ClassDef)\n", class_cnt, class_k)
        else:
            failed += 1
            printf("FAIL: parse class, children=%zu kind=%d\n", class_cnt, class_k)
    else:
        failed += 1
        printf("FAIL: parse class failed\n")

    # --- Test 44: parse try/except ---
    try_src: str = """try:
    x = 1
except:
    x = 0
"""
    try_mod: Module | CPtr = parse(try_src, pool)
    if try_mod is not None and try_mod.children is not None:
        try_cnt: t.CSizeT = try_mod.children.__len__()
        try_k: CInt = try_mod.children.get(0).kind()
        if try_cnt == 1 and try_k == ASTKind.Try:
            passed += 1
            printf("PASS: parse try/except, children=%zu kind=%d (Try)\n", try_cnt, try_k)
        else:
            failed += 1
            printf("FAIL: parse try/except, children=%zu kind=%d\n", try_cnt, try_k)
    else:
        failed += 1
        printf("FAIL: parse try/except failed\n")

    # --- Test 45: parse import 语句 ---
    import_src: str = """import os
from sys import path
"""
    import_mod: Module | CPtr = parse(import_src, pool)
    if import_mod is not None and import_mod.children is not None:
        import_cnt: t.CSizeT = import_mod.children.__len__()
        k0: CInt = import_mod.children.get(0).kind()
        k1: CInt = import_mod.children.get(1).kind()
        if import_cnt == 2 and k0 == ASTKind.Import and k1 == ASTKind.ImportFrom:
            passed += 1
            printf("PASS: parse import, children=%zu k0=%d(Import) k1=%d(ImportFrom)\n",
                   import_cnt, k0, k1)
        else:
            failed += 1
            printf("FAIL: parse import, children=%zu k0=%d k1=%d\n", import_cnt, k0, k1)
    else:
        failed += 1
        printf("FAIL: parse import failed\n")

    # --- Test 46: parse AugAssign (x += 1) ---
    aug_src: str = """x = 0
x += 1
"""
    aug_mod: Module | CPtr = parse(aug_src, pool)
    if aug_mod is not None and aug_mod.children is not None:
        aug_cnt: t.CSizeT = aug_mod.children.__len__()
        aug_k: CInt = aug_mod.children.get(1).kind()
        if aug_cnt == 2 and aug_k == ASTKind.AugAssign:
            passed += 1
            printf("PASS: parse AugAssign, children=%zu kind=%d (AugAssign)\n", aug_cnt, aug_k)
        else:
            failed += 1
            printf("FAIL: parse AugAssign, children=%zu kind=%d\n", aug_cnt, aug_k)
    else:
        failed += 1
        printf("FAIL: parse AugAssign failed\n")

    # --- Test 47: parse 条件表达式 (x if y else z) ---
    ifexp_src: str = "x if y else z"
    ifexp_tree: AST | CPtr = parse_expression(ifexp_src, pool)
    ifexp_expr: Expression | CPtr = (Expression | CPtr)(ifexp_tree)
    if ifexp_expr is not None and ifexp_expr.body is not None:
        ie_k: CInt = ifexp_expr.body.kind()
        if ie_k == ASTKind.IfExp:
            passed += 1
            printf("PASS: parse IfExp, kind=%d (IfExp)\n", ie_k)
        else:
            failed += 1
            printf("FAIL: parse IfExp, kind=%d\n", ie_k)
    else:
        failed += 1
        printf("FAIL: parse IfExp failed\n")

    # --- Test 48: parse 嵌套函数定义 ---
    nested_def_src: str = """def outer():
    x = 1
    def inner():
        return x
    return inner()
"""
    nested_def_mod: Module | CPtr = parse(nested_def_src, pool)
    if nested_def_mod is not None and nested_def_mod.children is not None:
        nd_cnt: t.CSizeT = nested_def_mod.children.__len__()
        nd_k: CInt = nested_def_mod.children.get(0).kind()
        if nd_cnt == 1 and nd_k == ASTKind.FunctionDef:
            passed += 1
            printf("PASS: parse nested def, children=%zu kind=%d (FunctionDef)\n", nd_cnt, nd_k)
        else:
            failed += 1
            printf("FAIL: parse nested def, children=%zu kind=%d\n", nd_cnt, nd_k)
    else:
        failed += 1
        printf("FAIL: parse nested def failed\n")

    # --- Test 49: dump 复杂代码 (类 + try + 嵌套函数) ---
    complex_src: str = """class Foo(Base):
    x = 1
try:
    y = Foo()
except:
    y = None
def bar():
    return y
"""
    complex_mod: Module | CPtr = parse(complex_src, pool)
    if complex_mod is not None:
        dump(complex_mod, dump_buf, DUMP_BUF_SIZE)
        printf("--- AST dump of complex module ---\n%s\n--- end dump ---\n", dump_buf)
        has_cls: str = string.strstr(dump_buf, "ClassDef")
        has_try: str = string.strstr(dump_buf, "Try")
        has_fdef2: str = string.strstr(dump_buf, "FunctionDef")
        if has_cls is not None and has_try is not None and has_fdef2 is not None:
            passed += 1
            printf("PASS: dump complex module contains ClassDef + Try + FunctionDef\n")
        else:
            failed += 1
            printf("FAIL: dump complex module missing nodes\n")
    else:
        failed += 1
        printf("FAIL: parse complex module failed\n")

    # --- Test 50: 复杂 mixed_src - 综合语法实例 ---
    complex_mixed_src: str = """def gcd(a, b):
    while b:
        t = b
        b = a % b
        a = t
    return a
x = gcd(48, 36)
if x > 1 and x < 100:
    y = x * 2 + 1
elif x == 1:
    y = 1
else:
    y = 0
"""
    cmix_mod: Module | CPtr = parse(complex_mixed_src, pool)
    if cmix_mod is not None and cmix_mod.children is not None:
        cmix_cnt: t.CSizeT = cmix_mod.children.__len__()
        dump(cmix_mod, dump_buf, DUMP_BUF_SIZE)
        printf("--- AST dump of complex mixed ---\n%s\n--- end dump ---\n", dump_buf)
        cm_def: str = string.strstr(dump_buf, "FunctionDef")
        cm_while: str = string.strstr(dump_buf, "While(")
        cm_call: str = string.strstr(dump_buf, "Call(")
        cm_bool: str = string.strstr(dump_buf, "BoolOp(")
        cm_cmp: str = string.strstr(dump_buf, "Compare(")
        cm_ret: str = string.strstr(dump_buf, "Return(")
        ok: t.CInt = 0
        if cmix_cnt == 3:
            if cm_def is not None and cm_while is not None:
                if cm_call is not None and cm_bool is not None:
                    if cm_cmp is not None and cm_ret is not None:
                        ok = 1
        if ok == 1:
            passed += 1
            printf("PASS: complex mixed_src, children=%zu contains Def+While+Call+BoolOp+Compare+Return\n", cmix_cnt)
        else:
            failed += 1
            printf("FAIL: complex mixed_src, children=%zu def=%d while=%d call=%d bool=%d cmp=%d ret=%d\n",
                   cmix_cnt, cm_def is not None, cm_while is not None,
                   cm_call is not None, cm_bool is not None, cm_cmp is not None,
                   cm_ret is not None)
    else:
        failed += 1
        printf("FAIL: complex mixed_src parse failed\n")

    # --- Test 51: Lambda 表达式 ---
    lambda_src: str = "f = lambda x: x + 1"
    lambda_mod: Module | CPtr = parse(lambda_src, pool)
    if lambda_mod is not None:
        dump(lambda_mod, dump_buf, DUMP_BUF_SIZE)
        has_lambda: str = string.strstr(dump_buf, "Lambda(")
        has_arg: str = string.strstr(dump_buf, "Arg(arg='x'")
        if has_lambda is not None and has_arg is not None:
            passed += 1
            printf("PASS: Lambda with arg parsed\n")
        else:
            failed += 1
            printf("FAIL: Lambda parse, lambda=%d arg=%d\n",
                   has_lambda is not None, has_arg is not None)
    else:
        failed += 1
        printf("FAIL: Lambda parse returned None\n")

    # --- Test 52: List comprehension ---
    listcomp_src: str = "squares = [x*x for x in range(10)]"
    lc_mod: Module | CPtr = parse(listcomp_src, pool)
    if lc_mod is not None:
        dump(lc_mod, dump_buf, DUMP_BUF_SIZE)
        has_lc: str = string.strstr(dump_buf, "ListComp(")
        has_comp: str = string.strstr(dump_buf, "Comprehension(")
        if has_lc is not None and has_comp is not None:
            passed += 1
            printf("PASS: ListComp with Comprehension parsed\n")
        else:
            failed += 1
            printf("FAIL: ListComp parse, lc=%d comp=%d\n",
                   has_lc is not None, has_comp is not None)
    else:
        failed += 1
        printf("FAIL: ListComp parse returned None\n")

    # --- Test 53: Dict comprehension ---
    dictcomp_src: str = "d = {k: v for k, v in items}"
    dc_mod: Module | CPtr = parse(dictcomp_src, pool)
    if dc_mod is not None:
        dump(dc_mod, dump_buf, DUMP_BUF_SIZE)
        has_dc: str = string.strstr(dump_buf, "DictComp(")
        if has_dc is not None:
            passed += 1
            printf("PASS: DictComp parsed\n")
        else:
            failed += 1
            printf("FAIL: DictComp parse, dc=%d\n", has_dc is not None)
    else:
        failed += 1
        printf("FAIL: DictComp parse returned None\n")

    # --- Test 54: Set comprehension ---
    setcomp_src: str = "s = {x for x in items}"
    sc_mod: Module | CPtr = parse(setcomp_src, pool)
    if sc_mod is not None:
        dump(sc_mod, dump_buf, DUMP_BUF_SIZE)
        has_sc: str = string.strstr(dump_buf, "SetComp(")
        if has_sc is not None:
            passed += 1
            printf("PASS: SetComp parsed\n")
        else:
            failed += 1
            printf("FAIL: SetComp parse, sc=%d\n", has_sc is not None)
    else:
        failed += 1
        printf("FAIL: SetComp parse returned None\n")

    # --- Test 55: With 语句 ---
    with_src: str = """with open('f') as f:
    data = f.read()
"""
    with_mod: Module | CPtr = parse(with_src, pool)
    if with_mod is not None and with_mod.children is not None:
        dump(with_mod, dump_buf, DUMP_BUF_SIZE)
        has_with: str = string.strstr(dump_buf, "With(")
        has_witem: str = string.strstr(dump_buf, "WithItem(")
        if has_with is not None and has_witem is not None:
            passed += 1
            printf("PASS: With + WithItem parsed\n")
        else:
            failed += 1
            printf("FAIL: With parse, with=%d witem=%d\n",
                   has_with is not None, has_witem is not None)
    else:
        failed += 1
        printf("FAIL: With parse returned None\n")

    # --- Test 56: Raise 语句 ---
    raise_src: str = "raise ValueError('bad')"
    raise_mod: Module | CPtr = parse(raise_src, pool)
    if raise_mod is not None:
        dump(raise_mod, dump_buf, DUMP_BUF_SIZE)
        has_raise: str = string.strstr(dump_buf, "Raise(")
        if has_raise is not None:
            passed += 1
            printf("PASS: Raise parsed\n")
        else:
            failed += 1
            printf("FAIL: Raise parse, raise=%d\n", has_raise is not None)
    else:
        failed += 1
        printf("FAIL: Raise parse returned None\n")

    # --- Test 57: Assert 语句 ---
    assert_src: str = "assert x > 0, 'x must be positive'"
    assert_mod: Module | CPtr = parse(assert_src, pool)
    if assert_mod is not None:
        dump(assert_mod, dump_buf, DUMP_BUF_SIZE)
        has_assert: str = string.strstr(dump_buf, "Assert(")
        if has_assert is not None:
            passed += 1
            printf("PASS: Assert parsed\n")
        else:
            failed += 1
            printf("FAIL: Assert parse, assert=%d\n", has_assert is not None)
    else:
        failed += 1
        printf("FAIL: Assert parse returned None\n")

    # --- Test 58: Del 语句 ---
    del_src: str = "del x"
    del_mod: Module | CPtr = parse(del_src, pool)
    if del_mod is not None:
        dump(del_mod, dump_buf, DUMP_BUF_SIZE)
        has_del: str = string.strstr(dump_buf, "Delete(")
        if has_del is not None:
            passed += 1
            printf("PASS: Delete parsed\n")
        else:
            failed += 1
            printf("FAIL: Delete parse, del=%d\n", has_del is not None)
    else:
        failed += 1
        printf("FAIL: Delete parse returned None\n")

    # --- Test 59: Subscript + Slice ---
    slice_src: str = "y = a[1:3]"
    slice_mod: Module | CPtr = parse(slice_src, pool)
    if slice_mod is not None:
        dump(slice_mod, dump_buf, DUMP_BUF_SIZE)
        has_sub: str = string.strstr(dump_buf, "Subscript(")
        has_slice: str = string.strstr(dump_buf, "Slice(")
        if has_sub is not None and has_slice is not None:
            passed += 1
            printf("PASS: Subscript + Slice parsed\n")
        else:
            failed += 1
            printf("FAIL: Slice parse, sub=%d slice=%d\n",
                   has_sub is not None, has_slice is not None)
    else:
        failed += 1
        printf("FAIL: Slice parse returned None\n")

    # --- Test 60: Tuple 解包 ---
    tuple_src: str = "a, b = 1, 2"
    tuple_mod: Module | CPtr = parse(tuple_src, pool)
    if tuple_mod is not None:
        dump(tuple_mod, dump_buf, DUMP_BUF_SIZE)
        has_tuple: str = string.strstr(dump_buf, "Tuple(")
        if has_tuple is not None:
            passed += 1
            printf("PASS: Tuple unpacking parsed\n")
        else:
            failed += 1
            printf("FAIL: Tuple parse, tuple=%d\n", has_tuple is not None)
    else:
        failed += 1
        printf("FAIL: Tuple parse returned None\n")

    # --- Test 61: 默认参数 + 关键字参数签名 ---
    defdef_src: str = "def f(a, b=10): return a + b"
    defdef_mod: Module | CPtr = parse(defdef_src, pool)
    if defdef_mod is not None:
        dump(defdef_mod, dump_buf, DUMP_BUF_SIZE)
        has_fdef: str = string.strstr(dump_buf, "FunctionDef(name='f'")
        has_def: str = string.strstr(dump_buf, "Constant(value=10)")
        if has_fdef is not None and has_def is not None:
            passed += 1
            printf("PASS: FunctionDef with default arg parsed\n")
        else:
            failed += 1
            printf("FAIL: defdef parse, fdef=%d def=%d\n",
                   has_fdef is not None, has_def is not None)
    else:
        failed += 1
        printf("FAIL: defdef parse returned None\n")

    # --- Test 62: 装饰器 ---
    deco_src: str = """@my_dec
def f():
    pass
"""
    deco_mod: Module | CPtr = parse(deco_src, pool)
    if deco_mod is not None:
        dump(deco_mod, dump_buf, DUMP_BUF_SIZE)
        has_dec: str = string.strstr(dump_buf, "decorator_list=[Name(id='my_dec'")
        if has_dec is not None:
            passed += 1
            printf("PASS: Decorator parsed\n")
        else:
            failed += 1
            printf("FAIL: Decorator parse, dec=%d\n", has_dec is not None)
    else:
        failed += 1
        printf("FAIL: Decorator parse returned None\n")

    # --- Test 63: 链式赋值 ---
    chain_src: str = "a = b = c = 42"
    chain_mod: Module | CPtr = parse(chain_src, pool)
    if chain_mod is not None:
        dump(chain_mod, dump_buf, DUMP_BUF_SIZE)
        has_chain: str = string.strstr(dump_buf, "Assign(targets=[Name(id='a'")
        has_b: str = string.strstr(dump_buf, "Name(id='b'")
        has_c: str = string.strstr(dump_buf, "Name(id='c'")
        if has_chain is not None and has_b is not None and has_c is not None:
            passed += 1
            printf("PASS: Chain assignment a=b=c=42 parsed\n")
        else:
            failed += 1
            printf("FAIL: Chain, a=%d b=%d c=%d\n",
                   has_chain is not None, has_b is not None, has_c is not None)
    else:
        failed += 1
        printf("FAIL: Chain parse returned None\n")

    # --- Test 64: 位运算 ---
    bit_src: str = "y = (a | b) & c ^ d << 2"
    bit_mod: Module | CPtr = parse(bit_src, pool)
    if bit_mod is not None:
        dump(bit_mod, dump_buf, DUMP_BUF_SIZE)
        has_bor: str = string.strstr(dump_buf, "op=BitOr")
        has_band: str = string.strstr(dump_buf, "op=BitAnd")
        has_bxor: str = string.strstr(dump_buf, "op=BitXor")
        if has_bor is not None and has_band is not None and has_bxor is not None:
            passed += 1
            printf("PASS: Bit ops (| & ^) parsed\n")
        else:
            failed += 1
            printf("FAIL: Bit ops, bor=%d band=%d bxor=%d\n",
                   has_bor is not None, has_band is not None, has_bxor is not None)
    else:
        failed += 1
        printf("FAIL: Bit ops parse returned None\n")

    # --- Test 65: 多继承 + 多装饰器 ---
    multi_src: str = """@dec1
@dec2
class C(Base1, Base2):
    pass
"""
    multi_mod: Module | CPtr = parse(multi_src, pool)
    if multi_mod is not None:
        dump(multi_mod, dump_buf, DUMP_BUF_SIZE)
        m_dec1: str = string.strstr(dump_buf, "Name(id='dec1'")
        m_dec2: str = string.strstr(dump_buf, "Name(id='dec2'")
        m_b1: str = string.strstr(dump_buf, "Name(id='Base1'")
        m_b2: str = string.strstr(dump_buf, "Name(id='Base2'")
        if m_dec1 is not None and m_dec2 is not None and m_b1 is not None and m_b2 is not None:
            passed += 1
            printf("PASS: Multi-decorator + multi-inheritance parsed\n")
        else:
            failed += 1
            printf("FAIL: multi, dec1=%d dec2=%d b1=%d b2=%d\n",
                   m_dec1 is not None, m_dec2 is not None,
                   m_b1 is not None, m_b2 is not None)
    else:
        failed += 1
        printf("FAIL: multi parse returned None\n")

    # --- Test 66: Global / Nonlocal ---
    glob_src: str = """def f():
    global x
    x = 1
"""
    glob_mod: Module | CPtr = parse(glob_src, pool)
    if glob_mod is not None:
        dump(glob_mod, dump_buf, DUMP_BUF_SIZE)
        has_glob: str = string.strstr(dump_buf, "Global(")
        if has_glob is not None:
            passed += 1
            printf("PASS: Global statement parsed\n")
        else:
            failed += 1
            printf("FAIL: Global parse, glob=%d\n", has_glob is not None)
    else:
        failed += 1
        printf("FAIL: Global parse returned None\n")

    # --- Test 67: f-string (FormattedValue) ---
    fstr_src: str = "s = f'value={x}'"
    fstr_mod: Module | CPtr = parse(fstr_src, pool)
    if fstr_mod is not None:
        dump(fstr_mod, dump_buf, DUMP_BUF_SIZE)
        has_fv: str = string.strstr(dump_buf, "FormattedValue(")
        has_js: str = string.strstr(dump_buf, "JoinedStr(")
        if has_fv is not None and has_js is not None:
            passed += 1
            printf("PASS: f-string with FormattedValue + JoinedStr parsed\n")
        else:
            failed += 1
            printf("FAIL: fstring, fv=%d js=%d\n",
                   has_fv is not None, has_js is not None)
    else:
        failed += 1
        printf("FAIL: fstring parse returned None\n")

    # --- Test 68: 嵌套函数 + 闭包 ---
    nested_src: str = """def outer():
    x = 10
    def inner():
        return x + 1
    return inner()
"""
    nested_mod: Module | CPtr = parse(nested_src, pool)
    if nested_mod is not None and nested_mod.children is not None:
        dump(nested_mod, dump_buf, DUMP_BUF_SIZE)
        n_outer: str = string.strstr(dump_buf, "FunctionDef(name='outer'")
        n_inner: str = string.strstr(dump_buf, "FunctionDef(name='inner'")
        if n_outer is not None and n_inner is not None:
            passed += 1
            printf("PASS: Nested function definitions parsed\n")
        else:
            failed += 1
            printf("FAIL: nested, outer=%d inner=%d\n",
                   n_outer is not None, n_inner is not None)
    else:
        failed += 1
        printf("FAIL: nested parse returned None\n")

    # --- Test 69: Match 字面量整数模式 ---
    m_lit_src: str = """match x:
    case 1:
        pass
"""
    m_lit_mod: Module | CPtr = parse(m_lit_src, pool)
    if m_lit_mod is not None:
        dump(m_lit_mod, dump_buf, DUMP_BUF_SIZE)
        has_mv: str = string.strstr(dump_buf, "MatchValue(")
        if has_mv is not None:
            passed += 1
            printf("PASS: Match literal int -> MatchValue\n")
        else:
            failed += 1
            printf("FAIL: Match literal int, mv=%d\n", has_mv is not None)
    else:
        failed += 1
        printf("FAIL: Match literal int parse returned None\n")

    # --- Test 70: Match 字面量字符串模式 ---
    m_str_src: str = """match x:
    case "hello":
        pass
"""
    m_str_mod: Module | CPtr = parse(m_str_src, pool)
    if m_str_mod is not None:
        dump(m_str_mod, dump_buf, DUMP_BUF_SIZE)
        has_mv2: str = string.strstr(dump_buf, "MatchValue(")
        if has_mv2 is not None:
            passed += 1
            printf("PASS: Match literal str -> MatchValue\n")
        else:
            failed += 1
            printf("FAIL: Match literal str\n")
    else:
        failed += 1
        printf("FAIL: Match literal str parse returned None\n")

    # --- Test 71: Match 负数字面量模式 ---
    m_neg_src: str = """match x:
    case -1:
        pass
"""
    m_neg_mod: Module | CPtr = parse(m_neg_src, pool)
    if m_neg_mod is not None:
        dump(m_neg_mod, dump_buf, DUMP_BUF_SIZE)
        has_mv3: str = string.strstr(dump_buf, "MatchValue(")
        if has_mv3 is not None:
            passed += 1
            printf("PASS: Match negative literal -> MatchValue\n")
        else:
            failed += 1
            printf("FAIL: Match negative literal\n")
    else:
        failed += 1
        printf("FAIL: Match negative literal parse returned None\n")

    # --- Test 72: Match None 单例模式 ---
    m_none_src: str = """match x:
    case None:
        pass
"""
    m_none_mod: Module | CPtr = parse(m_none_src, pool)
    if m_none_mod is not None:
        dump(m_none_mod, dump_buf, DUMP_BUF_SIZE)
        has_ms: str = string.strstr(dump_buf, "MatchSingleton(")
        if has_ms is not None:
            passed += 1
            printf("PASS: Match None -> MatchSingleton\n")
        else:
            failed += 1
            printf("FAIL: Match None, ms=%d\n", has_ms is not None)
    else:
        failed += 1
        printf("FAIL: Match None parse returned None\n")

    # --- Test 73: Match True 单例模式 ---
    m_true_src: str = """match x:
    case True:
        pass
"""
    m_true_mod: Module | CPtr = parse(m_true_src, pool)
    if m_true_mod is not None:
        dump(m_true_mod, dump_buf, DUMP_BUF_SIZE)
        has_ms2: str = string.strstr(dump_buf, "MatchSingleton(")
        if has_ms2 is not None:
            passed += 1
            printf("PASS: Match True -> MatchSingleton\n")
        else:
            failed += 1
            printf("FAIL: Match True\n")
    else:
        failed += 1
        printf("FAIL: Match True parse returned None\n")

    # --- Test 74: Match False 单例模式 ---
    m_false_src: str = """match x:
    case False:
        pass
"""
    m_false_mod: Module | CPtr = parse(m_false_src, pool)
    if m_false_mod is not None:
        dump(m_false_mod, dump_buf, DUMP_BUF_SIZE)
        has_ms3: str = string.strstr(dump_buf, "MatchSingleton(")
        if has_ms3 is not None:
            passed += 1
            printf("PASS: Match False -> MatchSingleton\n")
        else:
            failed += 1
            printf("FAIL: Match False\n")
    else:
        failed += 1
        printf("FAIL: Match False parse returned None\n")

    # --- Test 75: Match 通配符 _ 模式 ---
    m_wild_src: str = """match x:
    case _:
        pass
"""
    m_wild_mod: Module | CPtr = parse(m_wild_src, pool)
    if m_wild_mod is not None:
        dump(m_wild_mod, dump_buf, DUMP_BUF_SIZE)
        has_ma: str = string.strstr(dump_buf, "MatchAs(")
        if has_ma is not None:
            passed += 1
            printf("PASS: Match wildcard _ -> MatchAs\n")
        else:
            failed += 1
            printf("FAIL: Match wildcard, ma=%d\n", has_ma is not None)
    else:
        failed += 1
        printf("FAIL: Match wildcard parse returned None\n")

    # --- Test 76: Match 捕获变量模式 ---
    m_cap_src: str = """match x:
    case y:
        pass
"""
    m_cap_mod: Module | CPtr = parse(m_cap_src, pool)
    if m_cap_mod is not None:
        dump(m_cap_mod, dump_buf, DUMP_BUF_SIZE)
        has_ma2: str = string.strstr(dump_buf, "name='y'")
        if has_ma2 is not None:
            passed += 1
            printf("PASS: Match capture y -> MatchAs(name='y')\n")
        else:
            failed += 1
            printf("FAIL: Match capture, ma=%d\n", has_ma2 is not None)
    else:
        failed += 1
        printf("FAIL: Match capture parse returned None\n")

    # --- Test 77: Match 值模式 (dotted name Color.RED) ---
    m_val_src: str = """match x:
    case Color.RED:
        pass
"""
    m_val_mod: Module | CPtr = parse(m_val_src, pool)
    if m_val_mod is not None:
        dump(m_val_mod, dump_buf, DUMP_BUF_SIZE)
        has_mv4: str = string.strstr(dump_buf, "MatchValue(")
        has_attr: str = string.strstr(dump_buf, "Attribute(")
        if has_mv4 is not None and has_attr is not None:
            passed += 1
            printf("PASS: Match Color.RED -> MatchValue + Attribute\n")
        else:
            failed += 1
            printf("FAIL: Match value, mv=%d attr=%d\n",
                   has_mv4 is not None, has_attr is not None)
    else:
        failed += 1
        printf("FAIL: Match value parse returned None\n")

    # --- Test 78: Match 序列模式 [1, 2] ---
    m_seq_src: str = """match x:
    case [1, 2]:
        pass
"""
    m_seq_mod: Module | CPtr = parse(m_seq_src, pool)
    if m_seq_mod is not None:
        dump(m_seq_mod, dump_buf, DUMP_BUF_SIZE)
        has_msq: str = string.strstr(dump_buf, "MatchSequence(")
        if has_msq is not None:
            passed += 1
            printf("PASS: Match [1, 2] -> MatchSequence\n")
        else:
            failed += 1
            printf("FAIL: Match sequence, msq=%d\n", has_msq is not None)
    else:
        failed += 1
        printf("FAIL: Match sequence parse returned None\n")

    # --- Test 79: Match 序列带星号 [a, *rest] ---
    m_star_src: str = """match x:
    case [a, *rest]:
        pass
"""
    m_star_mod: Module | CPtr = parse(m_star_src, pool)
    if m_star_mod is not None:
        dump(m_star_mod, dump_buf, DUMP_BUF_SIZE)
        has_mstar: str = string.strstr(dump_buf, "MatchStar(name='rest')")
        if has_mstar is not None:
            passed += 1
            printf("PASS: Match [a, *rest] -> MatchStar\n")
        else:
            failed += 1
            printf("FAIL: Match star, mstar=%d\n", has_mstar is not None)
    else:
        failed += 1
        printf("FAIL: Match star parse returned None\n")

    # --- Test 80: Match 类模式 Point(x, y) ---
    m_cls_src: str = """match p:
    case Point(x, y):
        pass
"""
    m_cls_mod: Module | CPtr = parse(m_cls_src, pool)
    if m_cls_mod is not None:
        dump(m_cls_mod, dump_buf, DUMP_BUF_SIZE)
        has_mc: str = string.strstr(dump_buf, "MatchClass(")
        if has_mc is not None:
            passed += 1
            printf("PASS: Match Point(x, y) -> MatchClass\n")
        else:
            failed += 1
            printf("FAIL: Match class, mc=%d\n", has_mc is not None)
    else:
        failed += 1
        printf("FAIL: Match class parse returned None\n")

    # --- Test 81: Match 类模式带关键字 Point(x=0, y=0) ---
    m_kwcls_src: str = """match p:
    case Point(x=0, y=0):
        pass
"""
    m_kwcls_mod: Module | CPtr = parse(m_kwcls_src, pool)
    if m_kwcls_mod is not None:
        dump(m_kwcls_mod, dump_buf, DUMP_BUF_SIZE)
        has_mc2: str = string.strstr(dump_buf, "MatchClass(")
        if has_mc2 is not None:
            passed += 1
            printf("PASS: Match Point(x=0, y=0) -> MatchClass with kwd\n")
        else:
            failed += 1
            printf("FAIL: Match class kwd, mc=%d\n", has_mc2 is not None)
    else:
        failed += 1
        printf("FAIL: Match class kwd parse returned None\n")

    # --- Test 82: Match OR 模式 1 | 2 ---
    m_or_src: str = """match x:
    case 1 | 2:
        pass
"""
    m_or_mod: Module | CPtr = parse(m_or_src, pool)
    if m_or_mod is not None:
        dump(m_or_mod, dump_buf, DUMP_BUF_SIZE)
        has_mo: str = string.strstr(dump_buf, "MatchOr(")
        if has_mo is not None:
            passed += 1
            printf("PASS: Match 1 | 2 -> MatchOr\n")
        else:
            failed += 1
            printf("FAIL: Match OR, mo=%d\n", has_mo is not None)
    else:
        failed += 1
        printf("FAIL: Match OR parse returned None\n")

    # --- Test 83: Match AS 模式 [x] as p ---
    m_as_src: str = """match x:
    case [x] as p:
        pass
"""
    m_as_mod: Module | CPtr = parse(m_as_src, pool)
    if m_as_mod is not None:
        dump(m_as_mod, dump_buf, DUMP_BUF_SIZE)
        has_mas: str = string.strstr(dump_buf, "MatchAs(pattern=")
        has_msq2: str = string.strstr(dump_buf, "MatchSequence(")
        if has_mas is not None and has_msq2 is not None:
            passed += 1
            printf("PASS: Match [x] as p -> MatchAs(MatchSequence)\n")
        else:
            failed += 1
            printf("FAIL: Match AS, mas=%d msq=%d\n",
                   has_mas is not None, has_msq2 is not None)
    else:
        failed += 1
        printf("FAIL: Match AS parse returned None\n")

    # --- Test 84: Match guard 模式 case x if x > 0 ---
    m_guard_src: str = """match x:
    case x if x > 0:
        pass
"""
    m_guard_mod: Module | CPtr = parse(m_guard_src, pool)
    if m_guard_mod is not None:
        dump(m_guard_mod, dump_buf, DUMP_BUF_SIZE)
        has_guard: str = string.strstr(dump_buf, "guard=Compare(")
        if has_guard is not None:
            passed += 1
            printf("PASS: Match x if x > 0 -> guard=Compare\n")
        else:
            failed += 1
            printf("FAIL: Match guard, guard=%d\n", has_guard is not None)
    else:
        failed += 1
        printf("FAIL: Match guard parse returned None\n")

    # --- Test 85: Match 映射模式 {"k": v} ---
    m_map_src: str = """match x:
    case {"k": v}:
        pass
"""
    m_map_mod: Module | CPtr = parse(m_map_src, pool)
    if m_map_mod is not None:
        dump(m_map_mod, dump_buf, DUMP_BUF_SIZE)
        has_mm: str = string.strstr(dump_buf, "MatchMapping(")
        if has_mm is not None:
            passed += 1
            printf("PASS: Match {'k': v} -> MatchMapping\n")
        else:
            failed += 1
            printf("FAIL: Match mapping, mm=%d\n", has_mm is not None)
    else:
        failed += 1
        printf("FAIL: Match mapping parse returned None\n")

    # --- Test 86: Match 映射带 rest {"k": v, **rest} ---
    m_map2_src: str = """match x:
    case {"k": v, **rest}:
        pass
"""
    m_map2_mod: Module | CPtr = parse(m_map2_src, pool)
    if m_map2_mod is not None:
        dump(m_map2_mod, dump_buf, DUMP_BUF_SIZE)
        has_mm2: str = string.strstr(dump_buf, "MatchMapping(")
        has_rest: str = string.strstr(dump_buf, "rest='rest'")
        if has_mm2 is not None and has_rest is not None:
            passed += 1
            printf("PASS: Match {'k': v, **rest} -> MatchMapping with rest\n")
        else:
            failed += 1
            printf("FAIL: Match mapping rest, mm=%d rest=%d\n",
                   has_mm2 is not None, has_rest is not None)
    else:
        failed += 1
        printf("FAIL: Match mapping rest parse returned None\n")

    # --- Test 87: Match 组合模式 (1 | 2) as p ---
    m_combo_src: str = """match x:
    case (1 | 2) as p:
        pass
"""
    m_combo_mod: Module | CPtr = parse(m_combo_src, pool)
    if m_combo_mod is not None:
        dump(m_combo_mod, dump_buf, DUMP_BUF_SIZE)
        has_combo_or: str = string.strstr(dump_buf, "MatchOr(")
        has_combo_as: str = string.strstr(dump_buf, "MatchAs(")
        if has_combo_or is not None and has_combo_as is not None:
            passed += 1
            printf("PASS: Match (1|2) as p -> MatchAs(MatchOr)\n")
        else:
            failed += 1
            printf("FAIL: Match combo, or=%d as=%d\n",
                   has_combo_or is not None, has_combo_as is not None)
    else:
        failed += 1
        printf("FAIL: Match combo parse returned None\n")

    # --- Test 88: async def ---
    adef_src: str = """async def f():
    pass
"""
    adef_mod: Module | CPtr = parse(adef_src, pool)
    if adef_mod is not None and adef_mod.children is not None:
        adef_cnt: t.CSizeT = adef_mod.children.__len__()
        if adef_cnt == 1:
            adef_child: AST | CPtr = adef_mod.children.get(0)
            if adef_child is not None and adef_child.kind() == ASTKind.FunctionDef:
                adef_fd: FunctionDef | CPtr = (FunctionDef | CPtr)(adef_child)
                if (adef_fd.flags & FLAG_IS_ASYNC) != 0:
                    passed += 1
                    printf("PASS: async def f() -> FunctionDef with FLAG_IS_ASYNC\n")
                else:
                    failed += 1
                    printf("FAIL: async def flags=%d (no FLAG_IS_ASYNC)\n", adef_fd.flags)
            else:
                failed += 1
                printf("FAIL: async def child kind=%d\n",
                       adef_child.kind() if adef_child is not None else -1)
        else:
            failed += 1
            printf("FAIL: async def children=%zu (expected 1)\n", adef_cnt)
    else:
        failed += 1
        printf("FAIL: async def parse returned None\n")

    # --- Test 89: async for (inside async def) ---
    afor_src: str = """async def f():
    async for x in y:
        pass
"""
    afor_mod: Module | CPtr = parse(afor_src, pool)
    if afor_mod is not None and afor_mod.children is not None:
        afor_cnt: t.CSizeT = afor_mod.children.__len__()
        if afor_cnt == 1:
            afor_child: AST | CPtr = afor_mod.children.get(0)
            if afor_child is not None and afor_child.kind() == ASTKind.FunctionDef:
                afor_fd2: FunctionDef | CPtr = (FunctionDef | CPtr)(afor_child)
                if (afor_fd2.flags & FLAG_IS_ASYNC) != 0:
                    if afor_fd2.children is not None:
                        afor_inner: AST | CPtr = afor_fd2.children.get(0)
                        if afor_inner is not None and afor_inner.kind() == ASTKind.For:
                            afor_for: For | CPtr = (For | CPtr)(afor_inner)
                            if (afor_for.flags & FLAG_IS_ASYNC) != 0:
                                passed += 1
                                printf("PASS: async for -> For with FLAG_IS_ASYNC\n")
                            else:
                                failed += 1
                                printf("FAIL: async for flags=%d\n", afor_for.flags)
                        else:
                            failed += 1
                            printf("FAIL: async for inner kind=%d\n",
                                   afor_inner.kind() if afor_inner is not None else -1)
                    else:
                        failed += 1
                        printf("FAIL: async for no children\n")
                else:
                    failed += 1
                    printf("FAIL: async for outer def flags=%d\n", afor_fd2.flags)
            else:
                failed += 1
                printf("FAIL: async for outer kind=%d\n",
                       afor_child.kind() if afor_child is not None else -1)
        else:
            failed += 1
            printf("FAIL: async for children=%zu\n", afor_cnt)
    else:
        failed += 1
        printf("FAIL: async for parse returned None\n")

    # --- Test 90: async with (inside async def) ---
    awith_src: str = """async def f():
    async with ctx:
        pass
"""
    awith_mod: Module | CPtr = parse(awith_src, pool)
    if awith_mod is not None and awith_mod.children is not None:
        awith_cnt: t.CSizeT = awith_mod.children.__len__()
        if awith_cnt == 1:
            awith_child: AST | CPtr = awith_mod.children.get(0)
            if awith_child is not None and awith_child.kind() == ASTKind.FunctionDef:
                awith_fd: FunctionDef | CPtr = (FunctionDef | CPtr)(awith_child)
                if (awith_fd.flags & FLAG_IS_ASYNC) != 0:
                    if awith_fd.children is not None:
                        awith_inner: AST | CPtr = awith_fd.children.get(0)
                        if awith_inner is not None and awith_inner.kind() == ASTKind.With:
                            awith_w: With | CPtr = (With | CPtr)(awith_inner)
                            if (awith_w.flags & FLAG_IS_ASYNC) != 0:
                                passed += 1
                                printf("PASS: async with -> With with FLAG_IS_ASYNC\n")
                            else:
                                failed += 1
                                printf("FAIL: async with flags=%d\n", awith_w.flags)
                        else:
                            failed += 1
                            printf("FAIL: async with inner kind=%d\n",
                                   awith_inner.kind() if awith_inner is not None else -1)
                    else:
                        failed += 1
                        printf("FAIL: async with no children\n")
                else:
                    failed += 1
                    printf("FAIL: async with outer def flags=%d\n", awith_fd.flags)
            else:
                failed += 1
                printf("FAIL: async with outer kind=%d\n",
                       awith_child.kind() if awith_child is not None else -1)
        else:
            failed += 1
            printf("FAIL: async with children=%zu\n", awith_cnt)
    else:
        failed += 1
        printf("FAIL: async with parse returned None\n")

    # --- Test 91: Match 复合语句 (多 case + 多类型模式) ---
    m_complex_src: str = """match cmd:
    case "quit":
        pass
    case ["go", dir]:
        pass
    case Point(x=0, y=0):
        pass
    case _:
        pass
"""
    m_complex_mod: Module | CPtr = parse(m_complex_src, pool)
    if m_complex_mod is not None:
        dump(m_complex_mod, dump_buf, DUMP_BUF_SIZE)
        has_c_mv: str = string.strstr(dump_buf, "MatchValue(")
        has_c_msq: str = string.strstr(dump_buf, "MatchSequence(")
        has_c_mc: str = string.strstr(dump_buf, "MatchClass(")
        has_c_ma: str = string.strstr(dump_buf, "MatchAs(")
        if has_c_mv is not None and has_c_msq is not None and \
           has_c_mc is not None and has_c_ma is not None:
            passed += 1
            printf("PASS: Match complex (4 cases) -> all pattern types\n")
        else:
            failed += 1
            printf("FAIL: Match complex, mv=%d msq=%d mc=%d ma=%d\n",
                   has_c_mv is not None, has_c_msq is not None,
                   has_c_mc is not None, has_c_ma is not None)
    else:
        failed += 1
        printf("FAIL: Match complex parse returned None\n")

    # --- Test 92: async def + async for + async with 组合 ---
    acombo_src: str = """async def f():
    async with ctx:
        async for x in y:
            pass
"""
    acombo_mod: Module | CPtr = parse(acombo_src, pool)
    if acombo_mod is not None and acombo_mod.children is not None:
        acombo_cnt: t.CSizeT = acombo_mod.children.__len__()
        if acombo_cnt == 1:
            acombo_child: AST | CPtr = acombo_mod.children.get(0)
            if acombo_child is not None and acombo_child.kind() == ASTKind.FunctionDef:
                acombo_fd2: FunctionDef | CPtr = (FunctionDef | CPtr)(acombo_child)
                if (acombo_fd2.flags & FLAG_IS_ASYNC) != 0:
                    passed += 1
                    printf("PASS: async def + async with + async for combo\n")
                else:
                    failed += 1
                    printf("FAIL: async combo flags=%d\n", acombo_fd2.flags)
            else:
                failed += 1
                printf("FAIL: async combo kind=%d\n",
                       acombo_child.kind() if acombo_child is not None else -1)
        else:
            failed += 1
            printf("FAIL: async combo children=%zu\n", acombo_cnt)
    else:
        failed += 1
        printf("FAIL: async combo parse returned None\n")

    # --- 结果汇总 ---
    printf("\n=== Results: %d passed, %d failed ===\n", passed, failed)

    stdlib.free(dump_buf)
    stdlib.free(arena)
    if failed > 0:
        return 1
    return 0
