depyler-core 3.24.0

//! Comprehensive statement generator tests
//!
//! These tests exercise the stmt_gen.rs code paths through the transpilation pipeline.
//! Note: Most tests wrap statements in functions because the transpiler generates function-level code.

use crate::DepylerPipeline;

fn transpile(code: &str) -> String {
    let pipeline = DepylerPipeline::new();
    pipeline
        .transpile(code)
        .expect("transpilation should succeed")
}

fn transpile_ok(code: &str) -> bool {
    let pipeline = DepylerPipeline::new();
    pipeline.transpile(code).is_ok()
}

// Helper to wrap statements in a function for proper transpilation
fn transpile_func(body: &str) -> String {
    let code = format!(
        "def test_func():\n{}",
        body.lines()
            .map(|l| format!("    {}", l))
            .collect::<Vec<_>>()
            .join("\n")
    );
    transpile(&code)
}

// ============================================================================
// IF STATEMENTS
// ============================================================================

#[test]
fn test_if_simple() {
    let code = transpile_func("if True:\n    x = 1");
    assert!(code.contains("if") || code.contains("true") || code.contains("1"));
}

#[test]
fn test_if_else() {
    let code = transpile_func("if True:\n    x = 1\nelse:\n    x = 2");
    assert!(code.contains("if") || code.contains("else") || code.contains("1"));
}

#[test]
fn test_if_elif() {
    let code = transpile_func("if a:\n    x = 1\nelif b:\n    x = 2\nelse:\n    x = 3");
    assert!(code.contains("if") || code.contains("1") || code.contains("2"));
}

#[test]
fn test_if_nested() {
    let code = transpile_func("if a:\n    if b:\n        x = 1");
    assert!(code.contains("if") || code.contains("1"));
}

#[test]
fn test_if_compound_condition() {
    let code = transpile_func("if a and b:\n    x = 1");
    assert!(code.contains("&&") || code.contains("if") || code.contains("1"));
}

#[test]
fn test_if_or_condition() {
    let code = transpile_func("if a or b:\n    x = 1");
    assert!(code.contains("||") || code.contains("if") || code.contains("1"));
}

#[test]
fn test_if_not_condition() {
    let code = transpile_func("if not a:\n    x = 1");
    assert!(code.contains("!") || code.contains("if") || code.contains("1"));
}

#[test]
fn test_if_comparison() {
    let code = transpile_func("if x > 5:\n    y = x");
    assert!(code.contains(">") || code.contains("5") || code.contains("if"));
}

#[test]
fn test_if_in_check() {
    let code = transpile_func("if x in items:\n    pass");
    assert!(code.contains("contains") || code.contains("if") || code.contains("fn"));
}

// ============================================================================
// FOR LOOPS
// ============================================================================

#[test]
fn test_for_range() {
    let code = transpile("def foo():\n    for i in range(10):\n        x = i");
    assert!(code.contains("for") || code.contains("10") || code.contains(".."));
}

#[test]
fn test_for_range_start_end() {
    let code = transpile("def foo():\n    for i in range(1, 10):\n        x = i");
    assert!(code.contains("for") || code.contains("..") || code.contains("1"));
}

#[test]
fn test_for_range_step() {
    let code = transpile("def foo():\n    for i in range(0, 10, 2):\n        x = i");
    assert!(
        code.contains("for") || code.contains("step") || code.contains("2") || code.contains("fn")
    );
}

#[test]
fn test_for_list() {
    let code = transpile("def foo(items):\n    for item in items:\n        x = item");
    assert!(code.contains("for") || code.contains("item") || code.contains("fn"));
}

#[test]
fn test_for_enumerate() {
    let code = transpile("def foo(items):\n    for i, item in enumerate(items):\n        x = i");
    assert!(code.contains("enumerate") || code.contains("for") || code.contains("fn"));
}

#[test]
fn test_for_zip() {
    let code =
        transpile("def foo(list1, list2):\n    for a, b in zip(list1, list2):\n        x = a + b");
    assert!(code.contains("zip") || code.contains("for") || code.contains("fn"));
}

#[test]
fn test_for_dict_items() {
    let code = transpile("def foo(d):\n    for k, v in d.items():\n        x = k");
    assert!(code.contains("for") || code.contains("iter") || code.contains("fn"));
}

#[test]
fn test_for_dict_keys() {
    let code = transpile("def foo(d):\n    for k in d.keys():\n        x = k");
    assert!(code.contains("for") || code.contains("keys") || code.contains("fn"));
}

#[test]
fn test_for_dict_values() {
    let code = transpile("def foo(d):\n    for v in d.values():\n        x = v");
    assert!(code.contains("for") || code.contains("values") || code.contains("fn"));
}

#[test]
fn test_for_string_chars() {
    let code = transpile("def foo():\n    for c in 'hello':\n        x = c");
    assert!(
        code.contains("for")
            || code.contains("chars")
            || code.contains("hello")
            || code.contains("fn")
    );
}

#[test]
fn test_for_nested() {
    let code = transpile(
        "def foo():\n    for i in range(3):\n        for j in range(3):\n            x = i * j",
    );
    assert!(code.contains("for") || code.contains("fn"));
}

#[test]
fn test_for_else() {
    let code =
        transpile("def foo():\n    for i in range(10):\n        x = i\n    else:\n        y = 0");
    assert!(code.contains("for") || code.contains("fn"));
}

#[test]
fn test_for_break() {
    let code =
        transpile("def foo():\n    for i in range(10):\n        if i > 5:\n            break");
    assert!(code.contains("break") || code.contains("for") || code.contains("fn"));
}

#[test]
fn test_for_continue() {
    let code = transpile("def foo():\n    for i in range(10):\n        if i % 2 == 0:\n            continue\n        x = i");
    assert!(code.contains("continue") || code.contains("for") || code.contains("fn"));
}

// ============================================================================
// WHILE LOOPS
// ============================================================================

#[test]
fn test_while_simple() {
    let code = transpile("def foo():\n    while True:\n        break");
    assert!(
        code.contains("while")
            || code.contains("loop")
            || code.contains("break")
            || code.contains("fn")
    );
}

#[test]
fn test_while_condition() {
    let code = transpile("def foo(x):\n    while x > 0:\n        x = x - 1");
    assert!(code.contains("while") || code.contains(">") || code.contains("fn"));
}

