def test_merge_sorted_lists(self):
size = random.randint(1, 10)
lists = Array([get_random_sorted_singly_linked_list()[0] for _ in range(size)])
expected_lists = [get_linked_list_keys(list_) for list_ in lists]
expected_elements = sorted([element for list_ in expected_lists for element in list_])
actual_merged = merge_sorted_lists(lists)
actual_elements = get_linked_list_keys(actual_merged)
assert_that(actual_elements, is_(equal_to(expected_elements)))
def test_merge_sorted_lists(self):
size = random.randint(1, 10)
lists = Array(
[get_random_sorted_singly_linked_list()[0] for _ in range(size)])
expected_lists = [get_linked_list_keys(list_) for list_ in lists]
expected_elements = sorted(
[element for list_ in expected_lists for element in list_])
actual_merged = merge_sorted_lists(lists)
actual_elements = get_linked_list_keys(actual_merged)
assert_that(actual_elements, is_(equal_to(expected_elements)))
def test_singly_linked_list_reverse(self):
list_, nodes, keys = get_random_singly_linked_list()
singly_linked_list_reverse(list_)
actual_keys = get_linked_list_keys(list_)
expected_keys = list(reversed(keys))
assert_that(actual_keys, is_(equal_to(expected_keys)))
def test_singly_linked_list_pop(self):
list_, nodes, keys = get_random_singly_linked_list(max_size=5)
actual_deleted = singly_linked_list_pop(list_)
assert_that(actual_deleted, is_(equal_to(keys[0])))
actual_keys = get_linked_list_keys(list_)
expected_keys = keys[1:]
assert_that(actual_keys, is_(equal_to(expected_keys)))
def test_singly_linked_list_push(self):
list_, nodes, keys = get_random_singly_linked_list()
x = random.randint(0, 999)
singly_linked_list_push(list_, x)
actual_keys = get_linked_list_keys(list_)
expected_keys = [x] + keys
assert_that(actual_keys, is_(equal_to(expected_keys)))
def test_singly_linked_list_pop(self):
list_, nodes, keys = get_random_singly_linked_list(max_size=5)
actual_deleted = singly_linked_list_pop(list_)
assert_that(actual_deleted, is_(equal_to(keys[0])))
actual_keys = get_linked_list_keys(list_)
expected_keys = keys[1:]
assert_that(actual_keys, is_(equal_to(expected_keys)))
def test_delete_larger_half(self):
S, _, keys = get_random_doubly_linked_list(max_value=10)
delete_larger_half(S)
actual_keys = get_linked_list_keys(S)
expected_keys = sorted(keys)[:len(keys) // 2]
assert_that(actual_keys, contains_inanyorder(*expected_keys))
assert_prev_next_pointers_consistent(S)
def test_singly_linked_list_push(self):
list_, nodes, keys = get_random_singly_linked_list()
x = random.randint(0, 999)
singly_linked_list_push(list_, x)
actual_keys = get_linked_list_keys(list_)
expected_keys = [x] + keys
assert_that(actual_keys, is_(equal_to(expected_keys)))
def test_singly_linked_list_enqueue(self):
list_, nodes, keys = get_random_singly_linked_list()
list_.tail = nodes[-1]
x = random.randint(0, 999)
singly_linked_list_enqueue(list_, x)
actual_keys = get_linked_list_keys(list_)
expected_keys = keys + [x]
assert_that(actual_keys, is_(equal_to(expected_keys)))
def test_singly_linked_list_insert(self):
list_, nodes, keys = get_random_singly_linked_list()
new_key = random.randint(0, 999)
new_node = SNode(new_key)
singly_linked_list_insert(list_, new_node)
actual_keys = get_linked_list_keys(list_)
expected_keys = [new_key] + keys
assert_that(actual_keys, is_(equal_to(expected_keys)))
def test_singly_linked_list_enqueue(self):
list_, nodes, keys = get_random_singly_linked_list()
list_.tail = nodes[-1]
x = random.randint(0, 999)
singly_linked_list_enqueue(list_, x)
actual_keys = get_linked_list_keys(list_)
expected_keys = keys + [x]
assert_that(actual_keys, is_(equal_to(expected_keys)))
def test_singly_linked_list_delete(self):
list_, nodes, keys = get_random_singly_linked_list(max_size=5)
node_idx = random.randrange(len(nodes))
node_to_delete = nodes[node_idx]
singly_linked_list_delete(list_, node_to_delete)
actual_keys = get_linked_list_keys(list_)
expected_keys = keys[:node_idx] + keys[node_idx + 1:]
assert_that(actual_keys, is_(equal_to(expected_keys)))
def test_dlh_insert(self):
S, _, keys = get_random_doubly_linked_list()
new_key = random.randint(0, 999)
new_node = Node(new_key)
dlh_insert(S, new_node)
actual_keys = get_linked_list_keys(S)
expected_keys = [new_key] + keys
assert_that(actual_keys, is_(equal_to(expected_keys)))
assert_prev_next_pointers_consistent(S)
def test_mergeable_heap_on_sorted_list(self):
_, elements1 = get_random_unique_array(min_size=0)
_, elements2 = get_random_unique_array(min_size=0)
heap1 = sorted_list_make_min_heap()
heap2 = sorted_list_make_min_heap()
for element in elements1:
sorted_list_min_heap_insert(heap1, element)
for element in elements2:
sorted_list_min_heap_insert(heap2, element)
assert_sorted_list(heap1)
assert_sorted_list(heap2)
expected_elements = elements1 + elements2
if elements1:
actual_min = sorted_list_heap_minimum(heap1)
actual_extracted_min = sorted_list_heap_extract_min(heap1)
expected_min = min(elements1)
expected_elements.remove(expected_min)
assert_that(actual_min, is_(equal_to(expected_min)))
assert_that(actual_extracted_min, is_(equal_to(expected_min)))
assert_sorted_list(heap1)
else:
assert_that(
calling(sorted_list_heap_extract_min).with_args(heap1),
raises(RuntimeError, 'heap underflow'))
if elements2:
actual_min = sorted_list_heap_minimum(heap2)
actual_extracted_min = sorted_list_heap_extract_min(heap2)
expected_min = min(elements2)
expected_elements.remove(expected_min)
assert_that(actual_min, is_(equal_to(expected_min)))
assert_that(actual_extracted_min, is_(equal_to(expected_min)))
assert_sorted_list(heap2)
else:
assert_that(
calling(sorted_list_heap_extract_min).with_args(heap2),
raises(RuntimeError, 'heap underflow'))
merged_heap = sorted_list_min_heap_union(heap1, heap2)
actual_elements = get_linked_list_keys(merged_heap)
expected_elements = list(sorted(set(expected_elements)))
assert_that(actual_elements, is_(equal_to(expected_elements)))
assert_sorted_list(merged_heap)
def test_singly_linked_list_dequeue(self):
list_, nodes, keys = get_random_singly_linked_list(min_size=0, max_size=5)
if list_.head is None:
list_.tail = None
assert_that(calling(singly_linked_list_dequeue).with_args(list_), raises(RuntimeError, 'underflow'))
else:
list_.tail = nodes[-1]
actual_deleted = singly_linked_list_dequeue(list_)
assert_that(actual_deleted, is_(equal_to(keys[0])))
actual_keys = get_linked_list_keys(list_)
expected_keys = keys[1:]
assert_that(actual_keys, is_(equal_to(expected_keys)))
if list_.head is None:
assert_that(list_.tail, is_(none()))
def test_list_min_heap_disjoint_union(self):
array, elements = get_random_unique_array(min_size=0)
heap1_size = random.randint(0, len(elements))
elements1 = array[1:heap1_size].elements
elements2 = array[heap1_size + 1:array.length].elements
heap1 = list_make_min_heap()
heap2 = list_make_min_heap()
for element in elements1:
list_min_heap_insert(heap1, element)
for element in elements2:
list_min_heap_insert(heap2, element)
merged_heap = list_min_heap_disjoint_union(heap1, heap2)
actual_elements = get_linked_list_keys(merged_heap)
assert_that(actual_elements, contains_inanyorder(*elements))
def test_singly_linked_list_dequeue(self):
list_, nodes, keys = get_random_singly_linked_list(min_size=0,
max_size=5)
if list_.head is None:
list_.tail = None
assert_that(
calling(singly_linked_list_dequeue).with_args(list_),
raises(RuntimeError, 'underflow'))
else:
list_.tail = nodes[-1]
actual_deleted = singly_linked_list_dequeue(list_)
assert_that(actual_deleted, is_(equal_to(keys[0])))
actual_keys = get_linked_list_keys(list_)
expected_keys = keys[1:]
assert_that(actual_keys, is_(equal_to(expected_keys)))
if list_.head is None:
assert_that(list_.tail, is_(none()))