mirror of https://github.com/exaloop/codon.git
202 lines
7.0 KiB
Python
202 lines
7.0 KiB
Python
@test
|
|
def test_min_max():
|
|
assert max(2, 1, 1, 1, 1) == 2
|
|
assert max(1, 2, 1, 1, 1) == 2
|
|
assert max(1, 1, 2, 1, 1) == 2
|
|
assert max(1, 1, 1, 2, 1) == 2
|
|
assert max(1, 1, 1, 1, 2) == 2
|
|
assert max(2, 1, 1, 1) == 2
|
|
assert max(1, 2, 1, 1) == 2
|
|
assert max(1, 1, 2, 1) == 2
|
|
assert max(1, 1, 1, 2) == 2
|
|
assert max(2, 1, 1) == 2
|
|
assert max(1, 2, 1) == 2
|
|
assert max(1, 1, 2) == 2
|
|
assert max(2, 1) == 2
|
|
assert max(1, 2) == 2
|
|
|
|
assert min(2, 1, 1, 1, 1) == 1
|
|
assert min(1, 2, 1, 1, 1) == 1
|
|
assert min(1, 1, 2, 1, 1) == 1
|
|
assert min(1, 1, 1, 2, 1) == 1
|
|
assert min(1, 1, 1, 1, 2) == 1
|
|
assert min(2, 1, 1, 1) == 1
|
|
assert min(1, 2, 1, 1) == 1
|
|
assert min(1, 1, 2, 1) == 1
|
|
assert min(1, 1, 1, 2) == 1
|
|
assert min(2, 1, 1) == 1
|
|
assert min(1, 2, 1) == 1
|
|
assert min(1, 1, 2) == 1
|
|
assert min(2, 1) == 1
|
|
assert min(1, 2) == 1
|
|
|
|
assert max(0, 1, 1, 1, 1) == 1
|
|
assert max(1, 0, 1, 1, 1) == 1
|
|
assert max(1, 1, 0, 1, 1) == 1
|
|
assert max(1, 1, 1, 0, 1) == 1
|
|
assert max(1, 1, 1, 1, 0) == 1
|
|
assert max(0, 1, 1, 1) == 1
|
|
assert max(1, 0, 1, 1) == 1
|
|
assert max(1, 1, 0, 1) == 1
|
|
assert max(1, 1, 1, 0) == 1
|
|
assert max(0, 1, 1) == 1
|
|
assert max(1, 0, 1) == 1
|
|
assert max(1, 1, 0) == 1
|
|
assert max(0, 1) == 1
|
|
assert max(1, 0) == 1
|
|
|
|
assert min(0, 1, 1, 1, 1) == 0
|
|
assert min(1, 0, 1, 1, 1) == 0
|
|
assert min(1, 1, 0, 1, 1) == 0
|
|
assert min(1, 1, 1, 0, 1) == 0
|
|
assert min(1, 1, 1, 1, 0) == 0
|
|
assert min(0, 1, 1, 1) == 0
|
|
assert min(1, 0, 1, 1) == 0
|
|
assert min(1, 1, 0, 1) == 0
|
|
assert min(1, 1, 1, 0) == 0
|
|
assert min(0, 1, 1) == 0
|
|
assert min(1, 0, 1) == 0
|
|
assert min(1, 1, 0) == 0
|
|
assert min(0, 1) == 0
|
|
assert min(1, 0) == 0
|
|
|
|
assert min(a*a for a in range(3)) == 0
|
|
assert max(a*a for a in range(3)) == 4
|
|
assert min([0, 2, -1]) == -1
|
|
assert max([0, 2, -1]) == 2
|
|
|
|
@test
|
|
def test_map_filter():
|
|
assert list(map(lambda i: i+1, (i*2 for i in range(5)))) == [1, 3, 5, 7, 9]
|
|
assert list(map(lambda i: i+1, (i*2 for i in range(0)))) == []
|
|
assert list(map(lambda i: i//2, map(lambda i: i-1, map(lambda i: i+1, (i*2 for i in range(5)))))) == [0, 1, 2, 3, 4]
|
|
def f(x: int) -> int:
|
|
return x - 1
|
|
def g(x: int) -> int:
|
|
return x + 1
|
|
assert list(map(f, map(g, (i*2 for i in range(5))))) == [0, 2, 4, 6, 8]
|
|
|
|
def h(x: list[int]):
|
|
return x
|
|
assert h(list(map(lambda i: i-1, map(lambda i: i+1, range(5))))) == [0, 1, 2, 3, 4]
|
|
|
|
assert list(filter(lambda i: i % 2 == 0, range(5))) == [0, 2, 4]
|
|
assert list(filter(lambda i: i % 2 == 1, filter(lambda i: i % 2 == 0, range(5)))) == []
|
|
|
|
assert list(filter(lambda i: i%2 == 0, map(lambda i: i*i, range(10)))) == [0, 4, 16, 36, 64]
|
|
|
|
@test
|
|
def test_int_format():
|
|
n = 0
|
|
assert (str(n), bin(n), oct(n), hex(n)) == ('0', '0b0', '0o0', '0x0')
|
|
|
|
n = -1
|
|
assert (str(n), bin(n), oct(n), hex(n)) == ('-1', '-0b1', '-0o1', '-0x1')
|
|
|
|
n = 12345
|
|
assert (str(n), bin(n), oct(n), hex(n)) == ('12345', '0b11000000111001', '0o30071', '0x3039')
|
|
|
|
n = -12345
|
|
assert (str(n), bin(n), oct(n), hex(n)) == ('-12345', '-0b11000000111001', '-0o30071', '-0x3039')
|
|
|
|
# this one is different than Python due to 64-bit ints
|
|
n = 0x8000000000000000
|
|
assert (str(n), bin(n), oct(n), hex(n)) == ('-9223372036854775808', '-0b1000000000000000000000000000000000000000000000000000000000000000', '-0o1000000000000000000000', '-0x8000000000000000')
|
|
|
|
n = 0x7fffffffffffffff
|
|
assert (str(n), bin(n), oct(n), hex(n)) == ('9223372036854775807', '0b111111111111111111111111111111111111111111111111111111111111111', '0o777777777777777777777', '0x7fffffffffffffff')
|
|
|
|
m = i32(0)
|
|
assert (str(m), bin(m), oct(m), hex(m)) == ('0', '0b0', '0o0', '0x0')
|
|
|
|
m = i32(-1)
|
|
assert (str(m), bin(m), oct(m), hex(m)) == ('-1', '-0b1', '-0o1', '-0x1')
|
|
|
|
m = i32(12345)
|
|
assert (str(m), bin(m), oct(m), hex(m)) == ('12345', '0b11000000111001', '0o30071', '0x3039')
|
|
|
|
m = i32(-12345)
|
|
assert (str(m), bin(m), oct(m), hex(m)) == ('-12345', '-0b11000000111001', '-0o30071', '-0x3039')
|
|
|
|
k = Int[128](0)
|
|
assert (str(k), bin(k), oct(k), hex(k)) == ('0', '0b0', '0o0', '0x0')
|
|
|
|
k = Int[128](-1)
|
|
assert (str(k), bin(k), oct(k), hex(k)) == ('-1', '-0b1', '-0o1', '-0x1')
|
|
|
|
k = Int[128](12345)
|
|
assert (str(k), bin(k), oct(k), hex(k)) == ('12345', '0b11000000111001', '0o30071', '0x3039')
|
|
|
|
k = Int[128](-12345)
|
|
assert (str(k), bin(k), oct(k), hex(k)) == ('-12345', '-0b11000000111001', '-0o30071', '-0x3039')
|
|
|
|
# this one is different than Python due to 64-bit ints
|
|
k = Int[128](0x8000000000000000)
|
|
assert (str(k), bin(k), oct(k), hex(k)) == ('-9223372036854775808', '-0b1000000000000000000000000000000000000000000000000000000000000000', '-0o1000000000000000000000', '-0x8000000000000000')
|
|
|
|
k = Int[128](0x7fffffffffffffff)
|
|
assert (str(k), bin(k), oct(k), hex(k)) == ('9223372036854775807', '0b111111111111111111111111111111111111111111111111111111111111111', '0o777777777777777777777', '0x7fffffffffffffff')
|
|
|
|
class A:
|
|
def __len__(self):
|
|
return 42
|
|
def __getitem__(self, idx):
|
|
return idx
|
|
|
|
@test
|
|
def test_reversed():
|
|
assert list(reversed([1,2,3])) == [3,2,1]
|
|
assert list(reversed('abc')) == ['c','b','a']
|
|
assert list(reversed('')) == []
|
|
assert list(reversed(A())) == list(reversed(range(42)))
|
|
|
|
@test
|
|
def test_divmod():
|
|
import sys, math
|
|
assert divmod(12, 7) == (1, 5)
|
|
assert divmod(-12, 7) == (-2, 2)
|
|
assert divmod(12, -7) == (-2, -2)
|
|
assert divmod(-12, -7) == (1, -5)
|
|
|
|
assert divmod(i32(12), i32(7)) == (i32(1), i32(5))
|
|
assert divmod(i32(-12), i32(7)) == (i32(-2), i32(2))
|
|
assert divmod(i32(12), i32(-7)) == (i32(-2), i32(-2))
|
|
assert divmod(i32(-12), i32(-7)) == (i32(1), i32(-5))
|
|
|
|
assert divmod(u32(12), u32(7)) == (u32(1), u32(5))
|
|
|
|
i128 = Int[128]
|
|
assert divmod(i128(12), i128(7)) == (i128(1), i128(5))
|
|
assert divmod(i128(-12), i128(7)) == (i128(-2), i128(2))
|
|
assert divmod(i128(12), i128(-7)) == (i128(-2), i128(-2))
|
|
assert divmod(i128(-12), i128(-7)) == (i128(1), i128(-5))
|
|
|
|
class X:
|
|
n: int
|
|
def __floordiv__(self, other: X):
|
|
return X(self.n // other.n)
|
|
def __mod__(self, other: X):
|
|
return X(self.n % other.n)
|
|
def __eq__(self, other: X):
|
|
return self.n == other.n
|
|
def __nq__(self, other: X):
|
|
return self.n != other.n
|
|
assert divmod(X(12), X(7)) == (X(1), X(5))
|
|
|
|
# following is invalid in our case due to 64-bit ints
|
|
# print divmod(-sys.maxsize-1, -1), (sys.maxsize+1, 0)
|
|
|
|
for num, denom, exp_result in [ (3.25, 1.0, (3.0, 0.25)),
|
|
(-3.25, 1.0, (-4.0, 0.75)),
|
|
(3.25, -1.0, (-4.0, -0.75)),
|
|
(-3.25, -1.0, (3.0, -0.25))]:
|
|
result = divmod(num, denom)
|
|
assert math.isclose(result[0], exp_result[0])
|
|
assert math.isclose(result[1], exp_result[1])
|
|
|
|
test_min_max()
|
|
test_map_filter()
|
|
test_int_format()
|
|
test_reversed()
|
|
test_divmod()
|