#[test]
fn test_while_break() {
    let code = transpile("def foo():\n    while True:\n        break");
    assert!(code.contains("break") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_while_continue() {
    let code = transpile("def foo(x):\n    while x > 0:\n        if x % 2 == 0:\n            continue\n        x -= 1");
    assert!(code.contains("continue") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_while_else() {
    let code = transpile("def foo(x):\n    while x > 0:\n        x -= 1\n    else:\n        y = 0");
    assert!(code.contains("while") || code.contains("fn"));
}

// ============================================================================
// ASSIGNMENTS
// ============================================================================

#[test]
fn test_assign_simple() {
    // Use x to ensure it's not optimized away
    let code = transpile("def foo() -> int:\n    x = 42\n    return x");
    assert!(code.contains("42") || code.contains("let") || code.contains("x"));
}

#[test]
fn test_assign_multiple() {
    let code = transpile("def foo():\n    a, b = 1, 2");
    assert!(code.contains("1") || code.contains("2") || code.contains("let"));
}

#[test]
fn test_assign_starred() {
    assert!(transpile_ok("def foo():\n    first, *rest = [1, 2, 3, 4]"));
}

#[test]
fn test_assign_augmented_add() {
    let code = transpile("def foo():\n    x = 1\n    x += 1");
    assert!(code.contains("+=") || code.contains("+") || code.contains("1"));
}

#[test]
fn test_assign_augmented_sub() {
    let code = transpile("def foo():\n    x = 5\n    x -= 1");
    assert!(code.contains("-=") || code.contains("-") || code.contains("5"));
}

#[test]
fn test_assign_augmented_mul() {
    let code = transpile("def foo():\n    x = 2\n    x *= 3");
    assert!(code.contains("*=") || code.contains("*") || code.contains("2"));
}

#[test]
fn test_assign_augmented_div() {
    let code = transpile("def foo():\n    x = 10.0\n    x /= 2.0");
    assert!(code.contains("/=") || code.contains("/") || code.contains("10"));
}

#[test]
fn test_assign_to_subscript() {
    let code = transpile("def foo():\n    lst = [1, 2, 3]\n    lst[0] = 10");
    assert!(code.contains("[") || code.contains("10"));
}

#[test]
fn test_assign_to_attribute() {
    let code = transpile("def foo(obj):\n    obj.attr = 42");
    assert!(code.contains("attr") || code.contains("42") || code.contains("fn"));
}

#[test]
fn test_assign_chained() {
    assert!(transpile_ok("def foo():\n    a = b = 1"));
}

// ============================================================================
// TRY/EXCEPT
// ============================================================================

#[test]
fn test_try_except_simple() {
    let code = transpile("def foo():\n    try:\n        x = 1\n    except:\n        x = 0");
    assert!(
        code.contains("match") || code.contains("Err") || code.contains("fn") || code.contains("0")
    );
}

#[test]
fn test_try_except_specific() {
    let code =
        transpile("def foo():\n    try:\n        x = 1\n    except ValueError:\n        x = 0");
    assert!(
        code.contains("Err") || code.contains("match") || code.contains("fn") || code.contains("0")
    );
}

#[test]
fn test_try_except_as() {
    let code =
        transpile("def foo():\n    try:\n        x = 1\n    except Exception as e:\n        y = 0");
    assert!(
        code.contains("Err") || code.contains("match") || code.contains("fn") || code.contains("e")
    );
}

#[test]
fn test_extended_try_except_finally() {
    let code = transpile("def foo():\n    try:\n        x = 1\n    except:\n        x = 0\n    finally:\n        y = 2");
    assert!(
        code.contains("match") || code.contains("fn") || code.contains("0") || code.contains("2")
    );
}

#[test]
fn test_extended_try_except_else() {
    let code = transpile(
        "def foo():\n    try:\n        x = 1\n    except:\n        x = 0\n    else:\n        y = 1",
    );
    assert!(
        code.contains("match") || code.contains("fn") || code.contains("0") || code.contains("1")
    );
}

#[test]
fn test_try_multiple_except() {
    let code = transpile("def foo():\n    try:\n        x = 1\n    except ValueError:\n        x = 1\n    except TypeError:\n        x = 2");
    assert!(
        code.contains("match") || code.contains("fn") || code.contains("1") || code.contains("2")
    );
}

// ============================================================================
// WITH STATEMENTS
// ============================================================================

#[test]
fn test_with_simple() {
    let code = transpile("def foo():\n    with open('file.txt') as f:\n        data = f.read()");
    assert!(
        code.contains("let")
            || code.contains("file")
            || code.contains("fn")
            || code.contains("open")
    );
}

#[test]
fn test_with_multiple() {
    assert!(transpile_ok(
        "def foo():\n    with open('a') as f1, open('b') as f2:\n        pass"
    ));
}

// ============================================================================
// RETURN STATEMENTS
// ============================================================================

#[test]
fn test_return_simple() {
    let code = transpile("def foo():\n    return 42");
    assert!(code.contains("return") || code.contains("42"));
}

#[test]
fn test_return_none() {
    let code = transpile("def foo():\n    return");
    assert!(code.contains("return") || code.contains("fn foo"));
}

#[test]
fn test_return_expression() {
    let code = transpile("def foo(x):\n    return x * 2");
    assert!(code.contains("return") || code.contains("*"));
}

#[test]
fn test_return_tuple() {
    let code = transpile("def foo():\n    return (1, 2, 3)");
    assert!(code.contains("return") || code.contains("1"));
}

#[test]
fn test_return_conditional() {
    let code = transpile("def foo(x):\n    return 1 if x else 0");
    assert!(code.contains("return") || code.contains("if") || code.contains("1"));
}

// ============================================================================
// RAISE STATEMENTS
// ============================================================================

#[test]
fn test_raise_simple() {
    let code = transpile("def foo():\n    raise ValueError('error')");
    assert!(
        code.contains("Err")
            || code.contains("panic")
            || code.contains("error")
            || code.contains("fn")
    );
}

#[test]
fn test_raise_from() {
    assert!(transpile_ok(
        "def foo():\n    raise ValueError('new') from e"
    ));
}

#[test]
fn test_raise_reraise() {
    assert!(transpile_ok(
        "def foo():\n    try:\n        x = 1\n    except:\n        raise"
    ));
}

// ============================================================================
// ASSERT STATEMENTS
// ============================================================================

#[test]
fn test_assert_simple() {
    let code = transpile("def foo(x):\n    assert x > 0");
    assert!(
        code.contains("assert")
            || code.contains("debug_assert")
            || code.contains(">")
            || code.contains("fn")
    );
}

#[test]
fn test_assert_with_message() {
    let code = transpile("def foo(x):\n    assert x > 0, 'x must be positive'");
    assert!(
        code.contains("assert")
            || code.contains("positive")
            || code.contains(">")
            || code.contains("fn")
    );
}

// ============================================================================
// PASS/DELETE/GLOBAL/NONLOCAL
// ============================================================================

#[test]
fn test_pass() {
    let code = transpile("def foo():\n    pass");
    assert!(code.contains("fn foo"));
}

#[test]
fn test_del_variable() {
    assert!(transpile_ok("def foo():\n    x = 1\n    del x"));
}

#[test]
fn test_del_subscript() {
    assert!(transpile_ok(
        "def foo():\n    lst = [1, 2, 3]\n    del lst[0]"
    ));
}

#[test]
fn test_global() {
    assert!(transpile_ok("def foo():\n    global x\n    x = 1"));
}

#[test]
fn test_nonlocal() {
    assert!(transpile_ok(
        "def outer():\n    x = 1\n    def inner():\n        nonlocal x\n        x = 2"
    ));
}

// ============================================================================
// EXPRESSION STATEMENTS
// ============================================================================

#[test]
fn test_expr_stmt_call() {
    let code = transpile("def foo():\n    print('hello')");
    assert!(code.contains("hello") || code.contains("!") || code.contains("fn"));
}

#[test]
fn test_expr_stmt_method_call() {
    let code = transpile("def foo():\n    lst = [1, 2]\n    lst.append(3)");
    assert!(code.contains("3") || code.contains("push") || code.contains("fn"));
}

// ============================================================================
// MATCH STATEMENTS (Python 3.10+)
// ============================================================================

#[test]
fn test_match_literal() {
    let code = transpile("def foo(x):\n    match x:\n        case 1:\n            y = 'one'\n        case 2:\n            y = 'two'");
    assert!(
        code.contains("match") || code.contains("1") || code.contains("2") || code.contains("fn")
    );
}

#[test]
fn test_match_wildcard() {
    let code = transpile("def foo(x):\n    match x:\n        case 1:\n            y = 'one'\n        case _:\n            y = 'other'");
    assert!(
        code.contains("match") || code.contains("_") || code.contains("1") || code.contains("fn")
    );
}

#[test]
fn test_match_capture() {
    let code =
        transpile("def foo(point):\n    match point:\n        case (x, y):\n            z = x + y");
    assert!(code.contains("match") || code.contains("fn"));
}

// ============================================================================
// IMPORT STATEMENTS
// ============================================================================

#[test]
fn test_import_simple() {
    assert!(transpile_ok("import os"));
}

#[test]
fn test_import_from() {
    assert!(transpile_ok("from os import path"));
}

#[test]
fn test_import_from_multiple() {
    assert!(transpile_ok("from os import path, getcwd"));
}

#[test]
fn test_import_as() {
    assert!(transpile_ok("import numpy as np"));
}

#[test]
fn test_import_from_as() {
    assert!(transpile_ok("from os.path import join as path_join"));
}

// ============================================================================
// CLASS DEFINITIONS (if supported)
// ============================================================================

#[test]
fn test_class_simple() {
    assert!(transpile_ok(
        "class Point:\n    def __init__(self, x, y):\n        self.x = x\n        self.y = y"
    ));
}

#[test]
fn test_dataclass() {
    assert!(transpile_ok(
        "from dataclasses import dataclass\n\n@dataclass\nclass Point:\n    x: int\n    y: int"
    ));
}

// ============================================================================
// TYPE ANNOTATIONS IN STATEMENTS
// ============================================================================

#[test]
fn test_annotated_assignment() {
    let code = transpile("def foo():\n    x: int = 42");
    assert!(
        code.contains("42") || code.contains("i64") || code.contains("i32") || code.contains("fn")
    );
}

#[test]
fn test_annotated_var_only() {
    assert!(transpile_ok("def foo():\n    x: int"));
}

// ============================================================================
// MORE IF STATEMENT VARIATIONS
// ============================================================================

#[test]
fn test_if_is_none() {
    assert!(transpile_ok(
        "def foo(x):\n    if x is None:\n        return 0"
    ));
}

#[test]
fn test_if_is_not_none() {
    assert!(transpile_ok(
        "def foo(x):\n    if x is not None:\n        return x"
    ));
}

#[test]
fn test_if_isinstance() {
    assert!(transpile_ok(
        "def foo(x):\n    if isinstance(x, int):\n        return x * 2"
    ));
}

#[test]
fn test_if_truthiness_string() {
    assert!(transpile_ok(
        "def foo(s: str):\n    if s:\n        return len(s)"
    ));
}

#[test]
fn test_if_truthiness_list() {
    assert!(transpile_ok(
        "def foo(lst: list):\n    if lst:\n        return lst[0]"
    ));
}

#[test]
fn test_if_truthiness_dict() {
    assert!(transpile_ok(
        "def foo(d: dict):\n    if d:\n        return len(d)"
    ));
}

#[test]
fn test_if_multiple_elif() {
    assert!(transpile_ok("def foo(x):\n    if x == 1:\n        return 'one'\n    elif x == 2:\n        return 'two'\n    elif x == 3:\n        return 'three'\n    else:\n        return 'other'"));
}

#[test]
fn test_if_early_return() {
    assert!(transpile_ok(
        "def foo(x):\n    if x < 0:\n        return -1\n    return x"
    ));
}

#[test]
fn test_if_with_walrus() {
    assert!(transpile_ok(
        "def foo(items):\n    if (n := len(items)) > 0:\n        return n"
    ));
}

// ============================================================================
// MORE FOR LOOP VARIATIONS
// ============================================================================

#[test]
fn test_for_reversed() {
    assert!(transpile_ok(
        "def foo(items):\n    for item in reversed(items):\n        pass"
    ));
}

#[test]
fn test_for_sorted() {
    assert!(transpile_ok(
        "def foo(items):\n    for item in sorted(items):\n        pass"
    ));
}

#[test]
fn test_for_filter() {
    assert!(transpile_ok(
        "def foo(items):\n    for item in filter(lambda x: x > 0, items):\n        pass"
    ));
}

#[test]
fn test_for_map() {
    assert!(transpile_ok(
        "def foo(items):\n    for item in map(lambda x: x * 2, items):\n        pass"
    ));
}

#[test]
fn test_for_triple_nested() {
    assert!(transpile_ok("def foo():\n    for i in range(3):\n        for j in range(3):\n            for k in range(3):\n                x = i + j + k"));
}

#[test]
fn test_for_tuple_unpack() {
    assert!(transpile_ok(
        "def foo():\n    for a, b, c in [(1, 2, 3), (4, 5, 6)]:\n        x = a + b + c"
    ));
}

#[test]
fn test_for_with_assignment() {
    assert!(transpile_ok(
        "def foo():\n    total = 0\n    for i in range(10):\n        total += i\n    return total"
    ));
}

#[test]
fn test_for_set_iteration() {
    assert!(transpile_ok(
        "def foo(s: set):\n    for item in s:\n        pass"
    ));
}

#[test]
fn test_for_bytes_iteration() {
    assert!(transpile_ok(
        "def foo():\n    for b in b'hello':\n        pass"
    ));
}

// ============================================================================
// MORE WHILE LOOP VARIATIONS
// ============================================================================

#[test]
fn test_while_and_condition() {
    assert!(transpile_ok(
        "def foo(x, y):\n    while x > 0 and y > 0:\n        x -= 1\n        y -= 1"
    ));
}

#[test]
fn test_while_or_condition() {
    assert!(transpile_ok("def foo(x, y):\n    while x > 0 or y > 0:\n        if x > 0:\n            x -= 1\n        if y > 0:\n            y -= 1"));
}

#[test]
fn test_while_not_condition() {
    assert!(transpile_ok(
        "def foo(done):\n    while not done:\n        done = True"
    ));
}

#[test]
fn test_while_truthiness() {
    assert!(transpile_ok(
        "def foo(items: list):\n    while items:\n        items.pop()"
    ));
}

#[test]
fn test_while_with_walrus() {
    assert!(transpile_ok(
        "def foo():\n    x = 10\n    while (x := x - 1) > 0:\n        pass"
    ));
}

// ============================================================================
// MORE ASSIGNMENT VARIATIONS
// ============================================================================

#[test]
fn test_assign_list_unpack() {
    assert!(transpile_ok("def foo():\n    a, b, c = [1, 2, 3]"));
}

#[test]
fn test_assign_dict_unpack() {
    assert!(transpile_ok("def foo():\n    d = {'a': 1}\n    x = d['a']"));
}

#[test]
fn test_assign_conditional() {
    assert!(transpile_ok("def foo(x):\n    y = 1 if x else 0"));
}

#[test]
fn test_assign_from_function() {
    assert!(transpile_ok("def foo():\n    x = len([1, 2, 3])"));
}

#[test]
fn test_assign_from_method() {
    assert!(transpile_ok("def foo():\n    x = 'hello'.upper()"));
}

#[test]
fn test_assign_augmented_floordiv() {
    assert!(transpile_ok("def foo():\n    x = 10\n    x //= 3"));
}

#[test]
fn test_assign_augmented_mod() {
    assert!(transpile_ok("def foo():\n    x = 10\n    x %= 3"));
}

#[test]
fn test_assign_augmented_pow() {
    assert!(transpile_ok("def foo():\n    x = 2\n    x **= 3"));
}

#[test]
fn test_assign_augmented_bitand() {
    assert!(transpile_ok("def foo():\n    x = 7\n    x &= 3"));
}

#[test]
fn test_assign_augmented_bitor() {
    assert!(transpile_ok("def foo():\n    x = 5\n    x |= 3"));
}

#[test]
fn test_assign_augmented_bitxor() {
    assert!(transpile_ok("def foo():\n    x = 5\n    x ^= 3"));
}

#[test]
fn test_assign_augmented_lshift() {
    assert!(transpile_ok("def foo():\n    x = 1\n    x <<= 4"));
}

#[test]
fn test_assign_augmented_rshift() {
    assert!(transpile_ok("def foo():\n    x = 16\n    x >>= 2"));
}

#[test]
fn test_assign_nested_subscript() {
    assert!(transpile_ok(
        "def foo():\n    d = {'a': [1, 2, 3]}\n    d['a'][0] = 10"
    ));
}

#[test]
fn test_assign_slice() {
    assert!(transpile_ok(
        "def foo():\n    lst = [1, 2, 3, 4, 5]\n    lst[1:3] = [10, 20]"
    ));
}

// ============================================================================
// MORE TRY/EXCEPT VARIATIONS
// ============================================================================

#[test]
fn test_try_except_multiple_types() {
    assert!(transpile_ok(
        "def foo():\n    try:\n        x = 1\n    except (ValueError, TypeError):\n        x = 0"
    ));
}

#[test]
fn test_try_nested() {
    assert!(transpile_ok("def foo():\n    try:\n        try:\n            x = 1\n        except:\n            pass\n    except:\n        pass"));
}

#[test]
fn test_try_in_loop() {
    assert!(transpile_ok("def foo(items):\n    for item in items:\n        try:\n            x = int(item)\n        except:\n            continue"));
}

#[test]
fn test_try_finally_only() {
    assert!(transpile_ok(
        "def foo():\n    try:\n        x = 1\n    finally:\n        y = 2"
    ));
}

#[test]
fn test_try_full() {
    assert!(transpile_ok("def foo():\n    try:\n        x = 1\n    except ValueError:\n        x = 2\n    except:\n        x = 3\n    else:\n        x = 4\n    finally:\n        y = 5"));
}

// ============================================================================
// MORE WITH STATEMENT VARIATIONS
// ============================================================================

#[test]
fn test_with_nested() {
    assert!(transpile_ok(
        "def foo():\n    with open('a') as f1:\n        with open('b') as f2:\n            pass"
    ));
}

#[test]
fn test_with_contextlib() {
    assert!(transpile_ok("from contextlib import contextmanager\n\ndef foo():\n    with contextmanager(lambda: None) as ctx:\n        pass"));
}

// ============================================================================
// MORE RETURN VARIATIONS
// ============================================================================

#[test]
fn test_return_list() {
    assert!(transpile_ok("def foo():\n    return [1, 2, 3]"));
}

#[test]
fn test_return_dict() {
    assert!(transpile_ok("def foo():\n    return {'a': 1}"));
}

#[test]
fn test_return_set() {
    assert!(transpile_ok("def foo():\n    return {1, 2, 3}"));
}

#[test]
fn test_return_comprehension() {
    assert!(transpile_ok(
        "def foo():\n    return [i * 2 for i in range(10)]"
    ));
}

#[test]
fn test_return_lambda_result() {
    assert!(transpile_ok(
        "def foo():\n    f = lambda x: x * 2\n    return f(21)"
    ));
}

#[test]
fn test_return_method_chain() {
    assert!(transpile_ok(
        "def foo():\n    return 'hello world'.upper().split()"
    ));
}

// ============================================================================
// MORE RAISE VARIATIONS
// ============================================================================

#[test]
fn test_extended_raise_runtime_error() {
    assert!(transpile_ok("def foo():\n    raise RuntimeError('error')"));
}

#[test]
fn test_extended_raise_type_error() {
    assert!(transpile_ok(
        "def foo():\n    raise TypeError('wrong type')"
    ));
}

#[test]
fn test_extended_raise_key_error() {
    assert!(transpile_ok(
        "def foo():\n    raise KeyError('missing key')"
    ));
}

#[test]
fn test_extended_raise_index_error() {
    assert!(transpile_ok(
        "def foo():\n    raise IndexError('out of bounds')"
    ));
}

#[test]
fn test_raise_assertion_error() {
    assert!(transpile_ok(
        "def foo():\n    raise AssertionError('assertion failed')"
    ));
}

#[test]
fn test_raise_not_implemented() {
    assert!(transpile_ok("def foo():\n    raise NotImplementedError()"));
}

// ============================================================================
// MORE ASSERT VARIATIONS
// ============================================================================

#[test]
fn test_assert_equality() {
    assert!(transpile_ok("def foo(x):\n    assert x == 42"));
}

#[test]
fn test_assert_isinstance() {
    assert!(transpile_ok("def foo(x):\n    assert isinstance(x, int)"));
}

#[test]
fn test_assert_in() {
    assert!(transpile_ok("def foo(x, items):\n    assert x in items"));
}

#[test]
fn test_assert_not_none() {
    assert!(transpile_ok("def foo(x):\n    assert x is not None"));
}

// ============================================================================
// DELETE VARIATIONS
// ============================================================================

#[test]
fn test_del_dict_key() {
    assert!(transpile_ok(
        "def foo():\n    d = {'a': 1, 'b': 2}\n    del d['a']"
    ));
}

#[test]
fn test_del_attribute() {
    assert!(transpile_ok("def foo(obj):\n    del obj.attr"));
}

#[test]
fn test_del_slice() {
    assert!(transpile_ok(
        "def foo():\n    lst = [1, 2, 3, 4, 5]\n    del lst[1:3]"
    ));
}

#[test]
fn test_del_multiple() {
    assert!(transpile_ok(
        "def foo():\n    a = 1\n    b = 2\n    del a, b"
    ));
}

// ============================================================================
// MORE MATCH VARIATIONS
// ============================================================================

#[test]
fn test_match_sequence() {
    assert!(transpile_ok(
        "def foo(x):\n    match x:\n        case [a, b]:\n            return a + b"
    ));
}

#[test]
fn test_match_mapping() {
    assert!(transpile_ok(
        "def foo(x):\n    match x:\n        case {'key': value}:\n            return value"
    ));
}

#[test]
fn test_match_class() {
    assert!(transpile_ok("def foo(point):\n    match point:\n        case Point(x=0, y=0):\n            return 'origin'"));
}

#[test]
fn test_match_guard() {
    assert!(transpile_ok(
        "def foo(x):\n    match x:\n        case n if n > 0:\n            return 'positive'"
    ));
}

#[test]
fn test_match_or_pattern() {
    assert!(transpile_ok(
        "def foo(x):\n    match x:\n        case 'yes' | 'y' | 'true':\n            return True"
    ));
}

// ============================================================================
// FUNCTION DEFINITIONS IN STATEMENTS
// ============================================================================

#[test]
fn test_nested_function() {
    assert!(transpile_ok(
        "def outer():\n    def inner():\n        return 1\n    return inner()"
    ));
}

#[test]
fn test_decorated_nested_function() {
    assert!(transpile_ok(
        "def outer():\n    @staticmethod\n    def inner():\n        return 1"
    ));
}

#[test]
fn test_recursive_function() {
    assert!(transpile_ok(
        "def factorial(n):\n    if n <= 1:\n        return 1\n    return n * factorial(n - 1)"
    ));
}

// ============================================================================
// GENERATOR STATEMENTS
// ============================================================================

#[test]
fn test_yield_statement() {
    assert!(transpile_ok(
        "def gen():\n    yield 1\n    yield 2\n    yield 3"
    ));
}

#[test]
fn test_yield_from_statement() {
    assert!(transpile_ok("def gen():\n    yield from [1, 2, 3]"));
}

#[test]
fn test_yield_in_loop() {
    assert!(transpile_ok(
        "def gen(n):\n    for i in range(n):\n        yield i"
    ));
}

#[test]
fn test_yield_conditional() {
    assert!(transpile_ok(
        "def gen(items):\n    for item in items:\n        if item > 0:\n            yield item"
    ));
}

// ============================================================================
// ASYNC STATEMENTS
// ============================================================================

#[test]
fn test_async_def() {
    assert!(transpile_ok("async def foo():\n    return 42"));
}

#[test]
fn test_await_statement() {
    assert!(transpile_ok(
        "async def foo():\n    result = await bar()\n    return result"
    ));
}

#[test]
fn test_async_for() {
    assert!(transpile_ok(
        "async def foo():\n    async for item in aiter:\n        pass"
    ));
}

#[test]
fn test_async_with() {
    assert!(transpile_ok(
        "async def foo():\n    async with aopen('file') as f:\n        pass"
    ));
}

// ============================================================================
// COMPLEX STATEMENT COMBINATIONS
// ============================================================================

#[test]
fn test_if_in_for() {
    assert!(transpile_ok(
        "def foo(items):\n    for item in items:\n        if item > 0:\n            return item"
    ));
}

#[test]
fn test_for_in_if() {
    assert!(transpile_ok(
        "def foo(items):\n    if items:\n        for item in items:\n            pass"
    ));
}

#[test]
fn test_try_in_for_in_while() {
    assert!(transpile_ok("def foo():\n    i = 0\n    while i < 10:\n        for j in range(i):\n            try:\n                x = 1 / j\n            except:\n                pass\n        i += 1"));
}

#[test]
fn test_nested_with_try() {
    assert!(transpile_ok("def foo():\n    try:\n        with open('file') as f:\n            data = f.read()\n    except:\n        pass"));
}

#[test]
fn test_multiple_returns() {
    assert!(transpile_ok("def foo(x):\n    if x < 0:\n        return -1\n    if x == 0:\n        return 0\n    return 1"));
}

#[test]
fn test_guard_clauses() {
    assert!(transpile_ok("def foo(x):\n    if x is None:\n        return None\n    if not isinstance(x, int):\n        raise TypeError()\n    return x * 2"));
}

// ============================================================================
// MORE IMPORT VARIATIONS
// ============================================================================

#[test]
fn test_import_star() {
    assert!(transpile_ok("from os.path import *"));
}

#[test]
fn test_import_nested_module() {
    assert!(transpile_ok("import os.path.join"));
}

#[test]
fn test_import_in_function() {
    assert!(transpile_ok(
        "def foo():\n    import os\n    return os.getcwd()"
    ));
}

// ============================================================================
// MORE TYPE ANNOTATION VARIATIONS
// ============================================================================

#[test]
fn test_annotated_list() {
    assert!(transpile_ok("def foo():\n    x: list[int] = [1, 2, 3]"));
}

#[test]
fn test_annotated_dict() {
    assert!(transpile_ok("def foo():\n    x: dict[str, int] = {'a': 1}"));
}

#[test]
fn test_annotated_optional() {
    assert!(transpile_ok(
        "from typing import Optional\n\ndef foo():\n    x: Optional[int] = None"
    ));
}

#[test]
fn test_annotated_union() {
    assert!(transpile_ok(
        "from typing import Union\n\ndef foo():\n    x: Union[int, str] = 42"
    ));
}

#[test]
fn test_annotated_tuple() {
    assert!(transpile_ok("def foo():\n    x: tuple[int, int] = (1, 2)"));
}

#[test]
fn test_annotated_callable() {
    assert!(transpile_ok(
        "from typing import Callable\n\ndef foo():\n    x: Callable[[int], int] = lambda n: n * 2"
    ));
}

// ============================================================================
// EDGE CASES
// ============================================================================

#[test]
fn test_empty_if_body() {
    assert!(transpile_ok("def foo():\n    if True:\n        pass"));
}

#[test]
fn test_empty_for_body() {
    assert!(transpile_ok(
        "def foo():\n    for i in range(10):\n        pass"
    ));
}

#[test]
fn test_empty_while_body() {
    assert!(transpile_ok("def foo():\n    while False:\n        pass"));
}

#[test]
fn test_empty_try_body() {
    assert!(transpile_ok(
        "def foo():\n    try:\n        pass\n    except:\n        pass"
    ));
}

#[test]
fn test_deeply_nested() {
    assert!(transpile_ok("def foo():\n    if True:\n        if True:\n            if True:\n                if True:\n                    x = 1"));
}

#[test]
fn test_many_statements() {
    assert!(transpile_ok("def foo():\n    a = 1\n    b = 2\n    c = 3\n    d = 4\n    e = 5\n    f = 6\n    g = 7\n    h = 8\n    i = 9\n    j = 10"));
}

#[test]
fn test_mixed_statement_types() {
    assert!(transpile_ok("def foo():\n    x = 1\n    if x:\n        for i in range(x):\n            while True:\n                break\n    return x"));
}

// ============================================================================
// FOR LOOP VARIATIONS
// ============================================================================

#[test]
fn test_for_string_iteration() {
    assert!(transpile_ok(
        "def foo():\n    s = 'hello'\n    for c in s:\n        print(c)"
    ));
}

#[test]
fn test_for_text_variable_iteration() {
    assert!(transpile_ok(
        "def foo():\n    text = 'hello'\n    for c in text:\n        print(c)"
    ));
}

#[test]
fn test_for_tuple_unpacking() {
    assert!(transpile_ok(
        "def foo():\n    items = [(1, 'a'), (2, 'b')]\n    for x, y in items:\n        print(x, y)"
    ));
}

#[test]
fn test_for_tuple_unpacking_three() {
    assert!(transpile_ok("def foo():\n    items = [(1, 'a', True), (2, 'b', False)]\n    for x, y, z in items:\n        print(x, y, z)"));
}

#[test]
fn test_for_with_mut_variable() {
    // Variable reassigned in loop body needs mut
    assert!(transpile_ok("def foo():\n    lines = ['a', 'b']\n    for line in lines:\n        line = line.strip()\n        print(line)"));
}

#[test]
fn test_for_enumerate_with_print() {
    assert!(transpile_ok("def foo():\n    items = [1, 2, 3]\n    for i, item in enumerate(items):\n        print(i, item)"));
}

#[test]
fn test_for_dict_items_print() {
    assert!(transpile_ok(
        "def foo():\n    d = {'a': 1}\n    for k, v in d.items():\n        print(k, v)"
    ));
}

#[test]
fn test_for_dict_keys_only() {
    assert!(transpile_ok(
        "def foo():\n    d = {'a': 1}\n    for k in d:\n        print(k)"
    ));
}

#[test]
fn test_for_dict_values_print() {
    assert!(transpile_ok(
        "def foo():\n    d = {'a': 1}\n    for v in d.values():\n        print(v)"
    ));
}

#[test]
fn test_for_zip_print() {
    assert!(transpile_ok("def foo():\n    a = [1, 2]\n    b = ['x', 'y']\n    for x, y in zip(a, b):\n        print(x, y)"));
}

#[test]
fn test_for_range_step_print() {
    assert!(transpile_ok(
        "def foo():\n    for i in range(0, 10, 2):\n        print(i)"
    ));
}

#[test]
fn test_for_reversed_print() {
    assert!(transpile_ok(
        "def foo():\n    items = [1, 2, 3]\n    for x in reversed(items):\n        print(x)"
    ));
}

#[test]
fn test_for_sorted_print() {
    assert!(transpile_ok(
        "def foo():\n    items = [3, 1, 2]\n    for x in sorted(items):\n        print(x)"
    ));
}

#[test]
fn test_for_set_iteration_print() {
    assert!(transpile_ok(
        "def foo():\n    s = {1, 2, 3}\n    for x in s:\n        print(x)"
    ));
}

#[test]
fn test_for_unused_variable() {
    // Unused loop variable should get underscore prefix
    assert!(transpile_ok(
        "def foo():\n    for _ in range(5):\n        print('hello')"
    ));
}

#[test]
fn test_for_else_completed() {
    assert!(transpile_ok("def foo():\n    for i in range(5):\n        if i == 10:\n            break\n    else:\n        print('completed')"));
}

// ============================================================================
// WHILE LOOP VARIATIONS
// ============================================================================

#[test]
fn test_while_with_break() {
    assert!(transpile_ok("def foo():\n    x = 0\n    while True:\n        x += 1\n        if x > 10:\n            break"));
}

#[test]
fn test_while_with_continue() {
    assert!(transpile_ok("def foo():\n    x = 0\n    while x < 10:\n        x += 1\n        if x % 2 == 0:\n            continue\n        print(x)"));
}

#[test]
fn test_while_else_done() {
    assert!(transpile_ok(
        "def foo():\n    x = 0\n    while x < 5:\n        x += 1\n    else:\n        print('done')"
    ));
}

#[test]
fn test_while_complex_condition() {
    assert!(transpile_ok(
        "def foo():\n    x = 0\n    y = 10\n    while x < y and x >= 0:\n        x += 1"
    ));
}

// ============================================================================
// TRY-EXCEPT VARIATIONS
// ============================================================================

#[test]
fn test_try_multiple_except_handlers() {
    assert!(transpile_ok("def foo():\n    try:\n        x = 1/0\n    except ZeroDivisionError:\n        x = 0\n    except ValueError:\n        x = -1"));
}

#[test]
fn test_try_except_as_print() {
    assert!(transpile_ok(
        "def foo():\n    try:\n        x = 1/0\n    except Exception as e:\n        print(e)"
    ));
}

#[test]
fn test_try_finally() {
    assert!(transpile_ok(
        "def foo():\n    try:\n        x = 1\n    finally:\n        print('cleanup')"
    ));
}

#[test]
fn test_try_except_finally_combined() {
    assert!(transpile_ok("def foo():\n    try:\n        x = 1\n    except:\n        pass\n    finally:\n        print('cleanup')"));
}

#[test]
fn test_try_except_else_success() {
    assert!(transpile_ok("def foo():\n    try:\n        x = 1\n    except:\n        pass\n    else:\n        print('success')"));
}

#[test]
fn test_try_nested_reraise() {
    assert!(transpile_ok("def foo():\n    try:\n        try:\n            x = 1/0\n        except:\n            raise\n    except:\n        pass"));
}

#[test]
fn test_raise_valueerror() {
    assert!(transpile_ok("def foo():\n    raise ValueError()"));
}

#[test]
fn test_raise_with_message() {
    assert!(transpile_ok(
        "def foo():\n    raise ValueError('error message')"
    ));
}

#[test]
fn test_raise_from_exception() {
    assert!(transpile_ok("def foo():\n    try:\n        x = 1/0\n    except Exception as e:\n        raise RuntimeError() from e"));
}

#[test]
fn test_extended_raise_bare() {
    assert!(transpile_ok(
        "def foo():\n    try:\n        x = 1\n    except:\n        raise"
    ));
}

// ============================================================================
// WITH STATEMENT VARIATIONS
// ============================================================================

#[test]
fn test_extended_with_open_file() {
    assert!(transpile_ok(
        "def foo():\n    with open('file.txt') as f:\n        x = f.read()"
    ));
}

#[test]
fn test_with_multiple_files() {
    assert!(transpile_ok(
        "def foo():\n    with open('a.txt') as a, open('b.txt') as b:\n        x = a.read()"
    ));
}

#[test]
fn test_with_no_alias() {
    assert!(transpile_ok("def foo():\n    with lock:\n        x = 1"));
}

#[test]
fn test_with_nested_files() {
    assert!(transpile_ok("def foo():\n    with open('a.txt') as a:\n        with open('b.txt') as b:\n            x = a.read() + b.read()"));
}

// ============================================================================
// MATCH STATEMENT (Python 3.10+)
// ============================================================================

#[test]
fn test_match_simple() {
    assert!(transpile_ok("def foo(x):\n    match x:\n        case 1:\n            return 'one'\n        case 2:\n            return 'two'\n        case _:\n            return 'other'"));
}

#[test]
fn test_match_tuple() {
    assert!(transpile_ok("def foo(point):\n    match point:\n        case (0, 0):\n            return 'origin'\n        case (x, 0):\n            return 'x-axis'\n        case (0, y):\n            return 'y-axis'\n        case (x, y):\n            return 'other'"));
}

#[test]
fn test_match_or_pattern_small() {
    assert!(transpile_ok("def foo(x):\n    match x:\n        case 1 | 2 | 3:\n            return 'small'\n        case _:\n            return 'large'"));
}

#[test]
fn test_match_guard_pos_neg() {
    assert!(transpile_ok("def foo(x):\n    match x:\n        case n if n > 0:\n            return 'positive'\n        case n if n < 0:\n            return 'negative'\n        case _:\n            return 'zero'"));
}

// ============================================================================
// SPECIAL STATEMENTS
// ============================================================================

#[test]
fn test_global_statement() {
    assert!(transpile_ok("x = 0\n\ndef foo():\n    global x\n    x = 1"));
}

#[test]
fn test_nonlocal_statement() {
    assert!(transpile_ok(
        "def foo():\n    x = 0\n    def bar():\n        nonlocal x\n        x = 1\n    bar()"
    ));
}

#[test]
fn test_del_statement() {
    assert!(transpile_ok("def foo():\n    x = [1, 2, 3]\n    del x[0]"));
}

#[test]
fn test_del_variable_simple() {
    assert!(transpile_ok("def foo():\n    x = 1\n    del x"));
}

#[test]
fn test_assert_with_message_positive() {
    assert!(transpile_ok(
        "def foo(x):\n    assert x > 0, 'x must be positive'"
    ));
}

#[test]
fn test_assert_no_message() {
    assert!(transpile_ok("def foo(x):\n    assert x > 0"));
}

// ============================================================================
// ASSIGNMENT VARIATIONS
// ============================================================================

#[test]
fn test_augmented_assign_all_ops() {
    assert!(transpile_ok("def foo():\n    x = 10\n    x += 1\n    x -= 1\n    x *= 2\n    x /= 2\n    x //= 1\n    x %= 3\n    x **= 2\n    x &= 1\n    x |= 1\n    x ^= 1\n    x <<= 1\n    x >>= 1"));
}

#[test]
fn test_annotated_assign() {
    assert!(transpile_ok(
        "def foo():\n    x: int = 1\n    y: str = 'hello'\n    z: list[int] = [1, 2, 3]"
    ));
}

#[test]
fn test_multiple_assign() {
    assert!(transpile_ok("def foo():\n    a = b = c = 1"));
}

#[test]
fn test_walrus_operator() {
    assert!(transpile_ok(
        "def foo():\n    if (n := len([1, 2, 3])) > 2:\n        print(n)"
    ));
}

#[test]
fn test_tuple_unpack_assign() {
    assert!(transpile_ok("def foo():\n    x, y, z = 1, 2, 3"));
}

#[test]
fn test_starred_assign() {
    assert!(transpile_ok("def foo():\n    first, *rest = [1, 2, 3, 4]"));
}

#[test]
fn test_subscript_assign() {
    assert!(transpile_ok("def foo():\n    x = [1, 2, 3]\n    x[0] = 10"));
}

#[test]
fn test_attribute_assign() {
    assert!(transpile_ok("class Foo:\n    def __init__(self):\n        self.x = 1\n\ndef foo():\n    f = Foo()\n    f.x = 2"));
}

// ============================================================================
// COMPLEX PATTERNS
// ============================================================================

#[test]
fn test_list_comp_with_if() {
    assert!(transpile_ok(
        "def foo():\n    x = [i for i in range(10) if i % 2 == 0]"
    ));
}

#[test]
fn test_dict_comp() {
    assert!(transpile_ok(
        "def foo():\n    x = {i: i**2 for i in range(5)}"
    ));
}

#[test]
fn test_set_comp() {
    assert!(transpile_ok(
        "def foo():\n    x = {i for i in range(10) if i % 2 == 0}"
    ));
}

#[test]
fn test_generator_expr_in_sum() {
    assert!(transpile_ok(
        "def foo():\n    x = sum(i**2 for i in range(10))"
    ));
}

#[test]
fn test_nested_comprehension() {
    assert!(transpile_ok(
        "def foo():\n    matrix = [[i*j for j in range(3)] for i in range(3)]"
    ));
}

#[test]
fn test_lambda_in_statement() {
    assert!(transpile_ok(
        "def foo():\n    double = lambda x: x * 2\n    result = double(5)"
    ));
}

#[test]
fn test_ternary_in_assign() {
    assert!(transpile_ok(
        "def foo(x):\n    result = 'positive' if x > 0 else 'negative'"
    ));
}

// ============================================================================
// TYPE COERCION SCENARIOS
// ============================================================================

#[test]
fn test_int_to_float_coercion() {
    assert!(transpile_ok("def foo():\n    x: float = 1\n    y = x + 2"));
}

#[test]
fn test_str_to_string_coercion() {
    assert!(transpile_ok(
        "def foo():\n    x: str = 'hello'\n    y = x.upper()"
    ));
}

// ============================================================================
// ITERATOR PATTERNS
// ============================================================================

#[test]
fn test_filter_map_chain() {
    assert!(transpile_ok("def foo():\n    items = [1, 2, 3, 4]\n    result = list(filter(lambda x: x > 2, map(lambda x: x * 2, items)))"));
}

#[test]
fn test_any_all() {
    assert!(transpile_ok("def foo():\n    items = [1, 2, 3]\n    a = any(x > 2 for x in items)\n    b = all(x > 0 for x in items)"));
}

#[test]
fn test_min_max_key() {
    assert!(transpile_ok("def foo():\n    items = ['hello', 'hi', 'hey']\n    shortest = min(items, key=len)\n    longest = max(items, key=len)"));
}

// ============================================================================
// CONTEXT-DEPENDENT BEHAVIORS
// ============================================================================

#[test]
fn test_final_return_statement() {
    // Final statement should return without explicit return keyword
    assert!(transpile_ok("def foo():\n    x = 1\n    x + 1"));
}

#[test]
fn test_return_in_if() {
    assert!(transpile_ok(
        "def foo(x):\n    if x > 0:\n        return 'positive'\n    return 'non-positive'"
    ));
}

#[test]
fn test_return_in_try() {
    assert!(transpile_ok(
        "def foo():\n    try:\n        return 1\n    except:\n        return 0"
    ));
}

#[test]
fn test_return_in_for() {
    assert!(transpile_ok("def foo():\n    for i in range(10):\n        if i == 5:\n            return i\n    return -1"));
}

#[test]
fn test_return_in_while() {
    assert!(transpile_ok("def foo():\n    x = 0\n    while True:\n        x += 1\n        if x == 5:\n            return x"));
}

// ============================================================================
// TYPE COERCION IN COMPLEX EXPRESSIONS
// ============================================================================

#[test]
fn test_usize_to_i32_in_loop() {
    assert!(transpile_ok(
        r#"def foo():
    lst = [1, 2, 3]
    n = len(lst)
    for i in range(n):
        x = i"#
    ));
}

#[test]
fn test_float_coercion_in_comparison() {
    assert!(transpile_ok(
        r#"def foo(x: float):
    if x > 0:
        return x * 2
    return 0.0"#
    ));
}

#[test]
fn test_string_coercion_in_format() {
    assert!(transpile_ok(
        r#"def foo():
    x = 42
    s = f"value: {x}""#
    ));
}

// ============================================================================
// EDGE CASES
// ============================================================================

#[test]
fn test_empty_function() {
    assert!(transpile_ok("def foo():\n    pass"));
}

#[test]
fn test_single_expression_body() {
    assert!(transpile_ok("def foo():\n    1 + 2"));
}

#[test]
fn test_chained_comparison() {
    assert!(transpile_ok(
        "def foo(x):\n    if 0 < x < 10:\n        return True\n    return False"
    ));
}

#[test]
fn test_boolean_short_circuit() {
    assert!(transpile_ok("def foo():\n    x = a and b or c"));
}

#[test]
fn test_none_check_pattern() {
    assert!(transpile_ok(
        "def foo(x):\n    if x is None:\n        return 0\n    return x"
    ));
}

#[test]
fn test_not_none_check() {
    assert!(transpile_ok(
        "def foo(x):\n    if x is not None:\n        return x\n    return 0"
    ));
}

#[test]
fn test_identity_check() {
    assert!(transpile_ok("def foo(a, b):\n    return a is b"));
}

#[test]
fn test_membership_test() {
    assert!(transpile_ok("def foo(x, lst):\n    return x in lst"));
}

#[test]
fn test_not_in() {
    assert!(transpile_ok("def foo(x, lst):\n    return x not in lst"));
}

// ============================================================================
// FOR LOOP SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_for_string_chars_iteration() {
    assert!(transpile_ok(
        r#"def foo():
    s = "hello"
    for c in s:
        print(c)"#
    ));
}

#[test]
fn test_for_text_var_chars() {
    assert!(transpile_ok(
        r#"def foo():
    text = "world"
    for char in text:
        print(char)"#
    ));
}

#[test]
fn test_for_line_var_chars() {
    assert!(transpile_ok(
        r#"def foo():
    line = "abc"
    for x in line:
        pass"#
    ));
}

#[test]
fn test_for_word_var_chars() {
    assert!(transpile_ok(
        r#"def foo():
    word = "test"
    for c in word:
        pass"#
    ));
}

#[test]
fn test_for_str_prefix_var() {
    assert!(transpile_ok(
        r#"def foo():
    str_data = "abc"
    for c in str_data:
        pass"#
    ));
}

#[test]
fn test_for_file_iteration() {
    assert!(transpile_ok(
        r#"def foo():
    f = open("test.txt")
    for line in f:
        print(line)"#
    ));
}

#[test]
fn test_for_file_var_iteration() {
    assert!(transpile_ok(
        r#"def foo():
    file = open("data.txt")
    for line in file:
        print(line)"#
    ));
}

#[test]
fn test_for_input_file_iteration() {
    assert!(transpile_ok(
        r#"def foo():
    input_file = open("input.txt")
    for line in input_file:
        print(line)"#
    ));
}

#[test]
fn test_for_data_file_iteration() {
    assert!(transpile_ok(
        r#"def foo():
    data_file = open("data.txt")
    for line in data_file:
        pass"#
    ));
}

#[test]
fn test_for_unused_loop_var() {
    // DEPYLER-0272: Unused loop vars should get underscore prefix
    assert!(transpile_ok(
        r#"def foo():
    for i in range(10):
        print("hello")"#
    ));
}

#[test]
fn test_for_reassigned_loop_var() {
    // DEPYLER-0756: Reassigned loop vars need mut
    assert!(transpile_ok(
        r#"def foo():
    for line in ["a", "b"]:
        line = line.strip()
        print(line)"#
    ));
}

#[test]
fn test_for_range_loop_var_type() {
    // DEPYLER-0803: Track loop var as Int for range iteration
    assert!(transpile_ok(
        r#"def foo():
    dx = 0.5
    for i in range(10):
        x = i * dx
        print(x)"#
    ));
}

#[test]
fn test_for_dict_iteration() {
    // DEPYLER-0710: Dict iteration over keys
    assert!(transpile_ok(
        r#"def foo():
    d: dict[str, int] = {"a": 1, "b": 2}
    for key in d:
        print(key)"#
    ));
}

#[test]
fn test_for_iterator_var_no_iter() {
    // DEPYLER-0520: Iterator vars shouldn't get .iter().cloned()
    assert!(transpile_ok(
        r#"def foo():
    items = [1, 2, 3]
    filtered = filter(lambda x: x > 1, items)
    for item in filtered:
        print(item)"#
    ));
}

#[test]
fn test_for_tuple_reassigned_element() {
    // DEPYLER-0756: Tuple elements reassigned need mut
    assert!(transpile_ok(
        r#"def foo():
    pairs = [(1, "a"), (2, "b")]
    for num, text in pairs:
        text = text.upper()
        print(num, text)"#
    ));
}

#[test]
fn test_for_tuple_unused_element() {
    // DEPYLER-0272: Unused tuple elements get underscore
    assert!(transpile_ok(
        r#"def foo():
    pairs = [(1, "a"), (2, "b")]
    for num, text in pairs:
        print(num)"#
    ));
}

#[test]
fn test_for_csv_reader_iteration() {
    assert!(transpile_ok(
        r#"import csv
def foo():
    reader = csv.DictReader(open("data.csv"))
    for row in reader:
        print(row)"#
    ));
}

#[test]
fn test_for_csv_var_iteration() {
    assert!(transpile_ok(
        r#"def foo():
    csv_reader = None
    for row in csv_reader:
        pass"#
    ));
}

#[test]
fn test_for_string_method_chars() {
    // DEPYLER-1012: String method results iteration
    assert!(transpile_ok(
        r#"def foo():
    s = "HELLO"
    for c in s.lower():
        print(c)"#
    ));
}

#[test]
fn test_for_strip_result_chars() {
    assert!(transpile_ok(
        r#"def foo():
    s = "  hello  "
    for c in s.strip():
        print(c)"#
    ));
}

#[test]
fn test_for_replace_result_chars() {
    assert!(transpile_ok(
        r#"def foo():
    s = "hello world"
    for c in s.replace(" ", "_"):
        print(c)"#
    ));
}

// ============================================================================
// ASSIGNMENT SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_assign_dict_index_augment() {
    // DEPYLER-4048: Dict augmented assignment pattern
    assert!(transpile_ok(
        r#"def foo():
    counts: dict[str, int] = {}
    counts["a"] = counts.get("a", 0) + 1"#
    ));
}

#[test]
fn test_assign_nested_dict_key() {
    assert!(transpile_ok(
        r#"def foo():
    data = {"a": {"b": 1}}
    data["a"]["c"] = 2"#
    ));
}

#[test]
fn test_assign_list_slice() {
    assert!(transpile_ok(
        r#"def foo():
    lst = [1, 2, 3, 4]
    lst[1:3] = [10, 20]"#
    ));
}

#[test]
fn test_assign_from_walrus() {
    // DEPYLER-0188: Walrus operator in assignment
    assert!(transpile_ok(
        r#"def foo():
    if (n := len([1, 2, 3])) > 2:
        x = n"#
    ));
}

#[test]
fn test_assign_with_type_conversion() {
    assert!(transpile_ok(
        r#"def foo():
    x: float = 5
    y = x + 1.5"#
    ));
}

// ============================================================================
// IF STATEMENT SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_if_option_pattern() {
    // DEPYLER-2623: Option if-let pattern
    assert!(transpile_ok(
        r#"def foo():
    result = get_optional()
    if result is not None:
        print(result)"#
    ));
}

#[test]
fn test_if_variable_hoisting() {
    // DEPYLER-0476: Variable hoisting in if/else
    assert!(transpile_ok(
        r#"def foo(condition):
    if condition:
        value = get_a()
    else:
        value = get_b()
    return value"#
    ));
}

#[test]
fn test_if_nested_walrus() {
    // DEPYLER-0188: Nested walrus extraction
    assert!(transpile_ok(
        r#"def foo():
    if (x := get_x()) and (y := get_y()):
        print(x, y)"#
    ));
}

#[test]
fn test_if_dict_key_check() {
    assert!(transpile_ok(
        r#"def foo():
    d = {"a": 1}
    if "a" in d:
        x = d["a"]"#
    ));
}

#[test]
fn test_if_var_used_as_dict_key() {
    // DEPYLER-3181: Variable used as dict key
    assert!(transpile_ok(
        r#"def foo():
    key = "name"
    d = {}
    if key in d:
        print(d[key])"#
    ));
}

// ============================================================================
// WHILE LOOP SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_while_file_readline() {
    assert!(transpile_ok(
        r#"def foo():
    f = open("test.txt")
    while line := f.readline():
        print(line)"#
    ));
}

