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