forked from Rust-related/RustPython
327 lines
8.8 KiB
Python
327 lines
8.8 KiB
Python
from testutils import assert_raises
|
|
|
|
# int to int comparisons
|
|
|
|
assert 1 == 1
|
|
assert not 1 != 1
|
|
|
|
assert (1).__eq__(1)
|
|
assert not (1).__ne__(1)
|
|
|
|
# int to float comparisons
|
|
|
|
assert 1 == 1.0
|
|
assert not 1 != 1.0
|
|
assert not 1 > 1.0
|
|
assert not 1 < 1.0
|
|
assert 1 >= 1.0
|
|
assert 1 <= 1.0
|
|
|
|
# check for argument handling
|
|
|
|
assert int("101", base=2) == 5
|
|
|
|
# magic methods should only be implemented for other ints
|
|
|
|
assert (1).__eq__(1) is True
|
|
assert (1).__ne__(1) is False
|
|
assert (1).__gt__(1) is False
|
|
assert (1).__ge__(1) is True
|
|
assert (1).__lt__(1) is False
|
|
assert (1).__le__(1) is True
|
|
assert (1).__add__(1) == 2
|
|
assert (1).__radd__(1) == 2
|
|
assert (2).__sub__(1) == 1
|
|
assert (2).__rsub__(1) == -1
|
|
assert (2).__mul__(1) == 2
|
|
assert (2).__rmul__(1) == 2
|
|
assert (2).__truediv__(1) == 2.0
|
|
with assert_raises(ZeroDivisionError):
|
|
(2).__truediv__(0)
|
|
assert (2).__rtruediv__(1) == 0.5
|
|
assert (-2).__floordiv__(3) == -1
|
|
with assert_raises(ZeroDivisionError):
|
|
(2).__floordiv__(0)
|
|
assert (-3).__rfloordiv__(2) == -1
|
|
assert (-2).__divmod__(3) == (-1, 1)
|
|
with assert_raises(ZeroDivisionError):
|
|
(2).__divmod__(0)
|
|
assert (-3).__rdivmod__(2) == (-1, -1)
|
|
assert (2).__pow__(3) == 8
|
|
assert (10).__pow__(-1) == 0.1
|
|
with assert_raises(ZeroDivisionError):
|
|
(0).__pow__(-1)
|
|
assert (2).__rpow__(3) == 9
|
|
assert (10).__mod__(5) == 0
|
|
assert (10).__mod__(6) == 4
|
|
with assert_raises(ZeroDivisionError):
|
|
(10).__mod__(0)
|
|
assert (5).__rmod__(10) == 0
|
|
assert (6).__rmod__(10) == 4
|
|
with assert_raises(ZeroDivisionError):
|
|
(0).__rmod__(10)
|
|
|
|
# as_integer_ratio
|
|
# TODO uncomment the following tests once #1705 lands (or when the CPython version in test pipeline is upgraded to 3.8)
|
|
# assert (42).as_integer_ratio() == (42, 1)
|
|
# assert (-17).as_integer_ratio() == (-17, 1)
|
|
# assert (0).as_integer_ratio() == (0, 1)
|
|
|
|
# real/imag attributes
|
|
assert (1).real == 1
|
|
assert (1).imag == 0
|
|
# numerator/denominator attributes
|
|
assert (1).numerator == 1
|
|
assert (1).denominator == 1
|
|
assert (10).numerator == 10
|
|
assert (10).denominator == 1
|
|
assert (-10).numerator == -10
|
|
assert (-10).denominator == 1
|
|
|
|
assert_raises(OverflowError, lambda: 1 << 10 ** 100000)
|
|
|
|
assert (1).__eq__(1.0) == NotImplemented
|
|
assert (1).__ne__(1.0) == NotImplemented
|
|
assert (1).__gt__(1.0) == NotImplemented
|
|
assert (1).__ge__(1.0) == NotImplemented
|
|
assert (1).__lt__(1.0) == NotImplemented
|
|
assert (1).__le__(1.0) == NotImplemented
|
|
assert (1).__add__(1.0) == NotImplemented
|
|
assert (2).__sub__(1.0) == NotImplemented
|
|
assert (1).__radd__(1.0) == NotImplemented
|
|
assert (2).__rsub__(1.0) == NotImplemented
|
|
assert (2).__mul__(1.0) == NotImplemented
|
|
assert (2).__rmul__(1.0) == NotImplemented
|
|
assert (2).__truediv__(1.0) == NotImplemented
|
|
assert (2).__rtruediv__(1.0) == NotImplemented
|
|
assert (2).__pow__(3.0) == NotImplemented
|
|
assert (2).__rpow__(3.0) == NotImplemented
|
|
assert (2).__mod__(3.0) == NotImplemented
|
|
assert (2).__rmod__(3.0) == NotImplemented
|
|
|
|
assert 10 // 4 == 2
|
|
assert -10 // 4 == -3
|
|
assert 10 // -4 == -3
|
|
assert -10 // -4 == 2
|
|
|
|
assert int() == 0
|
|
assert int(1) == 1
|
|
assert int("101", 2) == 5
|
|
assert int("101", base=2) == 5
|
|
|
|
# implied base
|
|
assert int('1', base=0) == 1
|
|
assert int('123', base=0) == 123
|
|
assert int('0b101', base=0) == 5
|
|
assert int('0B101', base=0) == 5
|
|
assert int('0o100', base=0) == 64
|
|
assert int('0O100', base=0) == 64
|
|
assert int('0xFF', base=0) == 255
|
|
assert int('0XFF', base=0) == 255
|
|
with assert_raises(ValueError):
|
|
int('0xFF', base=10)
|
|
with assert_raises(ValueError):
|
|
int('0oFF', base=10)
|
|
with assert_raises(ValueError):
|
|
int('0bFF', base=10)
|
|
with assert_raises(ValueError):
|
|
int('0bFF', base=10)
|
|
with assert_raises(ValueError):
|
|
int(b"F\xc3\xb8\xc3\xb6\xbbB\xc3\xa5r")
|
|
with assert_raises(ValueError):
|
|
int(b"F\xc3\xb8\xc3\xb6\xbbB\xc3\xa5r")
|
|
|
|
# string looks like radix
|
|
assert int('0b1', base=12) == 133
|
|
assert int('0o1', base=25) == 601
|
|
assert int('0x1', base=34) == 1123
|
|
|
|
# underscore
|
|
assert int('0xFF_FF_FF', base=16) == 16_777_215
|
|
with assert_raises(ValueError):
|
|
int("_123_")
|
|
with assert_raises(ValueError):
|
|
int("123_")
|
|
with assert_raises(ValueError):
|
|
int("_123")
|
|
with assert_raises(ValueError):
|
|
int("1__23")
|
|
|
|
assert int('0x_10', base=0) == 16
|
|
|
|
# signed
|
|
assert int('-123') == -123
|
|
assert int('+0b101', base=2) == +5
|
|
|
|
# trailing spaces
|
|
assert int(' 1') == 1
|
|
assert int('1 ') == 1
|
|
assert int(' 1 ') == 1
|
|
assert int('10', base=0) == 10
|
|
|
|
# type byte, signed, implied base
|
|
assert int(b' -0XFF ', base=0) == -255
|
|
|
|
assert int.from_bytes(b'\x00\x10', 'big') == 16
|
|
assert int.from_bytes(b'\x00\x10', 'little') == 4096
|
|
assert int.from_bytes(b'\x00\x10', byteorder='big') == 16
|
|
assert int.from_bytes(b'\x00\x10', byteorder='little') == 4096
|
|
assert int.from_bytes(bytes=b'\x00\x10', byteorder='big') == 16
|
|
assert int.from_bytes(bytes=b'\x00\x10', byteorder='little') == 4096
|
|
|
|
assert int.from_bytes(b'\xfc\x00', 'big', signed=True) == -1024
|
|
assert int.from_bytes(b'\xfc\x00', 'big', signed=False) == 64512
|
|
assert int.from_bytes(b'\xfc\x00', byteorder='big', signed=True) == -1024
|
|
assert int.from_bytes(b'\xfc\x00', byteorder='big', signed=False) == 64512
|
|
assert int.from_bytes(bytes=b'\xfc\x00', byteorder='big', signed=True) == -1024
|
|
assert int.from_bytes(bytes=b'\xfc\x00', byteorder='big', signed=False) == 64512
|
|
|
|
assert int.from_bytes([255, 0, 0], 'big') == 16711680
|
|
assert int.from_bytes([255, 0, 0], 'little') == 255
|
|
assert int.from_bytes([255, 0, 0], 'big', signed=False) == 16711680
|
|
assert int.from_bytes([255, 0, 0], 'big', signed=True) == -65536
|
|
|
|
with assert_raises(ValueError):
|
|
int.from_bytes(b'\x00\x10', 'something')
|
|
|
|
with assert_raises(ValueError):
|
|
int.from_bytes([256, 0, 0], 'big')
|
|
|
|
with assert_raises(TypeError):
|
|
int.from_bytes(['something', 0, 0], 'big')
|
|
|
|
assert (1024).to_bytes(4, 'big') == b'\x00\x00\x04\x00'
|
|
assert (1024).to_bytes(2, 'little') == b'\x00\x04'
|
|
assert (1024).to_bytes(4, byteorder='big') == b'\x00\x00\x04\x00'
|
|
assert (1024).to_bytes(2, byteorder='little') == b'\x00\x04'
|
|
assert (1024).to_bytes(length=4, byteorder='big') == b'\x00\x00\x04\x00'
|
|
assert (1024).to_bytes(length=2, byteorder='little') == b'\x00\x04'
|
|
|
|
assert (-1024).to_bytes(4, 'big', signed=True) == b'\xff\xff\xfc\x00'
|
|
assert (-1024).to_bytes(4, 'little', signed=True) == b'\x00\xfc\xff\xff'
|
|
|
|
assert (2147483647).to_bytes(8, 'big', signed=False) == b'\x00\x00\x00\x00\x7f\xff\xff\xff'
|
|
assert (-2147483648).to_bytes(8, 'little', signed=True) == b'\x00\x00\x00\x80\xff\xff\xff\xff'
|
|
assert (2147483647).to_bytes(8, byteorder='big', signed=False) == b'\x00\x00\x00\x00\x7f\xff\xff\xff'
|
|
assert (-2147483648).to_bytes(8, byteorder='little', signed=True) == b'\x00\x00\x00\x80\xff\xff\xff\xff'
|
|
assert (2147483647).to_bytes(length=8, byteorder='big', signed=False) == b'\x00\x00\x00\x00\x7f\xff\xff\xff'
|
|
assert (-2147483648).to_bytes(length=8, byteorder='little', signed=True) == b'\x00\x00\x00\x80\xff\xff\xff\xff'
|
|
|
|
with assert_raises(ValueError):
|
|
(1024).to_bytes(4, 'something')
|
|
|
|
with assert_raises(OverflowError):
|
|
(-1024).to_bytes(4, 'big')
|
|
|
|
with assert_raises(OverflowError):
|
|
(1024).to_bytes(10000000000000000000000, 'big')
|
|
|
|
with assert_raises(OverflowError):
|
|
(1024).to_bytes(1, 'big')
|
|
|
|
with assert_raises(ValueError):
|
|
# check base first
|
|
int(' 1 ', base=1)
|
|
|
|
with assert_raises(ValueError):
|
|
int(' 1 ', base=37)
|
|
|
|
with assert_raises(ValueError):
|
|
int(' 1 ', base=-1)
|
|
|
|
with assert_raises(ValueError):
|
|
int(' 1 ', base=1000000000000000)
|
|
|
|
with assert_raises(ValueError):
|
|
int(' 1 ', base=-1000000000000000)
|
|
|
|
with assert_raises(TypeError):
|
|
int(base=2)
|
|
|
|
with assert_raises(TypeError):
|
|
int(1, base=2)
|
|
|
|
with assert_raises(TypeError):
|
|
# check that first parameter is truly positional only
|
|
int(val_options=1)
|
|
|
|
class A(object):
|
|
def __int__(self):
|
|
return 10
|
|
|
|
assert int(A()) == 10
|
|
|
|
class B(object):
|
|
pass
|
|
|
|
b = B()
|
|
b.__int__ = lambda: 20
|
|
|
|
with assert_raises(TypeError):
|
|
assert int(b) == 20
|
|
|
|
class C(object):
|
|
def __int__(self):
|
|
return 'str'
|
|
|
|
with assert_raises(TypeError):
|
|
int(C())
|
|
|
|
class I(int):
|
|
def __int__(self):
|
|
return 3
|
|
|
|
assert int(I(1)) == 3
|
|
|
|
class F(float):
|
|
def __int__(self):
|
|
return 3
|
|
|
|
assert int(F(1.2)) == 3
|
|
|
|
class BadInt(int):
|
|
def __int__(self):
|
|
return 42.0
|
|
|
|
with assert_raises(TypeError):
|
|
int(BadInt())
|
|
|
|
assert isinstance((0).__round__(), int)
|
|
assert isinstance((1).__round__(), int)
|
|
assert (0).__round__() == 0
|
|
assert (1).__round__() == 1
|
|
assert isinstance((0).__round__(0), int)
|
|
assert isinstance((1).__round__(0), int)
|
|
assert (0).__round__(0) == 0
|
|
assert (1).__round__(0) == 1
|
|
assert_raises(TypeError, lambda: (0).__round__(None))
|
|
assert_raises(TypeError, lambda: (1).__round__(None))
|
|
assert_raises(TypeError, lambda: (0).__round__(0.0))
|
|
assert_raises(TypeError, lambda: (1).__round__(0.0))
|
|
|
|
assert 00 == 0
|
|
assert 0_0 == 0
|
|
assert 03.2 == 3.2
|
|
assert 3+02j == 3+2j
|
|
|
|
# Invalid syntax:
|
|
src = """
|
|
b = 02
|
|
"""
|
|
|
|
with assert_raises(SyntaxError):
|
|
exec(src)
|
|
|
|
# Invalid syntax:
|
|
src = """
|
|
b = 03 + 2j
|
|
"""
|
|
|
|
with assert_raises(SyntaxError):
|
|
exec(src)
|
|
|
|
# Small int cache in [-5..256]
|
|
assert 1 is 1 # noqa
|
|
x = 6
|
|
assert 5 is (x-1) # noqa
|