mirror of https://github.com/exaloop/codon.git
1253 lines
37 KiB
Python
1253 lines
37 KiB
Python
from copy import copy, deepcopy
|
|
|
|
@tuple
|
|
class A:
|
|
a: int
|
|
b: float
|
|
|
|
def __getitem__(self: A, n: int):
|
|
return 1
|
|
|
|
def __getitem__(self: A, x: Slice):
|
|
if x.start is None and x.stop is None:
|
|
return -1
|
|
if x.start is None:
|
|
return 2
|
|
elif x.stop is None:
|
|
return 3
|
|
else:
|
|
return self.a
|
|
|
|
@dataclass(init=True, order=True, eq=True)
|
|
class A0:
|
|
pass
|
|
|
|
@dataclass(init=True, order=True, eq=True)
|
|
class A1:
|
|
a: int
|
|
|
|
@dataclass(init=True, order=True, eq=True)
|
|
class A2:
|
|
a: int
|
|
b: int
|
|
|
|
@dataclass(init=True, order=True, eq=True)
|
|
class A3:
|
|
a: int
|
|
b: int
|
|
c: int
|
|
|
|
@test
|
|
def test_tuple():
|
|
def test_in():
|
|
for i in range(10):
|
|
yield i, i in (4, 9, 10, -1, 3, 1), i in (7,)
|
|
assert list(test_in()) == [(0, False, False), (1, True, False), (2, False, False), (3, True, False), (4, True, False), (5, False, False), (6, False, False), (7, False, True), (8, False, False), (9, True, False)]
|
|
|
|
def test_cmp[T](a: T, b: T):
|
|
yield 'EQ', a == b
|
|
yield 'NE', a != b
|
|
yield 'LT', a < b
|
|
yield 'GT', a > b
|
|
yield 'LE', a <= b
|
|
yield 'GE', a >= b
|
|
|
|
assert list(test_cmp((1,), (2,))) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp((1,), (1,))) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp((2,), (1,))) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
assert list(test_cmp((1,2), (1,2))) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp((1,2,2), (1,2,3))) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp((1,2,-1), (1,0,1))) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
assert list(test_cmp((), ())) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp(A0(), A0())) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp(A1(1), A1(2))) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp(A1(1), A1(1))) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp(A1(2), A1(1))) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
assert list(test_cmp(A2(1,2), A2(1,2))) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp(A3(1,2,2), A3(1,2,3))) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp(A3(1,2,-1), A3(1,0,1))) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
|
|
t = (1,2,3)
|
|
assert (t[0], t[1], t[2]) == (1, 2, 3)
|
|
assert (t[-1], t[-2], t[-3]) == (3, 2, 1)
|
|
assert t[1:3] == (2, 3)
|
|
assert t[-3:1] == (1,)
|
|
assert t[-10:2] == (1, 2)
|
|
assert t[0:] == (1, 2, 3)
|
|
assert t[-2:] == (2, 3)
|
|
assert t[3:] == ()
|
|
assert t[:-1] == (1, 2)
|
|
assert t[:1] == (1,)
|
|
assert t[:] == (1, 2, 3)
|
|
assert t[::] == (1, 2, 3)
|
|
assert t[1::1] == (2, 3)
|
|
assert t[:2:1] == (1, 2)
|
|
assert t[::2] == (1, 3)
|
|
assert t[::-1] == (3, 2, 1)
|
|
assert t[0:3:-1] == ()
|
|
assert t[3:0:-1] == (3, 2)
|
|
|
|
a = A(42, 3.14)
|
|
assert a[0] == 1
|
|
assert a[:1] == 2
|
|
assert a[0:] == 3
|
|
assert a[0:1] == 42
|
|
assert a[:] == -1
|
|
|
|
assert str((11, 2, 333)) == '(11, 2, 333)'
|
|
assert str(()) == '()'
|
|
assert str((42,)) == '(42,)'
|
|
assert repr((11, 2, 333)) == '(11, 2, 333)'
|
|
assert repr(()) == '()'
|
|
assert repr((42,)) == '(42,)'
|
|
test_tuple()
|
|
|
|
@test
|
|
def test_dyn_tuple():
|
|
def D(*args):
|
|
return DynamicTuple(args)
|
|
|
|
def test_in():
|
|
for i in range(10):
|
|
yield i, i in D(4, 9, 10, -1, 3, 1), i in D(7)
|
|
assert list(test_in()) == [(0, False, False), (1, True, False), (2, False, False), (3, True, False), (4, True, False), (5, False, False), (6, False, False), (7, False, True), (8, False, False), (9, True, False)]
|
|
|
|
def test_cmp(a, b):
|
|
yield 'EQ', a == b
|
|
yield 'NE', a != b
|
|
yield 'LT', a < b
|
|
yield 'GT', a > b
|
|
yield 'LE', a <= b
|
|
yield 'GE', a >= b
|
|
|
|
assert list(test_cmp(D(1,2), D(1,2))) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp(D(1,2,2), D(1,2,3))) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp(D(1,2,-1), D(1,0,1))) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
assert list(test_cmp(DynamicTuple[int](), DynamicTuple[int]())) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
|
|
assert list(test_cmp((1,2), D(1,2))) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp((1,2,2), D(1,2,3))) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp((1,2,-1), D(1,0,1))) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
assert list(test_cmp((), DynamicTuple[int]())) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
|
|
assert list(test_cmp(D(1,2), (1,2))) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp(D(1,2,2), (1,2,3))) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp(D(1,2,-1), (1,0,1))) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
assert list(test_cmp(DynamicTuple[int](), ())) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
|
|
t = D(1,2,3)
|
|
assert D(t[0], t[1], t[2]) == D(1, 2, 3)
|
|
assert D(t[-1], t[-2], t[-3]) == D(3, 2, 1)
|
|
assert t[1:3] == D(2, 3)
|
|
assert t[-3:1] == D(1,)
|
|
assert t[-10:2] == D(1, 2)
|
|
assert t[0:] == D(1, 2, 3)
|
|
assert t[-2:] == D(2, 3)
|
|
assert t[3:] == DynamicTuple[int]()
|
|
assert t[:-1] == D(1, 2)
|
|
assert t[:1] == D(1)
|
|
assert t[:] == D(1, 2, 3)
|
|
assert t[::] == D(1, 2, 3)
|
|
assert t[1::1] == D(2, 3)
|
|
assert t[:2:1] == D(1, 2)
|
|
assert t[::2] == D(1, 3)
|
|
assert t[::-1] == D(3, 2, 1)
|
|
assert t[0:3:-1] == DynamicTuple[int]()
|
|
assert t[3:0:-1] == D(3, 2)
|
|
|
|
assert D(t[0], t[1], t[2]) == (1, 2, 3)
|
|
assert D(t[-1], t[-2], t[-3]) == (3, 2, 1)
|
|
assert t[1:3] == (2, 3)
|
|
assert t[-3:1] == (1,)
|
|
assert t[-10:2] == (1, 2)
|
|
assert t[0:] == (1, 2, 3)
|
|
assert t[-2:] == (2, 3)
|
|
assert t[3:] == ()
|
|
assert t[:-1] == (1, 2)
|
|
assert t[:1] == (1,)
|
|
assert t[:] == (1, 2, 3)
|
|
assert t[::] == (1, 2, 3)
|
|
assert t[1::1] == (2, 3)
|
|
assert t[:2:1] == (1, 2)
|
|
assert t[::2] == (1, 3)
|
|
assert t[::-1] == (3, 2, 1)
|
|
assert t[0:3:-1] == DynamicTuple[int]()
|
|
assert t[3:0:-1] == (3, 2)
|
|
|
|
t = (1,2,3)
|
|
assert (t[0], t[1], t[2]) == D(1, 2, 3)
|
|
assert (t[-1], t[-2], t[-3]) == D(3, 2, 1)
|
|
assert t[1:3] == D(2, 3)
|
|
assert t[-3:1] == D(1,)
|
|
assert t[-10:2] == D(1, 2)
|
|
assert t[0:] == D(1, 2, 3)
|
|
assert t[-2:] == D(2, 3)
|
|
assert t[3:] == DynamicTuple[int]()
|
|
assert t[:-1] == D(1, 2)
|
|
assert t[:1] == D(1)
|
|
assert t[:] == D(1, 2, 3)
|
|
assert t[::] == D(1, 2, 3)
|
|
assert t[1::1] == D(2, 3)
|
|
assert t[:2:1] == D(1, 2)
|
|
assert t[::2] == D(1, 3)
|
|
assert t[::-1] == D(3, 2, 1)
|
|
assert t[0:3:-1] == DynamicTuple[int]()
|
|
assert t[3:0:-1] == D(3, 2)
|
|
|
|
assert hash(D(1,2,3,4,5)) == hash((1,2,3,4,5))
|
|
|
|
assert (1, 2) + (3,) == (1, 2, 3)
|
|
assert (1,) + (2, 3) == (1, 2, 3)
|
|
assert (1, 2) + () == (1, 2)
|
|
assert () + () == ()
|
|
assert () + (1, 2) == (1, 2)
|
|
assert (1,) + (2,) == (1, 2)
|
|
assert (1, 2) * 3 == (1, 2, 1, 2, 1, 2)
|
|
assert () * 99 == ()
|
|
assert (1, 2, 3, 4) * 1 == (1, 2, 3, 4)
|
|
assert (1, 2) * 0 == ()
|
|
assert (1, 2) * (-1) == ()
|
|
assert () * -1 == ()
|
|
test_dyn_tuple()
|
|
|
|
@test
|
|
def test_list():
|
|
l1 = [i+1 for i in range(100)]
|
|
assert len(l1) == 100
|
|
l1 = l1[98:]
|
|
l2 = [1, 2] * 2
|
|
|
|
assert [a for a in l1] == [99, 100]
|
|
assert [a for a in l2] == [1, 2, 1, 2]
|
|
assert 2 * [1, 2] == l2
|
|
|
|
l1 = [i*2 for i in range(3)]
|
|
l1.insert(0, 99)
|
|
l1[0] += 1
|
|
del l1[1]
|
|
assert [a for a in l1[0:3]] == [100, 2, 4]
|
|
|
|
l3 = [1, 2, 3]
|
|
assert l3.remove(2) == True
|
|
assert l3.remove(2) == False
|
|
assert l3 == [1, 3]
|
|
assert list[int]().remove(0) == False
|
|
|
|
# l4 = [5, 1, 4, 2, 1, -10, 10, 100, -100]
|
|
# assert sorted(l4) == [-100, -10, 1, 1, 2, 4, 5, 10, 100]
|
|
#l4.sort()
|
|
#assert l4 == [-100, -10, 1, 1, 2, 4, 5, 10, 100]
|
|
#assert str(sorted(list[int]())) == "[]"
|
|
|
|
l5 = [11, 22, 33, 44]
|
|
del l5[-1]
|
|
assert l5 == [11, 22, 33]
|
|
l5.insert(-1, 55)
|
|
l5.insert(1000, 66)
|
|
l5.insert(-100, 77)
|
|
assert l5 == [77, 11, 22, 55, 33, 66]
|
|
l5 = [11, 22, 55, 33]
|
|
assert l5 + [1,2,3] == [11, 22, 55, 33, 1, 2, 3]
|
|
l5 += [1,2,3]
|
|
assert l5 == [11, 22, 55, 33, 1, 2, 3]
|
|
assert l5.pop() == 3
|
|
assert l5 * 2 == [11, 22, 55, 33, 1, 2, 11, 22, 55, 33, 1, 2]
|
|
l5 *= 2
|
|
assert l5 == [11, 22, 55, 33, 1, 2, 11, 22, 55, 33, 1, 2]
|
|
assert l5.index(33) == 3
|
|
try:
|
|
l5.index(0)
|
|
assert False
|
|
except ValueError as e:
|
|
assert str(e) == '0 is not in list'
|
|
l5 *= 0
|
|
assert len(l5) == 0
|
|
|
|
l6 = []
|
|
l6.extend('abc')
|
|
l6.extend(['xyz'])
|
|
l6.extend('')
|
|
assert l6 == ['a', 'b', 'c', 'xyz']
|
|
|
|
assert List[int]().copy() == List[int]()
|
|
assert [1,2,3].copy() == [1,2,3]
|
|
|
|
def test_cmp[T](a: T, b: T):
|
|
yield 'EQ', a == b
|
|
yield 'NE', a != b
|
|
yield 'LT', a < b
|
|
yield 'GT', a > b
|
|
yield 'LE', a <= b
|
|
yield 'GE', a >= b
|
|
|
|
assert list(test_cmp([1,2], [1,2])) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp([1,2,2], [1,2,3])) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp([1,2,-1], [1,0,1])) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
assert list(test_cmp(List[int](), List[int]())) == [('EQ', True), ('NE', False), ('LT', False), ('GT', False), ('LE', True), ('GE', True)]
|
|
assert list(test_cmp([1], List[int]())) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
assert list(test_cmp(List[int](), [1])) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp([1,2,-1], [2])) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp([1,2,-1], [1,2,-1,3])) == [('EQ', False), ('NE', True), ('LT', True), ('GT', False), ('LE', True), ('GE', False)]
|
|
assert list(test_cmp([1,2,-1,3], [1,2,-1])) == [('EQ', False), ('NE', True), ('LT', False), ('GT', True), ('LE', False), ('GE', True)]
|
|
|
|
assert str([1] + [2] + [] + [3]) == '[1, 2, 3]'
|
|
assert ['a', 'b'] + ['x', 'y', 'z'] == ['a', 'b'] + ['x', 'y', 'z']
|
|
assert [(1,1), (2,2)] + [] == [(1,1), (2,2)]
|
|
assert [] + [(1,1), (2,2)] == [(1,1), (2,2)]
|
|
assert List[int]() + List[int]() == List[int]()
|
|
l7 = [3.14, 2.5]
|
|
l7 += [9.99, -1.0]
|
|
assert l7 == [3.14, 2.5, 9.99, -1.0]
|
|
l8 = []
|
|
l8 += [11, 22, 33]
|
|
assert l8 == [11, 22, 33]
|
|
l8 = [11, 22, 33]
|
|
l8 += []
|
|
assert l8 == [11, 22, 33]
|
|
l8 = List[int]()
|
|
l8 += List[int]()
|
|
assert l8 == List[int]()
|
|
|
|
assert list(reversed(list('abc'))) == ['c', 'b', 'a']
|
|
assert list(list('abc')[::-1]) == ['c', 'b', 'a']
|
|
assert list(reversed(List[str]())) == List[str]()
|
|
|
|
# https://github.com/exaloop/codon/issues/402
|
|
b1 = [1 for _ in range(0)]
|
|
b2 = [str(x) for x in b1]
|
|
b3 = List[float](capacity=0)
|
|
b4 = List[float](capacity=-1)
|
|
assert len(b1) == 0
|
|
assert len(b2) == 0
|
|
assert len(b3) == 0
|
|
assert len(b4) == 0
|
|
b1.append(42)
|
|
b2.append('a')
|
|
b3.append(4.2)
|
|
b4.append(2.4)
|
|
assert b1 == [42]
|
|
assert b2 == ['a']
|
|
assert b3 == [4.2]
|
|
assert b4 == [2.4]
|
|
test_list()
|
|
|
|
@test
|
|
def test_setslice():
|
|
l = [0, 1]
|
|
a = l
|
|
|
|
for i in range(-3, 4):
|
|
a[:i] = l[:i]
|
|
assert a == l
|
|
a2 = a[:]
|
|
a2[:i] = a[:i]
|
|
assert a2 == a
|
|
a[i:] = l[i:]
|
|
assert a == l
|
|
a2 = a[:]
|
|
a2[i:] = a[i:]
|
|
assert a2 == a
|
|
for j in range(-3, 4):
|
|
a[i:j] = l[i:j]
|
|
assert a == l
|
|
a2 = a[:]
|
|
a2[i:j] = a[i:j]
|
|
assert a2 == a
|
|
|
|
a2 = a[:]
|
|
aa2 = a2[:]
|
|
aa2[:0] = [-2, -1]
|
|
assert aa2 == [-2, -1, 0, 1]
|
|
aa2[0:] = list[int]()
|
|
assert aa2 == list[int]()
|
|
|
|
a = [1, 2, 3, 4, 5]
|
|
a[:-1] = a
|
|
assert a == [1, 2, 3, 4, 5, 5]
|
|
a = [1, 2, 3, 4, 5]
|
|
a[1:] = a
|
|
assert a == [1, 1, 2, 3, 4, 5]
|
|
a = [1, 2, 3, 4, 5]
|
|
a[1:-1] = a
|
|
assert a == [1, 1, 2, 3, 4, 5, 5]
|
|
|
|
a = list[int]()
|
|
a[:] = list(range(10))
|
|
assert a == list(range(10))
|
|
|
|
a = list(range(20))
|
|
try:
|
|
a[0:10:0] = [1,2,3]
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
try:
|
|
a[0:10:2] = [1,2]
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
a[2:10:3] = [1,2,3]
|
|
assert a == [0, 1, 1, 3, 4, 2, 6, 7, 3, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
|
|
test_setslice()
|
|
|
|
@test
|
|
def test_delslice():
|
|
a = [0, 1]
|
|
del a[1:2]
|
|
del a[0:1]
|
|
assert a == list[int]()
|
|
|
|
a = [0, 1]
|
|
del a[1:2]
|
|
del a[0:1]
|
|
assert a == list[int]()
|
|
|
|
a = [0, 1]
|
|
del a[-2:-1]
|
|
assert a == [1]
|
|
|
|
a = [0, 1]
|
|
del a[-2:-1]
|
|
assert a == [1]
|
|
|
|
a = [0, 1]
|
|
del a[1:]
|
|
del a[:1]
|
|
assert a == list[int]()
|
|
|
|
a = [0, 1]
|
|
del a[1:]
|
|
del a[:1]
|
|
assert a == list[int]()
|
|
|
|
a = [0, 1]
|
|
del a[-1:]
|
|
assert a == [0]
|
|
|
|
a = [0, 1]
|
|
del a[-1:]
|
|
assert a == [0]
|
|
|
|
a = [0,1]
|
|
del a[:]
|
|
assert a == list[int]()
|
|
test_delslice()
|
|
|
|
@test
|
|
def test_extendedslicing():
|
|
a = [0,1,2,3,4]
|
|
del a[::2]
|
|
assert a == [1,3]
|
|
|
|
a = list(range(5))
|
|
del a[1::2]
|
|
assert a == [0,2,4]
|
|
|
|
a = list(range(5))
|
|
del a[1::-2]
|
|
assert a == [0,2,3,4]
|
|
|
|
a = list(range(10))
|
|
del a[::1000]
|
|
assert a == [1, 2, 3, 4, 5, 6, 7, 8, 9]
|
|
|
|
a = list(range(10))
|
|
a[::2] = [-1]*5
|
|
assert a == [-1, 1, -1, 3, -1, 5, -1, 7, -1, 9]
|
|
|
|
a = list(range(10))
|
|
a[::-4] = [10]*3
|
|
assert a == [0, 10, 2, 3, 4, 10, 6, 7, 8 ,10]
|
|
|
|
a = list(range(4))
|
|
a[::-1] = a
|
|
assert a == [3, 2, 1, 0]
|
|
|
|
a = list(range(10))
|
|
b = a[:]
|
|
c = a[:]
|
|
a[2:3] = [222, 333]
|
|
b[2:3] = [222, 333]
|
|
c[2:3:] = [222, 333]
|
|
assert a == b
|
|
assert a == c
|
|
|
|
a = list(range(10))
|
|
a[::2] = (0, 1, 2, 3, 4)
|
|
assert a == [0, 1, 1, 3, 2, 5, 3, 7, 4, 9]
|
|
|
|
assert repr(['x', 'y', 'z']) == "['x', 'y', 'z']"
|
|
assert repr(List[int]()) == '[]'
|
|
test_extendedslicing()
|
|
|
|
@test
|
|
def test_set():
|
|
s1 = {a for a in range(100)}
|
|
assert len(s1) == 100
|
|
s1 = {a%8 for a in range(100)}
|
|
for a in range(8):
|
|
assert a in s1
|
|
for a in range(8,100):
|
|
assert a not in s1
|
|
|
|
assert 5 in s1
|
|
s1.remove(5)
|
|
assert 5 not in s1
|
|
assert len(s1) == 7
|
|
|
|
s1 = {1,2,3,4}
|
|
s2 = {2,3,4,5}
|
|
s3 = set[int]()
|
|
|
|
assert (s1 | s2) == {1, 2, 3, 4, 5}
|
|
assert (s1 & s2) == {4, 2, 3}
|
|
assert (s1 ^ s2) == {1, 5}
|
|
assert (s1 | s3) == {1, 2, 3, 4}
|
|
assert (s1 & s3) == set[int]()
|
|
assert (s1 ^ s3) == {1, 2, 3, 4}
|
|
assert (s1 - s2) == {1}
|
|
assert (s2 - s1) == {5}
|
|
assert (s3 - s1 - s2) == set[int]()
|
|
assert (s1 > s2) == False
|
|
assert (s1 < s2) == False
|
|
assert (s3 <= s1) == True
|
|
assert (s2 >= s1) == False
|
|
assert ((s1 | s2) > s1) == True
|
|
|
|
s1c = copy(s1)
|
|
s2c = copy(s2)
|
|
s3c = copy(s3)
|
|
|
|
assert s1c == {1, 2, 3, 4}
|
|
s1c &= s2c
|
|
assert s1c == {2, 3, 4}
|
|
s1c -= s3c
|
|
assert s1c == {2, 3, 4}
|
|
s1c ^= s1c
|
|
assert s1c == set[int]()
|
|
s1c |= s2c
|
|
assert s1c == {2, 3, 4, 5}
|
|
assert s1 == {1, 2, 3, 4}
|
|
|
|
s1 = {1, 2, 3, 999999}
|
|
s2 = {1, 2, 3, 999999}
|
|
v = s1.pop()
|
|
assert v in s2
|
|
s2.remove(v)
|
|
|
|
v = s1.pop()
|
|
assert v in s2
|
|
s2.remove(v)
|
|
|
|
v = s1.pop()
|
|
assert v in s2
|
|
s2.remove(v)
|
|
|
|
v = s1.pop()
|
|
assert v in s2
|
|
s2.remove(v)
|
|
|
|
try:
|
|
s1.pop()
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
assert repr({(1,2)}) == '{(1, 2)}'
|
|
assert repr(Set[int]()) == 'set()'
|
|
test_set()
|
|
|
|
@test
|
|
def test_dict():
|
|
d1 = copy({a: a*a for a in range(100)})
|
|
assert len(d1) == 100
|
|
d1 = {a: a*a for a in range(5)}
|
|
assert len(copy(dict[int,int]())) == 0
|
|
|
|
assert [d1.get(a, -1) for a in range(6)] == [0, 1, 4, 9, 16, -1]
|
|
|
|
assert 2 in d1
|
|
del d1[2]
|
|
assert 2 not in d1
|
|
d1[2] = 44
|
|
assert 2 in d1
|
|
assert d1.get(2, -1) == 44
|
|
assert d1[3] == 9
|
|
|
|
del d1[3]
|
|
del d1[4]
|
|
|
|
assert [k for k in d1] == [0, 1, 2]
|
|
assert [t for t in d1.items()] == [(0, 0), (1, 1), (2, 44)]
|
|
|
|
d2 = {'x': 10, 'y': 0}
|
|
d2.increment('x')
|
|
d2.increment('y', by=-1)
|
|
d2.increment('z', by=2)
|
|
assert d2['x'] == 11
|
|
assert d2['y'] == -1
|
|
assert d2['z'] == 2
|
|
assert d2 == {'x': 11, 'y': -1, 'z': 2}
|
|
|
|
d3 = {1: 2, 42: 42}
|
|
d4 = {1: 5, 2: 9}
|
|
assert d3 | d4 == {1: 5, 42: 42, 2: 9}
|
|
d3 |= d4
|
|
assert d3 == {1: 5, 42: 42, 2: 9}
|
|
|
|
assert repr({1: ['x']}) == "{1: ['x']}"
|
|
assert repr(Dict[int,int]()) == '{}'
|
|
test_dict()
|
|
|
|
def slice_indices(slice, length):
|
|
"""
|
|
Reference implementation for the slice.indices method.
|
|
|
|
"""
|
|
# Compute step and length as integers.
|
|
#length = operator.index(length)
|
|
step: int = 1 if slice.step is None else slice.step
|
|
|
|
# Raise ValueError for negative length or zero step.
|
|
if length < 0:
|
|
raise ValueError("length should not be negative")
|
|
if step == 0:
|
|
raise ValueError("slice step cannot be zero")
|
|
|
|
# Find lower and upper bounds for start and stop.
|
|
lower = -1 if step < 0 else 0
|
|
upper = length - 1 if step < 0 else length
|
|
|
|
# Compute start.
|
|
if slice.start is None:
|
|
start = upper if step < 0 else lower
|
|
else:
|
|
start = slice.start
|
|
start = max(start + length, lower) if start < 0 else min(start, upper)
|
|
|
|
# Compute stop.
|
|
if slice.stop is None:
|
|
stop = lower if step < 0 else upper
|
|
else:
|
|
stop = slice.stop
|
|
stop = max(stop + length, lower) if stop < 0 else min(stop, upper)
|
|
|
|
return start, stop, step
|
|
|
|
def check_indices(slice, length):
|
|
err1 = False
|
|
err2 = False
|
|
|
|
try:
|
|
actual = slice.indices(length)
|
|
except ValueError:
|
|
err1 = True
|
|
|
|
try:
|
|
expected = slice_indices(slice, length)
|
|
except ValueError:
|
|
err2 = True
|
|
|
|
if err1 or err2:
|
|
return err1 and err2
|
|
|
|
if actual != expected:
|
|
return False
|
|
|
|
if length >= 0 and slice.step != 0:
|
|
actual = range(*slice.indices(length))
|
|
expected = range(length)[slice]
|
|
if actual != expected:
|
|
return False
|
|
|
|
return True
|
|
|
|
@test
|
|
def test_slice():
|
|
assert repr(slice(1, 2, 3)) == 'slice(1, 2, 3)'
|
|
|
|
s1 = slice(1, 2, 3)
|
|
s2 = slice(1, 2, 3)
|
|
s3 = slice(1, 2, 4)
|
|
|
|
assert s1 == s2
|
|
assert s1 != s3
|
|
|
|
s = slice(1)
|
|
assert s.start == None
|
|
assert s.stop == 1
|
|
assert s.step == None
|
|
|
|
s = slice(1, 2)
|
|
assert s.start == 1
|
|
assert s.stop == 2
|
|
assert s.step == None
|
|
|
|
s = slice(1, 2, 3)
|
|
assert s.start == 1
|
|
assert s.stop == 2
|
|
assert s.step == 3
|
|
|
|
# TODO
|
|
assert slice(None ).indices(10) == (0, 10, 1)
|
|
assert slice(None, None, 2).indices(10) == (0, 10, 2)
|
|
assert slice(1, None, 2).indices(10) == (1, 10, 2)
|
|
assert slice(None, None, -1).indices(10) == (9, -1, -1)
|
|
assert slice(None, None, -2).indices(10) == (9, -1, -2)
|
|
assert slice(3, None, -2).indices(10) == (3, -1, -2)
|
|
# issue 3004 tests
|
|
assert slice(None, -9).indices(10) == (0, 1, 1)
|
|
assert slice(None, -10).indices(10) == (0, 0, 1)
|
|
assert slice(None, -11).indices(10) == (0, 0, 1)
|
|
assert slice(None, -10, -1).indices(10) == (9, 0, -1)
|
|
assert slice(None, -11, -1).indices(10) == (9, -1, -1)
|
|
assert slice(None, -12, -1).indices(10) == (9, -1, -1)
|
|
assert slice(None, 9).indices(10) == (0, 9, 1)
|
|
assert slice(None, 10).indices(10) == (0, 10, 1)
|
|
assert slice(None, 11).indices(10) == (0, 10, 1)
|
|
assert slice(None, 8, -1).indices(10) == (9, 8, -1)
|
|
assert slice(None, 9, -1).indices(10) == (9, 9, -1)
|
|
assert slice(None, 10, -1).indices(10) == (9, 9, -1)
|
|
|
|
assert slice(-100, 100 ).indices(10) == slice(None).indices(10)
|
|
|
|
assert slice(100, -100, -1).indices(10) == slice(None, None, -1).indices(10)
|
|
|
|
assert slice(-100, 100, 2).indices(10) == (0, 10, 2)
|
|
|
|
import sys
|
|
assert list(range(10))[::sys.maxsize - 1] == [0]
|
|
|
|
# Check a variety of start, stop, step and length values, including
|
|
# values exceeding sys.maxsize (see issue #14794).
|
|
vals = [None, -2**100, -2**30, -53, -7, -1, 0, 1, 7, 53, 2**30, 2**100]
|
|
lengths = [0, 1, 7, 53, 2**30, 2**100]
|
|
#for slice_args in itertools.product(vals, repeat=3):
|
|
for a in vals:
|
|
for b in vals:
|
|
for c in vals:
|
|
slice_args = (a, b, c)
|
|
s = slice(*slice_args)
|
|
for length in lengths:
|
|
assert check_indices(s, length)
|
|
assert check_indices(slice(0, 10, 1), -3)
|
|
|
|
# Negative length should raise ValueError
|
|
try:
|
|
slice(None).indices(-1)
|
|
assert False
|
|
except ValueError:
|
|
pass
|
|
|
|
# Zero step should raise ValueError
|
|
try:
|
|
slice(0, 10, 0).indices(5)
|
|
except ValueError:
|
|
pass
|
|
|
|
# ... but it should be fine to use a custom class that provides index.
|
|
assert slice(0, 10, 1).indices(5) == (0, 5, 1)
|
|
''' # not yet supported in Codon
|
|
assert slice(MyIndexable(0), 10, 1).indices(5) == (0, 5, 1)
|
|
assert slice(0, MyIndexable(10), 1).indices(5) == (0, 5, 1)
|
|
assert slice(0, 10, MyIndexable(1)).indices(5) == (0, 5, 1)
|
|
assert slice(0, 10, 1).indices(MyIndexable(5)) == (0, 5, 1)
|
|
'''
|
|
tmp = []
|
|
class X[T](object):
|
|
tmp: T
|
|
def __setitem__(self, i, k):
|
|
self.tmp.append((i, k))
|
|
|
|
x = X(tmp)
|
|
x[1:2] = 42
|
|
assert tmp == [(slice(1, 2), 42)]
|
|
|
|
# Non-int elements
|
|
def check_types(s, T: type, U: type, V: type):
|
|
return (type(s.start) is Optional[T] and
|
|
type(s.stop) is Optional[U] and
|
|
type(s.step) is Optional[V])
|
|
assert check_types(slice(1j, 'x', 3.14), complex, str, float)
|
|
assert check_types(slice(None, 'x', 3.14), int, str, float)
|
|
assert check_types(slice(1j, None, 3.14), complex, int, float)
|
|
assert check_types(slice(1j, 'x', None), complex, str, int)
|
|
assert check_types(slice(1j, None, None), complex, int, int)
|
|
assert check_types(slice(None, 'x', None), int, str, int)
|
|
assert check_types(slice(None, None, 3.14), int, int, float)
|
|
assert check_types(slice(None, None, None), int, int, int)
|
|
assert check_types(slice(1j, 'x'), complex, str, int)
|
|
assert check_types(slice(None, 'x'), int, str, int)
|
|
assert check_types(slice(1j, None), complex, int, int)
|
|
assert check_types(slice(None, None), int, int, int)
|
|
assert check_types(slice(1j), int, complex, int)
|
|
assert check_types(slice(None), int, int, int)
|
|
|
|
# eq / ne
|
|
assert slice(1, 2, 3) == slice(1, 2, 3)
|
|
assert slice(0, 2, 3) != slice(1, 2, 3)
|
|
assert slice(1, 0, 3) != slice(1, 2, 3)
|
|
assert slice(1, 2, 0) != slice(1, 2, 3)
|
|
assert slice(None, None, None) == slice(None, None, None)
|
|
assert slice(None, 42, None) == slice(None, 42, None)
|
|
assert slice(None, 42, None) != slice(None, 43, None)
|
|
assert slice(1, None, 3) == slice(1, None, 3)
|
|
assert slice(1, None, 3) != slice(1, None, 0)
|
|
assert slice(1, None, 3) != slice(0, None, 3)
|
|
assert slice(1) == slice(1)
|
|
assert slice(1) != slice(2)
|
|
test_slice()
|
|
|
|
@test
|
|
def test_deque():
|
|
from collections import deque
|
|
|
|
dq = deque[int]()
|
|
dq.append(1)
|
|
dq.append(2)
|
|
dq.append(3)
|
|
dq.appendleft(11)
|
|
dq.appendleft(22)
|
|
assert str(dq) == 'deque([22, 11, 1, 2, 3])'
|
|
assert bool(dq) == True
|
|
|
|
# test cap increase:
|
|
dq.clear()
|
|
assert bool(dq) == False
|
|
for i in range(20):
|
|
dq.append(i)
|
|
dq.appendleft(i)
|
|
assert str(dq) == 'deque([19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19])'
|
|
assert len(dq) == 40
|
|
|
|
for i in range(19):
|
|
dq.pop()
|
|
dq.popleft()
|
|
assert str(dq) == 'deque([0, 0])'
|
|
for a in dq:
|
|
assert a == 0
|
|
|
|
assert (0 in dq) == True
|
|
assert (1 in dq) == False
|
|
assert str(copy(dq)) == 'deque([0, 0])'
|
|
|
|
# test maxlen:
|
|
dq = deque[int](5)
|
|
for i in range(100):
|
|
dq.append(i)
|
|
assert str(dq) == 'deque([95, 96, 97, 98, 99])'
|
|
|
|
for i in range(5):
|
|
dq.append(i)
|
|
assert str(dq) == 'deque([0, 1, 2, 3, 4])'
|
|
test_deque()
|
|
|
|
@test
|
|
def test_counter():
|
|
from collections import Counter
|
|
|
|
# main
|
|
c = Counter('abcaba')
|
|
assert c == Counter({'a':3 , 'b': 2, 'c': 1})
|
|
assert len(c) == 3
|
|
assert sum(c.values()) == 6
|
|
assert set(c.values()) == {1, 2, 3}
|
|
assert set(c.keys()) == {'a','b','c'}
|
|
assert set(c.items()) == {('a',3), ('b',2), ('c',1)}
|
|
assert c['b'] == 2
|
|
assert c['z'] == 0
|
|
assert c.__contains__('b')
|
|
assert not c.__contains__('z')
|
|
assert c.get('b', 10) == 2
|
|
assert c.get('z', 10) == 10
|
|
assert c == {'a':3 , 'b': 2, 'c': 1}
|
|
assert c.most_common() == [('a', 3), ('b', 2), ('c', 1)]
|
|
for i in range(5):
|
|
assert c.most_common(i) == [('a', 3), ('b', 2), ('c', 1)][:i]
|
|
|
|
c['a'] += 1 # increment an existing value
|
|
c['b'] -= 2 # sub existing value to zero
|
|
del c['c'] # remove an entry
|
|
del c['c'] # make sure that del doesn't raise KeyError
|
|
c['d'] -= 2 # sub from a missing value
|
|
c['e'] = -5 # directly assign a missing value
|
|
c['f'] += 4 # add to a missing value
|
|
|
|
assert dict(c) == {'a':4, 'b':0, 'd':-2, 'e':-5, 'f':4}
|
|
assert c.pop('f') == 4
|
|
assert 'f' not in c
|
|
for i in range(3):
|
|
elem, cnt = c.popitem()
|
|
assert elem not in c
|
|
c.clear()
|
|
assert c == {}
|
|
c.update({'a':5, 'b':3})
|
|
c.update({'c': 1})
|
|
c.update(Counter('a' * 50 + 'b' * 30))
|
|
c.update()
|
|
c.update('a' * 500 + 'b' * 300)
|
|
c.update('cdc')
|
|
assert c == {'a':555, 'b':333, 'c':3, 'd':1}
|
|
|
|
assert c.setdefault('d',5) == 1
|
|
assert c['d'] == 1
|
|
assert c.setdefault('e', 5) == 5
|
|
assert c['e'] == 5
|
|
|
|
|
|
# total
|
|
c = Counter({'a':10, 'b':5, 'c':0})
|
|
assert c.total() == 15
|
|
|
|
|
|
# conversions
|
|
s = 'she sells sea shells by the sea shore'
|
|
assert sorted(Counter(s).elements()) == sorted(s)
|
|
assert sorted(Counter(s)) == sorted(set(s))
|
|
assert dict(Counter(s)) == dict(Counter(s).items())
|
|
assert set(Counter(s)) == set(s)
|
|
|
|
|
|
# in invariant
|
|
c = Counter({'a':10, 'b':-2, 'c':0})
|
|
for elem in c:
|
|
assert elem in c
|
|
|
|
|
|
# multiset
|
|
c = Counter({'a':10, 'b':-2, 'c':0}) + Counter()
|
|
assert dict(c) == {'a':10}
|
|
|
|
from random import randrange, randint
|
|
elements = 'abcd'
|
|
for i in range(1000):
|
|
# test random pairs of multisets
|
|
p = Counter(dict((elem, randrange(-2,4)) for elem in elements))
|
|
p.update({'e':1, 'f':-1, 'g':0})
|
|
q = Counter(dict((elem, randrange(-2,4)) for elem in elements))
|
|
q.update({'h':1, 'i':-1, 'j':0})
|
|
|
|
result = p + q
|
|
for x in elements:
|
|
assert max(0, p[x] + q[x]) == result[x]
|
|
assert all(x>0 for x in result.values())
|
|
|
|
result = p - q
|
|
for x in elements:
|
|
assert max(0, p[x] - q[x]) == result[x]
|
|
assert all(x>0 for x in result.values())
|
|
|
|
result = p | q
|
|
for x in elements:
|
|
assert max(0, p[x], q[x]) == result[x]
|
|
assert all(x>0 for x in result.values())
|
|
|
|
result = p & q
|
|
for x in elements:
|
|
assert max(0, min(p[x], q[x])) == result[x]
|
|
assert all(x>0 for x in result.values())
|
|
|
|
elements = 'abcdef'
|
|
for i in range(100):
|
|
# verify that random multisets with no repeats are exactly like sets
|
|
p = Counter(dict((elem, randrange(0, 2)) for elem in elements))
|
|
q = Counter(dict((elem, randrange(0, 2)) for elem in elements))
|
|
|
|
counter_result = p - q
|
|
set_result = set(p.elements()) - set(q.elements())
|
|
assert counter_result == dict.fromkeys(set_result, 1)
|
|
|
|
counter_result = p | q
|
|
set_result = set(p.elements()) | set(q.elements())
|
|
assert counter_result == dict.fromkeys(set_result, 1)
|
|
|
|
counter_result = p & q
|
|
set_result = set(p.elements()) & set(q.elements())
|
|
assert counter_result == dict.fromkeys(set_result, 1)
|
|
|
|
|
|
# in-place
|
|
elements = 'abcd'
|
|
for i in range(1000):
|
|
# test random pairs of multisets
|
|
p = Counter(dict((elem, randrange(-2,4)) for elem in elements))
|
|
p.update({'e':1, 'f':-1, 'g':0})
|
|
q = Counter(dict((elem, randrange(-2,4)) for elem in elements))
|
|
q.update({'h':1, 'i':-1, 'j':0})
|
|
|
|
c = p.copy()
|
|
c_id = id(c)
|
|
regular_result = c + q
|
|
inplace_result = c.__iadd__(q)
|
|
assert inplace_result == regular_result
|
|
assert id(inplace_result) == c_id
|
|
|
|
c = p.copy()
|
|
c_id = id(c)
|
|
regular_result = c - q
|
|
inplace_result = c.__isub__(q)
|
|
assert inplace_result == regular_result
|
|
assert id(inplace_result) == c_id
|
|
|
|
c = p.copy()
|
|
c_id = id(c)
|
|
regular_result = c | q
|
|
inplace_result = c.__ior__(q)
|
|
assert inplace_result == regular_result
|
|
assert id(inplace_result) == c_id
|
|
|
|
c = p.copy()
|
|
c_id = id(c)
|
|
regular_result = c & q
|
|
inplace_result = c.__iand__(q)
|
|
assert inplace_result == regular_result
|
|
assert id(inplace_result) == c_id
|
|
|
|
|
|
# subtract
|
|
c = Counter({'a':-5, 'b':0, 'c':5, 'd':10, 'e':15,'g':40})
|
|
c.subtract({'a':1, 'b':2, 'c':-3, 'd':10, 'e':20, 'f':30, 'h':-50})
|
|
assert c == Counter({'a':-6, 'b':-2, 'c':8, 'd':0, 'e':-5, 'f':-30, 'g':40, 'h':50})
|
|
c = Counter({'a':-5, 'b':0, 'c':5, 'd':10, 'e':15,'g':40})
|
|
c.subtract(Counter({'a':1, 'b':2, 'c':-3, 'd':10, 'e':20, 'f':30, 'h':-50}))
|
|
assert c == Counter({'a':-6, 'b':-2, 'c':8, 'd':0, 'e':-5, 'f':-30, 'g':40, 'h':50})
|
|
|
|
c = Counter('aaabbcd')
|
|
c.subtract('aaaabbcce')
|
|
assert c == Counter({'a':-1, 'b':0, 'c':-1, 'd':1, 'e':-1})
|
|
|
|
c = Counter()
|
|
c.subtract({'self':42})
|
|
assert list(c.items()) == [('self', -42)]
|
|
c = Counter()
|
|
c.subtract({'iterable':42})
|
|
assert list(c.items()) == [('iterable', -42)]
|
|
|
|
|
|
# unary
|
|
c = Counter({'a':-5, 'b':0, 'c':5, 'd':10, 'e':15, 'g':40})
|
|
assert dict(+c) == {'c':5, 'd':10, 'e':15, 'g':40}
|
|
assert dict(-c) == {'a':5}
|
|
|
|
|
|
# equality
|
|
assert Counter({'a':3, 'b':2}) == Counter('ababa')
|
|
assert Counter({'a':3, 'b':2}) != Counter('babab')
|
|
|
|
|
|
# most common
|
|
c = Counter({v:k for k,v in enumerate('hgfedcba')})
|
|
q = [(v,k) for k,v in enumerate('hgfedcba')][::-1]
|
|
assert c.most_common() == q
|
|
for i in range(10):
|
|
assert c.most_common(i) == q[:i]
|
|
|
|
for limit in range(100):
|
|
for samples in range(100):
|
|
for most_common in range(100):
|
|
data = [randint(0, limit) for _ in range(samples)]
|
|
d = Counter(data)
|
|
exp = sorted(d.values(), reverse=True)[:most_common]
|
|
got = [v for k,v in d.most_common(most_common)]
|
|
assert exp == got
|
|
|
|
for limit in range(100):
|
|
for samples in range(100):
|
|
data = [randint(0, limit) for _ in range(samples)]
|
|
d = Counter(data)
|
|
exp = sorted(d.values(), reverse=True)
|
|
got = [v for k,v in d.most_common()]
|
|
assert exp == got
|
|
|
|
assert repr(Counter('abcabc')) == "Counter({'a': 2, 'b': 2, 'c': 2})"
|
|
test_counter()
|
|
|
|
@test
|
|
def test_defaultdict():
|
|
from collections import defaultdict
|
|
|
|
# basic
|
|
#d1 = defaultdict()
|
|
#self.assertEqual(d1.default_factory, None)
|
|
#d1.default_factory = list
|
|
d1 = defaultdict(list)
|
|
d1[12].append(42)
|
|
assert d1 == {12: [42]}
|
|
d1[12].append(24)
|
|
assert d1 == {12: [42, 24]}
|
|
d1[13]
|
|
d1[14]
|
|
assert d1 == {12: [42, 24], 13: [], 14: []}
|
|
assert d1[12] is not d1[13] is not d1[14]
|
|
#d2 = defaultdict(list, foo=1, bar=2)
|
|
#self.assertEqual(d2.default_factory, list)
|
|
#self.assertEqual(d2, {"foo": 1, "bar": 2})
|
|
#self.assertEqual(d2["foo"], 1)
|
|
#self.assertEqual(d2["bar"], 2)
|
|
#self.assertEqual(d2[42], [])
|
|
#self.assertIn("foo", d2)
|
|
#self.assertIn("foo", d2.keys())
|
|
#self.assertIn("bar", d2)
|
|
#self.assertIn("bar", d2.keys())
|
|
#self.assertIn(42, d2)
|
|
#self.assertIn(42, d2.keys())
|
|
#self.assertNotIn(12, d2)
|
|
#self.assertNotIn(12, d2.keys())
|
|
#d2.default_factory = None
|
|
#self.assertEqual(d2.default_factory, None)
|
|
#try:
|
|
# d2[15]
|
|
#except KeyError as err:
|
|
# self.assertEqual(err.args, (15,))
|
|
#else:
|
|
# self.fail("d2[15] didn't raise KeyError")
|
|
#self.assertRaises(TypeError, defaultdict, 1)
|
|
|
|
# missing
|
|
#d1 = defaultdict()
|
|
#self.assertRaises(KeyError, d1.__missing__, 42)
|
|
#d1.default_factory = list
|
|
#d1 = defaultdict(list)
|
|
assert d1.__missing__(42) == []
|
|
|
|
# repr
|
|
d1 = defaultdict(lambda: 0)
|
|
#self.assertEqual(d1.default_factory, None)
|
|
#self.assertEqual(repr(d1), "defaultdict(None, {})")
|
|
#self.assertEqual(eval(repr(d1)), d1)
|
|
d1[11] = 41
|
|
assert repr(d1) == "defaultdict(<default factory of 'int'>, {11: 41})"
|
|
d2 = defaultdict(lambda: 0) # TODO: use 'int' when it's fixed...
|
|
#self.assertEqual(d2.default_factory, int)
|
|
d2[12] = 42
|
|
assert repr(d2) == "defaultdict(<default factory of 'int'>, {12: 42})"
|
|
def foo(): return 43
|
|
d3 = defaultdict(foo)
|
|
#self.assertTrue(d3.default_factory is foo)
|
|
d3[13]
|
|
assert repr(d3) == "defaultdict(<default factory of 'int'>, {13: 43})"
|
|
|
|
|
|
# copy
|
|
d1 = defaultdict(list)
|
|
d2 = d1.copy()
|
|
#self.assertEqual(type(d2), defaultdict)
|
|
#self.assertEqual(d2.default_factory, None)
|
|
assert d2 == {}
|
|
#d1.default_factory = list
|
|
#d3 = d1.copy()
|
|
#self.assertEqual(type(d3), defaultdict)
|
|
#self.assertEqual(d3.default_factory, list)
|
|
#self.assertEqual(d3, {})
|
|
d1[42].append(0)
|
|
#d4 = d1.copy()
|
|
#assert d4 == {42: [0]}
|
|
#d4[12]
|
|
#assert d4 == {42: [], 12: []}
|
|
|
|
# Issue 6637: Copy fails for empty default dict
|
|
#d = defaultdict()
|
|
#d['a'] = 42
|
|
#e = d.copy()
|
|
#assert e['a'] == 42
|
|
|
|
|
|
# shallow copy
|
|
foobar = list
|
|
d1 = defaultdict(foobar)
|
|
d1[1] += [1]
|
|
d2 = copy(d1)
|
|
#self.assertEqual(d2.default_factory, foobar)
|
|
assert d2 == d1
|
|
#d1.default_factory = list
|
|
d2 = copy(d1)
|
|
#self.assertEqual(d2.default_factory, list)
|
|
assert d2 == d1
|
|
|
|
# deep copy
|
|
d1 = defaultdict(foobar)
|
|
d1[1].append(1)
|
|
d2 = deepcopy(d1)
|
|
#self.assertEqual(d2.default_factory, foobar)
|
|
assert d2 == d1
|
|
assert d1[1] is not d2[1]
|
|
#d1.default_factory = list
|
|
d2 = deepcopy(d1)
|
|
#self.assertEqual(d2.default_factory, list)
|
|
assert d2 == d1
|
|
|
|
# KeyError without factory
|
|
#d1 = defaultdict()
|
|
#try:
|
|
# d1[(1,)]
|
|
#except KeyError as err:
|
|
# self.assertEqual(err.args[0], (1,))
|
|
#else:
|
|
# self.fail("expected KeyError")
|
|
|
|
# pickling
|
|
#d = defaultdict(int)
|
|
#d[1]
|
|
#for proto in range(pickle.HIGHEST_PROTOCOL + 1):
|
|
# s = pickle.dumps(d, proto)
|
|
# o = pickle.loads(s)
|
|
# self.assertEqual(d, o)
|
|
|
|
# union
|
|
i = defaultdict(int, {1: 1, 2: 2})
|
|
s = defaultdict(int, {0: 0, 1: 111})
|
|
|
|
i_s = i | s
|
|
#self.assertIs(i_s.default_factory, int)
|
|
assert i_s == {1: 111, 2: 2, 0: 0}
|
|
assert sorted(i_s) == [0, 1, 2]
|
|
|
|
s_i = s | i
|
|
#self.assertIs(s_i.default_factory, str)
|
|
assert s_i == {0: 0, 1: 1, 2: 2}
|
|
assert sorted(s_i) == [0, 1, 2]
|
|
|
|
i_ds = i | dict(s)
|
|
#self.assertIs(i_ds.default_factory, int)
|
|
assert i_ds == {1: 111, 2: 2, 0: 0}
|
|
assert sorted(i_ds) == [0, 1, 2]
|
|
|
|
ds_i = dict(s) | i
|
|
#self.assertIs(ds_i.default_factory, int)
|
|
assert ds_i == {0: 0, 1: 1, 2: 2}
|
|
assert sorted(ds_i) == [0, 1, 2]
|
|
|
|
# We inherit a fine |= from dict, so just a few sanity checks here:
|
|
i |= list(s.items())
|
|
#self.assertIs(i.default_factory, int)
|
|
assert i == {1: 111, 2: 2, 0: 0}
|
|
assert sorted(i), [1, 2, 0]
|
|
|
|
# general
|
|
s = 'mississippi'
|
|
d = defaultdict(int)
|
|
for k in s:
|
|
d[k] += 1
|
|
assert sorted(d.items()) == [('i', 4), ('m', 1), ('p', 2), ('s', 4)]
|
|
|
|
s = 'mississippi'
|
|
d = defaultdict(int)
|
|
for k in s:
|
|
d[k] = d.get(k, 0) + 1
|
|
assert sorted(d.items()) == [('i', 4), ('m', 1), ('p', 2), ('s', 4)]
|
|
|
|
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
|
|
d = defaultdict(list)
|
|
for k, v in s:
|
|
d[k].append(v)
|
|
assert sorted(d.items()) == [('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
|
|
|
|
def constant_factory(value):
|
|
return lambda: value
|
|
|
|
d = defaultdict(constant_factory('<missing>'))
|
|
assert d[10] == '<missing>'
|
|
test_defaultdict()
|