jaclang 0.7.34__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/test-data/run-functions.test

@@ -1,1310 +0,0 @@
-# Test cases for functions and calls (compile and run)
-
-[case testCallTrivialFunction]
-def f(x: int) -> int:
-    return x
-[file driver.py]
-from native import f
-print(f(3))
-print(f(-157))
-print(f(10**20))
-print(f(-10**20))
-[out]
-3
--157
-100000000000000000000
--100000000000000000000
-
-[case testRecursiveFibonacci]
-def fib(n: int) -> int:
-    if n <= 1:
-        return 1
-    else:
-        return fib(n - 1) + fib(n - 2)
-[file driver.py]
-from native import fib
-print(fib(0))
-print(fib(1))
-print(fib(2))
-print(fib(6))
-[out]
-1
-1
-2
-13
-
-[case testNestedFunctions]
-from typing import Callable, List
-
-def a() -> Callable[[], object]:
-    def inner() -> object:
-        return None
-    return inner
-
-def b() -> Callable[[], Callable[[], str]]:
-    def first() -> Callable[[], str]:
-        def second() -> str:
-            return 'b.first.second: nested function'
-        return second
-    return first
-
-def c(num: float) -> Callable[[str], str]:
-    def inner(s: str) -> str:
-        return s + '!'
-    return inner
-
-def d(num: float) -> str:
-    def inner(s: str) -> str:
-        return s + '?'
-    a = inner('one')
-    b = inner('two')
-    return a
-
-def e() -> int:
-    return 0
-
-def f() -> int:
-    def inner() -> int:
-        return e()
-    return inner()
-
-def g() -> Callable[[], Callable[[], int]]:
-    def inner() -> Callable[[], int]:
-        return e
-    return inner
-
-def h(num: int) -> int:
-    def inner() -> int:
-        return num
-    return inner()
-
-def i() -> int:
-    num = 3
-    def inner() -> int:
-        return num
-    return inner()
-
-def j(num: int) -> int:
-    x = 1
-    y = 2
-    def inner() -> int:
-        nonlocal x
-        x = 3
-        return num + x + y
-    return inner()
-
-def k() -> int:
-    num = 3
-    def inner() -> int:
-        nonlocal num
-        num = 5
-        return num
-    return inner() + num
-
-def l() -> int:
-    num = 3
-    def inner() -> int:
-        num = 5
-        return num
-    return inner() + num
-
-def m() -> Callable[[], int]:
-    num = 1
-    def inner() -> int:
-        num += 1
-        return num
-    num += 1
-    return inner
-
-def n() -> int:
-    x = 1
-    def add_one() -> None:
-        x += 1
-    def add_two() -> None:
-        x += 2
-    add_one()
-    add_two()
-    return x
-
-def triple(a: int) -> Callable[[], Callable[[int], int]]:
-    x = 1
-    def outer() -> Callable[[int], int]:
-        nonlocal x
-        x += 1
-        x += a
-        a += 1
-        def inner(b: int) -> int:
-            x += b
-            return x
-        return inner
-    return outer
-
-def if_else(flag: int) -> str:
-    def dummy_funtion() -> str:
-        return 'if_else.dummy_function'
-
-    if flag < 0:
-        def inner() -> str:
-            return 'if_else.inner: first definition'
-    elif flag > 0:
-        def inner() -> str:
-            return 'if_else.inner: second definition'
-    else:
-        def inner() -> str:
-            return 'if_else.inner: third definition'
-    return inner()
-
-def for_loop() -> int:
-    def dummy_funtion() -> str:
-        return 'for_loop.dummy_function'
-
-    for i in range(5):
-        def inner(i: int) -> int:
-            return i
-        if i == 3:
-            return inner(i)
-    return 0
-
-def while_loop() -> int:
-    def dummy_funtion() -> str:
-        return 'while_loop.dummy_function'
-
-    i = 0
-    while i < 5:
-        def inner(i: int) -> int:
-            return i
-        if i == 3:
-            return inner(i)
-        i += 1
-    return 0
-
-def free_vars(foo: int, bar: int) -> int:
-    x = 1
-    y = 2
-    def g():  # type: ignore  # missing type annotation for testing
-        nonlocal y
-        y = 3
-        nonlocal bar
-        bar += y
-    z = 3
-    g()
-    return bar
-
-def lambdas(x: int, y: int) -> int:
-    s = lambda a, b: a + b + x + y
-    return s(1, 2)
-
-def outer() -> str:
-    return 'outer: normal function'
-
-def inner() -> str:
-    return 'inner: normal function'
-
-class A:
-    def __init__(self, x: int) -> None:
-        self.x = x
-
-    def outer(self, num: int) -> int:
-        y = 5
-        def inner() -> int:
-            return self.x + y + num
-        return inner()
-
-def o() -> int:
-    a = [0, 0]
-    b = 0
-    def b_incr() -> List[int]:
-        b += 10
-        return a
-    c = 0
-    def c_incr() -> int:
-        c += 1
-        return c
-
-    # x = 1, y = 1
-    x = y = c_incr()
-
-    # a = [2, 2], b = 20
-    b_incr()[0] = b_incr()[1] = c_incr()
-    # Should return 26.
-    return x + y + a[0] + a[1] + b
-
-global_upvar = 20
-
-toplevel_lambda = lambda x: 10 + global_upvar + x
-
-[file driver.py]
-from native import (
-    a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, triple, if_else, for_loop, while_loop,
-    free_vars, lambdas, outer, inner, A, toplevel_lambda
-)
-
-assert a()() == None
-assert b()()() == 'b.first.second: nested function'
-assert c(5.0)('c') == 'c!'
-assert d(4.0) == 'one?'
-assert e() == 0
-assert f() == 0
-assert g()()() == 0
-assert h(3) == 3
-assert i() == 3
-assert j(3) == 8
-assert k() == 10
-assert l() == 8
-assert m()() == 3
-assert n() == 4
-assert o() == 26
-
-triple_outer = triple(2)
-triple_inner = triple_outer()
-
-assert triple_inner(4) == 8
-assert triple_inner(4) == 12
-assert triple_outer()(4) == 20
-
-assert if_else(-1) == 'if_else.inner: first definition'
-assert if_else(1) == 'if_else.inner: second definition'
-assert if_else(0) == 'if_else.inner: third definition'
-
-assert for_loop() == 3
-assert while_loop() == 3
-
-assert free_vars(1, 2) == 5
-assert lambdas(3, 4) == 10
-
-assert outer() == 'outer: normal function'
-assert inner() == 'inner: normal function'
-
-assert A(3).outer(4) == 12
-
-assert toplevel_lambda(5) == 35
-
-[case testNestedFunctions2]
-from typing import Callable
-
-def outer() -> Callable[[], object]:
-    def inner() -> object:
-        return None
-    return inner
-
-def first() -> Callable[[], Callable[[], str]]:
-    def second() -> Callable[[], str]:
-        def third() -> str:
-            return 'third: nested function'
-        return third
-    return second
-
-def f1() -> int:
-        x = 1
-        def f2() -> int:
-                y = 2
-                def f3() -> int:
-                        z = 3
-                        return y
-                return f3()
-        return f2()
-
-def outer_func() -> int:
-    def inner_func() -> int:
-        return x
-    x = 1
-    return inner_func()
-
-def mutual_recursion(start : int) -> int:
-    def f1(k : int) -> int:
-        if k <= 0:
-            return 0
-        k -= 1
-        return f2(k)
-
-    def f2(k : int) -> int:
-        if k <= 0:
-            return 0
-        k -= 1
-        return f1(k)
-    return f1(start)
-
-def topLayer() -> int:
-    def middleLayer() -> int:
-        def bottomLayer() -> int:
-            return x
-
-        return bottomLayer()
-
-    x = 1
-    return middleLayer()
-
-def nest1() -> str:
-    def nest2() -> str:
-        def nest3() -> str:
-            def mut1(val: int) -> str:
-                if val <= 0:
-                    return "bottomed"
-                val -= 1
-                return mut2(val)
-            def mut2(val: int) -> str:
-                if val <= 0:
-                        return "bottomed"
-                val -= 1
-                return mut1(val)
-            return mut1(start)
-        return nest3()
-    start = 3
-    return nest2()
-
-def uno(num: float) -> Callable[[str], str]:
-    def dos(s: str) -> str:
-        return s + '!'
-    return dos
-
-def eins(num: float) -> str:
-    def zwei(s: str) -> str:
-        return s + '?'
-    a = zwei('eins')
-    b = zwei('zwei')
-    return a
-
-def call_other_inner_func(a: int) -> int:
-    def foo() -> int:
-        return a + 1
-
-    def bar() -> int:
-        return foo()
-
-    def baz(n: int) -> int:
-        if n == 0:
-            return 0
-        return n + baz(n - 1)
-
-    return bar() + baz(a)
-
-def inner() -> str:
-    return 'inner: normal function'
-
-def second() -> str:
-    return 'second: normal function'
-
-def third() -> str:
-    return 'third: normal function'
-
-[file driver.py]
-from native import (outer, inner, first, uno, eins, call_other_inner_func,
-second, third, f1, outer_func, mutual_recursion, topLayer, nest1)
-
-assert outer()() == None
-assert inner() == 'inner: normal function'
-assert first()()() == 'third: nested function'
-assert uno(5.0)('uno') == 'uno!'
-assert eins(4.0) == 'eins?'
-assert call_other_inner_func(5) == 21
-assert second() == 'second: normal function'
-assert third() == 'third: normal function'
-assert f1() == 2
-assert outer_func() == 1
-assert mutual_recursion(5) == 0
-assert topLayer() == 1
-assert nest1() == "bottomed"
-
-[case testFunctionCallWithDefaultArgs]
-from typing import Tuple, List, Optional, Callable, Any
-def f(x: int, y: int = 3, s: str = "test", z: object = 5) -> Tuple[int, str]:
-    def inner() -> int:
-        return x + y
-    return inner(), s
-def g() -> None:
-    assert f(2) == (5, "test")
-    assert f(s = "123", x = -2) == (1, "123")
-def h(a: Optional[object] = None, b: Optional[str] = None) -> Tuple[object, Optional[str]]:
-    return (a, b)
-
-def same(x: object = object()) -> object:
-    return x
-
-a_lambda: Callable[..., Any] = lambda n=20: n
-
-def nested_funcs(n: int) -> List[Callable[..., Any]]:
-    ls: List[Callable[..., Any]] = []
-    for i in range(n):
-        def f(i: int = i) -> int:
-            return i
-        ls.append(f)
-    return ls
-
-def bool_default(x: bool = False, y: bool = True) -> str:
-    return str(x) + '-' + str(y)
-
-[file driver.py]
-from native import f, g, h, same, nested_funcs, a_lambda, bool_default
-g()
-assert f(2) == (5, "test")
-assert f(s = "123", x = -2) == (1, "123")
-assert h() == (None, None)
-assert h(10) == (10, None)
-assert h(b='a') == (None, 'a')
-assert h(10, 'a') == (10, 'a')
-assert same() == same()
-
-assert [f() for f in nested_funcs(10)] == list(range(10))
-
-assert a_lambda(10) == 10
-assert a_lambda() == 20
-
-assert bool_default() == 'False-True'
-assert bool_default(True) == 'True-True'
-assert bool_default(True, False) == 'True-False'
-
-[case testMethodCallWithDefaultArgs]
-from typing import Tuple, List
-class A:
-    def f(self, x: int, y: int = 3, s: str = "test") -> Tuple[int, str]:
-        def inner() -> int:
-            return x + y
-        return inner(), s
-def g() -> None:
-    a = A()
-    assert a.f(2) == (5, "test")
-    assert a.f(s = "123", x = -2) == (1, "123")
-[file driver.py]
-from native import A, g
-g()
-a = A()
-assert a.f(2) == (5, "test")
-assert a.f(s = "123", x = -2) == (1, "123")
-
-[case testMethodCallOrdering]
-class A:
-    def __init__(self, s: str) -> None:
-        print(s)
-    def f(self, x: 'A', y: 'A') -> None:
-        pass
-
-def g() -> None:
-    A('A!').f(A('hello'), A('world'))
-[file driver.py]
-from native import g
-g()
-[out]
-A!
-hello
-world
-
-[case testPyMethodCall]
-from typing import List
-def f(x: List[int]) -> int:
-    return x.pop()
-def g(x: List[int], y: List[int]) -> None:
-    x.extend(y)
-[file driver.py]
-from native import f, g
-l = [1, 2]
-assert f(l) == 2
-g(l, [10])
-assert l == [1, 10]
-assert f(l) == 10
-assert f(l) == 1
-g(l, [11, 12])
-assert l == [11, 12]
-
-[case testMethodCallWithKeywordArgs]
-from typing import Tuple
-import testmodule
-class A:
-    def echo(self, a: int, b: int, c: int) -> Tuple[int, int, int]:
-        return a, b, c
-def test_native_method_call_with_kwargs() -> None:
-    a = A()
-    assert a.echo(1, c=3, b=2) == (1, 2, 3)
-    assert a.echo(c = 3, a = 1, b = 2) == (1, 2, 3)
-def test_module_method_call_with_kwargs() -> None:
-    a = testmodule.A()
-    assert a.echo(1, c=3, b=2) == (1, 2, 3)
-    assert a.echo(c = 3, a = 1, b = 2) == (1, 2, 3)
-[file testmodule.py]
-from typing import Tuple
-class A:
-    def echo(self, a: int, b: int, c: int) -> Tuple[int, int, int]:
-        return a, b, c
-[file driver.py]
-import native
-native.test_native_method_call_with_kwargs()
-native.test_module_method_call_with_kwargs()
-
-[case testAnyCall]
-from typing import Any
-def call(f: Any) -> Any:
-    return f(1, 'x')
-[file driver.py]
-from native import call
-def f(x, y):
-    return (x, y)
-def g(x): pass
-
-assert call(f) == (1, 'x')
-for bad in g, 1:
-    try:
-        call(bad)
-    except TypeError:
-        pass
-    else:
-        assert False, bad
-
-[case testCallableTypes]
-from typing import Callable
-def absolute_value(x: int) -> int:
-    return x if x > 0 else -x
-
-def call_native_function(x: int) -> int:
-    return absolute_value(x)
-
-def call_python_function(x: int) -> int:
-    return int(x)
-
-def return_float() -> float:
-    return 5.0
-
-def return_callable_type() -> Callable[[], float]:
-    return return_float
-
-def call_callable_type() -> float:
-    f = return_callable_type()
-    return f()
-
-def return_passed_in_callable_type(f: Callable[[], float]) -> Callable[[], float]:
-    return f
-
-def call_passed_in_callable_type(f: Callable[[], float]) -> float:
-    return f()
-
-[file driver.py]
-from native import call_native_function, call_python_function, return_float, return_callable_type, call_callable_type, return_passed_in_callable_type, call_passed_in_callable_type
-a = call_native_function(1)
-b = call_python_function(1)
-c = return_callable_type()
-d = call_callable_type()
-e = return_passed_in_callable_type(return_float)
-f = call_passed_in_callable_type(return_float)
-assert a == 1
-assert b == 1
-assert c() == 5.0
-assert d == 5.0
-assert e() == 5.0
-assert f == 5.0
-
-[case testKeywordArgs]
-from typing import Tuple
-import testmodule
-
-def g(a: int, b: int, c: int) -> Tuple[int, int, int]:
-    return a, b, c
-
-def test_call_native_function_with_keyword_args() -> None:
-    assert g(1, c = 3, b = 2) == (1, 2, 3)
-    assert g(c = 3, a = 1, b = 2) == (1, 2, 3)
-
-def test_call_module_function_with_keyword_args() -> None:
-    assert testmodule.g(1, c = 3, b = 2) == (1, 2, 3)
-    assert testmodule.g(c = 3, a = 1, b = 2) == (1, 2, 3)
-
-def test_call_python_function_with_keyword_args() -> None:
-    assert int("11", base=2) == 3
-
-def test_call_lambda_function_with_keyword_args() -> None:
-    g = testmodule.get_lambda_function()
-    assert g(1, c = 3, b = 2) == (1, 2, 3)
-    assert g(c = 3, a = 1, b = 2) == (1, 2, 3)
-
-[file testmodule.py]
-from typing import Tuple
-
-def g(a: int, b: int, c: int) -> Tuple[int, int, int]:
-    return a, b, c
-
-def get_lambda_function():
-    return (lambda a, b, c: (a, b, c))
-
-[file driver.py]
-import native
-native.test_call_native_function_with_keyword_args()
-native.test_call_module_function_with_keyword_args()
-native.test_call_python_function_with_keyword_args()
-native.test_call_lambda_function_with_keyword_args()
-
-[case testStarArgs]
-from typing import Tuple
-
-def g(a: int, b: int, c: int) -> Tuple[int, int, int]:
-    return a, b, c
-
-def test_star_args() -> None:
-    assert g(*[1, 2, 3]) == (1, 2, 3)
-    assert g(*(1, 2, 3)) == (1, 2, 3)
-    assert g(*(1,), *[2, 3]) == (1, 2, 3)
-    assert g(*(), *(1,), *(), *(2,), *(3,), *()) == (1, 2, 3)
-    assert g(*range(3)) == (0, 1, 2)
-
-[file driver.py]
-import native
-native.test_star_args()
-
-[case testStar2Args]
-from typing import Tuple
-
-def g(a: int, b: int, c: int) -> Tuple[int, int, int]:
-    return a, b, c
-
-def test_star2_args() -> None:
-    assert g(**{'a': 1, 'b': 2, 'c': 3}) == (1, 2, 3)
-    assert g(**{'c': 3, 'a': 1, 'b': 2}) == (1, 2, 3)
-    assert g(b=2, **{'a': 1, 'c': 3}) == (1, 2, 3)
-
-def test_star2_args_bad(v: dict) -> bool:
-    return g(a=1, b=2, **v) == (1, 2, 3)
-[file driver.py]
-import native
-native.test_star2_args()
-
-# this should raise TypeError due to duplicate kwarg, but currently it doesn't
-assert native.test_star2_args_bad({'b': 2, 'c': 3})
-
-[case testStarAndStar2Args]
-from typing import Tuple
-def g(a: int, b: int, c: int) -> Tuple[int, int, int]:
-    return a, b, c
-
-class C:
-    def g(self, a: int, b: int, c: int) -> Tuple[int, int, int]:
-        return a, b, c
-
-def test_star_and_star2_args() -> None:
-    assert g(1, *(2,), **{'c': 3}) == (1, 2, 3)
-    assert g(*[1], **{'b': 2, 'c': 3}) == (1, 2, 3)
-    c = C()
-    assert c.g(1, *(2,), **{'c': 3}) == (1, 2, 3)
-    assert c.g(*[1], **{'b': 2, 'c': 3}) == (1, 2, 3)
-
-[file driver.py]
-import native
-native.test_star_and_star2_args()
-
-[case testAllTheArgCombinations]
-from typing import Tuple
-def g(a: int, b: int, c: int, d: int = -1) -> Tuple[int, int, int, int]:
-    return a, b, c, d
-
-class C:
-    def g(self, a: int, b: int, c: int, d: int = -1) -> Tuple[int, int, int, int]:
-        return a, b, c, d
-
-def test_all_the_arg_combinations() -> None:
-    assert g(1, *(2,), **{'c': 3}) == (1, 2, 3, -1)
-    assert g(*[1], **{'b': 2, 'c': 3, 'd': 4}) == (1, 2, 3, 4)
-    c = C()
-    assert c.g(1, *(2,), **{'c': 3}) == (1, 2, 3, -1)
-    assert c.g(*[1], **{'b': 2, 'c': 3, 'd': 4}) == (1, 2, 3, 4)
-
-[file driver.py]
-import native
-native.test_all_the_arg_combinations()
-
-[case testOverloads]
-from typing import overload, Union, Tuple
-
-@overload
-def foo(x: int) -> int: ...
-
-@overload
-def foo(x: str) -> str: ...
-
-def foo(x: Union[int, str]) -> Union[int, str]:
-    return x
-
-class A:
-    @overload
-    def foo(self, x: int) -> int: ...
-
-    @overload
-    def foo(self, x: str) -> str: ...
-
-    def foo(self, x: Union[int, str]) -> Union[int, str]:
-        return x
-
-def call1() -> Tuple[int, str]:
-    return (foo(10), foo('10'))
-def call2() -> Tuple[int, str]:
-    x = A()
-    return (x.foo(10), x.foo('10'))
-
-[file driver.py]
-from native import *
-assert call1() == (10, '10')
-assert call2() == (10, '10')
-
-[case testDecorators1]
-from typing import Generator, Callable, Iterator
-from contextlib import contextmanager
-
-def a(f: Callable[[], None]) -> Callable[[], None]:
-    def g() -> None:
-        print('Entering')
-        f()
-        print('Exited')
-    return g
-
-def b(f: Callable[[], None]) -> Callable[[], None]:
-    def g() -> None:
-        print('***')
-        f()
-        print('***')
-    return g
-
-@contextmanager
-def foo() -> Iterator[int]:
-    try:
-        print('started')
-        yield 0
-    finally:
-        print('finished')
-
-@contextmanager
-def catch() -> Iterator[None]:
-    try:
-        print('started')
-        yield
-    except IndexError:
-        print('index')
-        raise
-    except Exception:
-        print('lol')
-
-def thing() -> None:
-    c()
-
-@a
-@b
-def c() -> None:
-    @a
-    @b
-    def d() -> None:
-        print('d')
-    print('c')
-    d()
-
-def hm() -> None:
-    x = [1]
-    with catch():
-        x[2]
-
-[file driver.py]
-from native import foo, c, thing, hm
-
-with foo() as f:
-    print('hello')
-
-c()
-thing()
-print('==')
-try:
-    hm()
-except IndexError:
-    pass
-else:
-    assert False
-
-[out]
-started
-hello
-finished
-Entering
-***
-c
-Entering
-***
-d
-***
-Exited
-***
-Exited
-Entering
-***
-c
-Entering
-***
-d
-***
-Exited
-***
-Exited
-==
-started
-index
-
-[case testDecoratorsMethods]
-from typing import Any, Callable, Iterator, TypeVar
-from contextlib import contextmanager
-
-T = TypeVar('T')
-def dec(f: T) -> T:
-    return f
-
-def a(f: Callable[[Any], None]) -> Callable[[Any], None]:
-    def g(a: Any) -> None:
-        print('Entering')
-        f(a)
-        print('Exited')
-    return g
-
-class A:
-    @a
-    def foo(self) -> None:
-        print('foo')
-
-    @contextmanager
-    def generator(self) -> Iterator[int]:
-        try:
-            print('contextmanager: entering')
-            yield 0
-        finally:
-            print('contextmanager: exited')
-
-class Lol:
-    @staticmethod
-    def foo() -> None:
-        Lol.bar()
-        Lol.baz()
-
-    @staticmethod
-    @dec
-    def bar() -> None:
-        pass
-
-    @classmethod
-    @dec
-    def baz(cls) -> None:
-        pass
-
-def inside() -> None:
-    with A().generator() as g:
-        print('hello!')
-
-with A().generator() as g:
-    print('hello!')
-
-def lol() -> None:
-    with A().generator() as g:
-        raise Exception
-
-[file driver.py]
-from native import A, lol
-
-A.foo(A())
-A().foo()
-with A().generator() as g:
-    print('hello!')
-try:
-    lol()
-except:
-    pass
-else:
-    assert False
-
-[out]
-contextmanager: entering
-hello!
-contextmanager: exited
-Entering
-foo
-Exited
-Entering
-foo
-Exited
-contextmanager: entering
-hello!
-contextmanager: exited
-contextmanager: entering
-contextmanager: exited
-
-[case testUnannotatedFunction]
-def g(x: int) -> int:
-    return x * 2
-
-def f(x):
-    return g(x)
-[file driver.py]
-from native import f
-assert f(3) == 6
-
-[case testUnannotatedModuleLevelInitFunction]
-# Ensure that adding an implicit `-> None` annotation only applies to `__init__`
-# _methods_ specifically (not module-level `__init__` functions).
-def __init__():
-    return 42
-[file driver.py]
-from native import __init__
-assert __init__() == 42
-
-[case testDifferentArgCountsFromInterpreted]
-# Test various signatures from interpreted code.
-def noargs() -> int:
-    return 5
-
-def onearg(x: int) -> int:
-    return x + 1
-
-def twoargs(x: int, y: str) -> int:
-    return x + len(y)
-
-def one_or_two(x: int, y: str = 'a') -> int:
-    return x + len(y)
-
-[file driver.py]
-from native import noargs, onearg, twoargs, one_or_two
-from testutil import assertRaises
-
-assert noargs() == 5
-t = ()
-assert noargs(*t) == 5
-d = {}
-assert noargs(**d) == 5
-assert noargs(*t, **d) == 5
-
-assert onearg(12) == 13
-assert onearg(x=8) == 9
-t = (1,)
-assert onearg(*t) == 2
-d = {'x': 5}
-assert onearg(**d) == 6
-
-# Test a bogus call to twoargs before any correct calls are made
-with assertRaises(TypeError, "twoargs() missing required argument 'x' (pos 1)"):
-    twoargs()
-
-assert twoargs(5, 'foo') == 8
-assert twoargs(4, y='foo') == 7
-assert twoargs(y='foo', x=7) == 10
-t = (1, 'xy')
-assert twoargs(*t) == 3
-d = {'y': 'xy'}
-assert twoargs(2, **d) == 4
-
-assert one_or_two(5) == 6
-assert one_or_two(x=3) == 4
-assert one_or_two(6, 'xy') == 8
-assert one_or_two(7, y='xy') == 9
-assert one_or_two(y='xy', x=2) == 4
-assert one_or_two(*t) == 3
-d = {'x': 5}
-assert one_or_two(**d) == 6
-assert one_or_two(y='xx', **d) == 7
-d = {'y': 'abc'}
-assert one_or_two(1, **d) == 4
-
-with assertRaises(TypeError, 'noargs() takes at most 0 arguments (1 given)'):
-    noargs(1)
-with assertRaises(TypeError, 'noargs() takes at most 0 keyword arguments (1 given)'):
-    noargs(x=1)
-
-with assertRaises(TypeError, "onearg() missing required argument 'x' (pos 1)"):
-    onearg()
-with assertRaises(TypeError, 'onearg() takes at most 1 argument (2 given)'):
-    onearg(1, 2)
-with assertRaises(TypeError, "onearg() missing required argument 'x' (pos 1)"):
-    onearg(y=1)
-with assertRaises(TypeError, "onearg() takes at most 1 argument (2 given)"):
-    onearg(1, y=1)
-
-with assertRaises(TypeError, "twoargs() missing required argument 'x' (pos 1)"):
-    twoargs()
-with assertRaises(TypeError, "twoargs() missing required argument 'y' (pos 2)"):
-    twoargs(1)
-with assertRaises(TypeError, 'twoargs() takes at most 2 arguments (3 given)'):
-    twoargs(1, 'x', 2)
-with assertRaises(TypeError, 'twoargs() takes at most 2 arguments (3 given)'):
-    twoargs(1, 'x', y=2)
-
-with assertRaises(TypeError, "one_or_two() missing required argument 'x' (pos 1)"):
-    one_or_two()
-with assertRaises(TypeError, 'one_or_two() takes at most 2 arguments (3 given)'):
-    one_or_two(1, 'x', 2)
-with assertRaises(TypeError, 'one_or_two() takes at most 2 arguments (3 given)'):
-    one_or_two(1, 'x', y=2)
-
-[case testComplicatedArgs]
-from typing import Tuple, Dict
-
-def kwonly1(x: int = 0, *, y: int) -> Tuple[int, int]:
-    return x, y
-
-def kwonly2(*, x: int = 0, y: int) -> Tuple[int, int]:
-    return x, y
-
-def kwonly3(a: int, b: int = 0, *, y: int, x: int = 1) -> Tuple[int, int, int, int]:
-    return a, b, x, y
-
-def kwonly4(*, x: int, y: int) -> Tuple[int, int]:
-    return x, y
-
-def varargs1(*args: int) -> Tuple[int, ...]:
-    return args
-
-def varargs2(*args: int, **kwargs: int) -> Tuple[Tuple[int, ...], Dict[str, int]]:
-    return args, kwargs
-
-def varargs3(**kwargs: int) -> Dict[str, int]:
-    return kwargs
-
-def varargs4(a: int, b: int = 0,
-             *args: int, y: int, x: int = 1,
-             **kwargs: int) -> Tuple[Tuple[int, ...], Dict[str, int]]:
-    return (a, b, *args), {'x': x, 'y': y, **kwargs}
-
-class A:
-    def f(self, x: int) -> Tuple[int, ...]:
-        return (x,)
-    def g(self, x: int) -> Tuple[Tuple[int, ...], Dict[str, int]]:
-        return (x,), {}
-
-class B(A):
-    def f(self, *args: int) -> Tuple[int, ...]:
-        return args
-    def g(self, *args: int, **kwargs: int) -> Tuple[Tuple[int, ...], Dict[str, int]]:
-        return args, kwargs
-
-[file other.py]
-# This file is imported in both compiled and interpreted mode in order to
-# test both native calls and calls via the C API.
-
-from native import (
-    kwonly1, kwonly2, kwonly3, kwonly4,
-    varargs1, varargs2, varargs3, varargs4,
-    A, B
-)
-
-# kwonly arg tests
-assert kwonly1(10, y=20) == (10, 20)
-assert kwonly1(y=20) == (0, 20)
-
-assert kwonly2(x=10, y=20) == (10, 20)
-assert kwonly2(y=20) == (0, 20)
-
-assert kwonly3(10, y=20) == (10, 0, 1, 20)
-assert kwonly3(a=10, y=20) == (10, 0, 1, 20)
-assert kwonly3(10, 30, y=20) == (10, 30, 1, 20)
-assert kwonly3(10, b=30, y=20) == (10, 30, 1, 20)
-assert kwonly3(a=10, b=30, y=20) == (10, 30, 1, 20)
-
-assert kwonly3(10, x=40, y=20) == (10, 0, 40, 20)
-assert kwonly3(a=10, x=40, y=20) == (10, 0, 40, 20)
-assert kwonly3(10, 30, x=40, y=20) == (10, 30, 40, 20)
-assert kwonly3(10, b=30, x=40, y=20) == (10, 30, 40, 20)
-assert kwonly3(a=10, b=30, x=40, y=20) == (10, 30, 40, 20)
-
-assert kwonly4(x=1, y=2) == (1, 2)
-assert kwonly4(y=2, x=1) == (1, 2)
-
-# varargs tests
-assert varargs1() == ()
-assert varargs1(1, 2, 3) == (1, 2, 3)
-assert varargs1(1, *[2, 3, 4], 5, *[6, 7, 8], 9) == (1, 2, 3, 4, 5, 6, 7, 8, 9)
-assert varargs2(1, 2, 3) == ((1, 2, 3), {})
-assert varargs2(1, 2, 3, x=4) == ((1, 2, 3), {'x': 4})
-assert varargs2(x=4) == ((), {'x': 4})
-assert varargs3() == {}
-assert varargs3(x=4) == {'x': 4}
-assert varargs3(x=4, y=5) == {'x': 4, 'y': 5}
-
-assert varargs4(-1, y=2) == ((-1, 0), {'x': 1, 'y': 2})
-assert varargs4(-1, 2, y=2) == ((-1, 2), {'x': 1, 'y': 2})
-assert varargs4(-1, 2, 3, y=2) == ((-1, 2, 3), {'x': 1, 'y': 2})
-assert varargs4(-1, 2, 3, x=10, y=2) == ((-1, 2, 3), {'x': 10, 'y': 2})
-assert varargs4(-1, x=10, y=2) == ((-1, 0), {'x': 10, 'y': 2})
-assert varargs4(-1, y=2, z=20) == ((-1, 0), {'x': 1, 'y': 2, 'z': 20})
-assert varargs4(-1, 2, y=2, z=20) == ((-1, 2), {'x': 1, 'y': 2, 'z': 20})
-assert varargs4(-1, 2, 3, y=2, z=20) == ((-1, 2, 3), {'x': 1, 'y': 2, 'z': 20})
-assert varargs4(-1, 2, 3, x=10, y=2, z=20) == ((-1, 2, 3), {'x': 10, 'y': 2, 'z': 20})
-assert varargs4(-1, x=10, y=2, z=20) == ((-1, 0), {'x': 10, 'y': 2, 'z': 20})
-
-x = B()  # type: A
-assert x.f(1) == (1,)
-assert x.g(1) == ((1,), {})
-# This one is really funny! When we make native calls we lose
-# track of which arguments are positional or keyword, so the glue
-# calls them all positional unless they are keyword only...
-# It would be possible to fix this by dynamically tracking which
-# arguments were passed by keyword (for example, by passing a bitmask
-# to functions indicating this), but paying a speed, size, and complexity
-# cost for something so deeply marginal seems like a bad choice.
-# assert x.g(x=1) == ((), {'x': 1})
-
-[file driver.py]
-from testutil import assertRaises
-from native import (
-    kwonly1, kwonly2, kwonly3, kwonly4,
-    varargs1, varargs2, varargs3, varargs4,
-)
-
-# Run the non-exceptional tests in both interpreted and compiled mode
-import other
-import other_interpreted
-
-
-# And the tests for errors at the interfaces in interpreted only
-with assertRaises(TypeError, "missing required keyword-only argument 'y'"):
-    kwonly1()
-with assertRaises(TypeError, "takes at most 1 positional argument (2 given)"):
-    kwonly1(10, 20)
-
-with assertRaises(TypeError, "missing required keyword-only argument 'y'"):
-    kwonly2()
-with assertRaises(TypeError, "takes no positional arguments"):
-    kwonly2(10, 20)
-
-with assertRaises(TypeError, "missing required argument 'a'"):
-    kwonly3(b=30, x=40, y=20)
-with assertRaises(TypeError, "missing required keyword-only argument 'y'"):
-    kwonly3(10)
-
-with assertRaises(TypeError, "missing required keyword-only argument 'y'"):
-    kwonly4(x=1)
-with assertRaises(TypeError, "missing required keyword-only argument 'x'"):
-    kwonly4(y=1)
-with assertRaises(TypeError, "missing required keyword-only argument 'x'"):
-    kwonly4()
-
-with assertRaises(TypeError, "'x' is an invalid keyword argument for varargs1()"):
-    varargs1(x=10)
-with assertRaises(TypeError, "'x' is an invalid keyword argument for varargs1()"):
-    varargs1(1, x=10)
-with assertRaises(TypeError, "varargs3() takes no positional arguments"):
-    varargs3(10)
-with assertRaises(TypeError, "varargs3() takes no positional arguments"):
-    varargs3(10, x=10)
-
-with assertRaises(TypeError, "varargs4() missing required argument 'a' (pos 1)"):
-    varargs4()
-with assertRaises(TypeError, "varargs4() missing required keyword-only argument 'y'"):
-    varargs4(1, 2)
-with assertRaises(TypeError, "varargs4() missing required keyword-only argument 'y'"):
-    varargs4(1, 2, x=1)
-with assertRaises(TypeError, "varargs4() missing required keyword-only argument 'y'"):
-    varargs4(1, 2, 3)
-with assertRaises(TypeError, "varargs4() missing required argument 'a' (pos 1)"):
-    varargs4(y=20)
-
-[case testDecoratorName]
-def dec(f): return f
-
-@dec
-def foo(): pass
-
-def test_decorator_name():
-    assert foo.__name__ == "foo"
-
-[case testLambdaArgToOverloaded]
-from lib import sub
-
-def test_str_overload() -> None:
-    assert sub('x', lambda m: m) == 'x'
-
-def test_bytes_overload() -> None:
-    assert sub(b'x', lambda m: m) == b'x'
-
-[file lib.py]
-from typing import overload, Callable, TypeVar, Generic
-
-T = TypeVar("T")
-
-class Match(Generic[T]):
-    def __init__(self, x: T) -> None:
-        self.x = x
-
-    def group(self, n: int) -> T:
-        return self.x
-
-@overload
-def sub(s: str, f: Callable[[str], str]) -> str: ...
-@overload
-def sub(s: bytes, f: Callable[[bytes], bytes]) -> bytes: ...
-def sub(s, f):
-    return f(s)
-
-[case testContextManagerSpecialCase]
-from typing import Generator, Callable, Iterator
-from contextlib import contextmanager
-
-@contextmanager
-def f() -> Iterator[None]:
-    yield
-
-def g() -> None:
-    a = ['']
-    with f():
-        a.pop()
-
-g()
-
-[case testUnpackKwargsCompiled]
-from typing_extensions import Unpack, TypedDict
-
-class Person(TypedDict):
-    name: str
-    age: int
-
-def foo(**kwargs: Unpack[Person]) -> None:
-    print(kwargs["name"])
-
-# This is not really supported yet, just test that we behave reasonably.
-foo(name='Jennifer', age=38)
-[out]
-Jennifer
-
-[case testNestedFunctionDunderDict312]
-import sys
-
-def foo() -> None:
-    def inner() -> str: return "bar"
-    print(inner.__dict__)  # type: ignore[attr-defined]
-    inner.__dict__.update({"x": 1})  # type: ignore[attr-defined]
-    print(inner.__dict__)  # type: ignore[attr-defined]
-    print(inner.x)  # type: ignore[attr-defined]
-
-if sys.version_info >= (3, 12):  # type: ignore
-    foo()
-[out]
-[out version>=3.12]
-{}
-{'x': 1}
-1
-
-[case testFunctoolsUpdateWrapper]
-import functools
-
-def bar() -> None:
-    def inner() -> str: return "bar"
-    functools.update_wrapper(inner, bar)  # type: ignore
-    print(inner.__dict__)  # type: ignore
-
-bar()
-[out]
-{'__module__': 'native', '__name__': 'bar', '__qualname__': 'bar', '__doc__': None, '__wrapped__': <built-in function bar>}
-
-[case testCallNestedFunctionWithNamed]
-def f() -> None:
-    def a() -> None:
-        pass
-    def b() -> None:
-        a()
-    b()
-[file driver.py]
-from native import f
-f()
-
-[case testCallNestedFunctionWithLambda]
-def f(x: int) -> int:
-    def inc(x: int) -> int:
-        return x + 1
-    return (lambda x: inc(x))(1)
-[file driver.py]
-from native import f
-print(f(1))
-[out]
-2