jaclang 0.6.1__py3-none-any.whl → 0.6.5__py3-none-any.whl

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

@@ -0,0 +1,1170 @@
+[case testMaybeUninitVar]
+class C:
+    def __init__(self, x: int) -> None:
+        self.x = x
+
+def f(b: bool) -> None:
+    u = C(1)
+    while b:
+        v = C(2)
+        if v is not u:
+            break
+    print(v.x)
+[file driver.py]
+from native import f
+f(True)
+[out]
+2
+
+[case testUninitBoom]
+def f(a: bool, b: bool) -> None:
+    if a:
+        x = 'lol'
+    if b:
+        print(x)
+
+def g() -> None:
+    try:
+        [0][1]
+        y = 1
+    except Exception:
+        pass
+    print(y)
+
+[file driver.py]
+from native import f, g
+from testutil import assertRaises
+
+f(True, True)
+f(False, False)
+with assertRaises(NameError):
+    f(False, True)
+with assertRaises(NameError):
+    g()
+[out]
+lol
+
+[case testBuiltins]
+y = 10
+def f(x: int) -> None:
+    print(5)
+    d = globals()
+    assert d['y'] == 10
+    d['y'] = 20
+    assert y == 20
+[file driver.py]
+from native import f
+f(5)
+[out]
+5
+
+[case testOptional]
+from typing import Optional
+
+class A: pass
+
+def f(x: Optional[A]) -> Optional[A]:
+    return x
+
+def g(x: Optional[A]) -> int:
+    if x is None:
+        return 1
+    if x is not None:
+        return 2
+    return 3
+
+def h(x: Optional[int], y: Optional[bool]) -> None:
+    pass
+
+[file driver.py]
+from native import f, g, A
+a = A()
+assert f(None) is None
+assert f(a) is a
+assert g(None) == 1
+assert g(a) == 2
+
+[case testInferredOptionalAssignment]
+from typing import Any, Generator
+
+def f(b: bool) -> Any:
+    if b:
+        x = None
+    else:
+        x = 1
+
+    if b:
+        y = 1
+    else:
+        y = None
+
+    m = 1 if b else None
+    n = None if b else 1
+    return ((x, y), (m, n))
+
+def gen(b: bool) -> Generator[Any, None, None]:
+    if b:
+        y = 1
+    else:
+        y = None
+    yield y
+
+assert f(False) == ((1, None), (None, 1))
+assert f(True) == ((None, 1), (1, None))
+assert next(gen(False)) is None
+assert next(gen(True)) == 1
+
+[case testWith]
+from typing import Any
+class Thing:
+    def __init__(self, x: str) -> None:
+        self.x = x
+    def __enter__(self) -> str:
+        print('enter!', self.x)
+        if self.x == 'crash':
+            raise Exception('ohno')
+        return self.x
+    def __exit__(self, x: Any, y: Any, z: Any) -> None:
+        print('exit!', self.x, y)
+
+def foo(i: int) -> int:
+    with Thing('a') as x:
+        print("yooo?", x)
+        if i == 0:
+            return 10
+        elif i == 1:
+            raise Exception('exception!')
+    return -1
+
+def bar() -> None:
+    with Thing('a') as x, Thing('b') as y:
+        print("yooo?", x, y)
+
+def baz() -> None:
+    with Thing('a') as x, Thing('crash') as y:
+        print("yooo?", x, y)
+
+[file driver.py]
+from native import foo, bar, baz
+assert foo(0) == 10
+print('== foo ==')
+try:
+    foo(1)
+except Exception:
+    print('caught')
+assert foo(2) == -1
+
+print('== bar ==')
+bar()
+
+print('== baz ==')
+try:
+    baz()
+except Exception:
+    print('caught')
+
+[out]
+enter! a
+yooo? a
+exit! a None
+== foo ==
+enter! a
+yooo? a
+exit! a exception!
+caught
+enter! a
+yooo? a
+exit! a None
+== bar ==
+enter! a
+enter! b
+yooo? a b
+exit! b None
+exit! a None
+== baz ==
+enter! a
+enter! crash
+exit! a ohno
+caught
+
+[case testDisplays]
+from typing import List, Set, Tuple, Sequence, Dict, Any, Mapping
+
+def listDisplay(x: List[int], y: List[int]) -> List[int]:
+    return [1, 2, *x, *y, 3]
+
+def setDisplay(x: Set[int], y: Set[int]) -> Set[int]:
+    return {1, 2, *x, *y, 3}
+
+def tupleDisplay(x: Sequence[str], y: Sequence[str]) -> Tuple[str, ...]:
+    return ('1', '2', *x, *y, '3')
+
+def dictDisplay(x: str, y1: Dict[str, int], y2: Dict[str, int]) -> Dict[str, int]:
+    return {x: 2, **y1, 'z': 3, **y2}
+
+def dictDisplayUnpackMapping(obj: Mapping[str, str]) -> Dict[str, str]:
+    return {**obj, "env": "value"}
+
+[file driver.py]
+import os
+from native import listDisplay, setDisplay, tupleDisplay, dictDisplay, dictDisplayUnpackMapping
+assert listDisplay([4], [5, 6]) == [1, 2, 4, 5, 6, 3]
+assert setDisplay({4}, {5}) == {1, 2, 3, 4, 5}
+assert tupleDisplay(['4', '5'], ['6']) == ('1', '2', '4', '5', '6', '3')
+assert dictDisplay('x', {'y1': 1}, {'y2': 2, 'z': 5}) == {'x': 2, 'y1': 1, 'y2': 2, 'z': 5}
+assert dictDisplayUnpackMapping(os.environ) == {**os.environ, "env": "value"}
+
+[case testArbitraryLvalues]
+from typing import List, Dict, Any
+
+class O(object):
+    def __init__(self) -> None:
+        self.x = 1
+
+def increment_attr(a: Any) -> Any:
+    a.x += 1
+    return a
+
+def increment_attr_o(o: O) -> O:
+    o.x += 1
+    return o
+
+def increment_all_indices(l: List[int]) -> List[int]:
+    for i in range(len(l)):
+        l[i] += 1
+    return l
+
+def increment_all_keys(d: Dict[str, int]) -> Dict[str, int]:
+    for k in d:
+        d[k] += 1
+    return d
+
+[file driver.py]
+from native import O, increment_attr, increment_attr_o, increment_all_indices, increment_all_keys
+
+class P(object):
+    def __init__(self) -> None:
+        self.x = 0
+
+assert increment_attr(P()).x == 1
+assert increment_attr_o(O()).x == 2
+assert increment_all_indices([1, 2, 3]) == [2, 3, 4]
+assert increment_all_keys({'a':1, 'b':2, 'c':3}) == {'a':2, 'b':3, 'c':4}
+
+[case testControlFlowExprs]
+from typing import Tuple
+def foo() -> object:
+    print('foo')
+    return 'foo'
+def bar() -> object:
+    print('bar')
+    return 'bar'
+def t(x: int) -> int:
+    print(x)
+    return x
+
+def f(b: bool) -> Tuple[object, object, object]:
+    x = foo() if b else bar()
+    y = b or foo()
+    z = b and foo()
+    return (x, y, z)
+def g() -> Tuple[object, object]:
+    return (foo() or bar(), foo() and bar())
+
+def nand(p: bool, q: bool) -> bool:
+    if not (p and q):
+        return True
+    return False
+
+def chained(x: int, y: int, z: int) -> bool:
+    return t(x) < t(y) > t(z)
+
+def chained2(x: int, y: int, z: int, w: int) -> bool:
+    return t(x) < t(y) < t(z) < t(w)
+[file driver.py]
+from native import f, g, nand, chained, chained2
+assert f(True) == ('foo', True, 'foo')
+print()
+assert f(False) == ('bar', 'foo', False)
+print()
+assert g() == ('foo', 'bar')
+
+assert nand(True, True) == False
+assert nand(True, False) == True
+assert nand(False, True) == True
+assert nand(False, False) == True
+
+print()
+assert chained(10, 20, 15) == True
+print()
+assert chained(10, 20, 30) == False
+print()
+assert chained(21, 20, 30) == False
+print()
+assert chained2(1, 2, 3, 4) == True
+print()
+assert chained2(1, 0, 3, 4) == False
+print()
+assert chained2(1, 2, 0, 4) == False
+[out]
+foo
+foo
+
+bar
+foo
+
+foo
+foo
+bar
+
+10
+20
+15
+
+10
+20
+30
+
+21
+20
+
+1
+2
+3
+4
+
+1
+0
+
+1
+2
+0
+
+[case testMultipleAssignment]
+from typing import Tuple, List, Any
+
+def from_tuple(t: Tuple[int, str]) -> List[Any]:
+    x, y = t
+    return [y, x]
+
+def from_tuple_sequence(t: Tuple[int, ...]) -> List[int]:
+    x, y, z = t
+    return [z, y, x]
+
+def from_list(l: List[int]) -> List[int]:
+    x, y = l
+    return [y, x]
+
+def from_list_complex(l: List[int]) -> List[int]:
+    ll = l[:]
+    ll[1], ll[0] = l
+    return ll
+
+def from_any(o: Any) -> List[Any]:
+    x, y = o
+    return [y, x]
+
+def multiple_assignments(t: Tuple[int, str]) -> List[Any]:
+    a, b = c, d = t
+    e, f = g, h = 1, 2
+    return [a, b, c, d, e, f, g, h]
+[file driver.py]
+from native import (
+    from_tuple, from_tuple_sequence, from_list, from_list_complex, from_any, multiple_assignments
+)
+
+assert from_tuple((1, 'x')) == ['x', 1]
+
+assert from_tuple_sequence((1, 5, 4)) == [4, 5, 1]
+try:
+    from_tuple_sequence((1, 5))
+except ValueError as e:
+    assert 'not enough values to unpack (expected 3, got 2)' in str(e)
+else:
+    assert False
+
+assert from_list([3, 4]) == [4, 3]
+try:
+    from_list([5, 4, 3])
+except ValueError as e:
+    assert 'too many values to unpack (expected 2)' in str(e)
+else:
+    assert False
+
+assert from_list_complex([7, 6]) == [6, 7]
+try:
+    from_list_complex([5, 4, 3])
+except ValueError as e:
+    assert 'too many values to unpack (expected 2)' in str(e)
+else:
+    assert False
+
+assert from_any('xy') == ['y', 'x']
+
+assert multiple_assignments((4, 'x')) == [4, 'x', 4, 'x', 1, 2, 1, 2]
+
+[case testUnpack]
+from typing import List
+
+a, *b = [1, 2, 3, 4, 5]
+
+*c, d = [1, 2, 3, 4, 5]
+
+e, *f = [1,2]
+
+j, *k, l = [1, 2, 3]
+
+m, *n, o = [1, 2, 3, 4, 5, 6]
+
+p, q, r, *s, t = [1,2,3,4,5,6,7,8,9,10]
+
+tup = (1,2,3)
+y, *z = tup
+
+def unpack1(l : List[int]) -> None:
+    *v1, v2, v3 = l
+
+def unpack2(l : List[int]) -> None:
+    v1, *v2, v3 = l
+
+def unpack3(l : List[int]) -> None:
+    v1, v2, *v3 = l
+
+[file driver.py]
+from native import a, b, c, d, e, f, j, k, l, m, n, o, p, q, r, s, t, y, z
+from native import unpack1, unpack2, unpack3
+from testutil import assertRaises
+
+assert a == 1
+assert b == [2,3,4,5]
+assert c == [1,2,3,4]
+assert d == 5
+assert e == 1
+assert f == [2]
+assert j == 1
+assert k == [2]
+assert l == 3
+assert m == 1
+assert n == [2,3,4,5]
+assert o == 6
+assert p == 1
+assert q == 2
+assert r == 3
+assert s == [4,5,6,7,8,9]
+assert t == 10
+assert y == 1
+assert z == [2,3]
+
+with assertRaises(ValueError, "not enough values to unpack"):
+    unpack1([1])
+
+with assertRaises(ValueError, "not enough values to unpack"):
+    unpack2([1])
+
+with assertRaises(ValueError, "not enough values to unpack"):
+    unpack3([1])
+
+[out]
+
+[case testModuleTopLevel]
+x = 1
+print(x)
+
+def f() -> None:
+    print(x + 1)
+
+def g() -> None:
+    global x
+    x = 77
+
+[file driver.py]
+import native
+native.f()
+native.x = 5
+native.f()
+native.g()
+print(native.x)
+
+[out]
+1
+2
+6
+77
+
+[case testComprehensions]
+from typing import List
+
+# A list comprehension
+l = [str(x) + "     " + str(y) + "   " + str(x*y) for x in range(10)
+     if x != 6 if x != 5 for y in range(x) if y*x != 8]
+
+# Test short-circuiting as well
+def pred(x: int) -> bool:
+    if x > 6:
+        raise Exception()
+    return x > 3
+# If we fail to short-circuit, pred(x) will be called with x=7
+# eventually and will raise an exception.
+l2 = [x for x in range(10) if x <= 6 if pred(x)]
+
+src = ['x']
+
+def f() -> List[str]:
+    global src
+    res = src
+    src = []
+    return res
+
+l3 = [s for s in f()]
+l4 = [s for s in f()]
+
+# A dictionary comprehension
+d = {k: k*k for k in range(10) if k != 5 if k != 6}
+
+# A set comprehension
+s = {str(x) + "     " + str(y) + "   " + str(x*y) for x in range(10)
+     if x != 6 if x != 5 for y in range(x) if y*x != 8}
+
+[file driver.py]
+from native import l, l2, l3, l4, d, s
+for a in l:
+    print(a)
+print(tuple(l2))
+assert l3 == ['x']
+assert l4 == []
+for k in sorted(d):
+    print(k, d[k])
+for a in sorted(s):
+    print(a)
+[out]
+1     0   0
+2     0   0
+2     1   2
+3     0   0
+3     1   3
+3     2   6
+4     0   0
+4     1   4
+4     3   12
+7     0   0
+7     1   7
+7     2   14
+7     3   21
+7     4   28
+7     5   35
+7     6   42
+8     0   0
+8     2   16
+8     3   24
+8     4   32
+8     5   40
+8     6   48
+8     7   56
+9     0   0
+9     1   9
+9     2   18
+9     3   27
+9     4   36
+9     5   45
+9     6   54
+9     7   63
+9     8   72
+(4, 5, 6)
+0 0
+1 1
+2 4
+3 9
+4 16
+7 49
+8 64
+9 81
+1     0   0
+2     0   0
+2     1   2
+3     0   0
+3     1   3
+3     2   6
+4     0   0
+4     1   4
+4     3   12
+7     0   0
+7     1   7
+7     2   14
+7     3   21
+7     4   28
+7     5   35
+7     6   42
+8     0   0
+8     2   16
+8     3   24
+8     4   32
+8     5   40
+8     6   48
+8     7   56
+9     0   0
+9     1   9
+9     2   18
+9     3   27
+9     4   36
+9     5   45
+9     6   54
+9     7   63
+9     8   72
+
+[case testDummyTypes]
+from typing import Tuple, List, Dict, NamedTuple
+from typing_extensions import Literal, TypedDict, NewType
+
+class A:
+    pass
+
+T = List[A]
+U = List[Tuple[int, str]]
+Z = List[List[int]]
+D = Dict[int, List[int]]
+N = NewType('N', int)
+G = Tuple[int, str]
+def foo(x: N) -> int:
+    return x
+foo(N(10))
+z = N(10)
+Lol = NamedTuple('Lol', (('a', int), ('b', T)))
+x = Lol(1, [])
+def take_lol(x: Lol) -> int:
+    return x.a
+
+TD = TypedDict('TD', {'a': int})
+def take_typed_dict(x: TD) -> int:
+    return x['a']
+
+def take_literal(x: Literal[1, 2, 3]) -> None:
+    print(x)
+
+[file driver.py]
+import sys
+from native import *
+
+if sys.version_info[:3] > (3, 5, 2):
+    assert "%s %s %s %s" % (T, U, Z, D) == "typing.List[native.A] typing.List[typing.Tuple[int, str]] typing.List[typing.List[int]] typing.Dict[int, typing.List[int]]"
+print(x)
+print(z)
+print(take_lol(x))
+print(take_typed_dict({'a': 20}))
+try:
+    take_typed_dict(None)
+except Exception as e:
+    print(type(e).__name__)
+
+
+take_literal(1)
+# We check that the type is the real underlying type
+try:
+    take_literal(None)
+except Exception as e:
+    print(type(e).__name__)
+# ... but not that it is a valid literal value
+take_literal(10)
+[out]
+Lol(a=1, b=[])
+10
+1
+20
+TypeError
+1
+TypeError
+10
+
+[case testClassBasedTypedDict]
+from typing_extensions import TypedDict
+
+class TD(TypedDict):
+    a: int
+
+class TD2(TD):
+    b: int
+
+class TD3(TypedDict, total=False):
+    c: int
+
+class TD4(TD3, TD2, total=False):
+    d: int
+
+def test_typed_dict() -> None:
+    d = TD(a=5)
+    assert d['a'] == 5
+    assert type(d) == dict
+    # TODO: This doesn't work yet
+    # assert TD.__annotations__ == {'a': int}
+
+def test_inherited_typed_dict() -> None:
+    d = TD2(a=5, b=3)
+    assert d['a'] == 5
+    assert d['b'] == 3
+    assert type(d) == dict
+
+def test_non_total_typed_dict() -> None:
+    d3 = TD3(c=3)
+    d4 = TD4(a=1, b=2, c=3, d=4)
+    assert d3['c'] == 3
+    assert d4['d'] == 4
+
+[case testClassBasedNamedTuple]
+from typing import NamedTuple
+import sys
+
+# Class-based NamedTuple requires Python 3.6+
+version = sys.version_info[:2]
+if version[0] == 3 and version[1] < 6:
+    exit()
+
+class NT(NamedTuple):
+    a: int
+
+def test_named_tuple() -> None:
+    t = NT(a=1)
+    assert t.a == 1
+    assert type(t) is NT
+    assert isinstance(t, tuple)
+    assert not isinstance(tuple([1]), NT)
+
+[case testUnion]
+from typing import Union
+
+class A:
+    def __init__(self, x: int) -> None:
+        self.x = x
+    def f(self, y: int) -> int:
+        return y + self.x
+
+class B:
+    def __init__(self, x: object) -> None:
+        self.x = x
+    def f(self, y: object) -> object:
+        return y
+
+def f(x: Union[A, str]) -> object:
+    if isinstance(x, A):
+        return x.x
+    else:
+        return x + 'x'
+
+def g(x: int) -> Union[A, int]:
+    if x == 0:
+        return A(1)
+    else:
+        return x + 1
+
+def get(x: Union[A, B]) -> object:
+    return x.x
+
+def call(x: Union[A, B]) -> object:
+    return x.f(5)
+
+[file driver.py]
+from native import A, B, f, g, get, call
+assert f('a') == 'ax'
+assert f(A(4)) == 4
+assert isinstance(g(0), A)
+assert g(2) == 3
+assert get(A(5)) == 5
+assert get(B('x')) == 'x'
+assert call(A(4)) == 9
+assert call(B('x')) == 5
+try:
+    f(1)
+except TypeError:
+    pass
+else:
+    assert False
+
+[case testAnyAll]
+from typing import Iterable
+
+def call_any_nested(l: Iterable[Iterable[int]], val: int = 0) -> int:
+    res = any(i == val for l2 in l for i in l2)
+    return 0 if res else 1
+
+def call_any(l: Iterable[int], val: int = 0) -> int:
+    res = any(i == val for i in l)
+    return 0 if res else 1
+
+def call_all(l: Iterable[int], val: int = 0) -> int:
+    res = all(i == val for i in l)
+    return 0 if res else 1
+
+[file driver.py]
+from native import call_any, call_all, call_any_nested
+
+zeros = [0, 0, 0]
+ones = [1, 1, 1]
+mixed_001 = [0, 0, 1]
+mixed_010 = [0, 1, 0]
+mixed_100 = [1, 0, 0]
+mixed_011 = [0, 1, 1]
+mixed_101 = [1, 0, 1]
+mixed_110 = [1, 1, 0]
+
+assert call_any([]) == 1
+assert call_any(zeros) == 0
+assert call_any(ones) == 1
+assert call_any(mixed_001) == 0
+assert call_any(mixed_010) == 0
+assert call_any(mixed_100) == 0
+assert call_any(mixed_011) == 0
+assert call_any(mixed_101) == 0
+assert call_any(mixed_110) == 0
+
+assert call_all([]) == 0
+assert call_all(zeros) == 0
+assert call_all(ones) == 1
+assert call_all(mixed_001) == 1
+assert call_all(mixed_010) == 1
+assert call_all(mixed_100) == 1
+assert call_all(mixed_011) == 1
+assert call_all(mixed_101) == 1
+assert call_all(mixed_110) == 1
+
+assert call_any_nested([[1, 1, 1], [1, 1], []]) == 1
+assert call_any_nested([[1, 1, 1], [0, 1], []]) == 0
+
+[case testSum]
+[typing fixtures/typing-full.pyi]
+from typing import Any, List
+
+def test_sum_of_numbers() -> None:
+    assert sum(x for x in [1, 2, 3]) == 6
+    assert sum(x for x in [0.0, 1.2, 2]) == 6.2
+    assert sum(x for x in [1, 1j]) == 1 + 1j
+
+def test_sum_callables() -> None:
+    assert sum((lambda x: x == 0)(x) for x in []) == 0
+    assert sum((lambda x: x == 0)(x) for x in [0]) == 1
+    assert sum((lambda x: x == 0)(x) for x in [0, 0, 0]) == 3
+    assert sum((lambda x: x == 0)(x) for x in [0, 1, 0]) == 2
+    assert sum((lambda x: x % 2 == 0)(x) for x in range(2**10)) == 2**9
+
+def test_sum_comparisons() -> None:
+    assert sum(x == 0 for x in []) == 0
+    assert sum(x == 0 for x in [0]) == 1
+    assert sum(x == 0 for x in [0, 0, 0]) == 3
+    assert sum(x == 0 for x in [0, 1, 0]) == 2
+    assert sum(x % 2 == 0 for x in range(2**10)) == 2**9
+
+def test_sum_multi() -> None:
+    assert sum(i + j == 0 for i, j in zip([0, 0, 0], [0, 1, 0])) == 2
+
+def test_sum_misc() -> None:
+    # misc cases we do optimize (note, according to sum's helptext, we don't need to support
+    # non-numeric cases, but CPython and mypyc both do anyway)
+    assert sum(c == 'd' for c in 'abcdd') == 2
+    # misc cases we do not optimize
+    assert sum([0, 1]) == 1
+    assert sum([0, 1], 1) == 2
+
+def test_sum_start_given() -> None:
+    a = 1
+    assert sum((x == 0 for x in [0, 1]), a) == 2
+    assert sum(((lambda x: x == 0)(x) for x in []), 1) == 1
+    assert sum(((lambda x: x == 0)(x) for x in [0]), 1) == 2
+    assert sum(((lambda x: x == 0)(x) for x in [0, 0, 0]), 1) == 4
+    assert sum(((lambda x: x == 0)(x) for x in [0, 1, 0]), 1) == 3
+    assert sum(((lambda x: x % 2 == 0)(x) for x in range(2**10)), 1) == 2**9 + 1
+    assert sum((x for x in [1, 1j]), 2j) == 1 + 3j
+    assert sum((c == 'd' for c in 'abcdd'), 1) == 3
+
+[case testNoneStuff]
+from typing import Optional
+class A:
+    x: int
+
+def lol(x: A) -> None:
+    setattr(x, 'x', 5)
+
+def none() -> None:
+    return
+
+def arg(x: Optional[A]) -> bool:
+    return x is None
+
+[file driver.py]
+import native
+native.lol(native.A())
+
+# Catch refcounting failures
+for i in range(10000):
+    native.none()
+    native.arg(None)
+
+[case testBorrowRefs]
+def make_garbage(arg: object) -> None:
+    b = True
+    while b:
+        arg = None
+        b = False
+
+[file driver.py]
+from native import make_garbage
+import sys
+
+def test():
+    x = object()
+    r0 = sys.getrefcount(x)
+    make_garbage(x)
+    r1 = sys.getrefcount(x)
+    assert r0 == r1
+
+test()
+
+[case testFinalStaticRunFail]
+if False:
+    from typing import Final
+
+if bool():
+    x: 'Final' = [1]
+
+def f() -> int:
+    return x[0]
+
+[file driver.py]
+from native import f
+try:
+    print(f())
+except NameError as e:
+    print(e.args[0])
+[out]
+value for final name "x" was not set
+
+[case testFinalStaticRunListTupleInt]
+if False:
+    from typing import Final
+
+x: 'Final' = [1]
+y: 'Final' = (1, 2)
+z: 'Final' = 1 + 1
+
+def f() -> int:
+    return x[0]
+def g() -> int:
+    return y[0]
+def h() -> int:
+    return z - 1
+
+[file driver.py]
+from native import f, g, h, x, y, z
+print(f())
+print(x[0])
+print(g())
+print(y)
+print(h())
+print(z)
+[out]
+1
+1
+1
+(1, 2)
+1
+2
+
+[case testCheckVersion]
+import sys
+
+if sys.version_info[:2] == (3, 12):
+    def version() -> int:
+        return 12
+elif sys.version_info[:2] == (3, 11):
+    def version() -> int:
+        return 11
+elif sys.version_info[:2] == (3, 10):
+    def version() -> int:
+        return 10
+elif sys.version_info[:2] == (3, 9):
+    def version() -> int:
+        return 9
+elif sys.version_info[:2] == (3, 8):
+    def version() -> int:
+        return 8
+elif sys.version_info[:2] == (3, 7):
+    def version() -> int:
+        return 7
+elif sys.version_info[:2] == (3, 6):
+    def version() -> int:
+        return 6
+else:
+    raise Exception("we don't support this version yet!")
+
+
+[file driver.py]
+import sys
+version = sys.version_info[:2]
+
+import native
+assert native.version() == sys.version_info[1]
+
+[case testTypeErrorMessages]
+from typing import Tuple
+class A:
+    pass
+class B:
+    pass
+
+def f(x: B) -> None:
+    pass
+def g(x: Tuple[int, A]) -> None:
+    pass
+[file driver.py]
+from testutil import assertRaises
+from native import A, f, g
+
+class Busted:
+    pass
+Busted.__module__ = None
+
+with assertRaises(TypeError, "int"):
+    f(0)
+with assertRaises(TypeError, "native.A"):
+    f(A())
+with assertRaises(TypeError, "tuple[None, native.A]"):
+    f((None, A()))
+with assertRaises(TypeError, "tuple[tuple[int, str], native.A]"):
+    f(((1, "ha"), A()))
+with assertRaises(TypeError, "tuple[<50 items>]"):
+    f(tuple(range(50)))
+
+with assertRaises(TypeError, "errored formatting real type!"):
+    f(Busted())
+
+with assertRaises(TypeError, "tuple[int, native.A] object expected; got tuple[int, int]"):
+    g((20, 30))
+
+[case testComprehensionShadowBinder]
+def foo(x: object) -> object:
+    if isinstance(x, list):
+        return tuple(x for x in x), x
+    return None
+
+[file driver.py]
+from native import foo
+
+assert foo(None) == None
+assert foo([1, 2, 3]) == ((1, 2, 3), [1, 2, 3])
+
+[case testAllLiterals]
+# Test having all sorts of literals in a single file
+
+def test_str() -> None:
+    assert '' == eval("''")
+    assert len('foo bar' + str()) == 7
+    assert 'foo bar' == eval("'foo bar'")
+    assert 'foo\u1245\0bar' == eval("'foo' + chr(0x1245) + chr(0) + 'bar'")
+    assert 'foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345' == eval("'foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345'")
+    assert 'Zoobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar123' == eval("'Zoobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar123'")
+
+def test_bytes() -> None:
+    assert b'' == eval("b''")
+    assert b'foo bar' == eval("b'foo bar'")
+    assert b'\xafde' == eval(r"b'\xafde'")
+    assert b'foo\xde\0bar' == eval("b'foo' + bytes([0xde, 0]) + b'bar'")
+    assert b'foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345' == eval("b'foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345foobar12345'")
+
+def test_int() -> None:
+    assert 2875872359823758923758923759 == eval('2875872359823758923758923759')
+    assert -552875872359823758923758923759 == eval('-552875872359823758923758923759')
+
+def test_float() -> None:
+    assert 1.5 == eval('1.5')
+    assert -3.75 == eval('-3.75')
+    assert 2.5e10 == eval('2.5e10')
+    assert 2.5e50 == eval('2.5e50')
+    assert 2.5e1000 == eval('2.5e1000')
+    assert -2.5e1000 == eval('-2.5e1000')
+
+def test_complex() -> None:
+    assert 1.5j == eval('1.5j')
+    assert 1.5j + 2.5 == eval('2.5 + 1.5j')
+    assert -3.75j == eval('-3.75j')
+    assert 2.5e10j == eval('2.5e10j')
+    assert 2.5e50j == eval('2.5e50j')
+    assert 2.5e1000j == eval('2.5e1000j')
+    assert 2.5e1000j + 3.5e2000 == eval('3.5e2000 + 2.5e1000j')
+    assert -2.5e1000j == eval('-2.5e1000j')
+
+[case testUnreachableExpressions]
+from typing import cast
+import sys
+
+A = sys.platform == 'x' and foobar
+B = sys.platform == 'x' and sys.foobar
+C = sys.platform == 'x' and f(a, -b, 'y') > [c + e, g(y=2)]
+C = sys.platform == 'x' and cast(a, b[c])
+C = sys.platform == 'x' and (lambda x: y + x)
+C = sys.platform == 'x' and (x for y in z)
+C = sys.platform == 'x' and [x for y in z]
+C = sys.platform == 'x' and {x: x for y in z}
+C = sys.platform == 'x' and {x for y in z}
+
+assert not A
+assert not B
+assert not C
+
+[case testDoesntSegfaultWhenTopLevelFails]
+# make the initial import fail
+assert False
+
+[file driver.py]
+# load native, cause PyInit to be run, create the module but don't finish initializing the globals
+for _ in range(2):
+    try:
+        import native
+        raise RuntimeError('exception expected')
+    except AssertionError:
+        pass
+
+[case testUnderscoreFunctionsInMethods]
+
+class A:
+    def _(arg): pass
+    def _(arg): pass
+class B(A):
+    def _(arg): pass
+    def _(arg): pass
+
+[case testGlobalRedefinition_toplevel]
+# mypy: allow-redefinition
+i = 0
+i += 1
+i = "foo"
+i += i
+i = b"foo"
+
+def test_redefinition() -> None:
+    assert i == b"foo"
+
+[case testWithNative]
+class DummyContext:
+    def __init__(self):
+        self.c = 0
+    def __enter__(self) -> None:
+        self.c += 1
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.c -= 1
+
+def test_dummy_context() -> None:
+    c = DummyContext()
+    with c:
+        assert c.c == 1
+    assert c.c == 0
+
+[case testWithNativeVarArgs]
+class DummyContext:
+    def __init__(self):
+        self.c = 0
+    def __enter__(self) -> None:
+        self.c += 1
+    def __exit__(self, *args: object) -> None:
+        self.c -= 1
+
+def test_dummy_context() -> None:
+    c = DummyContext()
+    with c:
+        assert c.c == 1
+    assert c.c == 0