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

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

@@ -1,1170 +0,0 @@
-[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