Tipragot
628be439b8
Cela permet de ne pas avoir de problèmes de compatibilité car python est dans le git.
541 lines
14 KiB
Plaintext
541 lines
14 KiB
Plaintext
# 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
|