mirror of
https://github.com/exaloop/codon.git
synced 2025-06-03 15:03:52 +08:00
575 lines
12 KiB
Plaintext
575 lines
12 KiB
Plaintext
from operator import *
|
|
import operator
|
|
|
|
def apply1(f, x, expected):
|
|
return f(x) == expected
|
|
|
|
def apply2(f, lhs, rhs, expected):
|
|
return f(lhs, rhs) == expected
|
|
|
|
n_eq = 0
|
|
n_ne = 0
|
|
n_lt = 0
|
|
n_le = 0
|
|
n_gt = 0
|
|
n_ge = 0
|
|
|
|
n_len = 0
|
|
n_bool = 0
|
|
|
|
n_abs = 0
|
|
n_pos = 0
|
|
n_neg = 0
|
|
n_inv = 0
|
|
n_index = 0
|
|
|
|
n_add = 0
|
|
n_sub = 0
|
|
n_mul = 0
|
|
n_matmul = 0
|
|
n_truediv = 0
|
|
n_floordiv = 0
|
|
n_mod = 0
|
|
n_pow = 0
|
|
n_and = 0
|
|
n_or = 0
|
|
n_xor = 0
|
|
n_lshift = 0
|
|
n_rshift = 0
|
|
|
|
n_iadd = 0
|
|
n_isub = 0
|
|
n_imul = 0
|
|
n_imatmul = 0
|
|
n_itruediv = 0
|
|
n_ifloordiv = 0
|
|
n_imod = 0
|
|
n_ipow = 0
|
|
n_iand = 0
|
|
n_ior = 0
|
|
n_ixor = 0
|
|
n_ilshift = 0
|
|
n_irshift = 0
|
|
|
|
class C:
|
|
def __eq__(self, other: C):
|
|
global n_eq
|
|
n_eq += 1
|
|
return False
|
|
|
|
def __ne__(self, other: C):
|
|
global n_ne
|
|
n_ne += 1
|
|
return False
|
|
|
|
def __lt__(self, other: C):
|
|
global n_lt
|
|
n_lt += 1
|
|
return False
|
|
|
|
def __le__(self, other: C):
|
|
global n_le
|
|
n_le += 1
|
|
return False
|
|
|
|
def __gt__(self, other: C):
|
|
global n_gt
|
|
n_gt += 1
|
|
return False
|
|
|
|
def __ge__(self, other: C):
|
|
global n_ge
|
|
n_ge += 1
|
|
return False
|
|
|
|
def __len__(self):
|
|
global n_len
|
|
n_len += 1
|
|
return 42
|
|
|
|
def __bool__(self):
|
|
global n_bool
|
|
n_bool += 1
|
|
return True
|
|
|
|
def __abs__(self):
|
|
global n_abs
|
|
n_abs += 1
|
|
return 'abs'
|
|
|
|
def __pos__(self):
|
|
global n_pos
|
|
n_pos += 1
|
|
return 'pos'
|
|
|
|
def __neg__(self):
|
|
global n_neg
|
|
n_neg += 1
|
|
return 'neg'
|
|
|
|
def __invert__(self):
|
|
global n_inv
|
|
n_inv += 1
|
|
return 'inv'
|
|
|
|
def __index__(self):
|
|
global n_index
|
|
n_index += 1
|
|
return 'index'
|
|
|
|
def __add__(self, other: C):
|
|
global n_add
|
|
n_add += 1
|
|
return 'add'
|
|
|
|
def __sub__(self, other: C):
|
|
global n_sub
|
|
n_sub += 1
|
|
return 'sub'
|
|
|
|
def __mul__(self, other: C):
|
|
global n_mul
|
|
n_mul += 1
|
|
return 'mul'
|
|
|
|
def __matmul__(self, other: C):
|
|
global n_matmul
|
|
n_matmul += 1
|
|
return 'matmul'
|
|
|
|
def __truediv__(self, other: C):
|
|
global n_truediv
|
|
n_truediv += 1
|
|
return 'truediv'
|
|
|
|
def __floordiv__(self, other: C):
|
|
global n_floordiv
|
|
n_floordiv += 1
|
|
return 'floordiv'
|
|
|
|
def __mod__(self, other: C):
|
|
global n_mod
|
|
n_mod += 1
|
|
return 'mod'
|
|
|
|
def __pow__(self, other: C):
|
|
global n_pow
|
|
n_pow += 1
|
|
return 'pow'
|
|
|
|
def __and__(self, other: C):
|
|
global n_and
|
|
n_and += 1
|
|
return 'and'
|
|
|
|
def __or__(self, other: C):
|
|
global n_or
|
|
n_or += 1
|
|
return 'or'
|
|
|
|
def __xor__(self, other: C):
|
|
global n_xor
|
|
n_xor += 1
|
|
return 'xor'
|
|
|
|
def __lshift__(self, other: C):
|
|
global n_lshift
|
|
n_lshift += 1
|
|
return 'lshift'
|
|
|
|
def __rshift__(self, other: C):
|
|
global n_rshift
|
|
n_rshift += 1
|
|
return 'rshift'
|
|
|
|
def __iadd__(self, other: C):
|
|
global n_iadd
|
|
n_iadd += 1
|
|
return self
|
|
|
|
def __isub__(self, other: C):
|
|
global n_isub
|
|
n_isub += 1
|
|
return self
|
|
|
|
def __imul__(self, other: C):
|
|
global n_imul
|
|
n_imul += 1
|
|
return self
|
|
|
|
def __imatmul__(self, other: C):
|
|
global n_imatmul
|
|
n_imatmul += 1
|
|
return self
|
|
|
|
def __itruediv__(self, other: C):
|
|
global n_itruediv
|
|
n_itruediv += 1
|
|
return self
|
|
|
|
def __ifloordiv__(self, other: C):
|
|
global n_ifloordiv
|
|
n_ifloordiv += 1
|
|
return self
|
|
|
|
def __imod__(self, other: C):
|
|
global n_imod
|
|
n_imod += 1
|
|
return self
|
|
|
|
def __ipow__(self, other: C):
|
|
global n_ipow
|
|
n_ipow += 1
|
|
return self
|
|
|
|
def __iand__(self, other: C):
|
|
global n_iand
|
|
n_iand += 1
|
|
return self
|
|
|
|
def __ior__(self, other: C):
|
|
global n_ior
|
|
n_ior += 1
|
|
return self
|
|
|
|
def __ixor__(self, other: C):
|
|
global n_ixor
|
|
n_ixor += 1
|
|
return self
|
|
|
|
def __ilshift__(self, other: C):
|
|
global n_ilshift
|
|
n_ilshift += 1
|
|
return self
|
|
|
|
def __irshift__(self, other: C):
|
|
global n_irshift
|
|
n_irshift += 1
|
|
return 'rshift'
|
|
|
|
@test
|
|
def test_comparisons():
|
|
assert apply2(eq, 1, 2, False)
|
|
assert apply2(eq, 2, 1, False)
|
|
assert apply2(eq, 1, 1, True)
|
|
assert apply2(eq, 1, 1.1, False)
|
|
|
|
assert apply2(operator.__eq__, 1, 2, False)
|
|
assert apply2(operator.__eq__, 2, 1, False)
|
|
assert apply2(operator.__eq__, 1, 1, True)
|
|
assert apply2(operator.__eq__, 1, 1.1, False)
|
|
|
|
assert apply2(ne, 1, 2, True)
|
|
assert apply2(ne, 2, 1, True)
|
|
assert apply2(ne, 1, 1, False)
|
|
assert apply2(ne, 1, 1.1, True)
|
|
|
|
assert apply2(operator.__ne__, 1, 2, True)
|
|
assert apply2(operator.__ne__, 2, 1, True)
|
|
assert apply2(operator.__ne__, 1, 1, False)
|
|
assert apply2(operator.__ne__, 1, 1.1, True)
|
|
|
|
assert apply2(lt, 1, 2, True)
|
|
assert apply2(lt, 2, 1, False)
|
|
assert apply2(lt, 1, 1, False)
|
|
assert apply2(lt, 1, 1.1, True)
|
|
|
|
assert apply2(operator.__lt__, 1, 2, True)
|
|
assert apply2(operator.__lt__, 2, 1, False)
|
|
assert apply2(operator.__lt__, 1, 1, False)
|
|
assert apply2(operator.__lt__, 1, 1.1, True)
|
|
|
|
assert apply2(le, 1, 2, True)
|
|
assert apply2(le, 2, 1, False)
|
|
assert apply2(le, 1, 1, True)
|
|
assert apply2(le, 1, 1.1, True)
|
|
|
|
assert apply2(operator.__le__, 1, 2, True)
|
|
assert apply2(operator.__le__, 2, 1, False)
|
|
assert apply2(operator.__le__, 1, 1, True)
|
|
assert apply2(operator.__le__, 1, 1.1, True)
|
|
|
|
assert apply2(gt, 1, 2, False)
|
|
assert apply2(gt, 2, 1, True)
|
|
assert apply2(gt, 1, 1, False)
|
|
assert apply2(gt, 1, 1.1, False)
|
|
|
|
assert apply2(operator.__gt__, 1, 2, False)
|
|
assert apply2(operator.__gt__, 2, 1, True)
|
|
assert apply2(operator.__gt__, 1, 1, False)
|
|
assert apply2(operator.__gt__, 1, 1.1, False)
|
|
|
|
assert apply2(ge, 1, 2, False)
|
|
assert apply2(ge, 2, 1, True)
|
|
assert apply2(ge, 1, 1, True)
|
|
assert apply2(ge, 1, 1.1, False)
|
|
|
|
assert apply2(operator.__ge__, 1, 2, False)
|
|
assert apply2(operator.__ge__, 2, 1, True)
|
|
assert apply2(operator.__ge__, 1, 1, True)
|
|
assert apply2(operator.__ge__, 1, 1.1, False)
|
|
|
|
assert apply2(eq, C(), C(), False)
|
|
assert n_eq == 1
|
|
assert apply2(ne, C(), C(), False)
|
|
assert n_ne == 1
|
|
assert apply2(lt, C(), C(), False)
|
|
assert n_lt == 1
|
|
assert apply2(le, C(), C(), False)
|
|
assert n_le == 1
|
|
assert apply2(gt, C(), C(), False)
|
|
assert n_gt == 1
|
|
assert apply2(ge, C(), C(), False)
|
|
assert n_ge == 1
|
|
|
|
assert apply2(operator.__eq__, C(), C(), False)
|
|
assert n_eq == 2
|
|
assert apply2(operator.__ne__, C(), C(), False)
|
|
assert n_ne == 2
|
|
assert apply2(operator.__lt__, C(), C(), False)
|
|
assert n_lt == 2
|
|
assert apply2(operator.__le__, C(), C(), False)
|
|
assert n_le == 2
|
|
assert apply2(operator.__gt__, C(), C(), False)
|
|
assert n_gt == 2
|
|
assert apply2(operator.__ge__, C(), C(), False)
|
|
assert n_ge == 2
|
|
test_comparisons()
|
|
|
|
class A1:
|
|
def __bool__(self):
|
|
return True
|
|
|
|
def __len__(self):
|
|
return 0
|
|
|
|
class A2:
|
|
def __len__(self):
|
|
return 42
|
|
|
|
@test
|
|
def test_truthiness():
|
|
assert truth(1)
|
|
assert not truth(0)
|
|
assert not_(False)
|
|
assert not not_(True)
|
|
assert not not_(A1())
|
|
assert not not_(A2())
|
|
|
|
a = A1()
|
|
b = A1()
|
|
|
|
assert is_(a, a)
|
|
assert not is_(a, b)
|
|
assert is_not(a, b)
|
|
assert not is_not(a, a)
|
|
|
|
assert truth(C())
|
|
assert n_bool == 1
|
|
test_truthiness()
|
|
|
|
@test
|
|
def test_ops():
|
|
x = C()
|
|
y = C()
|
|
|
|
assert abs(x) == 'abs'
|
|
assert n_abs == 1
|
|
assert operator.__abs__(x) == 'abs'
|
|
assert n_abs == 2
|
|
|
|
assert pos(x) == 'pos'
|
|
assert n_pos == 1
|
|
assert operator.__pos__(x) == 'pos'
|
|
assert n_pos == 2
|
|
|
|
assert neg(x) == 'neg'
|
|
assert n_neg == 1
|
|
assert operator.__neg__(x) == 'neg'
|
|
assert n_neg == 2
|
|
|
|
assert inv(x) == 'inv'
|
|
assert n_inv == 1
|
|
assert operator.__inv__(x) == 'inv'
|
|
assert n_inv == 2
|
|
assert invert(x) == 'inv'
|
|
assert n_inv == 3
|
|
assert operator.__invert__(x) == 'inv'
|
|
assert n_inv == 4
|
|
|
|
assert index(x) == 'index'
|
|
assert n_index == 1
|
|
assert operator.__index__(x) == 'index'
|
|
assert n_index == 2
|
|
|
|
assert add(x, y) == 'add'
|
|
assert n_add == 1
|
|
assert operator.__add__(x, y) == 'add'
|
|
assert n_add == 2
|
|
|
|
assert iadd(x, y) is x
|
|
assert n_iadd == 1
|
|
assert operator.__iadd__(x, y) is x
|
|
assert n_iadd == 2
|
|
|
|
assert sub(x, y) == 'sub'
|
|
assert n_sub == 1
|
|
assert operator.__sub__(x, y) == 'sub'
|
|
assert n_sub == 2
|
|
|
|
assert isub(x, y) is x
|
|
assert n_isub == 1
|
|
assert operator.__isub__(x, y) is x
|
|
assert n_isub == 2
|
|
|
|
assert mul(x, y) == 'mul'
|
|
assert n_mul == 1
|
|
assert operator.__mul__(x, y) == 'mul'
|
|
assert n_mul == 2
|
|
|
|
assert imul(x, y) is x
|
|
assert n_imul == 1
|
|
assert operator.__imul__(x, y) is x
|
|
assert n_imul == 2
|
|
|
|
assert matmul(x, y) == 'matmul'
|
|
assert n_matmul == 1
|
|
assert operator.__matmul__(x, y) == 'matmul'
|
|
assert n_matmul == 2
|
|
|
|
assert imatmul(x, y) is x
|
|
assert n_imatmul == 1
|
|
assert operator.__imatmul__(x, y) is x
|
|
assert n_imatmul == 2
|
|
|
|
assert truediv(x, y) == 'truediv'
|
|
assert n_truediv == 1
|
|
assert operator.__truediv__(x, y) == 'truediv'
|
|
assert n_truediv == 2
|
|
|
|
assert itruediv(x, y) is x
|
|
assert n_itruediv == 1
|
|
assert operator.__itruediv__(x, y) is x
|
|
assert n_itruediv == 2
|
|
|
|
assert floordiv(x, y) == 'floordiv'
|
|
assert n_floordiv == 1
|
|
assert operator.__floordiv__(x, y) == 'floordiv'
|
|
assert n_floordiv == 2
|
|
|
|
assert ifloordiv(x, y) is x
|
|
assert n_ifloordiv == 1
|
|
assert operator.__ifloordiv__(x, y) is x
|
|
assert n_ifloordiv == 2
|
|
|
|
assert mod(x, y) == 'mod'
|
|
assert n_mod == 1
|
|
assert operator.__mod__(x, y) == 'mod'
|
|
assert n_mod == 2
|
|
|
|
assert imod(x, y) is x
|
|
assert n_imod == 1
|
|
assert operator.__imod__(x, y) is x
|
|
assert n_imod == 2
|
|
|
|
assert pow(x, y) == 'pow'
|
|
assert n_pow == 1
|
|
assert operator.__pow__(x, y) == 'pow'
|
|
assert n_pow == 2
|
|
|
|
assert ipow(x, y) is x
|
|
assert n_ipow == 1
|
|
assert operator.__ipow__(x, y) is x
|
|
assert n_ipow == 2
|
|
|
|
assert and_(x, y) == 'and'
|
|
assert n_and == 1
|
|
assert operator.__and__(x, y) == 'and'
|
|
assert n_and == 2
|
|
|
|
assert iand(x, y) is x
|
|
assert n_iand == 1
|
|
assert operator.__iand__(x, y) is x
|
|
assert n_iand == 2
|
|
|
|
assert or_(x, y) == 'or'
|
|
assert n_or == 1
|
|
assert operator.__or__(x, y) == 'or'
|
|
assert n_or == 2
|
|
|
|
assert ior(x, y) is x
|
|
assert n_ior == 1
|
|
assert operator.__ior__(x, y) is x
|
|
assert n_ior == 2
|
|
|
|
assert xor(x, y) == 'xor'
|
|
assert n_xor == 1
|
|
assert operator.__xor__(x, y) == 'xor'
|
|
assert n_xor == 2
|
|
|
|
assert ixor(x, y) is x
|
|
assert n_ixor == 1
|
|
assert operator.__ixor__(x, y) is x
|
|
assert n_ixor == 2
|
|
|
|
assert lshift(x, y) == 'lshift'
|
|
assert n_lshift == 1
|
|
assert operator.__lshift__(x, y) == 'lshift'
|
|
assert n_lshift == 2
|
|
|
|
assert ilshift(x, y) is x
|
|
assert n_ilshift == 1
|
|
assert operator.__ilshift__(x, y) is x
|
|
assert n_ilshift == 2
|
|
|
|
assert rshift(x, y) == 'rshift'
|
|
assert n_rshift == 1
|
|
assert operator.__rshift__(x, y) == 'rshift'
|
|
assert n_rshift == 2
|
|
|
|
assert irshift(x, y) is x
|
|
assert n_irshift == 1
|
|
assert operator.__irshift__(x, y) is x
|
|
assert n_irshift == 2
|
|
test_ops()
|
|
|
|
class B1:
|
|
def __length_hint__(self):
|
|
return 101
|
|
|
|
class B2:
|
|
def __length_hint__(self):
|
|
return 202
|
|
|
|
def __len__(self):
|
|
return 303
|
|
|
|
class B3:
|
|
pass
|
|
|
|
@test
|
|
def test_sequence_ops():
|
|
assert concat([1,2], [3,4]) == [1,2,3,4]
|
|
assert operator.__concat__([1,2], [3,4]) == [1,2,3,4]
|
|
assert contains([1,2,3], 2)
|
|
assert not contains([1,2,3], 0)
|
|
assert operator.__contains__([1,2,3], 2)
|
|
assert not operator.__contains__([1,2,3], 0)
|
|
assert countOf([1,2,1,1], 1) == 3
|
|
|
|
v = [1,2,3]
|
|
assert getitem(v, 1) == 2
|
|
delitem(v, 1)
|
|
assert v == [1, 3]
|
|
setitem(v, 1, 99)
|
|
assert v == [1, 99]
|
|
|
|
assert length_hint(B1()) == 101
|
|
assert length_hint(B2()) == 303
|
|
assert length_hint(B3()) == 0
|
|
assert length_hint(B3(), default=404) == 404
|
|
|
|
assert itemgetter(-1)([11,22,33]) == 33
|
|
assert itemgetter(-1,-2,-3)([11,22,33]) == (33,22,11)
|
|
test_sequence_ops()
|