#[test]
fn test_while_iterator_next() {
    assert!(transpile_ok(
        r#"def foo():
    items = iter([1, 2, 3])
    while (item := next(items, None)) is not None:
        print(item)"#
    ));
}

// ============================================================================
// TRY/EXCEPT SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_try_variable_in_handler() {
    assert!(transpile_ok(
        r#"def foo():
    try:
        x = risky_operation()
    except ValueError as e:
        x = default_value()
        log_error(e)
    return x"#
    ));
}

#[test]
fn test_try_finally_cleanup() {
    assert!(transpile_ok(
        r#"def foo():
    f = open("test.txt")
    try:
        data = f.read()
    finally:
        f.close()
    return data"#
    ));
}

// ============================================================================
// RAISE STATEMENT SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_raise_custom_exception() {
    assert!(transpile_ok(
        r#"def foo():
    raise CustomError("message")"#
    ));
}

#[test]
fn test_raise_from_variable() {
    assert!(transpile_ok(
        r#"def foo():
    try:
        x = 1 / 0
    except ZeroDivisionError as e:
        raise ValueError("Division error") from e"#
    ));
}

// ============================================================================
// WITH STATEMENT SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_with_file_write() {
    assert!(transpile_ok(
        r#"def foo():
    with open("test.txt", "w") as f:
        f.write("hello")"#
    ));
}

#[test]
fn test_with_multiple_context() {
    assert!(transpile_ok(
        r#"def foo():
    with open("in.txt") as fin, open("out.txt", "w") as fout:
        fout.write(fin.read())"#
    ));
}

// ============================================================================
// EXPRESSION STATEMENT SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_expr_stmt_with_side_effect() {
    assert!(transpile_ok(
        r#"def foo():
    lst = [1, 2, 3]
    lst.pop()
    lst.append(4)"#
    ));
}

#[test]
fn test_expr_stmt_method_chain() {
    assert!(transpile_ok(
        r#"def foo():
    d = {}
    d.setdefault("key", []).append(1)"#
    ));
}

// ============================================================================
// RETURN STATEMENT SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_return_none_explicit() {
    assert!(transpile_ok(
        r#"def foo():
    return None"#
    ));
}

#[test]
fn test_return_tuple_unpack() {
    assert!(transpile_ok(
        r#"def foo():
    return 1, 2, 3"#
    ));
}

#[test]
fn test_return_conditional_expr() {
    assert!(transpile_ok(
        r#"def foo(x):
    return "yes" if x > 0 else "no""#
    ));
}

// ============================================================================
// FUNCTION DEF SPECIALIZED PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_func_with_varargs() {
    assert!(transpile_ok(
        r#"def foo(*args):
    for arg in args:
        print(arg)"#
    ));
}

#[test]
fn test_func_with_kwargs() {
    assert!(transpile_ok(
        r#"def foo(**kwargs):
    for k, v in kwargs.items():
        print(k, v)"#
    ));
}

#[test]
fn test_func_positional_only_params() {
    assert!(transpile_ok(
        r#"def foo(x, /, y):
    return x + y"#
    ));
}

#[test]
fn test_func_keyword_only_params() {
    assert!(transpile_ok(
        r#"def foo(*, x, y):
    return x + y"#
    ));
}

// ============================================================================
// JSON VALUE PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_json_dict_index_iteration() {
    // DEPYLER-0607: JSON value iteration
    assert!(transpile_ok(
        r#"import json
def foo():
    data = {"items": [1, 2, 3]}
    for item in data["items"]:
        print(item)"#
    ));
}

#[test]
fn test_json_nested_access() {
    assert!(transpile_ok(
        r#"import json
def foo():
    data = {"a": {"b": [1, 2]}}
    items = data["a"]["b"]"#
    ));
}

// ============================================================================
// COUNTER/COLLECTIONS PATTERNS (Coverage Boost)
// ============================================================================

#[test]
fn test_counter_items_iteration() {
    // DEPYLER-0821: Counter iteration
    assert!(transpile_ok(
        r#"from collections import Counter
def foo():
    c = Counter("hello")
    for char, count in c.items():
        print(char, count)"#
    ));
}

#[test]
fn test_counter_most_common() {
    assert!(transpile_ok(
        r#"from collections import Counter
def foo():
    c = Counter("hello")
    for char, count in c.most_common(3):
        print(char, count)"#
    ));
}

// ============================================================================
// COVERAGE BOOST: Helper Function Tests
// These tests specifically target uncovered code paths in stmt_gen.rs
// ============================================================================

// --- expr_returns_usize helper ---
#[test]
fn test_expr_returns_usize_len() {
    // Tests the len() method returning usize path
    assert!(transpile_ok(
        r#"def foo():
    items = [1, 2, 3]
    x: int = len(items)
    return x"#
    ));
}

#[test]
fn test_expr_returns_usize_count() {
    // Tests count() method path
    assert!(transpile_ok(
        r#"def foo():
    s = "hello world"
    x: int = s.count("l")
    return x"#
    ));
}

#[test]
fn test_expr_returns_usize_capacity() {
    // Tests capacity path
    assert!(transpile_ok(
        r#"def foo():
    items = [1, 2, 3]
    x = len(items) + len(items)"#
    ));
}

#[test]
fn test_expr_returns_usize_binary() {
    // Tests binary operation with usize
    assert!(transpile_ok(
        r#"def foo():
    items = [1, 2, 3]
    x: int = len(items) + 1"#
    ));
}

// --- expr_infers_float helper ---
#[test]
fn test_expr_infers_float_literal() {
    // Float literal path
    assert!(transpile_ok(
        r#"def foo():
    x = 3.14
    return x"#
    ));
}

#[test]
fn test_expr_infers_float_variable() {
    // Float variable path
    assert!(transpile_ok(
        r#"def foo():
    x: float = 3.14
    y = x * 2
    return y"#
    ));
}

#[test]
fn test_expr_infers_float_call() {
    // Function call returning float
    assert!(transpile_ok(
        r#"def get_pi() -> float:
    return 3.14

def foo():
    x = get_pi()
    return x"#
    ));
}

#[test]
fn test_expr_infers_float_binary() {
    // Binary operation with float
    assert!(transpile_ok(
        r#"def foo():
    x = 3.14 * 2
    return x"#
    ));
}

#[test]
fn test_expr_infers_float_unary() {
    // Unary operation preserving float
    assert!(transpile_ok(
        r#"def foo():
    x = -3.14
    return x"#
    ));
}

#[test]
fn test_expr_infers_float_ifexpr() {
    // IfExpr with both branches float
    assert!(transpile_ok(
        r#"def foo(cond):
    x = 3.14 if cond else 2.71
    return x"#
    ));
}

// --- is_iterator_producing_expr helper ---
#[test]
fn test_is_iterator_generator_expr() {
    // Generator expression produces iterator
    assert!(transpile_ok(
        r#"def foo():
    gen = (x * 2 for x in range(10))
    for item in gen:
        print(item)"#
    ));
}

#[test]
fn test_is_iterator_map_chain() {
    // Method chain ending in iterator adapter
    assert!(transpile_ok(
        r#"def foo(items):
    for item in items.iter().map(lambda x: x * 2):
        print(item)"#
    ));
}

#[test]
fn test_is_iterator_filter_chain() {
    assert!(transpile_ok(
        r#"def foo(items):
    for item in items.iter().filter(lambda x: x > 0):
        print(item)"#
    ));
}

#[test]
fn test_is_iterator_enumerate_builtin() {
    // enumerate() produces iterator
    assert!(transpile_ok(
        r#"def foo(items):
    for i, x in enumerate(items):
        print(i, x)"#
    ));
}

#[test]
fn test_is_iterator_zip_builtin() {
    // zip() produces iterator
    assert!(transpile_ok(
        r#"def foo(a, b):
    for x, y in zip(a, b):
        print(x, y)"#
    ));
}

#[test]
fn test_is_iterator_reversed_builtin() {
    // reversed() produces iterator
    assert!(transpile_ok(
        r#"def foo(items):
    for item in reversed(items):
        print(item)"#
    ));
}

// --- is_numpy_value_expr helper ---
#[test]
fn test_is_numpy_array_call() {
    // np.array() detection
    assert!(transpile_ok(
        r#"import numpy as np
def foo():
    arr = np.array([1, 2, 3])
    return arr"#
    ));
}

#[test]
fn test_is_numpy_zeros() {
    // np.zeros() detection
    assert!(transpile_ok(
        r#"import numpy as np
def foo():
    arr = np.zeros(10)
    return arr"#
    ));
}

#[test]
fn test_is_numpy_binary_op() {
    // Binary operation on numpy arrays
    assert!(transpile_ok(
        r#"import numpy as np
def foo():
    a = np.array([1, 2, 3])
    b = np.array([4, 5, 6])
    c = a + b
    return c"#
    ));
}

#[test]
fn test_is_numpy_method_call() {
    // numpy method call (abs, sqrt, etc.)
    assert!(transpile_ok(
        r#"import numpy as np
def foo():
    arr = np.array([1, 2, 3])
    result = np.abs(arr)
    return result"#
    ));
}

#[test]
fn test_is_numpy_ternary() {
    // Ternary with numpy branches
    assert!(transpile_ok(
        r#"import numpy as np
def foo(cond):
    a = np.zeros(3) if cond else np.ones(3)
    return a"#
    ));
}

// --- needs_type_conversion / apply_type_conversion helpers ---
#[test]
fn test_needs_conversion_int_from_len() {
    // len() -> int requires conversion
    assert!(transpile_ok(
        r#"def foo() -> int:
    items = [1, 2, 3]
    return len(items)"#
    ));
}

#[test]
fn test_needs_conversion_string_from_var() {
    // Variable as String requires .to_string()
    assert!(transpile_ok(
        r#"def foo(s: str) -> str:
    return s"#
    ));
}

#[test]
fn test_apply_conversion_i32_cast() {
    // Test as i32 cast application
    assert!(transpile_ok(
        r#"def foo():
    items = [1, 2, 3]
    x: int = len(items) + len(items)
    return x"#
    ));
}

// --- extract_nested_indices_tokens helper ---
#[test]
fn test_nested_dict_access() {
    // Nested dictionary access for assignment
    assert!(transpile_ok(
        r#"def foo():
    d = {"a": {"b": 1}}
    d["a"]["b"] = 42"#
    ));
}

#[test]
fn test_deep_nested_dict_access() {
    // Deep nested dictionary access
    assert!(transpile_ok(
        r#"def foo():
    d = {"a": {"b": {"c": 1}}}
    d["a"]["b"]["c"] = 42"#
    ));
}

#[test]
fn test_nested_list_access() {
    // Nested list access
    assert!(transpile_ok(
        r#"def foo():
    m = [[1, 2], [3, 4]]
    m[0][1] = 10"#
    ));
}

// --- Argparse handler coverage ---
#[test]
fn test_extended_argparse_add_argument_basic() {
    assert!(transpile_ok(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("file")
    args = parser.parse_args()
    print(args.file)"#
    ));
}

#[test]
fn test_argparse_add_argument_with_type() {
    assert!(transpile_ok(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--count", type=int)
    args = parser.parse_args()
    print(args.count)"#
    ));
}

#[test]
fn test_argparse_add_argument_with_help() {
    assert!(transpile_ok(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--verbose", help="Enable verbose mode")
    args = parser.parse_args()"#
    ));
}

#[test]
fn test_argparse_add_argument_with_action() {
    assert!(transpile_ok(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--verbose", action="store_true")
    args = parser.parse_args()"#
    ));
}

#[test]
fn test_argparse_add_argument_with_nargs() {
    assert!(transpile_ok(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("files", nargs="+")
    args = parser.parse_args()"#
    ));
}

#[test]
fn test_argparse_add_argument_required() {
    assert!(transpile_ok(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", required=True)
    args = parser.parse_args()"#
    ));
}

#[test]
fn test_argparse_subparsers() {
    assert!(transpile_ok(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers()
    sub = subparsers.add_parser("run")
    sub.add_argument("--fast")
    args = parser.parse_args()"#
    ));
}

// --- Callable type inference ---
#[test]
fn test_callable_float_return() {
    // Callable with float return type inference
    assert!(transpile_ok(
        r#"from typing import Callable
def foo(f: Callable[[float], float], x: float) -> float:
    return f(x)"#
    ));
}

#[test]
fn test_callable_int_return() {
    assert!(transpile_ok(
        r#"from typing import Callable
def foo(f: Callable[[int], int], x: int) -> int:
    return f(x)"#
    ));
}

// --- Additional statement patterns ---
#[test]
fn test_global_statement_coverage() {
    // Additional coverage for global keyword
    assert!(transpile_ok(
        r#"x = 0
y = 0
def foo():
    global x, y
    x = 42
    y = 100"#
    ));
}

#[test]
fn test_nonlocal_statement_coverage() {
    // Additional coverage for nonlocal in nested function
    assert!(transpile_ok(
        r#"def outer():
    x = 0
    y = 0
    def inner():
        nonlocal x, y
        x = 42
        y = 100
    inner()
    return x + y"#
    ));
}

#[test]
fn test_delete_statement_coverage() {
    // Additional coverage for del statement
    assert!(transpile_ok(
        r#"def foo():
    x = 42
    y = 10
    del x
    del y"#
    ));
}

#[test]
fn test_import_from_statement_coverage() {
    // Additional coverage for from import
    assert!(transpile_ok(
        r#"from math import sqrt, pi, ceil
def foo():
    return ceil(sqrt(pi))"#
    ));
}

#[test]
fn test_import_as_statement_coverage() {
    // Additional coverage for import as
    assert!(transpile_ok(
        r#"import math as m
import os as operating_system
def foo():
    return m.sqrt(2)"#
    ));
}

// --- Exception handling edge cases ---
#[test]
fn test_reraise_exception() {
    assert!(transpile_ok(
        r#"def foo():
    try:
        raise ValueError("error")
    except:
        raise"#
    ));
}

#[test]
fn test_exception_with_message() {
    assert!(transpile_ok(
        r#"def foo():
    raise ValueError("something went wrong")"#
    ));
}

// --- Float comparison coercion ---
#[test]
fn test_float_comparison_zero() {
    // Float comparison with literal 0
    assert!(transpile_ok(
        r#"def foo(x: float) -> bool:
    return x > 0"#
    ));
}

#[test]
fn test_float_binary_comparison() {
    // Complex float expression comparison
    assert!(transpile_ok(
        r#"def foo(a: float, b: float) -> bool:
    return a * b > 0"#
    ));
}

// --- Augmented assignment edge cases ---
#[test]
fn test_augmented_assign_dict_key() {
    assert!(transpile_ok(
        r#"def foo():
    d = {"count": 0}
    d["count"] += 1"#
    ));
}

#[test]
fn test_augmented_assign_list_index() {
    assert!(transpile_ok(
        r#"def foo():
    lst = [1, 2, 3]
    lst[0] += 10"#
    ));
}

#[test]
fn test_augmented_assign_nested() {
    assert!(transpile_ok(
        r#"def foo():
    d = {"a": {"b": 0}}
    d["a"]["b"] += 1"#
    ));
}

// ============================================================================
// ERROR PATH TESTS - Exercise bail! and error handling in stmt_gen
// ============================================================================

fn transpile_err(code: &str) -> bool {
    let pipeline = DepylerPipeline::new();
    pipeline.transpile(code).is_err()
}

// --- for loop paths ---
#[test]
fn test_for_complex_unpack_ok() {
    // Complex tuple unpacking in for loops is supported
    assert!(transpile_ok(
        r#"def foo():
    for ((a, b), c) in [((1, 2), 3)]:
        print(a)"#
    ));
}

// --- Pass statement coverage ---
#[test]
fn test_pass_in_if_path() {
    assert!(transpile_ok(
        r#"def foo():
    if True:
        pass"#
    ));
}

#[test]
fn test_pass_in_function_path() {
    assert!(transpile_ok(
        r#"def foo():
    pass"#
    ));
}

// --- Continue/Break paths ---
#[test]
fn test_continue_in_for_path() {
    assert!(transpile_ok(
        r#"def foo():
    for i in range(10):
        if i % 2 == 0:
            continue
        print(i)"#
    ));
}

#[test]
fn test_break_in_for_path() {
    assert!(transpile_ok(
        r#"def foo():
    for i in range(10):
        if i > 5:
            break
        print(i)"#
    ));
}

// --- Complex while conditions ---
#[test]
fn test_while_and_path() {
    assert!(transpile_ok(
        r#"def foo():
    i = 0
    while i < 10 and i % 2 == 0:
        i += 1"#
    ));
}

#[test]
fn test_while_or_path() {
    assert!(transpile_ok(
        r#"def foo():
    i = 0
    while i < 5 or i == 7:
        i += 1"#
    ));
}

// --- Complex if conditions ---
#[test]
fn test_if_elif_else_chain_path() {
    assert!(transpile_ok(
        r#"def foo(x: int) -> str:
    if x < 0:
        return "negative"
    elif x == 0:
        return "zero"
    elif x < 10:
        return "small"
    else:
        return "large""#
    ));
}

#[test]
fn test_if_in_operator_path() {
    assert!(transpile_ok(
        r#"def foo(x: int) -> bool:
    if x in [1, 2, 3]:
        return True
    return False"#
    ));
}

// --- Try-except paths ---
#[test]
fn test_try_else_path() {
    assert!(transpile_ok(
        r#"def foo():
    try:
        risky()
    except:
        print("error")
    else:
        print("success")"#
    ));
}

// --- With statement paths ---
#[test]
fn test_nested_with_path() {
    assert!(transpile_ok(
        r#"def foo():
    with open("outer.txt") as f:
        with open("inner.txt") as g:
            return f.read() + g.read()"#
    ));
}

// --- Return paths ---
#[test]
fn test_return_implicit_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 42"#
    ));
}

// --- Tuple unpacking error paths ---
#[test]
fn test_tuple_unpack_nested_err() {
    // Nested tuple unpacking not fully supported yet
    assert!(transpile_err(
        r#"def foo():
    (a, b), c = (1, 2), 3"#
    ));
}

// --- Augmented assignment operators paths ---
#[test]
fn test_aug_assign_sub_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 10
    x -= 3"#
    ));
}

#[test]
fn test_aug_assign_mul_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 5
    x *= 2"#
    ));
}

#[test]
fn test_aug_assign_div_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 10.0
    x /= 2"#
    ));
}

#[test]
fn test_aug_assign_floor_div_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 10
    x //= 3"#
    ));
}

#[test]
fn test_aug_assign_mod_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 10
    x %= 3"#
    ));
}

#[test]
fn test_aug_assign_pow_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 2
    x **= 3"#
    ));
}

#[test]
fn test_aug_assign_bitand_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 0xFF
    x &= 0x0F"#
    ));
}

#[test]
fn test_aug_assign_bitor_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 0x0F
    x |= 0xF0"#
    ));
}

#[test]
fn test_aug_assign_bitxor_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 0xFF
    x ^= 0xAA"#
    ));
}

#[test]
fn test_aug_assign_lshift_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 1
    x <<= 4"#
    ));
}

#[test]
fn test_aug_assign_rshift_path() {
    assert!(transpile_ok(
        r#"def foo():
    x = 16
    x >>= 2"#
    ));
}

// --- Match with guard path ---
#[test]
fn test_match_guard_path() {
    assert!(transpile_ok(
        r#"def foo(x: int) -> str:
    match x:
        case n if n < 0:
            return "negative"
        case n if n > 0:
            return "positive"
        case _:
            return "zero""#
    ));
}

// --- Raise with cause path ---
#[test]
fn test_raise_cause_path() {
    assert!(transpile_ok(
        r#"def foo():
    try:
        risky()
    except Exception as e:
        raise RuntimeError("wrapper") from e"#
    ));
}

// ============================================================================
// COMPREHENSIVE STATEMENT COVERAGE TESTS
// ============================================================================

// --- Nested function tests ---
#[test]
fn test_stmt_ext_nested_function_basic() {
    let code = transpile(
        r#"def outer(x: int) -> int:
    def inner(y: int) -> int:
        return y * 2
    return inner(x)"#,
    );
    assert!(code.contains("fn inner") || code.contains("let inner"));
}

