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

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

@@ -0,0 +1,540 @@
+# Test cases for integers (compile and run)
+
+[case testInc]
+def inc(x: int) -> int:
+    return x + 1
+[file driver.py]
+from native import inc
+print(inc(3))
+print(inc(-5))
+print(inc(10**20))
+[out]
+4
+-4
+100000000000000000001
+
+[case testCount]
+def count(n: int) -> int:
+    i = 1
+    while i <= n:
+        i = i + 1
+    return i
+[file driver.py]
+from native import count
+print(count(0))
+print(count(1))
+print(count(5))
+[out]
+1
+2
+6
+
+[case testIntMathOps]
+# This tests integer math things that are either easier to test in Python than
+# in our C tests or are tested here because (for annoying reasons) we don't run
+# the C unit tests in our 32-bit CI.
+def multiply(x: int, y: int) -> int:
+    return x * y
+
+# these stringify their outputs because that will catch if exceptions are mishandled
+def floor_div(x: int, y: int) -> str:
+    return str(x // y)
+def remainder(x: int, y: int) -> str:
+    return str(x % y)
+
+[file driver.py]
+from native import multiply, floor_div, remainder
+
+def test_multiply(x, y):
+    assert multiply(x, y) == x * y
+def test_floor_div(x, y):
+    assert floor_div(x, y) == str(x // y)
+def test_remainder(x, y):
+    assert remainder(x, y) == str(x % y)
+
+test_multiply(10**6, 10**6)
+test_multiply(2**15, 2**15-1)
+test_multiply(2**14, 2**14)
+
+test_multiply(10**12, 10**12)
+test_multiply(2**30, 2**30-1)
+test_multiply(2**29, 2**29)
+
+test_floor_div(-2**62, -1)
+test_floor_div(-2**30, -1)
+try:
+    floor_div(10, 0)
+except ZeroDivisionError:
+    pass
+else:
+    assert False, "Expected ZeroDivisionError"
+
+test_remainder(-2**62, -1)
+test_remainder(-2**30, -1)
+try:
+    remainder(10, 0)
+except ZeroDivisionError:
+    pass
+else:
+    assert False, "Expected ZeroDivisionError"
+
+[case testBigIntLiteral]
+def big_int() -> None:
+    a_62_bit = 4611686018427387902
+    max_62_bit = 4611686018427387903
+    b_63_bit = 4611686018427387904
+    c_63_bit = 9223372036854775806
+    max_63_bit = 9223372036854775807
+    d_64_bit = 9223372036854775808
+    max_32_bit = 2147483647
+    max_32_bit_plus1 = 2147483648
+    max_31_bit = 1073741823
+    max_31_bit_plus1 = 1073741824
+    neg = -1234567
+    min_signed_63_bit = -4611686018427387904
+    underflow = -4611686018427387905
+    min_signed_64_bit = -9223372036854775808
+    min_signed_31_bit = -1073741824
+    min_signed_31_bit_plus1 = -1073741823
+    min_signed_31_bit_minus1 = -1073741825
+    min_signed_32_bit = -2147483648
+    print(a_62_bit)
+    print(max_62_bit)
+    print(b_63_bit)
+    print(c_63_bit)
+    print(max_63_bit)
+    print(d_64_bit)
+    print('==')
+    print(max_32_bit)
+    print(max_32_bit_plus1)
+    print(max_31_bit)
+    print(max_31_bit_plus1)
+    print(neg)
+    print(min_signed_63_bit)
+    print(underflow)
+    print(min_signed_64_bit)
+    print(min_signed_31_bit)
+    print(min_signed_31_bit_plus1)
+    print(min_signed_31_bit_minus1)
+    print(min_signed_32_bit)
+[file driver.py]
+from native import big_int
+big_int()
+[out]
+4611686018427387902
+4611686018427387903
+4611686018427387904
+9223372036854775806
+9223372036854775807
+9223372036854775808
+==
+2147483647
+2147483648
+1073741823
+1073741824
+-1234567
+-4611686018427387904
+-4611686018427387905
+-9223372036854775808
+-1073741824
+-1073741823
+-1073741825
+-2147483648
+
+[case testNeg]
+def neg(x: int) -> int:
+    return -x
+[file driver.py]
+from native import neg
+assert neg(5) == -5
+assert neg(-5) == 5
+assert neg(1073741823) == -1073741823
+assert neg(-1073741823) == 1073741823
+assert neg(1073741824) == -1073741824
+assert neg(-1073741824) == 1073741824
+assert neg(2147483647) == -2147483647
+assert neg(-2147483647) == 2147483647
+assert neg(2147483648) == -2147483648
+assert neg(-2147483648) == 2147483648
+assert neg(4611686018427387904) == -4611686018427387904
+assert neg(-4611686018427387904) == 4611686018427387904
+assert neg(9223372036854775807) == -9223372036854775807
+assert neg(-9223372036854775807) == 9223372036854775807
+assert neg(9223372036854775808) == -9223372036854775808
+assert neg(-9223372036854775808) == 9223372036854775808
+
+[case testIsinstanceIntAndNotBool]
+def test_isinstance_int_and_not_bool(value: object) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool)
+[file driver.py]
+from native import test_isinstance_int_and_not_bool
+assert test_isinstance_int_and_not_bool(True) == False
+assert test_isinstance_int_and_not_bool(1) == True
+
+[case testIntOps]
+from typing import Any
+from testutil import assertRaises
+
+def check_and(x: int, y: int) -> None:
+    # eval() can be trusted to calculate expected result
+    expected = eval('{} & {}'.format(x, y))
+    actual = x & y
+    assert actual == expected, '{} & {}: got {}, expected {}'.format(x, y, actual, expected)
+
+def check_or(x: int, y: int) -> None:
+    # eval() can be trusted to calculate expected result
+    expected = eval('{} | {}'.format(x, y))
+    actual = x | y
+    assert actual == expected, '{} | {}: got {}, expected {}'.format(x, y, actual, expected)
+
+def check_xor(x: int, y: int) -> None:
+    # eval() can be trusted to calculate expected result
+    expected = eval('{} ^ {}'.format(x, y))
+    actual = x ^ y
+    assert actual == expected, '{} ^ {}: got {}, expected {}'.format(x, y, actual, expected)
+
+def check_bitwise(x: int, y: int) -> None:
+    for l, r in (x, y), (y, x):
+        for ll, rr in (l, r), (-l, r), (l, -r), (-l, -r):
+            check_and(ll, rr)
+            check_or(ll, rr)
+            check_xor(ll, rr)
+
+SHIFT = 30
+DIGIT0a = 615729753
+DIGIT0b = 832796681
+DIGIT1a = 744342356 << SHIFT
+DIGIT1b = 321006080 << SHIFT
+DIGIT2a = 643582106 << (SHIFT * 2)
+DIGIT2b = 656420725 << (SHIFT * 2)
+DIGIT50 = 315723472 << (SHIFT * 50)
+DIGIT100a = 1020652627 << (SHIFT * 100)
+DIGIT100b = 923752451 << (SHIFT * 100)
+BIG_SHORT = 3491190729721336556
+MAX_SHORT = (1 << 62) - 1
+MIN_SHORT = -(1 << 62)
+MAX_SHORT_32 = (1 << 30) - 1
+MIN_SHORT_32 = -(1 << 30)
+
+def test_and_or_xor() -> None:
+    check_bitwise(0, 0)
+    check_bitwise(0, 1)
+    check_bitwise(1, 1)
+    check_bitwise(DIGIT0a, DIGIT0b)
+    check_bitwise(DIGIT1a, DIGIT1b)
+    check_bitwise(DIGIT2a, DIGIT2b)
+    check_bitwise(DIGIT100a, DIGIT100b)
+    check_bitwise(DIGIT0a, DIGIT0b + DIGIT2a)
+    check_bitwise(DIGIT0a, DIGIT0b + DIGIT50)
+    check_bitwise(DIGIT50 + DIGIT1a, DIGIT100a + DIGIT2b)
+    check_bitwise(BIG_SHORT, DIGIT0a)
+    check_bitwise(BIG_SHORT, DIGIT0a + DIGIT1a)
+    check_bitwise(BIG_SHORT, DIGIT0a + DIGIT1a + DIGIT2a)
+    check_bitwise(BIG_SHORT, DIGIT0a + DIGIT1a + DIGIT2a + DIGIT50)
+
+    for x in range(-25, 25):
+        for y in range(-25, 25):
+            check_bitwise(x, y)
+
+def test_bitwise_inplace() -> None:
+    # Basic sanity checks; these should use the same code as the non-in-place variants
+    for x, y in (DIGIT0a, DIGIT1a), (DIGIT2a, DIGIT0a + DIGIT2b):
+        n = x
+        n &= y
+        assert n == x & y
+        n = x
+        n |= y
+        assert n == x | y
+        n = x
+        n ^= y
+        assert n == x ^ y
+
+def check_invert(x: int) -> None:
+    # Use eval() as the source of truth
+    assert ~x == eval('~{}'.format(x))
+    assert ~(-x) == eval('~({})'.format(-x))
+
+def test_invert() -> None:
+    check_invert(0)
+    check_invert(1)
+    check_invert(DIGIT0a)
+    check_invert(DIGIT0a + DIGIT1a)
+    check_invert(DIGIT0a + DIGIT1a + DIGIT2a)
+    check_invert(DIGIT0a + DIGIT1a + DIGIT2a + DIGIT50)
+    check_invert(BIG_SHORT)
+    for delta in -1, 0, 1:
+        check_invert(MAX_SHORT + delta)
+        check_invert(MIN_SHORT + delta)
+        check_invert(MAX_SHORT_32 + delta)
+        check_invert(MIN_SHORT_32 + delta)
+
+def check_right_shift(x: int, n: int) -> None:
+    if n < 0:
+        try:
+            x >> n
+        except ValueError:
+            return
+        assert False, "no exception raised"
+    # Use eval() as the source of truth
+    expected = eval('{} >> {}'.format(x, n))
+    actual = x >> n
+    assert actual == expected, "{} >> {}: got {}, expected {}".format(x, n, actual, expected)
+
+def test_right_shift() -> None:
+    for x in 0, 1, 1235, DIGIT0a, DIGIT0a + DIGIT1a, DIGIT0a + DIGIT50:
+        for n in 0, 1, 2, 3, 4, 10, 40, 10000, DIGIT1a, -1, -1334444, -DIGIT1a:
+            check_right_shift(x, n)
+            check_right_shift(-x, n)
+    x = DIGIT0a
+    x >>= 1
+    assert x == DIGIT0a >> 1
+    x = DIGIT50
+    x >>= 5
+    assert x == DIGIT50 >> 5
+    for i in range(256):
+        check_right_shift(1, i)
+        check_right_shift(137, i)
+        check_right_shift(MAX_SHORT, i)
+        check_right_shift(MAX_SHORT_32, i)
+        check_right_shift(MAX_SHORT + 1, i)
+        check_right_shift(MAX_SHORT_32 + 1, i)
+    for x in 1, DIGIT50:
+        try:
+            # It's okay if this raises an exception
+            assert x >> DIGIT2a == 0
+        except Exception:
+            pass
+        try:
+            x >> -DIGIT2a
+            assert False
+        except Exception:
+            pass
+
+def check_left_shift(x: int, n: int) -> None:
+    if n < 0:
+        try:
+            x << n
+        except ValueError:
+            return
+        assert False, "no exception raised"
+    # Use eval() as the source of truth
+    expected = eval('{} << {}'.format(x, n))
+    actual = x << n
+    assert actual == expected, "{} << {}: got {}, expected {}".format(x, n, actual, expected)
+
+def test_left_shift() -> None:
+    for x in 0, 1, 1235, DIGIT0a, DIGIT0a + DIGIT1a, DIGIT0a + DIGIT50:
+        for n in 0, 1, 2, 10, 40, 10000, -1, -1334444:
+            check_left_shift(x, n)
+            check_left_shift(-x, n)
+    x = DIGIT0a
+    x <<= 1
+    assert x == DIGIT0a << 1
+    x = DIGIT50
+    x <<= 5
+    assert x == DIGIT50 << 5
+    for shift in range(256):
+        check_left_shift(1, shift)
+        check_left_shift(137, shift)
+    for x in 1, DIGIT50:
+        try:
+            x << DIGIT50
+            assert False
+        except Exception:
+            pass
+        try:
+            x << -DIGIT50
+            assert False
+        except Exception:
+            pass
+
+def is_true(x: int) -> bool:
+    if x:
+        return True
+    else:
+        return False
+
+def is_true2(x: int) -> bool:
+    return bool(x)
+
+def is_false(x: int) -> bool:
+    if not x:
+        return True
+    else:
+        return False
+
+def test_int_as_bool() -> None:
+    assert not is_true(0)
+    assert not is_true2(0)
+    assert is_false(0)
+    for x in 1, 55, -1, -7, 1 << 50, 1 << 101, -(1 << 50), -(1 << 101):
+        assert is_true(x)
+        assert is_true2(x)
+        assert not is_false(x)
+
+def bool_as_int(b: bool) -> int:
+    return b
+
+def bool_as_int2(b: bool) -> int:
+    return int(b)
+
+def test_bool_as_int() -> None:
+    assert bool_as_int(False) == 0
+    assert bool_as_int(True) == 1
+    assert bool_as_int2(False) == 0
+    assert bool_as_int2(True) == 1
+
+def no_op_conversion(n: int) -> int:
+    return int(n)
+
+def test_no_op_conversion() -> None:
+    for x in 1, 55, -1, -7, 1 << 50, 1 << 101, -(1 << 50), -(1 << 101):
+        assert no_op_conversion(x) == x
+
+def test_floor_divide() -> None:
+    for x in range(-100, 100):
+        for y in range(-100, 100):
+            if y != 0:
+                assert x // y == getattr(x, "__floordiv__")(y)
+
+def test_mod() -> None:
+    for x in range(-100, 100):
+        for y in range(-100, 100):
+            if y != 0:
+                assert x % y == getattr(x, "__mod__")(y)
+
+def test_constant_fold() -> None:
+    assert str(-5 + 3) == "-2"
+    assert str(15 - 3) == "12"
+    assert str(1000 * 1000) == "1000000"
+    assert str(12325 // 12 ) == "1027"
+    assert str(87645 % 321) == "12"
+    assert str(674253 | 76544) == "748493"
+    assert str(765 ^ 82) == "687"
+    assert str(6546 << 3) == "52368"
+    assert str(6546 >> 7) == "51"
+    assert str(3**5) == "243"
+    assert str(~76) == "-77"
+    try:
+        2 / 0
+    except ZeroDivisionError:
+        pass
+    else:
+        assert False, "no exception raised"
+
+    x = int()
+    y = int() - 1
+    assert x == -1 or y != -3
+    assert -1 <= x
+    assert -1 == y
+
+    # Use int() to avoid constant propagation
+    i30 = (1 << 30) + int()
+    assert i30 == 1 << 30
+    i31 = (1 << 31) + int()
+    assert i31 == 1 << 31
+    i32 = (1 << 32) + int()
+    assert i32 == 1 << 32
+    i62 = (1 << 62) + int()
+    assert i62 == 1 << 62
+    i63 = (1 << 63) + int()
+    assert i63 == 1 << 63
+    i64 = (1 << 64) + int()
+    assert i64 == 1 << 64
+
+    n30 = -(1 << 30) + int()
+    assert n30 == -(1 << 30)
+    n31 = -(1 << 31) + int()
+    assert n31 == -(1 << 31)
+    n32 = -(1 << 32) + int()
+    assert n32 == -(1 << 32)
+    n62 = -(1 << 62) + int()
+    assert n62 == -(1 << 62)
+    n63 = -(1 << 63) + int()
+    assert n63 == -(1 << 63)
+    n64 = -(1 << 64) + int()
+    assert n64 == -(1 << 64)
+
+def div_by_2(x: int) -> int:
+    return x // 2
+
+def div_by_3(x: int) -> int:
+    return x // 3
+
+def div_by_4(x: int) -> int:
+    return x // 4
+
+def test_floor_divide_by_literal() -> None:
+    for i in range(-100, 100):
+        i_boxed: Any = i
+        assert div_by_2(i) == i_boxed // int('2')
+        assert div_by_3(i) == i_boxed // int('3')
+        assert div_by_4(i) == i_boxed // int('4')
+
+def test_true_divide() -> None:
+    for x in range(-150, 100):
+        for y in range(-150, 100):
+            if y != 0:
+                assert x / y == getattr(x, "__truediv__")(y)
+    large1 = (123 + int())**123
+    large2 = (121 + int())**121
+    assert large1 / large2 == getattr(large1, "__truediv__")(large2)
+    assert large1 / 135 == getattr(large1, "__truediv__")(135)
+    assert large1 / -2 == getattr(large1, "__truediv__")(-2)
+    assert 17 / large2 == getattr(17, "__truediv__")(large2)
+
+    huge = 10**1000 + int()
+    with assertRaises(OverflowError, "integer division result too large for a float"):
+        huge / 2
+    with assertRaises(OverflowError, "integer division result too large for a float"):
+        huge / -2
+    assert 1 / huge == 0.0
+
+[case testIntMinMax]
+def test_int_min_max() -> None:
+    x: int = 200
+    y: int = 30
+    assert min(x, y) == 30
+    assert max(x, y) == 200
+    assert min(y, x) == 30
+    assert max(y, x) == 200
+
+def test_int_hybrid_min_max() -> None:
+    from typing import Any
+
+    x: object = 30
+    y: Any = 20.0
+    assert min(x, y) == 20.0
+    assert max(x, y) == 30
+
+    u: object = 20
+    v: float = 30.0
+    assert min(u, v) == 20
+    assert max(u, v) == 30.0
+
+def test_int_incompatible_min_max() -> None:
+    x: int = 2
+    y: str = 'aaa'
+    try:
+        print(min(x, y))
+    except TypeError as e:
+        assert str(e) == "'<' not supported between instances of 'str' and 'int'"
+    try:
+        print(max(x, y))
+    except TypeError as e:
+        assert str(e) == "'>' not supported between instances of 'str' and 'int'"
+
+def test_int_bool_min_max() -> None:
+    x: int = 2
+    y: bool = False
+    z: bool = True
+    assert min(x, y) == False
+    assert min(x, z) == True
+    assert max(x, y) == 2
+    assert max(x, z) == 2
+
+    u: int = -10
+    assert min(u, y) == -10
+    assert min(u, z) == -10
+    assert max(u, y) == False
+    assert max(u, z) == True