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

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

@@ -1,540 +0,0 @@
-# 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