def test_remove_duplicates():
for ds in to_test:
a = ds([1, 2, 10, None, 3.4, "Hello", True])
a.remove_duplicates()
assert a == ds([1, 2, 10, None, 3.4, "Hello"
]) # True is considered duplicated as there is 1 there
b = ds([2, 1, 1, 2])
b.remove_duplicates()
assert b == ds([2, 1])
c = ds([2, 1, 1, 1, 1, 1, 1, 3])
c.remove_duplicates()
assert c == ds([2, 1, 3])
d = ds([1, 1, 1, 1, 1, 1])
d.remove_duplicates()
assert d == ds([1])
e = ds([])
e.remove_duplicates()
assert e == ds([])
f = ds([1, 1, 1, 1, 2])
f.remove_duplicates()
assert f == ds([1, 2])
g = ds([2, 1, 3, 1, 4])
g.remove_duplicates()
assert g == ds([2, 1, 3, 4])
circular = ds([1, 2])
circular.head.next_node.next_node = circular.head
is_error(ExceedMaxIter, circular.remove_duplicates)
def test_op_mul(item):
if item == StaticList:
a = item([7, 8, 9], 12)
else:
a = item([7, 8, 9])
a *= 4
assert a == item([7, 8, 9, 7, 8, 9, 7, 8, 9, 7, 8, 9])
a *= 1
assert a == item([7, 8, 9, 7, 8, 9, 7, 8, 9, 7, 8, 9])
a *= 0
assert a == item([])
a *= -1
assert a == item([])
a *= -100
assert a == item([])
assert isinstance(a, item)
if item == StaticList:
assert 4 * item([7, 8, 9], 12) == item([7, 8, 9, 7, 8, 9, 7, 8, 9, 7, 8, 9])
assert isinstance(3 * item([7, 8, 9], 12), item)
elif item == DynamicList:
assert 4 * item([7, 8, 9]) == item([7, 8, 9, 7, 8, 9, 7, 8, 9, 7, 8, 9])
assert isinstance(3 * item([7, 8, 9]), item)
assert item([7, 8, 9]) * 1 == item([7, 8, 9])
assert item([7, 8, 9]) * 0 == item([])
assert item([7, 8, 9]) * -1 == item([])
assert -100 * item([7, 8, 9]) == item([])
if item == StaticList:
def _test():
item([1, 2, 3]) * 3
is_error(ExceedMaxLengthError, _test)
def test_extend(item):
if item == StaticList:
a = item()
is_error(ExceedMaxLengthError, a.extend, ["nothing here"])
b = item([1, 2, 3], 10)
b.extend([4, 5, 4, 3, 2])
assert b == item([1, 2, 3, 4, 5, 4, 3, 2])
is_error(ExceedMaxLengthError, b.extend, [0, 0, "exceed"])
elif item == DynamicList:
c = item([])
c.extend([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
assert c == item([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
assert c.max_length == 16
d = item([1, 2])
d.extend(reversed(d)) # noqa
assert d == item([1, 2, 2, 1])
d.extend([3, 4, 5, 6, 7, 8, 9])
assert d == item([1, 2, 2, 1, 3, 4, 5, 6, 7, 8, 9])
assert d.max_length == 16
if item == StaticList:
e = item(max_length=50)
else:
e = item()
e.extend(filter(lambda x: x % 2, range(10)))
assert e == item([1, 3, 5, 7, 9])
def test_append(item):
if item == StaticList:
a = item()
def _test():
a.append(10)
is_error(ExceedMaxLengthError, _test)
b = item([1, 2, 3], 5)
b.append(9)
assert b == item([1, 2, 3, 9])
elif item == DynamicList:
c = item([])
c.append(10)
assert c == item([10])
assert c.max_length == 1
assert c != StaticList([10])
c.append(20)
c.append(30)
assert c == item([10, 20, 30])
assert c.max_length == 4
c.append(40)
c.append(50)
assert c == item([10, 20, 30, 40, 50])
assert c.max_length == 8
def test_index(item):
a = item()
is_error(ValueError, a.index, "")
b = item([1, 2, 2, 2, 2, 3])
assert b.index(1) == 0
assert b.index(2) == 1
assert b.index(3) == 5
def test_digital_root():
assert digital_root(0) == 0
assert digital_root(7) == 7
assert digital_root(10) == 1
assert digital_root(365) == 5
assert digital_root(2504152185) == 6
is_error(ValueError, digital_root, -10)
is_error(TypeError, digital_root, 3.2)
def _primality_test(f):
for num in range(2, 100):
result = f(num)
assert result == (num in primes)
is_error(ValueError, f, 0)
is_error(ArithmeticError, f, 1)
is_error(TypeError, f, "some string")
is_error(TypeError, f, 1.1)
is_error(TypeError, f, "some string", 1.1)
def test_del():
for ds in to_test:
a = ds([1, 2, 3])
del a.head
assert a == ds([])
def _test():
del a.copy
is_error(AttributeError, _test)
def _test(arr, t, int_float_only=True):
arr.sort()
for f in functs:
if f == searching.interpolation_search and not int_float_only:
is_error(ValueError, f, arr, t)
else:
idx = f(arr, t)
if idx == -1:
assert t not in arr, f.__name__
else:
assert arr[idx] == t, f.__name__
def test_del():
a = Node(10, next_node=None)
def _test():
del a.value
is_error(TypeError, _test)
def _test2():
del a.next_node # noqa
is_error(TypeError, _test2)
def test_set(item):
item([1, 2, 0.3])
def _test():
item([4, 5, 6]).some_random_stuff = 1 # noqa
is_error(AttributeError, _test)
def _test1():
item([1, 2, 3]).max_length = 10
is_error(ConstantError, _test1)
def test_get(item):
a = item(["a", "c", "b", "d"])
assert a[2] == "b"
assert a[0:4] == ["a", "c", "b", "d"]
assert a[0::2] == ["a", "b"]
assert a[5::] == []
assert a.max_length == 4
def _test():
return a[10]
is_error(IndexError, _test)
def test_find_middle():
for ds in to_test:
a = ds([1, 2, 3, 4, 5])
middle = a.find_middle()
assert middle == 3
assert middle is a.head.next_node.next_node
b = ds([1, 2, 10, 3.4, "Hello", True])
middle = b.find_middle()
assert middle == 10
assert middle is b.head.next_node.next_node
c = ds()
is_error(IndexError, c.find_middle)
def test_pop(item):
a = item([20, 18, 15, 10])
a.pop(0)
assert a == item([18, 15, 10])
a.pop(-1)
assert a == item([18, 15])
a.pop(1)
assert a == item([18])
a.pop()
assert a == item([])
def _test():
a.pop()
is_error(IndexError, _test)
def test_set():
for ds in to_test:
a = ds([1, 2, 0.3])
a.head = Node(10,
next_node=Node(20, next_node=Node(30, next_node=None)))
assert a.head == 10
assert a.traverse(2) == 30
def _test():
a.some_random_stuff = 1
is_error(AttributeError, _test)
a.MAX_ITER = 10
a.head = Node()
def test_remove(item):
a = item([])
def _test():
a.remove(10)
is_error(ValueError, _test)
b = item([2, 2, 2, 2])
b.remove(2)
assert b == item([2, 2, 2])
if item == DynamicList:
c = item([1, 2, 3, 3, 3, 3, 3, 3])
for _ in range(6):
c.remove(3)
assert c == item([1, 2])
assert c.max_length == 2
def test_set_annotations():
b = Node(70, next_node=None)
a = Node(70, next_node=b, smth_int=10)
a.set_annotations(next_node=[None, NodeType], smth_int=int) # noqa
b.set_annotations(next_node=[None, NodeType]) # noqa
a.next_node = b
assert a.next_node == b
def _test():
b.next_node = 123
is_error(TypeError, _test)
def _test2():
a.something_float = 1.2
is_error(AttributeError, _test2)
def test_remove():
for ds in to_test:
a = ds([1, 2, 10, None, 3.4, "Hello", True, None])
a.remove(None)
assert a == ds([1, 2, 10, 3.4, "Hello", True, None])
a.remove(None)
assert a == ds([1, 2, 10, 3.4, "Hello", True])
a.remove(1)
assert a.head == 2
assert a == ds([2, 10, 3.4, "Hello", True])
a.remove(True)
assert a == ds([2, 10, 3.4, "Hello"])
is_error(ValueError, lambda: a.remove(1011))
is_error(ValueError, lambda: ds().remove(10))
def test_gcd_lcm():
assert gcd(13, 13) == 13 == abs(13 * 13) // lcm(13, 13)
assert gcd(-10, 5) == 5 == abs(-10 * 5) // lcm(-10, 5)
assert gcd(1, 505) == 1 == abs(1 * 505) // lcm(1, 505)
assert gcd(0, 5) == 5
assert gcd(5, 0) == 5
is_error(ArithmeticError, lcm, 0, 5)
is_error(ArithmeticError, lcm, 0, 0)
is_error(ArithmeticError, gcd, 0, 0)
assert gcd(20, 100, 20) == 20
assert lcm(20, 100, 20) == 100
assert gcd(-10, -5, -150) == 5
assert lcm(-10, -5, -150) == 150
assert gcd(624129, 2061517, 18913) == 18913
assert lcm(624129, 2061517, 18913) == 68030061
is_error(TypeError, gcd, 1)
is_error(TypeError, lcm, 1)
def test_init(item):
item([])
item([1, 2, 3])
is_error(TypeError, item, 123)
is_error(TypeError, item, [], 1.2)
if item == StaticList:
item([7, 8, 9], 10)
is_error(ExceedMaxLengthError, item, [1, 2, 3], 1)
def test_del(item):
a = item([1, 2, 3])
del a[1]
assert a == item([1, 3])
def _test():
del a.copy
is_error(AttributeError, _test)
def _test1():
del a.some_random_stuff
is_error(AttributeError, _test1)
def _test2():
del a.max_length
is_error(AttributeError, _test2)
def test_swap():
def _op(idx1, idx2):
ll.swap(idx1, idx2)
a[idx1], a[idx2] = a[idx2], a[idx1]
assert ll == ds(a)
_check(a, ll, ds)
for ds in to_test:
a = [1, 2, 10, None, 3.4, "Hello", True, None]
ll = ds(a)
_op(1, 2)
_op(0, 6)
_op(3, -1)
_op(0, 7)
_op(-5, -3)
_op(-1, -1)
is_error(IndexError, lambda: ll.swap(-9, 0))
is_error(IndexError, lambda: ll.swap(0, 8))
is_error(IndexError, lambda: ll.swap(9, -10))
def test_pop():
for ds in to_test:
a = ds([1, 2, 10, None, 3.4, "Hello", True, None])
a.pop()
assert a == ds([1, 2, 10, None, 3.4, "Hello", True])
a.pop(3)
assert a == ds([1, 2, 10, 3.4, "Hello", True])
a.pop(0)
assert a == ds([2, 10, 3.4, "Hello", True])
assert a.head == 2
a.pop(-2)
assert a == ds([2, 10, 3.4, True])
a.pop(-4)
assert a == ds([10, 3.4, True])
assert a.head == 10
is_error(IndexError, lambda: ds().pop())
is_error(IndexError, lambda: ds([""]).pop(1))
is_error(IndexError, lambda: ds([""]).pop(-2))
def test_traverse():
for ds in to_test:
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, None]
ll = ds(a)
for idx in range(-11, 10):
assert ll.traverse(idx) == a[idx]
is_error(TypeError, lambda: ll[-12])
is_error(IndexError, lambda: ll.traverse(-12))
is_error(IndexError, lambda: ll.traverse(11))
is_error(IndexError, lambda: ll.traverse(12))
ll1 = ds([])
is_error(IndexError, lambda: ll1.traverse(0))
is_error(IndexError, lambda: ll1.traverse(-1))
is_error(IndexError, lambda: ll1.traverse(-2))
b = [10] * 100
ll2 = ds(b)
is_error(ExceedMaxIter, lambda: ll2.traverse(100))
def test_op_add(item):
if item == StaticList:
assert item([1, 2, 3], 6) + item([4, 5, 6]) == item([1, 2, 3, 4, 5, 6])
def _test():
item([1, 2, 3]) + item([4, 5, 6])
is_error(ExceedMaxLengthError, _test)
def _test1():
item([1, 2, 3]) + item([4, 5, 6], 100)
is_error(ExceedMaxLengthError, _test1)
def _test2():
instance = item([1, 2, 3])
instance += item([4, 5, 6])
is_error(ExceedMaxLengthError, _test2)
def _test3():
StaticList([1, 2, 3]) + DynamicList([1, 2, 3])
is_error(TypeError, _test3)
elif item == DynamicList:
assert item([1, 2, 3]) + item([4, 5, 6]) == item([1, 2, 3, 4, 5, 6])
def _test4():
DynamicList([1, 2, 3]) + StaticList([1, 2, 3])
is_error(TypeError, _test4)
if item == StaticList:
a = item([7, 8, 9], 6)
else:
a = item([7, 8, 9])
a += item([10, 11, "Test"])
assert a == item([7, 8, 9, 10, 11, "Test"])
def _test5():
a + [1, 2, 3]
is_error(TypeError, _test5)
if item == StaticList:
b = item(["a", "b"], 4)
else:
b = item(["a", "b"])
b += item(["c", "d"])
assert b == item("abcd")
def test_index():
for ds in to_test:
a = ds([1, 2, 10, None, 3.4, "Hello", True, None])
assert a.index(None) == 3
assert a.index(10) == 2
assert a.index(True) == 0 # 1 == True
assert a.index(1) == 0
assert a.index(3.4, 2, 6) == 4
assert a.index(3.4, 2, 100) == 4
assert a.index(3.4, -7, -2) == 4
assert a.index(3.4, -100, -2) == 4
assert a.index(None, 1, -3) == 3
is_error(ValueError, lambda: a.index(1, -1, 0))
is_error(ValueError, lambda: a.index(2, 5, 0))
is_error(ValueError, lambda: a.index(2, -10))
is_error(ValueError, lambda: a.index(3))
b = ds()
is_error(ValueError, lambda: b.index(None))
is_error(ValueError, lambda: b.index(100))
c = ds([1, 2, 3, 4, 5, 1, 10])
assert c.index(1, -4) == 5
def test_get():
a = Node(10, next_node=None)
assert a.value == 10
assert a.next_node is None # noqa
is_error(AttributeError, lambda: a.smth_else) # noqa
