import t
import stdio
import testcheck

# Test 1: generic function with explicit type arg - basic call
# def xxx[T](x: int) then call xxx[T](x)
def double[T](x: int) -> int:
    return x * 2

def test_explicit_type_arg():
    testcheck.section("Test 1: explicit type arg xxx[T](x)")
    r: int = double[int](21)
    testcheck.check(r == 42, "double[t.CInt](21) = 42", "expect 42")

# Test 2: generic function with explicit type arg - multiple call types
def identity[T](x: int) -> int:
    return x

def test_identity_explicit():
    testcheck.section("Test 2: identity[T](x)")
    r1: int = identity[int](10)
    r2: int = identity[int](20)
    testcheck.check(r1 == 10 and r2 == 20, "identity[t.CInt](10)=10 (20)=20", "expect 10 20")

# Test 3: generic function with explicit type arg - T as parameter type
def add_one[T](x: T) -> T:
    return x + T(1)

def test_add_one_explicit():
    testcheck.section("Test 3: add_one[T](x) with T param")
    r: int = add_one[int](41)
    testcheck.check(r == 42, "add_one[t.CInt](41) = 42", "expect 42")

# Test 4: generic function with explicit type arg - mixed inference
def test_mixed_inference_explicit():
    testcheck.section("Test 4: mixed inference and explicit")
    # Inferred
    r1: int = add_one(99)
    # Explicit
    r2: int = add_one[int](99)
    testcheck.check(r1 == 100 and r2 == 100, "add_one(99)=100 add_one[t.CInt](99)=100", "expect 100 100")

def main() -> int:
    testcheck.begin("GenericTest3: 手动传类型参数 xxx[T](x)")
    test_explicit_type_arg()
    test_identity_explicit()
    test_add_one_explicit()
    test_mixed_inference_explicit()
    return testcheck.end()