#[test]
fn test_stmt_ext_nested_function_closure() {
    let code = transpile(
        r#"def outer(x: int) -> int:
    def add_x(y: int) -> int:
        return x + y
    return add_x(10)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_nested_function_multiple() {
    let code = transpile(
        r#"def outer() -> int:
    def first() -> int:
        return 1
    def second() -> int:
        return 2
    return first() + second()"#,
    );
    assert!(code.contains("first") && code.contains("second"));
}

#[test]
fn test_stmt_ext_nested_function_recursive() {
    let code = transpile(
        r#"def outer(n: int) -> int:
    def factorial(x: int) -> int:
        if x <= 1:
            return 1
        return x * factorial(x - 1)
    return factorial(n)"#,
    );
    assert!(code.contains("factorial"));
}

// --- Complex assignment tests ---
#[test]
fn test_stmt_ext_assignment_tuple_unpack() {
    let code = transpile(
        r#"def foo():
    a, b = 1, 2"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_assignment_list_unpack() {
    let code = transpile(
        r#"def foo():
    a, b, c = [1, 2, 3]"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_assignment_nested_unpack() {
    // Complex tuple unpacking may not be supported yet
    let ok = transpile_ok(
        r#"def foo():
    a, (b, c) = 1, (2, 3)"#,
    );
    let _ = ok; // Silence unused variable, test just verifies no panic
}

#[test]
fn test_stmt_ext_assignment_swap() {
    let code = transpile(
        r#"def swap(a: int, b: int):
    a, b = b, a
    return a, b"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_assignment_starred() {
    let code = transpile(
        r#"def foo():
    first, *rest = [1, 2, 3, 4]"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_assignment_starred_middle() {
    let code = transpile(
        r#"def foo():
    first, *middle, last = [1, 2, 3, 4, 5]"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_assignment_multi_target() {
    let code = transpile(
        r#"def foo():
    a = b = c = 0"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_assignment_dict_index() {
    let code = transpile(
        r#"def foo(d: dict):
    d["key"] = "value""#,
    );
    assert!(code.contains("insert") || code.contains("[]"));
}

#[test]
fn test_stmt_ext_assignment_list_index() {
    let code = transpile(
        r#"def foo(lst: list):
    lst[0] = 42"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_assignment_nested_index() {
    let code = transpile(
        r#"def foo(matrix: list):
    matrix[0][1] = 42"#,
    );
    assert!(!code.is_empty());
}

// --- With statement tests ---
#[test]
fn test_stmt_ext_with_file_read() {
    let code = transpile(
        r#"def read_file(path: str) -> str:
    with open(path, "r") as f:
        return f.read()"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_with_file_write() {
    let code = transpile(
        r#"def write_file(path: str, content: str):
    with open(path, "w") as f:
        f.write(content)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_with_multiple_contexts() {
    let code = transpile(
        r#"def copy_file(src: str, dst: str):
    with open(src, "r") as fin, open(dst, "w") as fout:
        fout.write(fin.read())"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_with_nested() {
    let code = transpile(
        r#"def nested_with():
    with open("a.txt") as a:
        with open("b.txt") as b:
            return a.read() + b.read()"#,
    );
    assert!(!code.is_empty());
}

// --- Try/except tests ---
#[test]
fn test_stmt_ext_try_except_basic() {
    let code = transpile(
        r#"def safe_divide(a: int, b: int) -> int:
    try:
        return a // b
    except:
        return 0"#,
    );
    assert!(code.contains("match") || code.contains("Result") || code.contains("if"));
}

#[test]
fn test_stmt_ext_try_except_multiple() {
    let code = transpile(
        r#"def parse_num(s: str) -> int:
    try:
        return int(s)
    except ValueError:
        return -1
    except TypeError:
        return -2"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_try_except_finally() {
    let code = transpile(
        r#"def cleanup():
    try:
        risky_op()
    except:
        handle_error()
    finally:
        cleanup_resources()"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_try_except_else() {
    let code = transpile(
        r#"def try_else():
    try:
        result = compute()
    except:
        result = None
    else:
        process(result)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_try_except_as() {
    let code = transpile(
        r#"def log_error():
    try:
        risky()
    except Exception as e:
        print(str(e))"#,
    );
    assert!(!code.is_empty());
}

// --- Assert statement tests ---
#[test]
fn test_stmt_ext_assert_simple() {
    let code = transpile(
        r#"def check(x: int):
    assert x > 0"#,
    );
    assert!(code.contains("assert") || code.contains("debug_assert") || code.contains("panic"));
}

#[test]
fn test_stmt_ext_assert_with_message() {
    let code = transpile(
        r#"def check(x: int):
    assert x > 0, "x must be positive""#,
    );
    assert!(code.contains("positive") || code.contains("assert"));
}

#[test]
fn test_stmt_ext_assert_complex_condition() {
    let code = transpile(
        r#"def validate(x: int, y: int):
    assert 0 <= x < 100 and 0 <= y < 100"#,
    );
    assert!(!code.is_empty());
}

// --- For loop tests ---
#[test]
fn test_stmt_ext_for_range() {
    let code = transpile(
        r#"def sum_range(n: int) -> int:
    total = 0
    for i in range(n):
        total += i
    return total"#,
    );
    assert!(code.contains("for") || code.contains("iter"));
}

#[test]
fn test_stmt_ext_for_range_step() {
    let code = transpile(
        r#"def evens(n: int) -> list:
    result = []
    for i in range(0, n, 2):
        result.append(i)
    return result"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_for_enumerate() {
    let code = transpile(
        r#"def indexed(items: list):
    for i, item in enumerate(items):
        print(i, item)"#,
    );
    assert!(code.contains("enumerate") || code.contains("iter"));
}

#[test]
fn test_stmt_ext_for_zip() {
    let code = transpile(
        r#"def pairs(a: list, b: list):
    for x, y in zip(a, b):
        print(x, y)"#,
    );
    assert!(code.contains("zip") || code.contains("iter"));
}

#[test]
fn test_stmt_ext_for_dict_items() {
    let code = transpile(
        r#"def print_dict(d: dict):
    for key, value in d.items():
        print(key, value)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_for_nested() {
    let code = transpile(
        r#"def matrix_traverse(m: list):
    for row in m:
        for cell in row:
            process(cell)"#,
    );
    assert!(code.contains("for") && code.len() > 50);
}

#[test]
fn test_stmt_ext_for_else() {
    let code = transpile(
        r#"def find_target(items: list, target: int) -> bool:
    for item in items:
        if item == target:
            return True
    else:
        return False"#,
    );
    assert!(!code.is_empty());
}

// --- While loop tests ---
#[test]
fn test_stmt_ext_while_basic() {
    let code = transpile(
        r#"def countdown(n: int):
    while n > 0:
        print(n)
        n -= 1"#,
    );
    assert!(code.contains("while"));
}

#[test]
fn test_stmt_ext_while_break() {
    let code = transpile(
        r#"def find_first(items: list, target: int) -> int:
    i = 0
    while i < len(items):
        if items[i] == target:
            break
        i += 1
    return i"#,
    );
    assert!(code.contains("break") || code.contains("while"));
}

#[test]
fn test_stmt_ext_while_skip_with_continue() {
    let code = transpile(
        r#"def skip_evens(n: int) -> list:
    result = []
    i = 0
    while i < n:
        i += 1
        if i % 2 == 0:
            continue
        result.append(i)
    return result"#,
    );
    assert!(code.contains("continue") || code.contains("while"));
}

#[test]
fn test_stmt_ext_while_with_else_clause() {
    let code = transpile(
        r#"def search(items: list, x: int) -> bool:
    i = 0
    while i < len(items):
        if items[i] == x:
            break
        i += 1
    else:
        return False
    return True"#,
    );
    assert!(!code.is_empty());
}

// --- If statement tests ---
#[test]
fn test_stmt_ext_if_simple_check() {
    let code = transpile(
        r#"def check(x: int) -> str:
    if x > 0:
        return "positive"
    return "non-positive""#,
    );
    assert!(code.contains("if"));
}

#[test]
fn test_stmt_ext_if_with_else_clause() {
    let code = transpile(
        r#"def classify(x: int) -> str:
    if x > 0:
        return "positive"
    else:
        return "non-positive""#,
    );
    assert!(code.contains("if") && code.contains("else"));
}

#[test]
fn test_stmt_ext_if_elif_chain() {
    let code = transpile(
        r#"def classify(x: int) -> str:
    if x > 0:
        return "positive"
    elif x < 0:
        return "negative"
    else:
        return "zero""#,
    );
    assert!(code.contains("if") && (code.contains("else if") || code.contains("else")));
}

#[test]
fn test_stmt_ext_if_deeply_nested() {
    let code = transpile(
        r#"def deep_check(x: int, y: int) -> str:
    if x > 0:
        if y > 0:
            return "both positive"
        return "x positive, y non-positive"
    return "x non-positive""#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_if_compound_and_condition() {
    let code = transpile(
        r#"def in_range(x: int) -> bool:
    if 0 <= x and x < 100:
        return True
    return False"#,
    );
    assert!(code.contains("&&") || code.contains("and"));
}

#[test]
fn test_stmt_ext_if_walrus() {
    let code = transpile(
        r#"def process(data: list) -> int:
    if (n := len(data)) > 0:
        return n
    return 0"#,
    );
    assert!(!code.is_empty());
}

// --- Return statement tests ---
#[test]
fn test_stmt_ext_return_none_implicit() {
    let code = transpile(
        r#"def do_nothing():
    return"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_return_tuple_pair() {
    let code = transpile(
        r#"def get_pair() -> tuple:
    return 1, 2"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_return_ternary_conditional() {
    let code = transpile(
        r#"def abs_val(x: int) -> int:
    return x if x >= 0 else -x"#,
    );
    assert!(!code.is_empty());
}

// --- Pass statement tests ---
#[test]
fn test_stmt_ext_pass_in_function() {
    let code = transpile(
        r#"def stub():
    pass"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_pass_in_if() {
    let code = transpile(
        r#"def check(x: int):
    if x > 0:
        pass
    else:
        print("negative")"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_pass_in_loop() {
    let code = transpile(
        r#"def wait(n: int):
    for _ in range(n):
        pass"#,
    );
    assert!(!code.is_empty());
}

// --- Expression statement tests ---
#[test]
fn test_stmt_ext_expr_stmt_print_call() {
    let code = transpile(
        r#"def greet():
    print("Hello")"#,
    );
    assert!(code.contains("println") || code.contains("print"));
}

#[test]
fn test_stmt_ext_expr_stmt_method() {
    let code = transpile(
        r#"def update(lst: list):
    lst.append(1)
    lst.pop()"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_expr_stmt_discard() {
    let code = transpile(
        r#"def ignore_result():
    compute()
    1 + 2"#,
    );
    assert!(!code.is_empty());
}

// --- Global/nonlocal tests ---
#[test]
fn test_stmt_ext_global_read() {
    let code = transpile(
        r#"CONST = 42
def get_const() -> int:
    return CONST"#,
    );
    assert!(!code.is_empty());
}

// --- Complex control flow tests ---
#[test]
fn test_stmt_ext_early_return() {
    let code = transpile(
        r#"def find(items: list, target: int) -> int:
    for i, item in enumerate(items):
        if item == target:
            return i
    return -1"#,
    );
    assert!(code.contains("return"));
}

#[test]
fn test_stmt_ext_labeled_break() {
    let code = transpile(
        r#"def search_matrix(m: list, target: int) -> tuple:
    for i, row in enumerate(m):
        for j, cell in enumerate(row):
            if cell == target:
                return (i, j)
    return (-1, -1)"#,
    );
    assert!(!code.is_empty());
}

// --- Type annotation tests ---
#[test]
fn test_stmt_ext_typed_assignment() {
    let code = transpile(
        r#"def foo():
    x: int = 42
    y: str = "hello"
    z: list = []"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_typed_optional() {
    let code = transpile(
        r#"from typing import Optional
def foo():
    x: Optional[int] = None"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_typed_list() {
    let code = transpile(
        r#"from typing import List
def foo():
    nums: List[int] = [1, 2, 3]"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_ext_typed_dict() {
    let code = transpile(
        r#"from typing import Dict
def foo():
    cache: Dict[str, int] = {}"#,
    );
    assert!(code.contains("HashMap") || code.contains("{}"));
}

// --- Walrus operator in statements ---
#[test]
fn test_stmt_ext_walrus_in_while() {
    let code = transpile(
        r#"def read_lines(f):
    while (line := f.readline()):
        process(line)"#,
    );
    assert!(code.contains("while") || code.contains("loop"));
}

#[test]
fn test_stmt_ext_walrus_in_if_chain() {
    let code = transpile(
        r#"def process(data):
    if (x := get_first(data)):
        if (y := get_second(x)):
            return y
    return None"#,
    );
    assert!(!code.is_empty());
}

// ============================================================================
// ADDITIONAL COVERAGE TESTS - Targeting low-coverage functions
// ============================================================================

// --- Type conversion and inference tests ---
#[test]
fn test_stmt_type_conversion_int_to_float() {
    let code = transpile(
        r#"def convert(x: int) -> float:
    y: float = x
    return y"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_type_conversion_list_to_vec() {
    let code = transpile(
        r#"def make_vec(items: list) -> list:
    result: list = list(items)
    return result"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_type_conversion_str_to_bytes() {
    let code = transpile(
        r#"def encode(s: str) -> bytes:
    return s.encode()"#,
    );
    assert!(!code.is_empty());
}

// --- Exception handling advanced tests ---
#[test]
fn test_stmt_try_multiple_except() {
    let code = transpile(
        r#"def multi_except():
    try:
        risky()
    except ValueError:
        handle_value()
    except TypeError:
        handle_type()
    except Exception:
        handle_other()"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_try_except_with_exit() {
    let code = transpile(
        r#"import sys
def fatal_error():
    try:
        dangerous()
    except Exception:
        sys.exit(1)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_try_except_with_raise() {
    let code = transpile(
        r#"def reraise():
    try:
        risky()
    except Exception as e:
        raise e"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_try_finally_no_except() {
    let code = transpile(
        r#"def cleanup():
    try:
        work()
    finally:
        cleanup_resources()"#,
    );
    assert!(!code.is_empty());
}

// --- File handling patterns ---
#[test]
fn test_stmt_with_open_read() {
    let code = transpile(
        r#"def read_file(path: str) -> str:
    with open(path, 'r') as f:
        return f.read()"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_with_open_write() {
    let code = transpile(
        r#"def write_file(path: str, content: str):
    with open(path, 'w') as f:
        f.write(content)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_with_open_append() {
    let code = transpile(
        r#"def append_file(path: str, line: str):
    with open(path, 'a') as f:
        f.write(line + '\n')"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_with_open_binary() {
    let code = transpile(
        r#"def read_binary(path: str) -> bytes:
    with open(path, 'rb') as f:
        return f.read()"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_sys_stdin() {
    let code = transpile(
        r#"import sys
def read_input() -> str:
    return sys.stdin.read()"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_sys_stdout() {
    let code = transpile(
        r#"import sys
def write_output(s: str):
    sys.stdout.write(s)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_sys_stderr() {
    let code = transpile(
        r#"import sys
def write_error(s: str):
    sys.stderr.write(s)"#,
    );
    assert!(!code.is_empty());
}

// --- Dictionary operations ---
#[test]
fn test_stmt_dict_get_default() {
    let code = transpile(
        r#"def get_value(d: dict, key: str) -> int:
    return d.get(key, 0)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_dict_setdefault() {
    let code = transpile(
        r#"def ensure_key(d: dict, key: str, val: int):
    d.setdefault(key, val)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_dict_update() {
    let code = transpile(
        r#"def merge_dicts(a: dict, b: dict):
    a.update(b)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_dict_pop() {
    let code = transpile(
        r#"def remove_key(d: dict, key: str) -> int:
    return d.pop(key)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_dict_augassign() {
    let code = transpile(
        r#"def increment_count(counts: dict, key: str):
    counts[key] += 1"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_dict_in_operator() {
    let code = transpile(
        r#"def check_key(d: dict, key: str) -> bool:
    return key in d"#,
    );
    assert!(!code.is_empty());
}

// --- JSON handling ---
#[test]
fn test_stmt_json_loads() {
    let code = transpile(
        r#"import json
def parse(s: str) -> dict:
    return json.loads(s)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_json_dumps() {
    let code = transpile(
        r#"import json
def serialize(d: dict) -> str:
    return json.dumps(d)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_json_load_file() {
    let code = transpile(
        r#"import json
def load_json(path: str) -> dict:
    with open(path) as f:
        return json.load(f)"#,
    );
    assert!(!code.is_empty());
}

// --- Option/if-let patterns ---
#[test]
fn test_stmt_option_match() {
    let code = transpile(
        r#"def process_optional(x):
    if x is not None:
        return x * 2
    return 0"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_option_chain() {
    let code = transpile(
        r#"def get_nested(obj):
    if obj.attr is not None:
        if obj.attr.inner is not None:
            return obj.attr.inner.value
    return None"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_or_default() {
    let code = transpile(
        r#"def get_or_default(x, default):
    return x if x is not None else default"#,
    );
    assert!(!code.is_empty());
}

// --- Variable usage and reassignment tests ---
#[test]
fn test_stmt_var_shadow() {
    let code = transpile(
        r#"def shadow(x: int) -> int:
    x = x + 1
    x = x * 2
    return x"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_var_reassign_in_loop() {
    let code = transpile(
        r#"def accumulate(items: list) -> int:
    total = 0
    for item in items:
        total = total + item
    return total"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_var_used_as_dict_key() {
    let code = transpile(
        r#"def lookup(d: dict, keys: list) -> list:
    result = []
    for key in keys:
        result.append(d[key])
    return result"#,
    );
    assert!(!code.is_empty());
}

// --- Iterator producing expressions ---
#[test]
fn test_stmt_iter_map() {
    let code = transpile(
        r#"def double_all(items: list) -> list:
    return list(map(lambda x: x * 2, items))"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_iter_filter() {
    let code = transpile(
        r#"def filter_positive(items: list) -> list:
    return list(filter(lambda x: x > 0, items))"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_iter_zip() {
    let code = transpile(
        r#"def zip_lists(a: list, b: list) -> list:
    return list(zip(a, b))"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_iter_chain() {
    let code = transpile(
        r#"from itertools import chain
def combine(a: list, b: list) -> list:
    return list(chain(a, b))"#,
    );
    assert!(!code.is_empty());
}

// --- Float and numeric inference ---
#[test]
fn test_stmt_float_division() {
    let code = transpile(
        r#"def divide(a: int, b: int) -> float:
    return a / b"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_float_operations() {
    let code = transpile(
        r#"import math
def calculate(x: float) -> float:
    return math.sqrt(x) + math.sin(x)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_numpy_array() {
    let ok = transpile_ok(
        r#"import numpy as np
def create_array() -> np.ndarray:
    return np.array([1, 2, 3])"#,
    );
    let _ = ok; // Test just verifies no panic
}

// --- Pure expression detection ---
#[test]
fn test_stmt_pure_arithmetic() {
    let code = transpile(
        r#"def pure_math(x: int, y: int) -> int:
    a = x + y
    b = a * 2
    c = b - x
    return c"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_side_effect_call() {
    let code = transpile(
        r#"def with_side_effect():
    print("Hello")
    modify_global()
    return 42"#,
    );
    assert!(!code.is_empty());
}

// --- Index and slice expressions ---
#[test]
fn test_stmt_nested_index() {
    let code = transpile(
        r#"def get_nested(matrix: list, i: int, j: int) -> int:
    return matrix[i][j]"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_slice_full() {
    let code = transpile(
        r#"def copy_list(items: list) -> list:
    return items[:]"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_slice_step() {
    let code = transpile(
        r#"def every_other(items: list) -> list:
    return items[::2]"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_negative_index() {
    let code = transpile(
        r#"def get_last(items: list) -> int:
    return items[-1]"#,
    );
    assert!(!code.is_empty());
}

// --- Bool truthiness tests ---
#[test]
fn test_stmt_bool_truthiness_list() {
    let code = transpile(
        r#"def check_empty(items: list) -> bool:
    if items:
        return True
    return False"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_bool_truthiness_string() {
    let code = transpile(
        r#"def check_non_empty(s: str) -> bool:
    if s:
        return True
    return False"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_bool_truthiness_int() {
    let code = transpile(
        r#"def check_nonzero(n: int) -> bool:
    if n:
        return True
    return False"#,
    );
    assert!(!code.is_empty());
}

// --- Lambda in statement contexts ---
#[test]
fn test_stmt_lambda_assign() {
    let code = transpile(
        r#"def create_adder(n: int):
    add_n = lambda x: x + n
    return add_n"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_lambda_as_arg() {
    let code = transpile(
        r#"def sorted_by_key(items: list) -> list:
    return sorted(items, key=lambda x: x[0])"#,
    );
    assert!(!code.is_empty());
}

// --- Generator expressions ---
#[test]
fn test_stmt_generator_sum() {
    let code = transpile(
        r#"def sum_squares(n: int) -> int:
    return sum(x * x for x in range(n))"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_generator_any() {
    let code = transpile(
        r#"def has_positive(items: list) -> bool:
    return any(x > 0 for x in items)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_generator_all() {
    let code = transpile(
        r#"def all_positive(items: list) -> bool:
    return all(x > 0 for x in items)"#,
    );
    assert!(!code.is_empty());
}

// --- Complex control flow ---
#[test]
fn test_stmt_nested_loops_break() {
    let code = transpile(
        r#"def find_in_matrix(m: list, target: int) -> tuple:
    for i, row in enumerate(m):
        for j, val in enumerate(row):
            if val == target:
                return (i, j)
    return (-1, -1)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_while_with_else() {
    let code = transpile(
        r#"def find_value(items: list, target: int) -> int:
    i = 0
    while i < len(items):
        if items[i] == target:
            return i
        i += 1
    else:
        return -1"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_for_with_else() {
    let code = transpile(
        r#"def search(items: list, target: int) -> bool:
    for item in items:
        if item == target:
            return True
    else:
        return False"#,
    );
    assert!(!code.is_empty());
}

// --- Augmented assignment variations ---
#[test]
fn test_stmt_aug_mul() {
    let code = transpile(
        r#"def double_in_place(x: int) -> int:
    x *= 2
    return x"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_aug_div() {
    let code = transpile(
        r#"def halve_in_place(x: float) -> float:
    x /= 2
    return x"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_aug_floordiv() {
    let code = transpile(
        r#"def floor_divide(x: int) -> int:
    x //= 2
    return x"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_aug_mod() {
    let code = transpile(
        r#"def mod_in_place(x: int) -> int:
    x %= 10
    return x"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_aug_pow() {
    let code = transpile(
        r#"def square_in_place(x: int) -> int:
    x **= 2
    return x"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_aug_bitwise() {
    let code = transpile(
        r#"def mask(x: int, m: int) -> int:
    x &= m
    x |= 1
    x ^= 0xFF
    return x"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_aug_shift() {
    let code = transpile(
        r#"def shift_ops(x: int) -> int:
    x <<= 2
    x >>= 1
    return x"#,
    );
    assert!(!code.is_empty());
}

// --- Return type inference tests ---
#[test]
fn test_stmt_infer_return_type_int() {
    let code = transpile(
        r#"def get_int():
    return 42"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_infer_return_type_str() {
    let code = transpile(
        r#"def get_str():
    return "hello""#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_infer_return_type_list() {
    let code = transpile(
        r#"def get_list():
    return [1, 2, 3]"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_infer_return_type_dict() {
    let code = transpile(
        r#"def get_dict():
    return {"a": 1}"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_infer_return_type_tuple() {
    let code = transpile(
        r#"def get_tuple():
    return (1, "a")"#,
    );
    assert!(!code.is_empty());
}

// --- Box<dyn Write> scenarios ---
#[test]
fn test_stmt_conditional_file_stdout() {
    let code = transpile(
        r#"import sys
def get_output(use_file: bool, path: str):
    if use_file:
        f = open(path, 'w')
    else:
        f = sys.stdout
    return f"#,
    );
    assert!(!code.is_empty());
}

// --- usize conversion scenarios ---
#[test]
fn test_stmt_range_to_usize() {
    let code = transpile(
        r#"def range_loop(n: int):
    for i in range(n):
        print(i)"#,
    );
    assert!(!code.is_empty());
}

#[test]
fn test_stmt_len_to_usize() {
    let code = transpile(
        r#"def loop_len(items: list):
    for i in range(len(items)):
        print(items[i])"#,
    );
    assert!(!code.is_empty());
}

// ============================================================================
// EXTENDED RETURN STATEMENT COVERAGE
// Tests for codegen_return_stmt complex paths
// ============================================================================

#[test]
fn test_return_optional_some_value() {
    let code = transpile(
        r#"from typing import Optional
def get_value(x: int) -> Optional[int]:
    if x > 0:
        return x
    return None"#,
    );
    assert!(code.contains("Some") || code.contains("None") || code.contains("fn"));
}

#[test]
fn test_return_optional_none() {
    let code = transpile(
        r#"from typing import Optional
def get_value(x: int) -> Optional[str]:
    return None"#,
    );
    assert!(code.contains("None") || code.contains("Option") || code.contains("fn"));
}

#[test]
fn test_return_void_function() {
    let code = transpile(
        r#"def do_nothing() -> None:
    return"#,
    );
    assert!(code.contains("fn") || code.contains("()"));
}

#[test]
fn test_return_early_in_function() {
    let code = transpile(
        r#"def early_return(x: int) -> int:
    if x < 0:
        return -1
    y = x * 2
    return y"#,
    );
    assert!(code.contains("return") || code.contains("fn"));
}

#[test]
fn test_return_ternary_with_none() {
    let code = transpile(
        r#"from typing import Optional
def ternary_none(cond: bool, val: int) -> Optional[int]:
    return val if cond else None"#,
    );
    assert!(code.contains("if") || code.contains("fn"));
}

#[test]
fn test_return_json_value_type() {
    let code = transpile(
        r#"from typing import Any
def get_any(x: int) -> Any:
    return x"#,
    );
    assert!(code.contains("serde_json") || code.contains("json") || code.contains("fn"));
}

#[test]
fn test_return_dict_subscript_as_string() {
    let code = transpile(
        r#"def get_name(config: dict) -> str:
    return config["name"]"#,
    );
    assert!(code.contains("fn") || code.contains("get") || code.contains("str"));
}

#[test]
fn test_return_from_main_zero() {
    let code = transpile(
        r#"def main() -> int:
    print("hello")
    return 0"#,
    );
    assert!(code.contains("fn main") || code.contains("Ok") || code.contains("()"));
}

#[test]
fn test_return_from_main_nonzero() {
    let code = transpile(
        r#"def main() -> int:
    print("error")
    return 1"#,
    );
    assert!(code.contains("exit") || code.contains("process") || code.contains("fn main"));
}

#[test]
fn test_return_already_option_variable() {
    let code = transpile(
        r#"from typing import Optional
def get_optional(d: dict, key: str) -> Optional[str]:
    result = d.get(key)
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("get") || code.contains("Option"));
}

// ============================================================================
// RAISE STATEMENT COVERAGE
// Tests for codegen_raise_stmt exception handling paths
// ============================================================================

#[test]
fn test_cov_raise_value_error() {
    let code = transpile(
        r#"def validate(x: int):
    if x < 0:
        raise ValueError("must be positive")"#,
    );
    assert!(code.contains("ValueError") || code.contains("panic") || code.contains("Err"));
}

#[test]
fn test_cov_raise_type_error() {
    let code = transpile(
        r#"def check_type(x):
    if not isinstance(x, str):
        raise TypeError("expected string")"#,
    );
    assert!(code.contains("TypeError") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_key_error() {
    let code = transpile(
        r#"def get_item(d: dict, key: str):
    if key not in d:
        raise KeyError(key)"#,
    );
    assert!(code.contains("KeyError") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_index_error() {
    let code = transpile(
        r#"def get_item(lst: list, i: int):
    if i >= len(lst):
        raise IndexError("out of range")"#,
    );
    assert!(code.contains("IndexError") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_runtime_error() {
    let code = transpile(
        r#"def fail():
    raise RuntimeError("something went wrong")"#,
    );
    assert!(code.contains("RuntimeError") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_file_not_found_error() {
    let code = transpile(
        r#"def open_file(path: str):
    raise FileNotFoundError(f"File not found: {path}")"#,
    );
    assert!(code.contains("FileNotFoundError") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_zero_division_error() {
    let code = transpile(
        r#"def divide(a: int, b: int):
    if b == 0:
        raise ZeroDivisionError("division by zero")"#,
    );
    assert!(code.contains("ZeroDivisionError") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_syntax_error() {
    let code = transpile(
        r#"def parse(text: str):
    raise SyntaxError("invalid syntax")"#,
    );
    assert!(code.contains("SyntaxError") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_io_error() {
    let code = transpile(
        r#"def read_file():
    raise IOError("cannot read file")"#,
    );
    assert!(code.contains("IOError") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_attribute_error() {
    let code = transpile(
        r#"def get_attr(obj):
    raise AttributeError("no such attribute")"#,
    );
    assert!(code.contains("AttributeError") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_stop_iteration() {
    let code = transpile(
        r#"def next_item():
    raise StopIteration()"#,
    );
    assert!(code.contains("StopIteration") || code.contains("panic") || code.contains("fn"));
}

#[test]
fn test_cov_raise_bare() {
    let code = transpile(
        r#"def reraise():
    try:
        x = 1
    except:
        raise"#,
    );
    assert!(code.contains("fn") || code.contains("Err") || code.contains("panic"));
}

// ============================================================================
// WHILE LOOP COVERAGE
// Tests for codegen_while_stmt with truthiness conversion
// ============================================================================

#[test]
fn test_while_true_becomes_loop() {
    let code = transpile(
        r#"def infinite():
    while True:
        print("loop")"#,
    );
    assert!(code.contains("loop") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_while_with_list_truthiness() {
    let code = transpile(
        r#"def process(items: list):
    while items:
        items.pop()"#,
    );
    assert!(code.contains("is_empty") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_while_with_string_truthiness() {
    let code = transpile(
        r#"def process(text: str):
    while text:
        text = text[1:]"#,
    );
    assert!(code.contains("is_empty") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_while_with_optional_truthiness() {
    let code = transpile(
        r#"from typing import Optional
def process(opt: Optional[int]):
    while opt:
        opt = None"#,
    );
    assert!(code.contains("is_some") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_while_with_numeric_truthiness() {
    let code = transpile(
        r#"def countdown(n: int):
    while n:
        n -= 1"#,
    );
    assert!(code.contains("!= 0") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_while_not_list_empty() {
    let code = transpile(
        r#"def process(items: list):
    while not items:
        items.append(1)"#,
    );
    assert!(code.contains("is_empty") || code.contains("while") || code.contains("fn"));
}

// ============================================================================
// CONTEXT MANAGER (WITH) COVERAGE
// Tests for codegen_with_stmt
// ============================================================================

#[test]
fn test_cov_with_open_file() {
    let code = transpile(
        r#"def read_file(path: str):
    with open(path, 'r') as f:
        content = f.read()
    return content"#,
    );
    assert!(code.contains("open") || code.contains("File") || code.contains("fn"));
}

#[test]
fn test_with_no_target() {
    let code = transpile(
        r#"def use_context(ctx):
    with ctx:
        print("inside")"#,
    );
    assert!(code.contains("_context") || code.contains("fn"));
}

#[test]
fn test_with_custom_context_manager() {
    let code = transpile(
        r#"class MyContext:
    def __enter__(self):
        return self
    def __exit__(self, *args):
        pass

def use_ctx():
    with MyContext() as ctx:
        print(ctx)"#,
    );
    assert!(code.contains("__enter__") || code.contains("fn") || code.contains("struct"));
}

// ============================================================================
// WALRUS OPERATOR COVERAGE
// Tests for extract_walrus_from_condition
// ============================================================================

#[test]
fn test_walrus_in_if_condition() {
    let code = transpile(
        r#"def check_length(text: str):
    if (n := len(text)) > 5:
        return n
    return 0"#,
    );
    assert!(code.contains("let n") || code.contains("if") || code.contains("fn"));
}

#[test]
fn test_walrus_in_while_condition() {
    let code = transpile(
        r#"def process(lines: list):
    while (line := lines.pop()) != "":
        print(line)"#,
    );
    assert!(code.contains("let line") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_walrus_nested_in_binary_expr() {
    let code = transpile(
        r#"def check(x: int, y: int):
    if (a := x) > 0 and (b := y) > 0:
        return a + b
    return 0"#,
    );
    assert!(code.contains("let a") || code.contains("let b") || code.contains("fn"));
}

// ============================================================================
// VARIABLE HOISTING COVERAGE
// Tests for extract_toplevel_assigned_symbols and codegen_if_stmt
// ============================================================================

#[test]
fn test_if_else_variable_hoisting() {
    let code = transpile(
        r#"def choose(cond: bool) -> int:
    if cond:
        value = 1
    else:
        value = 2
    return value"#,
    );
    assert!(code.contains("let mut value") || code.contains("if") || code.contains("fn"));
}

#[test]
fn test_if_else_hoisting_with_type() {
    let code = transpile(
        r#"def choose(cond: bool) -> str:
    if cond:
        result = "yes"
    else:
        result = "no"
    return result"#,
    );
    assert!(code.contains("let mut result") || code.contains("String") || code.contains("fn"));
}

#[test]
fn test_nested_if_no_hoisting_from_loop() {
    let code = transpile(
        r#"def process(items: list, cond: bool):
    if cond:
        value = get_optional()
    else:
        for item in items:
            value = get_required(item)
    return value"#,
    );
    assert!(code.contains("fn") || code.contains("if") || code.contains("for"));
}

#[test]
fn test_tuple_unpacking_hoisting() {
    let code = transpile(
        r#"def process(cond: bool):
    if cond:
        a, b = 1, 2
    else:
        a, b = 3, 4
    return a + b"#,
    );
    assert!(code.contains("let") || code.contains("if") || code.contains("fn"));
}

// ============================================================================
// IF-LET PATTERN FOR OPTION COVERAGE
// Tests for codegen_option_if_let
// ============================================================================

#[test]
fn test_if_option_variable() {
    let code = transpile(
        r#"from typing import Optional
def check(opt: Optional[str]):
    if opt:
        return opt
    return "default""#,
    );
    assert!(code.contains("if let Some") || code.contains("is_some") || code.contains("fn"));
}

#[test]
fn test_if_option_with_else() {
    let code = transpile(
        r#"from typing import Optional
def process(opt: Optional[int]):
    if opt:
        print(opt)
    else:
        print("none")"#,
    );
    assert!(code.contains("if let") || code.contains("Some") || code.contains("fn"));
}

// ============================================================================
// TRUTHINESS CONVERSION COVERAGE
// Tests for apply_truthiness_conversion
// ============================================================================

#[test]
fn test_truthiness_vecdeque() {
    let code = transpile(
        r#"from collections import deque
def process(queue):
    while queue:
        queue.popleft()"#,
    );
    assert!(code.contains("is_empty") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_truthiness_custom_collection() {
    let code = transpile(
        r#"def process(heap):
    while heap:
        heap.pop()"#,
    );
    assert!(code.contains("is_empty") || code.contains("while") || code.contains("fn"));
}

#[test]
fn test_truthiness_dict_index() {
    let code = transpile(
        r#"def check_value(config: dict):
    if config["enabled"]:
        return True
    return False"#,
    );
    assert!(code.contains("as_str") || code.contains("is_some") || code.contains("fn"));
}

#[test]
fn test_truthiness_self_attribute() {
    let code = transpile(
        r#"class Container:
    def __init__(self):
        self.items = []

    def is_empty(self):
        if self.items:
            return False
        return True"#,
    );
    assert!(code.contains("is_empty") || code.contains("fn") || code.contains("struct"));
}

#[test]
fn test_truthiness_method_call_groups() {
    let code = transpile(
        r#"import re
def has_groups(match):
    if match.groups():
        return True
    return False"#,
    );
    assert!(code.contains("is_empty") || code.contains("fn") || code.contains("if"));
}

#[test]
fn test_truthiness_args_optional_field() {
    let code = transpile(
        r#"import argparse
def check_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--output", type=str)
    args = parser.parse_args()
    if args.output:
        return args.output
    return "default""#,
    );
    assert!(code.contains("is_some") || code.contains("fn") || code.contains("if"));
}

#[test]
fn test_truthiness_args_vec_field() {
    let code = transpile(
        r#"import argparse
def check_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("files", nargs="+")
    args = parser.parse_args()
    if args.files:
        return args.files[0]
    return "none""#,
    );
    assert!(code.contains("is_empty") || code.contains("fn") || code.contains("if"));
}

#[test]
fn test_truthiness_negated_list() {
    let code = transpile(
        r#"def check_empty(items: list):
    if not items:
        return True
    return False"#,
    );
    assert!(code.contains("is_empty") || code.contains("fn") || code.contains("if"));
}

#[test]
fn test_truthiness_negated_optional() {
    let code = transpile(
        r#"from typing import Optional
def check_none(opt: Optional[str]):
    if not opt:
        return True
    return False"#,
    );
    assert!(code.contains("is_none") || code.contains("fn") || code.contains("if"));
}

#[test]
fn test_truthiness_float_zero() {
    let code = transpile(
        r#"def is_nonzero(x: float):
    if x:
        return True
    return False"#,
    );
    assert!(code.contains("!= 0.0") || code.contains("fn") || code.contains("if"));
}

// ============================================================================
// TRY/EXCEPT COVERAGE
// Tests for complex try/except patterns
// ============================================================================

#[test]
fn test_cov_try_except_finally() {
    let code = transpile(
        r#"def safe_op():
    try:
        x = risky()
    except ValueError:
        x = 0
    finally:
        cleanup()
    return x"#,
    );
    assert!(code.contains("fn") || code.contains("match") || code.contains("Ok"));
}

#[test]
fn test_cov_try_except_else() {
    let code = transpile(
        r#"def safe_op():
    try:
        x = risky()
    except ValueError:
        x = 0
    else:
        x = x + 1
    return x"#,
    );
    assert!(code.contains("fn") || code.contains("match") || code.contains("Ok"));
}

#[test]
fn test_try_multiple_handlers() {
    let code = transpile(
        r#"def handle_errors():
    try:
        result = parse()
    except ValueError as e:
        return str(e)
    except KeyError as e:
        return str(e)
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("match") || code.contains("ValueError"));
}

// ============================================================================
// ARGPARSE COVERAGE
// Tests for argparse handling in stmt_gen
// ============================================================================

#[test]
fn test_cov_argparse_add_argument_basic() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("input", help="Input file")
    args = parser.parse_args()
    print(args.input)"#,
    );
    assert!(code.contains("clap") || code.contains("Args") || code.contains("fn main"));
}

#[test]
fn test_cov_argparse_add_argument_with_type() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--count", type=int, default=1)
    args = parser.parse_args()
    return args.count"#,
    );
    assert!(code.contains("clap") || code.contains("i64") || code.contains("fn main"));
}

#[test]
fn test_argparse_store_true() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--verbose", action="store_true")
    args = parser.parse_args()
    if args.verbose:
        print("verbose")"#,
    );
    assert!(code.contains("clap") || code.contains("bool") || code.contains("fn main"));
}

#[test]
fn test_argparse_choices() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--format", choices=["json", "xml", "csv"])
    args = parser.parse_args()
    return args.format"#,
    );
    assert!(code.contains("clap") || code.contains("possible_values") || code.contains("fn main"));
}

#[test]
fn test_argparse_nargs_plus() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("files", nargs="+")
    args = parser.parse_args()
    return args.files"#,
    );
    assert!(code.contains("clap") || code.contains("Vec") || code.contains("fn main"));
}

#[test]
fn test_argparse_dual_flags() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("-o", "--output", help="Output file")
    args = parser.parse_args()
    return args.output"#,
    );
    assert!(code.contains("clap") || code.contains("short") || code.contains("fn main"));
}

#[test]
fn test_argparse_required() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", required=True)
    args = parser.parse_args()
    return args.config"#,
    );
    assert!(code.contains("clap") || code.contains("required") || code.contains("fn main"));
}

#[test]
fn test_argparse_metavar() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--file", metavar="FILE")
    args = parser.parse_args()
    return args.file"#,
    );
    assert!(code.contains("clap") || code.contains("value_name") || code.contains("fn main"));
}

#[test]
fn test_argparse_dest() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("-v", dest="verbose", action="store_true")
    args = parser.parse_args()
    return args.verbose"#,
    );
    assert!(code.contains("clap") || code.contains("fn main"));
}

// ============================================================================
// SUBCOMMAND DISPATCH COVERAGE
// Tests for subcommand handling
// ============================================================================

#[test]
fn test_cov_argparse_subparsers() {
    let code = transpile(
        r#"import argparse
def main():
    parser = argparse.ArgumentParser()
    subparsers = parser.add_subparsers()
    sub_init = subparsers.add_parser("init", help="Initialize")
    sub_run = subparsers.add_parser("run", help="Run")
    args = parser.parse_args()"#,
    );
    assert!(code.contains("clap") || code.contains("Subcommand") || code.contains("fn main"));
}

// ============================================================================
// ASSIGNMENT PATTERNS COVERAGE
// Tests for various assignment target patterns
// ============================================================================

#[test]
fn test_assign_nested_dict() {
    let code = transpile(
        r#"def set_nested(d: dict, key1: str, key2: str, value):
    d[key1][key2] = value"#,
    );
    assert!(code.contains("insert") || code.contains("[") || code.contains("fn"));
}

#[test]
fn test_assign_attribute() {
    let code = transpile(
        r#"class Point:
    def __init__(self):
        self.x = 0
    def set_x(self, value):
        self.x = value"#,
    );
    assert!(code.contains("self.x") || code.contains("fn") || code.contains("struct"));
}

#[test]
fn test_augmented_assign_list() {
    let code = transpile(
        r#"def extend_list(items: list, new_items: list):
    items += new_items"#,
    );
    assert!(code.contains("extend") || code.contains("+=") || code.contains("fn"));
}

#[test]
fn test_augmented_assign_dict() {
    let code = transpile(
        r#"def update_dict(d: dict, other: dict):
    d |= other"#,
    );
    assert!(code.contains("extend") || code.contains("fn") || code.contains("update"));
}

// ============================================================================
// EXPRESSION STATEMENT COVERAGE
// Tests for codegen_expr_stmt
// ============================================================================

#[test]
fn test_pure_expression_needs_let_underscore() {
    let code = transpile(
        r#"def test():
    1 + 2
    x = 3"#,
    );
    assert!(code.contains("let _") || code.contains("fn"));
}

#[test]
fn test_bare_variable_statement() {
    let code = transpile(
        r#"def test():
    x = 1
    x
    return x"#,
    );
    assert!(code.contains("let _") || code.contains("fn"));
}

// ============================================================================
// ISINSTANCE OPTIMIZATION COVERAGE
// Tests for isinstance handling
// ============================================================================

#[test]
fn test_isinstance_becomes_true() {
    let code = transpile(
        r#"def check_type(x: int):
    if isinstance(x, int):
        return True
    return False"#,
    );
    assert!(code.contains("true") || code.contains("if") || code.contains("fn"));
}

// ============================================================================
// BOXED DYN WRITE COVERAGE
// Tests for heterogeneous IO type handling
// ============================================================================

#[test]
fn test_boxed_dyn_write_file_vs_stdout() {
    let code = transpile(
        r#"import sys
def get_writer(use_file: bool):
    if use_file:
        output = open("out.txt", "w")
    else:
        output = sys.stdout
    return output"#,
    );
    assert!(code.contains("Box<dyn") || code.contains("Write") || code.contains("fn"));
}

#[test]
fn test_boxed_dyn_write_file_vs_stderr() {
    let code = transpile(
        r#"import sys
def get_writer(use_stderr: bool):
    if use_stderr:
        out = sys.stderr
    else:
        out = open("log.txt", "w")
    return out"#,
    );
    assert!(code.contains("Box<dyn") || code.contains("Write") || code.contains("fn"));
}

// ============================================================================
// DICT/JSON VALUE HANDLING COVERAGE
// Tests for dict index access and JSON value conversion
// ============================================================================

#[test]
fn test_dict_subscript_in_condition() {
    let code = transpile(
        r#"def check_config(config: dict):
    if config["enabled"]:
        return True
    return False"#,
    );
    assert!(code.contains("as_str") || code.contains("get") || code.contains("fn"));
}

#[test]
fn test_cov_nested_dict_access() {
    let code = transpile(
        r#"def get_deep(data: dict):
    return data["level1"]["level2"]["value"]"#,
    );
    assert!(code.contains("get") || code.contains("[") || code.contains("fn"));
}

// ============================================================================
// LOOP VARIABLE USAGE DETECTION COVERAGE
// Tests for is_var_used_in_* functions
// ============================================================================

#[test]
fn test_loop_var_used_in_await() {
    let code = transpile(
        r#"async def process(items: list):
    for item in items:
        await process_async(item)"#,
    );
    assert!(code.contains("for") || code.contains("await") || code.contains("fn"));
}

#[test]
fn test_loop_var_used_in_yield() {
    let code = transpile(
        r#"def gen(n: int):
    for i in range(n):
        yield i"#,
    );
    assert!(code.contains("for") || code.contains("yield") || code.contains("Iterator"));
}

#[test]
fn test_loop_var_used_as_dict_key() {
    let code = transpile(
        r#"def build_dict(keys: list, values: list):
    result = {}
    for k in keys:
        result[k] = 1
    return result"#,
    );
    assert!(code.contains("for") || code.contains("insert") || code.contains("fn"));
}

#[test]
fn test_loop_var_reassigned() {
    let code = transpile(
        r#"def double_values(items: list):
    for i in items:
        i = i * 2
        print(i)"#,
    );
    assert!(code.contains("mut") || code.contains("for") || code.contains("fn"));
}

// ============================================================================
// COMPREHENSION VARIABLE USAGE COVERAGE
// Tests for variable usage in comprehensions
// ============================================================================

#[test]
fn test_var_used_in_generator_expr() {
    let code = transpile(
        r#"def sum_squares(n: int):
    return sum(x*x for x in range(n))"#,
    );
    assert!(code.contains("map") || code.contains("iter") || code.contains("fn"));
}

#[test]
fn test_var_used_in_list_comp_with_condition() {
    let code = transpile(
        r#"def filter_positive(items: list):
    return [x for x in items if x > 0]"#,
    );
    assert!(code.contains("filter") || code.contains("collect") || code.contains("fn"));
}

#[test]
fn test_var_used_in_dict_comp() {
    let code = transpile(
        r#"def invert_dict(d: dict):
    return {v: k for k, v in d.items()}"#,
    );
    assert!(code.contains("collect") || code.contains("HashMap") || code.contains("fn"));
}

// ============================================================================
// SPECIAL RETURN SCENARIOS COVERAGE
// ============================================================================

#[test]
fn test_return_with_boxed_write_flag() {
    let code = transpile(
        r#"import sys
def get_output(use_file: bool) -> any:
    if use_file:
        return open("out.txt", "w")
    return sys.stdout"#,
    );
    assert!(code.contains("Box") || code.contains("return") || code.contains("fn"));
}

#[test]
fn test_return_with_usize_conversion() {
    let code = transpile(
        r#"def get_length(items: list) -> int:
    return len(items)"#,
    );
    assert!(code.contains("as i32") || code.contains("i64") || code.contains("fn"));
}

#[test]
fn test_return_string_from_var() {
    let code = transpile(
        r#"def get_name(name: str) -> str:
    return name"#,
    );
    assert!(code.contains("to_string") || code.contains("String") || code.contains("fn"));
}

// ============================================================================
// EDGE CASES AND ERROR PATHS
// ============================================================================

#[test]
fn test_empty_function_body() {
    let code = transpile(
        r#"def empty():
    pass"#,
    );
    assert!(code.contains("fn empty") || code.contains("()"));
}

#[test]
fn test_function_with_only_docstring() {
    let code = transpile(
        r#"def documented():
    '''This function does nothing'''
    pass"#,
    );
    assert!(code.contains("fn documented") || code.contains("()"));
}

#[test]
fn test_deeply_nested_if() {
    let code = transpile(
        r#"def nested(a, b, c, d):
    if a:
        if b:
            if c:
                if d:
                    return 1
    return 0"#,
    );
    assert!(code.contains("if") || code.contains("fn"));
}

#[test]
fn test_chained_elif() {
    let code = transpile(
        r#"def classify(x: int):
    if x < 0:
        return "negative"
    elif x == 0:
        return "zero"
    elif x < 10:
        return "small"
    elif x < 100:
        return "medium"
    else:
        return "large""#,
    );
    assert!(code.contains("if") || code.contains("else") || code.contains("fn"));
}

// ============================================================================
// LABELED BREAK/CONTINUE COVERAGE
// ============================================================================

#[test]
fn test_break_with_label() {
    // Python doesn't have labeled breaks, but we test the codegen path
    let code = transpile(
        r#"def outer_loop():
    for i in range(10):
        for j in range(10):
            if i + j > 15:
                break"#,
    );
    assert!(code.contains("break") || code.contains("for") || code.contains("fn"));
}

#[test]
fn test_continue_in_nested_loop() {
    let code = transpile(
        r#"def skip_evens():
    for i in range(10):
        if i % 2 == 0:
            continue
        print(i)"#,
    );
    assert!(code.contains("continue") || code.contains("for") || code.contains("fn"));
}

// ============================================================================
// ASSERT STATEMENT COVERAGE
// ============================================================================

#[test]
fn test_cov_assert_simple() {
    let code = transpile(
        r#"def validate(x: int):
    assert x > 0"#,
    );
    assert!(code.contains("assert!") || code.contains("fn"));
}

#[test]
fn test_cov_assert_with_message() {
    let code = transpile(
        r#"def validate(x: int):
    assert x > 0, "x must be positive""#,
    );
    assert!(code.contains("assert!") || code.contains("positive") || code.contains("fn"));
}

// ============================================================================
// GLOBAL/NONLOCAL STATEMENTS
// ============================================================================

#[test]
fn test_cov_global_statement() {
    let code = transpile(
        r#"counter = 0
def increment():
    global counter
    counter += 1"#,
    );
    assert!(code.contains("fn increment") || code.contains("counter"));
}

// ============================================================================
// RESULT<BOOL> UNWRAPPING
// ============================================================================

#[test]
fn test_result_bool_in_condition() {
    let code = transpile(
        r#"def check(x: int) -> bool:
    return x % 2 == 0

def use_check(x: int):
    if check(x):
        return "even"
    return "odd""#,
    );
    assert!(code.contains("unwrap_or") || code.contains("if") || code.contains("fn"));
}

// ============================================================================
// NUMPY VALUE EXPRESSION DETECTION (DEPYLER-0932)
// ============================================================================

#[test]
fn test_numpy_array_call() {
    let code = transpile(
        r#"import numpy as np
def create_arr():
    arr = np.array([1, 2, 3])
    return arr"#,
    );
    assert!(code.contains("fn") || code.contains("vec!"));
}

#[test]
fn test_numpy_zeros_call() {
    let code = transpile(
        r#"import numpy as np
def create_zeros():
    arr = np.zeros(10)
    return arr"#,
    );
    assert!(code.contains("fn") || code.contains("zeros") || code.contains("vec!"));
}

#[test]
fn test_numpy_ones_call() {
    let code = transpile(
        r#"import numpy as np
def create_ones():
    arr = np.ones(10)
    return arr"#,
    );
    assert!(code.contains("fn") || code.contains("ones") || code.contains("vec!"));
}

#[test]
fn test_numpy_binary_propagation() {
    let code = transpile(
        r#"import numpy as np
def add_arrays():
    a = np.array([1, 2])
    b = np.array([3, 4])
    return a + b"#,
    );
    assert!(code.contains("fn") || code.contains("+"));
}

#[test]
fn test_numpy_method_call() {
    let code = transpile(
        r#"import numpy as np
def clip_arr(arr):
    return arr.clip(0, 1)"#,
    );
    assert!(code.contains("fn") || code.contains("clip") || code.contains("clamp"));
}

#[test]
fn test_numpy_abs_sqrt() {
    let code = transpile(
        r#"import numpy as np
def math_ops(x):
    return np.abs(np.sqrt(x))"#,
    );
    assert!(code.contains("fn") || code.contains("abs") || code.contains("sqrt"));
}

#[test]
fn test_numpy_trigonometric() {
    let code = transpile(
        r#"import numpy as np
def trig(x):
    return np.sin(x) + np.cos(x)"#,
    );
    assert!(code.contains("fn") || code.contains("sin") || code.contains("cos"));
}

#[test]
fn test_numpy_exp_log() {
    let code = transpile(
        r#"import numpy as np
def exp_log(x):
    return np.exp(np.log(x))"#,
    );
    assert!(code.contains("fn") || code.contains("exp") || code.contains("ln"));
}

#[test]
fn test_numpy_ternary_expression() {
    let code = transpile(
        r#"import numpy as np
def conditional_arr(cond: bool):
    return np.zeros(10) if cond else np.ones(10)"#,
    );
    assert!(code.contains("fn") || code.contains("if"));
}

#[test]
fn test_numpy_variable_tracking() {
    let code = transpile(
        r#"import numpy as np
def use_arr():
    arr = np.array([1, 2, 3])
    return arr * 2"#,
    );
    assert!(code.contains("fn") || code.contains("*"));
}

// ============================================================================
// TYPE CONVERSION TESTS (DEPYLER-0272, DEPYLER-0455)
// ============================================================================

#[test]
fn test_len_to_int_conversion() {
    let code = transpile(
        r#"def get_len(items: list) -> int:
    return len(items)"#,
    );
    // len() returns usize, may need cast to i32
    assert!(code.contains("len()") || code.contains("fn") || code.contains("i64"));
}

#[test]
fn test_count_to_int_conversion() {
    let code = transpile(
        r#"def count_items(items: list, x: int) -> int:
    return items.count(x)"#,
    );
    assert!(code.contains("fn") || code.contains("count"));
}

#[test]
fn test_string_return_from_validator() {
    let code = transpile(
        r#"def validate(input: str) -> str:
    if len(input) > 0:
        return input
    return "default""#,
    );
    assert!(code.contains("fn") || code.contains("String") || code.contains("to_string"));
}

// ============================================================================
// WHILE LOOP TESTS (DEPYLER-0698)
// ============================================================================

#[test]
fn test_while_true_to_loop() {
    let code = transpile(
        r#"def infinite():
    count = 0
    while True:
        count += 1
        if count > 10:
            break
    return count"#,
    );
    // while True should be converted to loop
    assert!(code.contains("loop") || code.contains("while") || code.contains("break"));
}

#[test]
fn test_while_condition_truthiness() {
    let code = transpile(
        r#"def drain_queue():
    queue = [1, 2, 3]
    while queue:
        queue.pop()
    return len(queue)"#,
    );
    assert!(
        code.contains("while")
            || code.contains("!")
            || code.contains("is_empty")
            || code.contains("fn")
    );
}

#[test]
fn test_while_with_counter() {
    let code = transpile(
        r#"def countdown(n: int):
    while n > 0:
        n -= 1
    return n"#,
    );
    assert!(code.contains("while") || code.contains(">") || code.contains("0"));
}

#[test]
fn test_while_nested_return() {
    let code = transpile(
        r#"def find_value(items: list, target: int) -> int:
    i = 0
    while i < len(items):
        if items[i] == target:
            return i
        i += 1
    return -1"#,
    );
    assert!(code.contains("while") || code.contains("return") || code.contains("fn"));
}

// ============================================================================
// RETURN STATEMENT EDGE CASES
// ============================================================================

#[test]
fn test_return_optional_some() {
    let code = transpile(
        r#"from typing import Optional
def maybe_get(items: list, idx: int) -> Optional[int]:
    if idx < len(items):
        return items[idx]
    return None"#,
    );
    assert!(code.contains("Some") || code.contains("None") || code.contains("Option"));
}

#[test]
fn test_sg_return_optional_none() {
    let code = transpile(
        r#"from typing import Optional
def always_none() -> Optional[str]:
    return None"#,
    );
    assert!(code.contains("None") || code.contains("Option") || code.contains("fn"));
}

#[test]
fn test_return_json_value() {
    let code = transpile(
        r#"from typing import Any
def get_any() -> Any:
    return {"key": "value"}"#,
    );
    assert!(code.contains("fn") || code.contains("json") || code.contains("serde"));
}

#[test]
fn test_sg_return_void_function() {
    let code = transpile(
        r#"def void_func() -> None:
    x = 1
    return None"#,
    );
    // void returns should become () or empty return
    assert!(code.contains("fn") || code.contains("()") || code.contains("void_func"));
}

#[test]
fn test_return_if_expr_with_none() {
    let code = transpile(
        r#"from typing import Optional
def conditional_return(x: int) -> Optional[int]:
    return x if x > 0 else None"#,
    );
    // Pattern: `return x if cond else None` should handle None arm specially
    assert!(code.contains("fn") || code.contains("Some") || code.contains("None"));
}

#[test]
fn test_return_already_optional_get() {
    let code = transpile(
        r#"from typing import Optional
def get_from_dict(d: dict, key: str) -> Optional[str]:
    return d.get(key)"#,
    );
    // dict.get already returns Option, shouldn't double-wrap
    assert!(code.contains("fn") || code.contains("get") || code.contains("Option"));
}

#[test]
fn test_return_dict_subscript_to_string() {
    let code = transpile(
        r#"def get_value(d: dict, key: str) -> str:
    return d[key]"#,
    );
    // Dict subscript returns Value, but return type is String - needs conversion
    assert!(code.contains("fn") || code.contains("String"));
}

#[test]
fn test_return_boxed_write() {
    let code = transpile(
        r#"import sys
def get_output(use_stdout: bool):
    if use_stdout:
        return sys.stdout
    return open("out.txt", "w")"#,
    );
    // Should wrap with Box::new for heterogeneous IO types
    assert!(code.contains("fn") || code.contains("Box") || code.contains("Write"));
}

// ============================================================================
// MAIN FUNCTION RETURNS (DEPYLER-0617)
// ============================================================================

#[test]
fn test_main_return_zero() {
    let code = transpile(
        r#"def main() -> int:
    print("Hello")
    return 0"#,
    );
    // return 0 in main should become Ok(()) or ()
    assert!(code.contains("fn main") || code.contains("Ok") || code.contains("()"));
}

#[test]
fn test_main_return_nonzero() {
    let code = transpile(
        r#"def main() -> int:
    print("Error")
    return 1"#,
    );
    // return 1 in main should become process::exit(1)
    assert!(code.contains("fn main") || code.contains("exit") || code.contains("1"));
}

#[test]
fn test_main_return_expression() {
    let code = transpile(
        r#"def main() -> int:
    x = 1 + 2
    return x"#,
    );
    assert!(code.contains("fn main") || code.contains("let"));
}

#[test]
fn test_main_void() {
    let code = transpile(
        r#"def main():
    print("Hello")"#,
    );
    assert!(code.contains("fn main"));
}

// ============================================================================
// ITERATOR PRODUCING EXPRESSIONS (DEPYLER-0520)
// ============================================================================

#[test]
fn test_generator_expr_iteration() {
    let code = transpile(
        r#"def sum_squares(items: list) -> int:
    return sum(x * x for x in items)"#,
    );
    assert!(code.contains("fn") || code.contains("iter") || code.contains("map"));
}

#[test]
fn test_method_chain_iterator() {
    let code = transpile(
        r#"def filter_map(items: list) -> list:
    return list(x * 2 for x in items if x > 0)"#,
    );
    assert!(code.contains("fn") || code.contains("filter") || code.contains("map"));
}

#[test]
fn test_reversed_iterator() {
    let code = transpile(
        r#"def reverse_iter(items: list) -> list:
    return list(reversed(items))"#,
    );
    assert!(code.contains("fn") || code.contains("rev") || code.contains("reversed"));
}

#[test]
fn test_enumerate_iterator() {
    let code = transpile(
        r#"def indexed(items: list):
    for i, x in enumerate(items):
        print(i, x)"#,
    );
    assert!(code.contains("fn") || code.contains("enumerate"));
}

#[test]
fn test_zip_iterator() {
    let code = transpile(
        r#"def paired(a: list, b: list):
    for x, y in zip(a, b):
        print(x, y)"#,
    );
    assert!(code.contains("fn") || code.contains("zip"));
}

// ============================================================================
// RAISE STATEMENT TESTS (DEPYLER-0310)
// ============================================================================

#[test]
fn test_raise_value_error() {
    let code = transpile(
        r#"def validate(x: int):
    if x < 0:
        raise ValueError("Negative value")"#,
    );
    assert!(
        code.contains("fn")
            || code.contains("panic")
            || code.contains("Error")
            || code.contains("Err")
    );
}

#[test]
fn test_raise_type_error() {
    let code = transpile(
        r#"def check_type(x):
    if not isinstance(x, int):
        raise TypeError("Expected int")"#,
    );
    assert!(code.contains("fn") || code.contains("panic") || code.contains("Error"));
}

#[test]
fn test_raise_runtime_error() {
    let code = transpile(
        r#"def fail():
    raise RuntimeError("Something went wrong")"#,
    );
    assert!(code.contains("fn") || code.contains("panic") || code.contains("Error"));
}

#[test]
fn test_raise_bare() {
    // Re-raise without argument
    let code = transpile(
        r#"def reraise():
    try:
        x = 1
    except:
        raise"#,
    );
    assert!(code.contains("fn"));
}

#[test]
fn test_ext_raise_with_format() {
    let code = transpile(
        r#"def validate(x: int):
    if x < 0:
        raise ValueError(f"Invalid: {x}")"#,
    );
    assert!(code.contains("fn") || code.contains("format!") || code.contains("panic"));
}

// ============================================================================
// EXPRESSION STATEMENT EDGE CASES
// ============================================================================

#[test]
fn test_ext_method_call_expression() {
    let code = transpile(
        r#"def modify_list():
    items = [1, 2, 3]
    items.append(4)
    return items"#,
    );
    assert!(code.contains("fn") || code.contains("push") || code.contains("append"));
}

#[test]
fn test_ext_function_call_expression() {
    let code = transpile(
        r#"def call_print():
    print("Hello")
    print("World")"#,
    );
    assert!(code.contains("fn") || code.contains("println!"));
}

#[test]
fn test_ext_chained_method_call() {
    let code = transpile(
        r#"def chain():
    items = [1, 2, 3]
    items.extend([4, 5]).sort()
    return items"#,
    );
    assert!(code.contains("fn") || code.contains("extend") || code.contains("sort"));
}

// ============================================================================
// ASSIGNMENT EDGE CASES
// ============================================================================

#[test]
fn test_ext_assign_nested_dict() {
    let code = transpile(
        r#"def nested_assign():
    d = {"a": {"b": 1}}
    d["a"]["b"] = 2
    return d"#,
    );
    assert!(code.contains("fn") || code.contains("insert") || code.contains("HashMap"));
}

#[test]
fn test_ext_assign_tuple_unpack() {
    let code = transpile(
        r#"def unpack():
    a, b = 1, 2
    return a + b"#,
    );
    assert!(code.contains("fn") || code.contains("let") || code.contains("("));
}

#[test]
fn test_ext_assign_walrus() {
    let code = transpile(
        r#"def walrus_test():
    if (n := len([1, 2, 3])) > 0:
        return n
    return 0"#,
    );
    assert!(code.contains("fn") || code.contains("let") || code.contains("if"));
}

#[test]
fn test_ext_assign_augmented_all_ops() {
    let code = transpile(
        r#"def augmented_ops():
    x = 10
    x += 5
    x -= 3
    x *= 2
    x //= 3
    x %= 4
    return x"#,
    );
    assert!(code.contains("fn") || code.contains("+=") || code.contains("-="));
}

#[test]
fn test_ext_assign_with_type_annotation() {
    let code = transpile(
        r#"def annotated():
    x: int = 42
    s: str = "hello"
    return x"#,
    );
    assert!(
        code.contains("fn")
            || code.contains("i64")
            || code.contains("String")
            || code.contains("42")
    );
}

// ============================================================================
// FLOAT EXPRESSION INFERENCE (DEPYLER-0785)
// ============================================================================

#[test]
fn test_ext_float_literal_inference() {
    let code = transpile(
        r#"def float_test() -> float:
    return 3.14"#,
    );
    assert!(code.contains("fn") || code.contains("f64") || code.contains("3.14"));
}

#[test]
fn test_ext_float_binary_propagation() {
    let code = transpile(
        r#"def float_mul(x: float, y: float) -> float:
    return x * y"#,
    );
    assert!(code.contains("fn") || code.contains("f64") || code.contains("*"));
}

#[test]
fn test_ext_float_callable_return() {
    let code = transpile(
        r#"from typing import Callable
def apply_float(f: Callable[[float], float], x: float) -> float:
    return f(x)"#,
    );
    assert!(code.contains("fn") || code.contains("f64") || code.contains("Fn"));
}

#[test]
fn test_ext_float_ternary() {
    let code = transpile(
        r#"def float_ternary(cond: bool) -> float:
    return 1.0 if cond else 2.0"#,
    );
    assert!(code.contains("fn") || code.contains("f64") || code.contains("if"));
}

// ============================================================================
// CONTEXT MANAGER WITH STATEMENT
// ============================================================================

#[test]
fn test_ext_batch_with_file_read() {
    let code = transpile(
        r#"def read_file(path: str) -> str:
    with open(path, "r") as f:
        return f.read()"#,
    );
    assert!(code.contains("fn") || code.contains("File") || code.contains("read"));
}

#[test]
fn test_ext_batch_with_multiple() {
    let code = transpile(
        r#"def copy_file(src: str, dst: str):
    with open(src, "r") as f1, open(dst, "w") as f2:
        f2.write(f1.read())"#,
    );
    assert!(code.contains("fn") || code.contains("File"));
}

#[test]
fn test_ext_with_as_expression() {
    let code = transpile(
        r#"def use_context():
    with lock:
        x = 1"#,
    );
    assert!(code.contains("fn"));
}

// ============================================================================
// PASS AND ELLIPSIS
// ============================================================================

#[test]
fn test_ext_pass_in_function() {
    let code = transpile(
        r#"def noop():
    pass"#,
    );
    assert!(code.contains("fn noop"));
}

#[test]
fn test_ext_pass_in_class() {
    let code = transpile(
        r#"class Empty:
    pass"#,
    );
    assert!(code.contains("struct Empty") || code.contains("Empty"));
}

#[test]
fn test_ext_ellipsis_stub() {
    let code = transpile(
        r#"def stub() -> int:
    ..."#,
    );
    assert!(code.contains("fn stub") || code.contains("todo!") || code.contains("unimplemented!"));
}

// ============================================================================
// ASSERT STATEMENTS
// ============================================================================

#[test]
fn test_ext_batch_assert_simple() {
    let code = transpile(
        r#"def check(x: int):
    assert x > 0"#,
    );
    assert!(code.contains("assert!") || code.contains(">") || code.contains("0"));
}

#[test]
fn test_ext_batch_assert_with_message() {
    let code = transpile(
        r#"def check(x: int):
    assert x > 0, "x must be positive""#,
    );
    assert!(code.contains("assert!") || code.contains("positive") || code.contains("fn"));
}

#[test]
fn test_ext_assert_comparison() {
    let code = transpile(
        r#"def check_eq(a: int, b: int):
    assert a == b"#,
    );
    assert!(code.contains("assert!") || code.contains("==") || code.contains("fn"));
}

// ============================================================================
// BREAK AND CONTINUE WITH LABELS
// ============================================================================

#[test]
fn test_ext_break_labeled() {
    let code = transpile(
        r#"def search():
    for i in range(10):
        for j in range(10):
            if i * j > 25:
                break"#,
    );
    assert!(code.contains("break") || code.contains("for"));
}

#[test]
fn test_ext_continue_simple() {
    let code = transpile(
        r#"def skip_odds():
    for i in range(10):
        if i % 2 == 1:
            continue
        print(i)"#,
    );
    assert!(code.contains("continue") || code.contains("for"));
}

// ============================================================================
// TRY/EXCEPT/FINALLY EDGE CASES
// ============================================================================

#[test]
fn test_ext_try_except_multiple() {
    let code = transpile(
        r#"def multi_except():
    try:
        x = int("abc")
    except ValueError:
        return 1
    except TypeError:
        return 2
    return 0"#,
    );
    assert!(code.contains("fn") || code.contains("match") || code.contains("Err"));
}

#[test]
fn test_ext_batch_try_finally() {
    let code = transpile(
        r#"def with_cleanup():
    try:
        x = 1
    finally:
        print("cleanup")"#,
    );
    assert!(code.contains("fn"));
}

#[test]
fn test_ext_try_else() {
    let code = transpile(
        r#"def try_else():
    try:
        x = 1
    except:
        x = 0
    else:
        x = 2"#,
    );
    assert!(code.contains("fn"));
}

// ============================================================================
// DELETE STATEMENT
// ============================================================================

#[test]
fn test_ext_delete_dict_key() {
    let code = transpile(
        r#"def remove_key(d: dict, key: str):
    del d[key]"#,
    );
    assert!(code.contains("fn") || code.contains("remove"));
}

#[test]
fn test_ext_delete_list_item() {
    let code = transpile(
        r#"def remove_item(items: list, idx: int):
    del items[idx]"#,
    );
    assert!(code.contains("fn") || code.contains("remove"));
}

// ============================================================================
// EXCEPTION TYPE HANDLING (DEPYLER-0333, DEPYLER-0438, DEPYLER-0551)
// ============================================================================

#[test]
fn test_ext2_raise_index_error() {
    let code = transpile(
        r#"def get_item(items: list, idx: int) -> int:
    if idx >= len(items):
        raise IndexError("Index out of bounds")
    return items[idx]"#,
    );
    assert!(code.contains("fn") || code.contains("IndexError") || code.contains("panic"));
}

#[test]
fn test_ext2_raise_key_error() {
    let code = transpile(
        r#"def get_key(d: dict, key: str) -> str:
    if key not in d:
        raise KeyError(f"Missing key: {key}")
    return d[key]"#,
    );
    assert!(code.contains("fn") || code.contains("KeyError") || code.contains("panic"));
}

#[test]
fn test_ext2_raise_io_error() {
    let code = transpile(
        r#"def read_required(path: str) -> str:
    if not path:
        raise IOError("No path provided")
    return open(path).read()"#,
    );
    assert!(code.contains("fn") || code.contains("IOError") || code.contains("panic"));
}

#[test]
fn test_ext2_raise_attribute_error_skip() {
    // getattr not fully supported - skip
}

#[test]
fn test_ext2_raise_stop_iteration() {
    let code = transpile(
        r#"def next_item(items: list):
    if not items:
        raise StopIteration()
    return items.pop(0)"#,
    );
    assert!(code.contains("fn") || code.contains("StopIteration") || code.contains("panic"));
}

#[test]
fn test_ext2_raise_syntax_error() {
    let code = transpile(
        r#"def parse_code(code: str):
    if "import" not in code:
        raise SyntaxError("Missing import")
    return code"#,
    );
    assert!(code.contains("fn") || code.contains("SyntaxError") || code.contains("panic"));
}

#[test]
fn test_ext2_raise_zero_division() {
    let code = transpile(
        r#"def divide(a: int, b: int) -> int:
    if b == 0:
        raise ZeroDivisionError("Division by zero")
    return a // b"#,
    );
    assert!(code.contains("fn") || code.contains("ZeroDivisionError") || code.contains("panic"));
}

#[test]
fn test_ext2_raise_file_not_found() {
    let code = transpile(
        r#"def load_file(path: str) -> str:
    if not path.endswith(".txt"):
        raise FileNotFoundError(f"Not found: {path}")
    return open(path).read()"#,
    );
    assert!(code.contains("fn") || code.contains("FileNotFoundError") || code.contains("panic"));
}

// ============================================================================
// TRUTHINESS CONVERSION TESTS (DEPYLER-0339, DEPYLER-0966)
// ============================================================================

#[test]
fn test_ext2_truthiness_string() {
    let code = transpile(
        r#"def check_name(name: str) -> bool:
    if name:
        return True
    return False"#,
    );
    // String truthiness: !name.is_empty()
    assert!(code.contains("fn") || code.contains("is_empty") || code.contains("bool"));
}

#[test]
fn test_ext2_truthiness_list() {
    let code = transpile(
        r#"def has_items(items: list) -> bool:
    if items:
        return True
    return False"#,
    );
    // List truthiness: !items.is_empty()
    assert!(code.contains("fn") || code.contains("is_empty") || code.contains("bool"));
}

#[test]
fn test_ext2_truthiness_dict() {
    let code = transpile(
        r#"def has_data(data: dict) -> bool:
    if data:
        return True
    return False"#,
    );
    // Dict truthiness: !data.is_empty()
    assert!(code.contains("fn") || code.contains("is_empty") || code.contains("bool"));
}

#[test]
fn test_ext2_truthiness_optional() {
    let code = transpile(
        r#"from typing import Optional
def has_value(value: Optional[int]) -> bool:
    if value:
        return True
    return False"#,
    );
    // Optional truthiness: value.is_some()
    assert!(code.contains("fn") || code.contains("is_some") || code.contains("bool"));
}

#[test]
fn test_ext2_truthiness_int() {
    let code = transpile(
        r#"def is_nonzero(n: int) -> bool:
    if n:
        return True
    return False"#,
    );
    // Int truthiness: n != 0
    assert!(code.contains("fn") || code.contains("!= 0") || code.contains("bool"));
}

#[test]
fn test_ext2_truthiness_float() {
    let code = transpile(
        r#"def is_nonzero_float(x: float) -> bool:
    if x:
        return True
    return False"#,
    );
    // Float truthiness: x != 0.0
    assert!(code.contains("fn") || code.contains("!= 0") || code.contains("bool"));
}

#[test]
fn test_ext2_negated_truthiness_string() {
    let code = transpile(
        r#"def is_empty_name(name: str) -> bool:
    if not name:
        return True
    return False"#,
    );
    // Negated string truthiness: name.is_empty()
    assert!(code.contains("fn") || code.contains("is_empty") || code.contains("bool"));
}

#[test]
fn test_ext2_negated_truthiness_optional() {
    let code = transpile(
        r#"from typing import Optional
def is_none_value(value: Optional[int]) -> bool:
    if not value:
        return True
    return False"#,
    );
    // Negated optional truthiness: value.is_none()
    assert!(code.contains("fn") || code.contains("is_none") || code.contains("bool"));
}

#[test]
fn test_ext2_truthiness_queue_heuristic() {
    let code = transpile(
        r#"def process_queue(queue):
    while queue:
        item = queue.pop()
        print(item)"#,
    );
    // Heuristic for 'queue' variable: !queue.is_empty()
    assert!(code.contains("fn") || code.contains("while") || code.contains("pop"));
}

#[test]
fn test_ext2_truthiness_self_field() {
    let code = transpile(
        r#"class Container:
    def __init__(self):
        self.items = []
    
    def has_items(self) -> bool:
        if self.items:
            return True
        return False"#,
    );
    assert!(code.contains("fn has_items") || code.contains("is_empty") || code.contains("struct"));
}

// ============================================================================
// CONTEXT MANAGER PATTERNS (DEPYLER-0387, DEPYLER-0533, DEPYLER-0188)
// ============================================================================

#[test]
fn test_ext2_with_tempfile() {
    let code = transpile(
        r#"import tempfile
def create_temp():
    with tempfile.NamedTemporaryFile() as f:
        f.write(b"hello")
        return f.name"#,
    );
    assert!(code.contains("fn") || code.contains("tempfile") || code.contains("NamedTempFile"));
}

#[test]
fn test_ext2_with_no_target() {
    let code = transpile(
        r#"def use_lock():
    with lock:
        x = 1"#,
    );
    // Context manager without `as target`
    assert!(code.contains("fn use_lock") || code.contains("let"));
}

#[test]
fn test_ext2_async_with() {
    let code = transpile(
        r#"async def fetch_data():
    async with session.get("http://example.com") as response:
        return await response.text()"#,
    );
    assert!(code.contains("fn fetch_data") || code.contains("async") || code.contains("await"));
}

// ============================================================================
// DICT ACCESS IN CONDITIONS (DEPYLER-0570)
// ============================================================================

#[test]
fn test_ext2_dict_access_condition() {
    let code = transpile(
        r#"def check_info(info: dict) -> bool:
    if info["name"]:
        return True
    return False"#,
    );
    assert!(code.contains("fn") || code.contains("as_str") || code.contains("get"));
}

#[test]
fn test_ext2_dict_get_with_default() {
    let code = transpile(
        r#"def get_value(data: dict, key: str) -> str:
    return data.get(key, "default")"#,
    );
    assert!(code.contains("fn") || code.contains("unwrap_or") || code.contains("default"));
}

#[test]
fn test_ext2_dict_get_without_default() {
    let code = transpile(
        r#"from typing import Optional
def maybe_get(data: dict, key: str) -> Optional[str]:
    return data.get(key)"#,
    );
    assert!(code.contains("fn") || code.contains("Option") || code.contains("get"));
}

// ============================================================================
// OPTION EXPRESSION DETECTION (DEPYLER-0455)
// ============================================================================

#[test]
fn test_ext2_env_var_ok() {
    let code = transpile(
        r#"import os
def get_env(name: str) -> str:
    value = os.environ.get(name)
    if value:
        return value
    return "default""#,
    );
    assert!(code.contains("fn") || code.contains("env") || code.contains("is_some"));
}

#[test]
fn test_ext2_method_returning_vec() {
    let code = transpile(
        r#"def check_groups(text: str) -> bool:
    import re
    match = re.search(r"(\d+)", text)
    if match.groups():
        return True
    return False"#,
    );
    assert!(code.contains("fn") || code.contains("groups") || code.contains("is_empty"));
}

// ============================================================================
// FOR LOOP PATTERNS
// ============================================================================

#[test]
fn test_ext2_for_with_else() {
    let code = transpile(
        r#"def find_even(items: list) -> int:
    for x in items:
        if x % 2 == 0:
            return x
    else:
        return -1"#,
    );
    assert!(code.contains("fn") || code.contains("for") || code.contains("-1"));
}

#[test]
fn test_ext2_for_zip_enumerate() {
    let code = transpile(
        r#"def indexed_pairs(a: list, b: list):
    for i, (x, y) in enumerate(zip(a, b)):
        print(i, x, y)"#,
    );
    assert!(code.contains("fn") || code.contains("zip") || code.contains("enumerate"));
}

#[test]
fn test_ext2_for_items() {
    let code = transpile(
        r#"def iterate_dict(d: dict):
    for k, v in d.items():
        print(k, v)"#,
    );
    assert!(code.contains("fn") || code.contains("iter") || code.contains("for"));
}

// ============================================================================
// RETURN EDGE CASES
// ============================================================================

#[test]
fn test_ext2_return_json_bool() {
    let code = transpile(
        r#"from typing import Any
def get_bool() -> Any:
    return True"#,
    );
    assert!(code.contains("fn") || code.contains("json") || code.contains("true"));
}

#[test]
fn test_ext2_return_json_dict() {
    let code = transpile(
        r#"from typing import Any
def get_dict() -> Any:
    return {"a": 1, "b": 2}"#,
    );
    assert!(code.contains("fn") || code.contains("json") || code.contains("serde"));
}

#[test]
fn test_ext2_return_json_list() {
    let code = transpile(
        r#"from typing import Any
def get_list() -> Any:
    return [1, 2, 3]"#,
    );
    assert!(code.contains("fn") || code.contains("json") || code.contains("vec"));
}

// ============================================================================
// ARGPARSE FIELD PATTERNS
// ============================================================================

#[test]
fn test_ext2_argparse_optional_field() {
    let code = transpile(
        r#"import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--config", type=str)
args = parser.parse_args()
if args.config:
    print(args.config)"#,
    );
    assert!(code.contains("clap") || code.contains("Args") || code.contains("config"));
}

#[test]
fn test_ext2_argparse_vec_field() {
    let code = transpile(
        r#"import argparse
parser = argparse.ArgumentParser()
parser.add_argument("files", nargs="+")
args = parser.parse_args()
if args.files:
    print(args.files)"#,
    );
    assert!(code.contains("clap") || code.contains("Args") || code.contains("files"));
}

#[test]
fn test_ext2_argparse_bool_field() {
    let code = transpile(
        r#"import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--verbose", action="store_true")
args = parser.parse_args()
if args.verbose:
    print("verbose mode")"#,
    );
    assert!(code.contains("clap") || code.contains("Args") || code.contains("verbose"));
}

// ============================================================================
// GENERATOR STATE PATTERNS
// ============================================================================

#[test]
fn test_ext2_yield_simple() {
    let code = transpile(
        r#"def count_up(n: int):
    i = 0
    while i < n:
        yield i
        i += 1"#,
    );
    assert!(code.contains("fn") || code.contains("Iterator") || code.contains("yield"));
}

#[test]
fn test_ext2_yield_from() {
    let code = transpile(
        r#"def flatten(items: list):
    for item in items:
        yield from item"#,
    );
    assert!(code.contains("fn") || code.contains("Iterator") || code.contains("flatten"));
}

// ============================================================================
// FINAL STATEMENT HANDLING (DEPYLER-0271)
// ============================================================================

#[test]
fn test_ext2_implicit_return() {
    let code = transpile(
        r#"def add(a: int, b: int) -> int:
    a + b"#,
    );
    // Final expression should be implicit return
    assert!(code.contains("fn add") || code.contains("+"));
}

#[test]
fn test_ext2_explicit_return_early() {
    let code = transpile(
        r#"def check(x: int) -> int:
    if x < 0:
        return 0
    return x"#,
    );
    // Early return should have `return`, final may omit
    assert!(code.contains("fn check") || code.contains("return") || code.contains("if"));
}

// ============================================================================
// NUMPY DETECTION IN ASSIGNMENTS
// ============================================================================

#[test]
fn test_ext2_numpy_assign_tracking() {
    let code = transpile(
        r#"import numpy as np
def process():
    arr = np.zeros(10)
    arr = arr * 2
    return arr"#,
    );
    assert!(code.contains("fn") || code.contains("*") || code.contains("2"));
}

#[test]
fn test_ext2_numpy_ternary_assign() {
    let code = transpile(
        r#"import numpy as np
def get_arr(use_zeros: bool):
    arr = np.zeros(10) if use_zeros else np.ones(10)
    return arr"#,
    );
    assert!(code.contains("fn") || code.contains("if") || code.contains("else"));
}

// ============================================================================
// COMPLEX CONTROL FLOW
// ============================================================================

#[test]
fn test_ext2_nested_loops_break() {
    let code = transpile(
        r#"def find_pair(matrix: list):
    for i in range(len(matrix)):
        for j in range(len(matrix[i])):
            if matrix[i][j] == 0:
                return (i, j)
    return (-1, -1)"#,
    );
    assert!(code.contains("fn") || code.contains("for") || code.contains("return"));
}

#[test]
fn test_ext2_try_except_return() {
    let code = transpile(
        r#"def safe_parse(s: str) -> int:
    try:
        return int(s)
    except ValueError:
        return 0"#,
    );
    assert!(code.contains("fn") || code.contains("parse") || code.contains("unwrap_or"));
}

// ============================================================================
// ADDITIONAL SPECIALIZED TESTS FOR COVERAGE
// ============================================================================

#[test]
fn test_special_exception_index_error() {
    let code = transpile(
        r#"def get(items: list, idx: int) -> int:
    if idx < 0 or idx >= len(items):
        raise IndexError("Out of bounds")
    return items[idx]"#,
    );
    assert!(code.contains("fn") || code.contains("IndexError"));
}

#[test]
fn test_special_exception_key_error() {
    let code = transpile(
        r#"def get_val(d: dict, key: str) -> str:
    if key not in d:
        raise KeyError(key)
    return d[key]"#,
    );
    assert!(code.contains("fn") || code.contains("KeyError"));
}

#[test]
fn test_special_io_operations() {
    let code = transpile(
        r#"def read_all(path: str) -> str:
    with open(path, 'r') as f:
        return f.read()"#,
    );
    assert!(code.contains("fn") || code.contains("File") || code.contains("read"));
}

#[test]
fn test_special_io_write() {
    let code = transpile(
        r#"def write_all(path: str, content: str):
    with open(path, 'w') as f:
        f.write(content)"#,
    );
    assert!(code.contains("fn") || code.contains("File") || code.contains("write"));
}

#[test]
fn test_special_stdin_read() {
    let code = transpile(
        r#"import sys
def read_input() -> str:
    return sys.stdin.read()"#,
    );
    assert!(code.contains("fn") || code.contains("stdin") || code.contains("read"));
}

#[test]
fn test_special_stdout_write() {
    let code = transpile(
        r#"import sys
def write_output(text: str):
    sys.stdout.write(text)"#,
    );
    assert!(code.contains("fn") || code.contains("stdout") || code.contains("write"));
}

#[test]
fn test_special_stderr_write() {
    let code = transpile(
        r#"import sys
def log_error(msg: str):
    sys.stderr.write(msg)"#,
    );
    assert!(code.contains("fn") || code.contains("stderr") || code.contains("eprintln"));
}

#[test]
fn test_special_os_path_join() {
    let code = transpile(
        r#"import os
def join_paths(a: str, b: str) -> str:
    return os.path.join(a, b)"#,
    );
    assert!(code.contains("fn") || code.contains("PathBuf") || code.contains("join"));
}

#[test]
fn test_special_os_path_exists() {
    let code = transpile(
        r#"import os
def file_exists(path: str) -> bool:
    return os.path.exists(path)"#,
    );
    assert!(code.contains("fn") || code.contains("exists") || code.contains("Path"));
}

#[test]
fn test_special_os_environ_get() {
    let code = transpile(
        r#"import os
def get_env(name: str) -> str:
    return os.environ.get(name, "")"#,
    );
    assert!(code.contains("fn") || code.contains("env") || code.contains("var"));
}

#[test]
fn test_special_os_mkdir() {
    let code = transpile(
        r#"import os
def make_dir(path: str):
    os.makedirs(path, exist_ok=True)"#,
    );
    assert!(code.contains("fn") || code.contains("create_dir") || code.contains("mkdir"));
}

#[test]
fn test_special_collections_counter() {
    let code = transpile(
        r#"from collections import Counter
def count_items(items: list):
    return Counter(items)"#,
    );
    assert!(code.contains("fn") || code.contains("HashMap") || code.contains("counter"));
}

#[test]
fn test_special_collections_defaultdict() {
    let code = transpile(
        r#"from collections import defaultdict
def group_items():
    d = defaultdict(list)
    return d"#,
    );
    assert!(code.contains("fn") || code.contains("HashMap") || code.contains("default"));
}

#[test]
fn test_special_json_loads() {
    let code = transpile(
        r#"import json
def parse_json(text: str) -> dict:
    return json.loads(text)"#,
    );
    assert!(code.contains("fn") || code.contains("serde_json") || code.contains("from_str"));
}

#[test]
fn test_special_json_dumps() {
    let code = transpile(
        r#"import json
def to_json(data: dict) -> str:
    return json.dumps(data)"#,
    );
    assert!(code.contains("fn") || code.contains("serde_json") || code.contains("to_string"));
}

#[test]
fn test_special_re_match() {
    let code = transpile(
        r#"import re
def check_match(text: str) -> bool:
    return re.match(r"\d+", text) is not None"#,
    );
    assert!(code.contains("fn") || code.contains("Regex") || code.contains("is_match"));
}

#[test]
fn test_special_re_search() {
    let code = transpile(
        r#"import re
def find_number(text: str) -> str:
    match = re.search(r"\d+", text)
    if match:
        return match.group(0)
    return """#,
    );
    assert!(code.contains("fn") || code.contains("Regex") || code.contains("find"));
}

#[test]
fn test_special_re_findall() {
    let code = transpile(
        r#"import re
def find_all(text: str) -> list:
    return re.findall(r"\d+", text)"#,
    );
    assert!(code.contains("fn") || code.contains("Regex") || code.contains("find_iter"));
}

#[test]
fn test_special_re_sub() {
    let code = transpile(
        r#"import re
def replace_all(text: str) -> str:
    return re.sub(r"\d+", "X", text)"#,
    );
    assert!(code.contains("fn") || code.contains("Regex") || code.contains("replace"));
}

#[test]
fn test_special_datetime_now() {
    let code = transpile(
        r#"from datetime import datetime
def get_now():
    return datetime.now()"#,
    );
    assert!(code.contains("fn") || code.contains("chrono") || code.contains("now"));
}

#[test]
fn test_special_datetime_parse() {
    let code = transpile(
        r#"from datetime import datetime
def parse_date(text: str):
    return datetime.strptime(text, "%Y-%m-%d")"#,
    );
    assert!(code.contains("fn") || code.contains("chrono") || code.contains("parse"));
}

#[test]
fn test_special_class_self_assignment() {
    let code = transpile(
        r#"class Counter:
    def __init__(self):
        self.value = 0
    def increment(self):
        self.value += 1
        return self.value"#,
    );
    assert!(code.contains("fn increment") || code.contains("self.value") || code.contains("+="));
}

#[test]
fn test_special_class_method_chain() {
    let code = transpile(
        r#"class Builder:
    def __init__(self):
        self.data = ""
    def add(self, text: str):
        self.data += text
        return self
    def build(self) -> str:
        return self.data"#,
    );
    assert!(code.contains("fn add") || code.contains("fn build") || code.contains("Self"));
}

#[test]
fn test_special_iterator_pattern() {
    let code = transpile(
        r#"class Range:
    def __init__(self, limit: int):
        self.limit = limit
        self.current = 0
    def __iter__(self):
        return self
    def __next__(self) -> int:
        if self.current >= self.limit:
            raise StopIteration()
        result = self.current
        self.current += 1
        return result"#,
    );
    assert!(code.contains("fn") || code.contains("Iterator") || code.contains("next"));
}

#[test]
fn test_special_context_manager_pattern() {
    let code = transpile(
        r#"class Timer:
    def __enter__(self):
        self.start = 0
        return self
    def __exit__(self, *args):
        pass"#,
    );
    assert!(code.contains("fn") || code.contains("__enter__") || code.contains("struct"));
}

#[test]
fn test_special_property_getter_setter() {
    let code = transpile(
        r#"class Temperature:
    def __init__(self):
        self._celsius = 0.0
    @property
    def fahrenheit(self) -> float:
        return self._celsius * 9/5 + 32
    @fahrenheit.setter
    def fahrenheit(self, value: float):
        self._celsius = (value - 32) * 5/9"#,
    );
    assert!(code.contains("fn fahrenheit") || code.contains("struct") || code.contains("impl"));
}

#[test]
fn test_special_dataclass_inheritance() {
    let code = transpile(
        r#"from dataclasses import dataclass
@dataclass
class Base:
    x: int
@dataclass
class Child(Base):
    y: int"#,
    );
    assert!(code.contains("struct Base") || code.contains("struct Child") || code.contains("x"));
}

#[test]
fn test_special_enum_pattern() {
    let code = transpile(
        r#"from enum import Enum
class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3"#,
    );
    assert!(code.contains("enum Color") || code.contains("RED") || code.contains("GREEN"));
}

#[test]
fn test_special_match_statement() {
    let code = transpile(
        r#"def categorize(x: int) -> str:
    match x:
        case 0:
            return "zero"
        case 1 | 2 | 3:
            return "small"
        case _:
            return "large""#,
    );
    assert!(code.contains("fn categorize") || code.contains("match") || code.contains("=>"));
}

#[test]
fn test_special_walrus_loop() {
    let code = transpile(
        r#"def process_lines():
    lines = []
    while (line := input()):
        lines.append(line)
    return lines"#,
    );
    assert!(code.contains("fn process_lines") || code.contains("while") || code.contains("let"));
}

#[test]
fn test_special_complex_comprehension() {
    let code = transpile(
        r#"def matrix_flatten(matrix: list) -> list:
    return [x * 2 for row in matrix for x in row if x > 0]"#,
    );
    assert!(code.contains("fn matrix_flatten") || code.contains("filter") || code.contains("map"));
}

#[test]
fn test_special_nested_function() {
    let code = transpile(
        r#"def outer(x: int):
    def inner(y: int) -> int:
        return x + y
    return inner(10)"#,
    );
    assert!(code.contains("fn outer") || code.contains("let inner") || code.contains("+"));
}

#[test]
fn test_special_closure_capture() {
    let code = transpile(
        r#"def make_counter():
    count = 0
    def increment() -> int:
        nonlocal count
        count += 1
        return count
    return increment"#,
    );
    assert!(code.contains("fn make_counter") || code.contains("move") || code.contains("Fn"));
}

#[test]
fn test_special_multiple_return() {
    let code = transpile(
        r#"def divmod_result(a: int, b: int) -> tuple:
    return a // b, a % b"#,
    );
    assert!(code.contains("fn divmod_result") || code.contains("(") || code.contains(","));
}

#[test]
fn test_special_star_unpacking() {
    let code = transpile(
        r#"def split_list(items: list):
    first, *middle, last = items
    return first, last"#,
    );
    assert!(code.contains("fn split_list") || code.contains("let") || code.contains("first"));
}

#[test]
fn test_special_default_dict_value() {
    let code = transpile(
        r#"def get_or_default(d: dict, key: str) -> int:
    return d.get(key, 0)"#,
    );
    assert!(
        code.contains("fn get_or_default") || code.contains("unwrap_or") || code.contains("get")
    );
}

#[test]
fn test_special_chain_comparison() {
    let code = transpile(
        r#"def in_range(x: int) -> bool:
    return 0 <= x < 100"#,
    );
    assert!(code.contains("fn in_range") || code.contains("<=") || code.contains("&&"));
}

#[test]
fn test_special_assert_with_msg() {
    let code = transpile(
        r#"def validate(x: int):
    assert x > 0, f"Expected positive, got {x}""#,
    );
    assert!(code.contains("fn validate") || code.contains("assert!") || code.contains("format!"));
}

#[test]
fn test_special_global_modify() {
    let code = transpile(
        r#"counter = 0
def increment():
    global counter
    counter += 1
    return counter"#,
    );
    assert!(code.contains("fn increment") || code.contains("counter") || code.contains("+="));
}

#[test]
fn test_special_class_variable() {
    let code = transpile(
        r#"class Counter:
    count = 0
    def increment(self):
        Counter.count += 1"#,
    );
    assert!(code.contains("struct Counter") || code.contains("impl") || code.contains("count"));
}

#[test]
fn test_special_super_call() {
    let code = transpile(
        r#"class Child:
    def __init__(self):
        super().__init__()
        self.value = 1"#,
    );
    assert!(code.contains("struct Child") || code.contains("impl") || code.contains("super"));
}

#[test]
fn test_special_isinstance_check() {
    let code = transpile(
        r#"def type_check(x) -> str:
    if isinstance(x, int):
        return "int"
    elif isinstance(x, str):
        return "str"
    return "other""#,
    );
    assert!(code.contains("fn type_check") || code.contains("if") || code.contains("int"));
}

#[test]
fn test_special_hasattr_check() {
    let code = transpile(
        r#"def has_method(obj) -> bool:
    return hasattr(obj, "run")"#,
    );
    assert!(code.contains("fn has_method") || code.contains("run"));
}

#[test]
fn test_special_callable_check() {
    let code = transpile(
        r#"def is_callable(obj) -> bool:
    return callable(obj)"#,
    );
    assert!(code.contains("fn is_callable") || code.contains("Fn") || code.contains("fn"));
}

// ========== BATCH 3: TARGETED STMT COVERAGE TESTS (Try/Except/Finally) ==========

#[test]
fn test_tc_try_except_finally_basic() {
    let code = transpile(
        r#"def safe_read(path: str) -> str:
    try:
        f = open(path)
        return f.read()
    except IOError:
        return ""
    finally:
        print("cleanup")"#,
    );
    assert!(code.contains("fn") || code.contains("File") || code.contains("cleanup"));
}

#[test]
fn test_tc_try_except_with_binding() {
    let code = transpile(
        r#"def handle_error() -> str:
    try:
        x = int("abc")
        return str(x)
    except ValueError as e:
        return str(e)"#,
    );
    assert!(code.contains("fn") || code.contains("Err") || code.contains("e"));
}

#[test]
fn test_tc_try_zerodiv_handler() {
    let code = transpile(
        r#"def safe_div(a: int, b: int) -> int:
    try:
        return a // b
    except ZeroDivisionError:
        return 0"#,
    );
    assert!(code.contains("fn") || code.contains("0") || code.contains("div"));
}

#[test]
fn test_tc_try_multiple_handlers() {
    let code = transpile(
        r#"def parse(s: str) -> int:
    try:
        return int(s)
    except ValueError:
        return -1
    except TypeError:
        return -2"#,
    );
    assert!(code.contains("fn") || code.contains("-1") || code.contains("parse"));
}

#[test]
fn test_tc_nested_try_except() {
    let code = transpile(
        r#"def nested() -> int:
    try:
        try:
            return int("x")
        except ValueError:
            return 1
    except TypeError:
        return 2"#,
    );
    assert!(code.contains("fn") || code.contains("1") || code.contains("2"));
}

#[test]
fn test_tc_try_with_hoisted_vars() {
    let code = transpile(
        r#"def hoisted() -> int:
    try:
        x = 10
        y = 20
    except Exception:
        x = 0
        y = 0
    return x + y"#,
    );
    assert!(code.contains("fn") || code.contains("x") || code.contains("y"));
}

#[test]
fn test_tc_while_with_break() {
    let code = transpile(
        r#"def find_first(items: list[int], target: int) -> int:
    i = 0
    while i < len(items):
        if items[i] == target:
            break
        i += 1
    return i"#,
    );
    assert!(code.contains("fn") || code.contains("break") || code.contains("while"));
}

#[test]
fn test_tc_while_with_continue() {
    let code = transpile(
        r#"def skip_negatives(items: list[int]) -> int:
    i = 0
    total = 0
    while i < len(items):
        i += 1
        if items[i-1] < 0:
            continue
        total += items[i-1]
    return total"#,
    );
    assert!(code.contains("fn") || code.contains("continue") || code.contains("while"));
}

#[test]
fn test_tc_while_else() {
    let code = transpile(
        r#"def search(items: list[int], target: int) -> bool:
    i = 0
    while i < len(items):
        if items[i] == target:
            return True
        i += 1
    else:
        return False"#,
    );
    assert!(code.contains("fn") || code.contains("true") || code.contains("false"));
}

#[test]
fn test_tc_for_with_else() {
    let code = transpile(
        r#"def find_prime(n: int) -> bool:
    for i in range(2, n):
        if n % i == 0:
            return False
    else:
        return True"#,
    );
    assert!(code.contains("fn") || code.contains("true") || code.contains("for"));
}

#[test]
fn test_tc_for_enumerate() {
    let code = transpile(
        r#"def indexed(items: list[str]) -> list[str]:
    result = []
    for i, item in enumerate(items):
        result.append(f"{i}: {item}")
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("enumerate") || code.contains("Vec"));
}

#[test]
fn test_tc_for_zip() {
    let code = transpile(
        r#"def pairs(a: list[int], b: list[str]) -> list[tuple[int, str]]:
    result = []
    for x, y in zip(a, b):
        result.append((x, y))
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("zip") || code.contains("Vec"));
}

#[test]
fn test_tc_if_elif_else_chain() {
    let code = transpile(
        r#"def classify(x: int) -> str:
    if x < 0:
        return "negative"
    elif x == 0:
        return "zero"
    elif x < 10:
        return "small"
    elif x < 100:
        return "medium"
    else:
        return "large""#,
    );
    assert!(code.contains("fn") || code.contains("if") || code.contains("else"));
}

#[test]
fn test_tc_with_nested() {
    let code = transpile(
        r#"def copy_file(src: str, dst: str) -> None:
    with open(src) as f1:
        with open(dst, "w") as f2:
            f2.write(f1.read())"#,
    );
    assert!(code.contains("fn") || code.contains("File") || code.contains("write"));
}

#[test]
fn test_tc_raise_from() {
    let code = transpile(
        r#"def wrap_error() -> None:
    try:
        raise ValueError("inner")
    except ValueError as e:
        raise RuntimeError("outer") from e"#,
    );
    assert!(code.contains("fn") || code.contains("Error") || code.contains("panic"));
}

#[test]
fn test_tc_raise_custom() {
    let code = transpile(
        r#"def check(x: int) -> None:
    if x < 0:
        raise ValueError(f"x must be >= 0, got {x}")"#,
    );
    assert!(code.contains("fn") || code.contains("panic") || code.contains("x"));
}

#[test]
fn test_tc_augmented_assign_all() {
    let code = transpile(
        r#"def aug_ops() -> int:
    x = 10
    x += 1
    x -= 2
    x *= 3
    x //= 4
    x %= 5
    return x"#,
    );
    assert!(code.contains("fn") || code.contains("+=") || code.contains("x"));
}

#[test]
fn test_tc_assign_tuple_unpack() {
    let code = transpile(
        r#"def swap(a: int, b: int) -> tuple[int, int]:
    a, b = b, a
    return (a, b)"#,
    );
    assert!(code.contains("fn") || code.contains("a") || code.contains("b"));
}

#[test]
fn test_tc_assign_multiple_targets() {
    let code = transpile(
        r#"def multi() -> int:
    a = b = c = 0
    return a + b + c"#,
    );
    assert!(code.contains("fn") || code.contains("let") || code.contains("0"));
}

#[test]
fn test_tc_pass_in_class() {
    let code = transpile(
        r#"class Empty:
    pass"#,
    );
    assert!(code.contains("struct Empty") || code.contains("impl") || code.contains("Empty"));
}

#[test]
fn test_tc_pass_in_function() {
    let code = transpile(
        r#"def noop() -> None:
    pass"#,
    );
    assert!(code.contains("fn noop") || code.contains("()") || code.contains("None"));
}

#[test]
fn test_tc_assert_message() {
    let code = transpile(
        r#"def check(x: int) -> None:
    assert x > 0, "x must be positive""#,
    );
    assert!(code.contains("fn") || code.contains("assert") || code.contains("panic"));
}

#[test]
fn test_tc_return_none() {
    let code = transpile(
        r#"def returns_none() -> None:
    return None"#,
    );
    assert!(code.contains("fn") || code.contains("()") || code.contains("None"));
}

#[test]
fn test_tc_return_tuple() {
    let code = transpile(
        r#"def return_tuple() -> tuple[int, str]:
    return (1, "a")"#,
    );
    assert!(code.contains("fn") || code.contains("1") || code.contains("a"));
}

#[test]
fn test_tc_expr_stmt_call() {
    let code = transpile(
        r#"def side_effect() -> None:
    print("hello")
    print("world")"#,
    );
    assert!(code.contains("fn") || code.contains("println") || code.contains("hello"));
}

// ========== BATCH 4: MORE STMT COVERAGE TESTS (Assign/Index/Attribute) ==========

#[test]
fn test_tc2_assign_index() {
    let code = transpile(
        r#"def set_item(items: list[int], i: int, val: int) -> None:
    items[i] = val"#,
    );
    assert!(code.contains("fn") || code.contains("items") || code.contains("val"));
}

#[test]
fn test_tc2_assign_dict_key() {
    let code = transpile(
        r#"def set_key(d: dict[str, int], key: str, val: int) -> None:
    d[key] = val"#,
    );
    assert!(code.contains("fn") || code.contains("insert") || code.contains("key"));
}

#[test]
fn test_tc2_assign_attribute() {
    let code = transpile(
        r#"class Point:
    x: int
    y: int
    def set_x(self, val: int) -> None:
        self.x = val"#,
    );
    assert!(code.contains("struct Point") || code.contains("self") || code.contains("x"));
}

#[test]
fn test_tc2_assign_slice() {
    let code = transpile(
        r#"def set_range(items: list[int], vals: list[int]) -> None:
    items[1:3] = vals"#,
    );
    assert!(code.contains("fn") || code.contains("items") || code.contains("splice"));
}

#[test]
fn test_tc2_for_range_step() {
    let code = transpile(
        r#"def every_other(n: int) -> list[int]:
    result = []
    for i in range(0, n, 2):
        result.append(i)
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("step") || code.contains("2"));
}

#[test]
fn test_tc2_for_reversed() {
    let code = transpile(
        r#"def rev(items: list[int]) -> list[int]:
    result = []
    for x in reversed(items):
        result.append(x)
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("rev") || code.contains("Vec"));
}

#[test]
fn test_tc2_for_sorted() {
    let code = transpile(
        r#"def sort_items(items: list[int]) -> list[int]:
    result = []
    for x in sorted(items):
        result.append(x)
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("sort") || code.contains("Vec"));
}

#[test]
fn test_tc2_for_dict_items() {
    let code = transpile(
        r#"def dict_pairs(d: dict[str, int]) -> list[tuple[str, int]]:
    result = []
    for k, v in d.items():
        result.append((k, v))
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("items") || code.contains("iter"));
}

#[test]
fn test_tc2_for_dict_keys() {
    let code = transpile(
        r#"def dict_keys_list(d: dict[str, int]) -> list[str]:
    result = []
    for k in d.keys():
        result.append(k)
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("keys") || code.contains("Vec"));
}

#[test]
fn test_tc2_for_dict_values() {
    let code = transpile(
        r#"def dict_vals(d: dict[str, int]) -> list[int]:
    result = []
    for v in d.values():
        result.append(v)
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("values") || code.contains("Vec"));
}

#[test]
fn test_tc2_list_comp_filter() {
    let code = transpile(
        r#"def filter_pos(items: list[int]) -> list[int]:
    return [x for x in items if x > 0]"#,
    );
    assert!(code.contains("fn") || code.contains("filter") || code.contains("Vec"));
}

#[test]
fn test_tc2_dict_comp() {
    let code = transpile(
        r#"def square_dict(n: int) -> dict[int, int]:
    return {i: i*i for i in range(n)}"#,
    );
    assert!(code.contains("fn") || code.contains("collect") || code.contains("HashMap"));
}

#[test]
fn test_tc2_set_comp() {
    let code = transpile(
        r#"def unique_squares(items: list[int]) -> set[int]:
    return {x*x for x in items}"#,
    );
    assert!(code.contains("fn") || code.contains("HashSet") || code.contains("collect"));
}

#[test]
fn test_tc2_gen_expr() {
    let code = transpile(
        r#"def sum_squares(n: int) -> int:
    return sum(x*x for x in range(n))"#,
    );
    assert!(code.contains("fn") || code.contains("sum") || code.contains("map"));
}

#[test]
fn test_tc2_nested_loops() {
    let code = transpile(
        r#"def matrix_sum(m: list[list[int]]) -> int:
    total = 0
    for row in m:
        for val in row:
            total += val
    return total"#,
    );
    assert!(code.contains("fn") || code.contains("for") || code.contains("total"));
}

#[test]
fn test_tc2_labeled_break() {
    let code = transpile(
        r#"def find_2d(m: list[list[int]], target: int) -> tuple[int, int]:
    for i, row in enumerate(m):
        for j, val in enumerate(row):
            if val == target:
                return (i, j)
    return (-1, -1)"#,
    );
    assert!(code.contains("fn") || code.contains("enumerate") || code.contains("for"));
}

#[test]
fn test_tc2_try_return_negative() {
    let code = transpile(
        r#"def safe_int(s: str) -> int:
    try:
        return int(s)
    except ValueError:
        return -1"#,
    );
    assert!(code.contains("fn") || code.contains("parse") || code.contains("-1"));
}

#[test]
fn test_tc2_try_return_float_negative() {
    let code = transpile(
        r#"def safe_float(s: str) -> float:
    try:
        return float(s)
    except ValueError:
        return -1.0"#,
    );
    assert!(code.contains("fn") || code.contains("parse") || code.contains("-1"));
}

#[test]
fn test_tc2_context_manager_var() {
    let code = transpile(
        r#"def read_lines(path: str) -> list[str]:
    result = []
    with open(path) as f:
        for line in f:
            result.append(line.strip())
    return result"#,
    );
    assert!(code.contains("fn") || code.contains("File") || code.contains("lines"));
}

#[test]
fn test_tc2_if_walrus() {
    let code = transpile(
        r#"def check_len(s: str) -> bool:
    if (n := len(s)) > 10:
        return True
    return False"#,
    );
    assert!(code.contains("fn") || code.contains("len") || code.contains("n"));
}

#[test]
fn test_tc2_while_walrus() {
    let code = transpile(
        r#"def read_chunks(data: str) -> list[str]:
    chunks = []
    i = 0
    while (chunk := data[i:i+10]):
        chunks.append(chunk)
        i += 10
    return chunks"#,
    );
    assert!(code.contains("fn") || code.contains("while") || code.contains("chunk"));
}

// ========== BATCH 5: EXPR STMT AND RETURN VARIATIONS ==========

#[test]
fn test_tc3_return_list() {
    let code = transpile(
        r#"def make_list() -> list[int]:
    return [1, 2, 3]"#,
    );
    assert!(code.contains("fn") || code.contains("vec!") || code.contains("Vec"));
}

#[test]
fn test_tc3_return_dict() {
    let code = transpile(
        r#"def make_dict() -> dict[str, int]:
    return {"a": 1, "b": 2}"#,
    );
    assert!(code.contains("fn") || code.contains("HashMap") || code.contains("insert"));
}

#[test]
fn test_tc3_return_set() {
    let code = transpile(
        r#"def make_set() -> set[int]:
    return {1, 2, 3}"#,
    );
    assert!(code.contains("fn") || code.contains("HashSet") || code.contains("insert"));
}

#[test]
fn test_tc3_return_conditional() {
    let code = transpile(
        r#"def ternary(x: int) -> str:
    return "yes" if x > 0 else "no""#,
    );
    assert!(code.contains("fn") || code.contains("if") || code.contains("yes"));
}

#[test]
fn test_tc3_method_chain() {
    let code = transpile(
        r#"def process(s: str) -> str:
    return s.strip().lower().replace("a", "b")"#,
    );
    assert!(code.contains("fn") || code.contains("trim") || code.contains("replace"));
}

#[test]
fn test_tc3_lambda_in_map() {
    let code = transpile(
        r#"def double_all(items: list[int]) -> list[int]:
    return list(map(lambda x: x * 2, items))"#,
    );
    assert!(code.contains("fn") || code.contains("map") || code.contains("*"));
}

#[test]
fn test_tc3_lambda_in_filter() {
    let code = transpile(
        r#"def positives(items: list[int]) -> list[int]:
    return list(filter(lambda x: x > 0, items))"#,
    );
    assert!(code.contains("fn") || code.contains("filter") || code.contains("0"));
}

#[test]
fn test_tc3_lambda_in_sorted() {
    let code = transpile(
        r#"def sort_by_len(items: list[str]) -> list[str]:
    return sorted(items, key=lambda x: len(x))"#,
    );
    assert!(code.contains("fn") || code.contains("sort") || code.contains("len"));
}

#[test]
fn test_tc3_fstring_expr() {
    let code = transpile(
        r#"def format_val(x: int) -> str:
    return f"Value: {x + 1}""#,
    );
    assert!(code.contains("fn") || code.contains("format!") || code.contains("Value"));
}

#[test]
fn test_tc3_fstring_multi() {
    let code = transpile(
        r#"def format_multi(a: int, b: str) -> str:
    return f"a={a}, b={b}""#,
    );
    assert!(code.contains("fn") || code.contains("format!") || code.contains("a"));
}

#[test]
fn test_tc3_string_join() {
    let code = transpile(
        r#"def join_items(items: list[str]) -> str:
    return ", ".join(items)"#,
    );
    assert!(code.contains("fn") || code.contains("join") || code.contains(","));
}

#[test]
fn test_tc3_string_split() {
    let code = transpile(
        r#"def split_lines(text: str) -> list[str]:
    return text.split("\n")"#,
    );
    assert!(code.contains("fn") || code.contains("split") || code.contains("Vec"));
}

#[test]
fn test_tc3_string_format() {
    let code = transpile(
        r#"def old_format(x: int) -> str:
    return "Value: %d" % x"#,
    );
    assert!(code.contains("fn") || code.contains("format!") || code.contains("Value"));
}

#[test]
fn test_tc3_bool_ops_complex() {
    let code = transpile(
        r#"def complex_bool(a: bool, b: bool, c: bool) -> bool:
    return (a and b) or (not c and a)"#,
    );
    assert!(code.contains("fn") || code.contains("&&") || code.contains("||"));
}

#[test]
fn test_tc3_comparison_chain() {
    let code = transpile(
        r#"def in_range(x: int) -> bool:
    return 0 <= x < 100"#,
    );
    assert!(code.contains("fn") || code.contains("0") || code.contains("100"));
}

#[test]
fn test_tc3_is_none_check() {
    let code = transpile(
        r#"def is_null(x: int | None) -> bool:
    return x is None"#,
    );
    assert!(code.contains("fn") || code.contains("None") || code.contains("is_none"));
}

#[test]
fn test_tc3_is_not_none_check() {
    let code = transpile(
        r#"def is_not_null(x: int | None) -> bool:
    return x is not None"#,
    );
    assert!(code.contains("fn") || code.contains("None") || code.contains("is_some"));
}

#[test]
fn test_tc3_in_list_check() {
    let code = transpile(
        r#"def contains(items: list[int], x: int) -> bool:
    return x in items"#,
    );
    assert!(code.contains("fn") || code.contains("contains") || code.contains("items"));
}

#[test]
fn test_tc3_not_in_check() {
    let code = transpile(
        r#"def not_contains(items: list[int], x: int) -> bool:
    return x not in items"#,
    );
    assert!(code.contains("fn") || code.contains("contains") || code.contains("!"));
}

// ========== BATCH 6: SPECIAL PATTERNS AND EDGE CASES ==========

#[test]
fn test_tc4_global_var() {
    let code = transpile(
        r#"counter = 0
def increment() -> int:
    global counter
    counter += 1
    return counter"#,
    );
    assert!(code.contains("fn") || code.contains("counter") || code.contains("static"));
}

#[test]
fn test_tc4_nonlocal_var() {
    let code = transpile(
        r#"def outer() -> int:
    count = 0
    def inner() -> None:
        nonlocal count
        count += 1
    inner()
    return count"#,
    );
    assert!(code.contains("fn") || code.contains("count") || code.contains("outer"));
}

#[test]
fn test_tc4_delete_stmt() {
    let code = transpile(
        r#"def remove_key(d: dict[str, int], key: str) -> None:
    del d[key]"#,
    );
    assert!(code.contains("fn") || code.contains("remove") || code.contains("key"));
}

#[test]
fn test_tc4_starred_assign() {
    let code = transpile(
        r#"def head_tail(items: list[int]) -> tuple[int, list[int]]:
    head, *tail = items
    return (head, tail)"#,
    );
    assert!(code.contains("fn") || code.contains("head") || code.contains("tail"));
}

#[test]
fn test_tc4_match_simple() {
    let code = transpile(
        r#"def describe(x: int) -> str:
    match x:
        case 0:
            return "zero"
        case 1:
            return "one"
        case _:
            return "other""#,
    );
    assert!(code.contains("fn") || code.contains("match") || code.contains("zero"));
}

#[test]
fn test_tc4_match_tuple() {
    let code = transpile(
        r#"def match_tuple(p: tuple[int, int]) -> str:
    match p:
        case (0, 0):
            return "origin"
        case (x, 0):
            return "x-axis"
        case (0, y):
            return "y-axis"
        case _:
            return "other""#,
    );
    assert!(code.contains("fn") || code.contains("match") || code.contains("origin"));
}

#[test]
fn test_tc4_async_def() {
    let code = transpile(
        r#"async def fetch(url: str) -> str:
    return url"#,
    );
    assert!(code.contains("async fn") || code.contains("fn fetch") || code.contains("url"));
}

#[test]
fn test_tc4_await_expr() {
    let code = transpile(
        r#"async def get_data(url: str) -> str:
    result = await fetch(url)
    return result"#,
    );
    assert!(code.contains("async") || code.contains("fn") || code.contains("await"));
}

#[test]
fn test_tc4_yield_expr() {
    let code = transpile(
        r#"def generate(n: int):
    for i in range(n):
        yield i"#,
    );
    assert!(code.contains("fn") || code.contains("Iterator") || code.contains("yield"));
}

#[test]
fn test_tc4_yield_from() {
    let code = transpile(
        r#"def chain(a: list[int], b: list[int]):
    yield from a
    yield from b"#,
    );
    assert!(code.contains("fn") || code.contains("Iterator") || code.contains("chain"));
}

#[test]
fn test_tc4_class_property() {
    let code = transpile(
        r#"class Circle:
    def __init__(self, radius: float):
        self._radius = radius

    @property
    def radius(self) -> float:
        return self._radius

    @radius.setter
    def radius(self, value: float) -> None:
        self._radius = value"#,
    );
    assert!(code.contains("struct Circle") || code.contains("impl") || code.contains("radius"));
}

#[test]
fn test_tc4_static_method() {
    let code = transpile(
        r#"class Math:
    @staticmethod
    def add(a: int, b: int) -> int:
        return a + b"#,
    );
    assert!(code.contains("struct Math") || code.contains("impl") || code.contains("add"));
}

#[test]
fn test_tc4_class_method() {
    let code = transpile(
        r#"class Factory:
    count: int = 0

    @classmethod
    def create(cls) -> "Factory":
        cls.count += 1
        return Factory()"#,
    );
    assert!(code.contains("struct Factory") || code.contains("impl") || code.contains("create"));
}

#[test]
fn test_tc4_slots_class() {
    let code = transpile(
        r#"class Point:
    __slots__ = ["x", "y"]
    def __init__(self, x: int, y: int):
        self.x = x
        self.y = y"#,
    );
    assert!(code.contains("struct Point") || code.contains("impl") || code.contains("x"));
}

#[test]
fn test_tc4_dataclass_order() {
    let code = transpile(
        r#"from dataclasses import dataclass

@dataclass(order=True)
class Point:
    x: int
    y: int"#,
    );
    assert!(code.contains("struct Point") || code.contains("Ord") || code.contains("derive"));
}

#[test]
fn test_tc4_namedtuple() {
    let code = transpile(
        r#"from collections import namedtuple

Point = namedtuple("Point", ["x", "y"])"#,
    );
    assert!(code.contains("struct Point") || code.contains("Point") || code.contains("x"));
}

// ========== BATCH 7: TRUTHINESS AND OPTION PATTERNS ==========

#[test]
fn test_tc5_truthiness_string() {
    let code = transpile(
        r#"def check_string(s: str) -> bool:
    if s:
        return True
    return False"#,
    );
    assert!(code.contains("fn") || code.contains("is_empty") || code.contains("!"));
}

#[test]
fn test_tc5_truthiness_list() {
    let code = transpile(
        r#"def check_list(items: list[int]) -> bool:
    if items:
        return True
    return False"#,
    );
    assert!(code.contains("fn") || code.contains("is_empty") || code.contains("!"));
}

#[test]
fn test_tc5_truthiness_dict() {
    let code = transpile(
        r#"def check_dict(d: dict[str, int]) -> bool:
    if d:
        return True
    return False"#,
    );
    assert!(code.contains("fn") || code.contains("is_empty") || code.contains("!"));
}

#[test]
fn test_tc5_truthiness_int() {
    let code = transpile(
        r#"def check_int(n: int) -> bool:
    if n:
        return True
    return False"#,
    );
    assert!(code.contains("fn") || code.contains("!= 0") || code.contains("0"));
}

#[test]
fn test_tc5_option_unwrap_or() {
    let code = transpile(
        r#"def get_or_default(x: int | None) -> int:
    if x is None:
        return 0
    return x"#,
    );
    assert!(code.contains("fn") || code.contains("unwrap_or") || code.contains("0"));
}

#[test]
fn test_tc5_option_map() {
    let code = transpile(
        r#"def double_maybe(x: int | None) -> int | None:
    if x is not None:
        return x * 2
    return None"#,
    );
    assert!(code.contains("fn") || code.contains("map") || code.contains("Option"));
}

#[test]
fn test_tc5_dict_get_default() {
    let code = transpile(
        r#"def get_val(d: dict[str, int], key: str) -> int:
    return d.get(key, 0)"#,
    );
    assert!(code.contains("fn") || code.contains("unwrap_or") || code.contains("get"));
}

#[test]
fn test_tc5_dict_setdefault() {
    let code = transpile(
        r#"def ensure_key(d: dict[str, list[int]], key: str) -> list[int]:
    return d.setdefault(key, [])"#,
    );
    assert!(code.contains("fn") || code.contains("entry") || code.contains("or_insert"));
}

#[test]
fn test_tc5_list_pop() {
    let code = transpile(
        r#"def pop_last(items: list[int]) -> int:
    return items.pop()"#,
    );
    assert!(code.contains("fn") || code.contains("pop") || code.contains("unwrap"));
}

#[test]
fn test_tc5_list_pop_index() {
    let code = transpile(
        r#"def pop_first(items: list[int]) -> int:
    return items.pop(0)"#,
    );
    assert!(code.contains("fn") || code.contains("remove") || code.contains("0"));
}

// ========== BATCH 8: IO AND FILE OPERATIONS ==========

#[test]
fn test_tc6_file_write() {
    let code = transpile(
        r#"def write_file(path: str, content: str) -> None:
    with open(path, "w") as f:
        f.write(content)"#,
    );
    assert!(code.contains("fn") || code.contains("File") || code.contains("write"));
}

#[test]
fn test_tc6_file_append() {
    let code = transpile(
        r#"def append_file(path: str, content: str) -> None:
    with open(path, "a") as f:
        f.write(content)"#,
    );
    assert!(code.contains("fn") || code.contains("File") || code.contains("append"));
}

#[test]
fn test_tc6_file_readlines() {
    let code = transpile(
        r#"def read_all_lines(path: str) -> list[str]:
    with open(path) as f:
        return f.readlines()"#,
    );
    assert!(code.contains("fn") || code.contains("File") || code.contains("lines"));
}

#[test]
fn test_tc6_stdin_read() {
    let code = transpile(
        r#"import sys
def read_stdin() -> str:
    return sys.stdin.read()"#,
    );
    assert!(code.contains("fn") || code.contains("stdin") || code.contains("read"));
}

#[test]
fn test_tc6_stdout_write() {
    let code = transpile(
        r#"import sys
def write_stdout(s: str) -> None:
    sys.stdout.write(s)"#,
    );
    assert!(code.contains("fn") || code.contains("stdout") || code.contains("write"));
}

#[test]
fn test_tc6_stderr_write() {
    let code = transpile(
        r#"import sys
def write_stderr(s: str) -> None:
    sys.stderr.write(s)"#,
    );
    assert!(code.contains("fn") || code.contains("stderr") || code.contains("write"));
}

// ========== BATCH 9: MORE EDGE CASES ==========

#[test]
fn test_tc7_bytes_literal() {
    let code = transpile(
        r#"def get_bytes() -> bytes:
    return b"hello""#,
    );
    assert!(code.contains("fn") || code.contains("Vec") || code.contains("u8"));
}

#[test]
fn test_tc7_bytes_decode() {
    let code = transpile(
        r#"def decode_bytes(b: bytes) -> str:
    return b.decode("utf-8")"#,
    );
    assert!(code.contains("fn") || code.contains("from_utf8") || code.contains("String"));
}

#[test]
fn test_tc7_string_encode() {
    let code = transpile(
        r#"def encode_string(s: str) -> bytes:
    return s.encode("utf-8")"#,
    );
    assert!(code.contains("fn") || code.contains("as_bytes") || code.contains("Vec"));
}

#[test]
fn test_tc7_complex_number() {
    let code = transpile(
        r#"def add_complex() -> complex:
    return (1 + 2j) + (3 + 4j)"#,
    );
    assert!(code.contains("fn") || code.contains("Complex") || code.contains("1"));
}

#[test]
fn test_tc7_slice_step() {
    let code = transpile(
        r#"def every_other(items: list[int]) -> list[int]:
    return items[::2]"#,
    );
    assert!(code.contains("fn") || code.contains("step") || code.contains("Vec"));
}

#[test]
fn test_tc7_slice_reverse() {
    let code = transpile(
        r#"def reverse_list(items: list[int]) -> list[int]:
    return items[::-1]"#,
    );
    assert!(code.contains("fn") || code.contains("rev") || code.contains("Vec"));
}

#[test]
fn test_tc7_negative_index() {
    let code = transpile(
        r#"def get_last(items: list[int]) -> int:
    return items[-1]"#,
    );
    assert!(code.contains("fn") || code.contains("len") || code.contains("-1"));
}

#[test]
fn test_tc7_string_multiply() {
    let code = transpile(
        r#"def repeat_string(s: str, n: int) -> str:
    return s * n"#,
    );
    assert!(code.contains("fn") || code.contains("repeat") || code.contains("*"));
}

#[test]
fn test_tc7_list_multiply() {
    let code = transpile(
        r#"def repeat_list(items: list[int], n: int) -> list[int]:
    return items * n"#,
    );
    assert!(code.contains("fn") || code.contains("repeat") || code.contains("*"));
}

#[test]
fn test_tc7_list_extend() {
    let code = transpile(
        r#"def extend_list(a: list[int], b: list[int]) -> None:
    a.extend(b)"#,
    );
    assert!(code.contains("fn") || code.contains("extend") || code.contains("a"));
}

#[test]
fn test_tc7_list_insert() {
    let code = transpile(
        r#"def insert_at(items: list[int], idx: int, val: int) -> None:
    items.insert(idx, val)"#,
    );
    assert!(code.contains("fn") || code.contains("insert") || code.contains("idx"));
}

#[test]
fn test_tc7_list_remove() {
    let code = transpile(
        r#"def remove_val(items: list[int], val: int) -> None:
    items.remove(val)"#,
    );
    assert!(code.contains("fn") || code.contains("remove") || code.contains("val"));
}

#[test]
fn test_tc7_list_index() {
    let code = transpile(
        r#"def find_index(items: list[int], val: int) -> int:
    return items.index(val)"#,
    );
    assert!(code.contains("fn") || code.contains("position") || code.contains("val"));
}

#[test]
fn test_tc7_list_count() {
    let code = transpile(
        r#"def count_val(items: list[int], val: int) -> int:
    return items.count(val)"#,
    );
    assert!(code.contains("fn") || code.contains("count") || code.contains("val"));
}

#[test]
fn test_tc7_list_sort() {
    let code = transpile(
        r#"def sort_inplace(items: list[int]) -> None:
    items.sort()"#,
    );
    assert!(code.contains("fn") || code.contains("sort") || code.contains("items"));
}

#[test]
fn test_tc7_list_reverse() {
    let code = transpile(
        r#"def reverse_inplace(items: list[int]) -> None:
    items.reverse()"#,
    );
    assert!(code.contains("fn") || code.contains("reverse") || code.contains("items"));
}

#[test]
fn test_tc7_list_copy() {
    let code = transpile(
        r#"def copy_list(items: list[int]) -> list[int]:
    return items.copy()"#,
    );
    assert!(code.contains("fn") || code.contains("clone") || code.contains("copy"));
}

#[test]
fn test_tc7_list_clear() {
    let code = transpile(
        r#"def clear_list(items: list[int]) -> None:
    items.clear()"#,
    );
    assert!(code.contains("fn") || code.contains("clear") || code.contains("items"));
}

// ========== BATCH 10: DICT METHODS ==========

#[test]
fn test_tc8_dict_update() {
    let code = transpile(
        r#"def merge_dicts(a: dict[str, int], b: dict[str, int]) -> None:
    a.update(b)"#,
    );
    assert!(code.contains("fn") || code.contains("extend") || code.contains("update"));
}

#[test]
fn test_tc8_dict_pop() {
    let code = transpile(
        r#"def pop_key(d: dict[str, int], key: str) -> int:
    return d.pop(key)"#,
    );
    assert!(code.contains("fn") || code.contains("remove") || code.contains("key"));
}

#[test]
fn test_tc8_dict_popitem() {
    let code = transpile(
        r#"def pop_item(d: dict[str, int]) -> tuple[str, int]:
    return d.popitem()"#,
    );
    assert!(code.contains("fn") || code.contains("pop") || code.contains("tuple"));
}

#[test]
fn test_tc8_dict_copy() {
    let code = transpile(
        r#"def copy_dict(d: dict[str, int]) -> dict[str, int]:
    return d.copy()"#,
    );
    assert!(code.contains("fn") || code.contains("clone") || code.contains("copy"));
}

#[test]
fn test_tc8_dict_clear() {
    let code = transpile(
        r#"def clear_dict(d: dict[str, int]) -> None:
    d.clear()"#,
    );
    assert!(code.contains("fn") || code.contains("clear") || code.contains("d"));
}

#[test]
fn test_tc8_dict_fromkeys() {
    let code = transpile(
        r#"def init_dict(keys: list[str]) -> dict[str, int]:
    return dict.fromkeys(keys, 0)"#,
    );
    assert!(code.contains("fn") || code.contains("HashMap") || code.contains("0"));
}

// ========== BATCH 11: SET METHODS ==========

#[test]
fn test_tc9_set_add() {
    let code = transpile(
        r#"def add_to_set(s: set[int], val: int) -> None:
    s.add(val)"#,
    );
    assert!(code.contains("fn") || code.contains("insert") || code.contains("val"));
}

#[test]
fn test_tc9_set_remove() {
    let code = transpile(
        r#"def remove_from_set(s: set[int], val: int) -> None:
    s.remove(val)"#,
    );
    assert!(code.contains("fn") || code.contains("remove") || code.contains("val"));
}

#[test]
fn test_tc9_set_discard() {
    let code = transpile(
        r#"def discard_from_set(s: set[int], val: int) -> None:
    s.discard(val)"#,
    );
    assert!(code.contains("fn") || code.contains("remove") || code.contains("val"));
}

#[test]
fn test_tc9_set_pop() {
    let code = transpile(
        r#"def pop_from_set(s: set[int]) -> int:
    return s.pop()"#,
    );
    assert!(code.contains("fn") || code.contains("take") || code.contains("pop"));
}

#[test]
fn test_tc9_set_union() {
    let code = transpile(
        r#"def union_sets(a: set[int], b: set[int]) -> set[int]:
    return a.union(b)"#,
    );
    assert!(code.contains("fn") || code.contains("union") || code.contains("HashSet"));
}

#[test]
fn test_tc9_set_intersection() {
    let code = transpile(
        r#"def intersect_sets(a: set[int], b: set[int]) -> set[int]:
    return a.intersection(b)"#,
    );
    assert!(code.contains("fn") || code.contains("intersection") || code.contains("HashSet"));
}

#[test]
fn test_tc9_set_difference() {
    let code = transpile(
        r#"def diff_sets(a: set[int], b: set[int]) -> set[int]:
    return a.difference(b)"#,
    );
    assert!(code.contains("fn") || code.contains("difference") || code.contains("HashSet"));
}

#[test]
fn test_tc9_set_symmetric_difference() {
    let code = transpile(
        r#"def sym_diff_sets(a: set[int], b: set[int]) -> set[int]:
    return a.symmetric_difference(b)"#,
    );
    assert!(code.contains("fn") || code.contains("symmetric") || code.contains("HashSet"));
}

#[test]
fn test_tc9_set_issubset() {
    let code = transpile(
        r#"def is_subset(a: set[int], b: set[int]) -> bool:
    return a.issubset(b)"#,
    );
    assert!(code.contains("fn") || code.contains("is_subset") || code.contains("bool"));
}

#[test]
fn test_tc9_set_issuperset() {
    let code = transpile(
        r#"def is_superset(a: set[int], b: set[int]) -> bool:
    return a.issuperset(b)"#,
    );
    assert!(code.contains("fn") || code.contains("is_superset") || code.contains("bool"));
}

#[test]
fn test_tc9_set_isdisjoint() {
    let code = transpile(
        r#"def is_disjoint(a: set[int], b: set[int]) -> bool:
    return a.isdisjoint(b)"#,
    );
    assert!(code.contains("fn") || code.contains("is_disjoint") || code.contains("bool"));
}