def test_minheap_not_equal(self): """ Test operator "inequal". """ heap1 = min_heap.MinHeap([1, 2, 3, 17, 19, 36, 7, 25, 100]) heap2 = min_heap.MinHeap([1, 2, 3, 17, 19, 36, 7, 25, 200]) self.assertNotEqual(heap1, heap2)
def test_minheap_merge(self): """ Test method "heap_merge". """ ref = [1, 7, 2, 17, 36, 25, 3, 19, 100] heap1 = min_heap.MinHeap([100, 36, 25, 19]) heap2 = min_heap.MinHeap([17, 7, 3, 2, 1]) heap = heap1.heap_merge(heap2) test1 = ref == heap.array test2 = heap.is_min_heap() test = test1 and test2 self.assertTrue(test)
def test_build_minheap_recursive(self): """ Test constructor "MinHeap" - recursive. """ ref = [1, 2, 3, 19, 17, 7, 25, 36, 100] res = min_heap.MinHeap([100, 36, 25, 19, 17, 7, 3, 2, 1]) self.assertEqual(ref, res.array)
def test_minheap_insert(self): """ Test method "insert". """ ref = min_heap.MinHeap([100, 36, 25, 19, 17, 7, 3, 2, 1]) res = min_heap.MinHeap() res.insert(1) res.insert(2) res.insert(3) res.insert(19) res.insert(17) res.insert(7) res.insert(25) res.insert(36) res.insert(100) self.assertEqual(res, ref)
def test_minheap_is_heap_not(self): """ Test method "is_min_heap" - inverted. """ heap = min_heap.MinHeap() heap.array = [100, 36, 25, 19, 17, 7, 3, 2, 1] self.assertFalse(heap.is_min_heap())
def test_build_minheap_recursive_empty(self): """ Test constructor (empty) "MinHeap" - recursive. """ ref = [] res = min_heap.MinHeap() self.assertEqual(ref, res.array)
def test_minheap_build_minheap_iterative(self): """ Test method "build_min_heap" - iterative. """ ref = [1, 2, 3, 4, 7, 8, 9, 10, 14, 16] res = [1, 2, 3, 4, 7, 8, 9, 10, 14, 16] heap = min_heap.MinHeap() heap.build_min_heap(res, False) self.assertEqual(res, ref)
def test_minheap_clear(self): """ Test method "clear". """ heap = min_heap.MinHeap([100, 36, 25, 19, 17, 7, 3, 2, 1]) heap.clear() test1 = len(heap) == 0 test2 = heap.array == [] test = test1 and test2 self.assertTrue(test)
def setUp(self): self.heap1 = min_heap.MinHeap() self.heap1.insert(1) self.heap1.insert(2) self.heap1.insert(3) self.heap1.insert(17) self.heap1.insert(19) self.heap1.insert(36) self.heap1.insert(7) self.heap1.insert(25) self.heap1.insert(100)
def test_minheap_remove(self): """ Test method "remove". """ ref = [1, 2, 3, 36, 17, 7, 25, 100] heap = min_heap.MinHeap([100, 36, 25, 19, 17, 7, 3, 2, 1]) heap.remove(3) test1 = heap.is_min_heap() == True test2 = ref == heap.array test = test1 and test2 self.assertTrue(test)
def test_minheap_right_child_not(self): """ Test method "right_child" - inverted. """ heap = min_heap.MinHeap([100, 36, 25, 19, 17, 7, 3, 2, 1]) index = 2 right_index = heap.right_child(index) right_value = heap.array[right_index] test1 = right_index == 6 test2 = right_value == 25 test = test1 and test2 self.assertTrue(test)
def test_minheap_parent(self): """ Test method "parent". """ heap = min_heap.MinHeap([100, 36, 25, 19, 17, 7, 3, 2, 1]) index = 7 parent_index = heap.parent(index) parent_value = heap.array[parent_index] test1 = parent_index == 3 test2 = parent_value == 19 test = test1 and test2 self.assertTrue(test)
def test_minheap_left_child_not(self): """ Test method "left_child" - inverted. """ heap = min_heap.MinHeap([100, 36, 25, 19, 17, 7, 3, 2, 1]) index = 2 left_index = heap.left_child(index) left_value = heap.array[left_index] test1 = left_index == 7 test2 = left_value == 36 test = test1 and test2 self.assertFalse(test)
def test_minheap_is_leaf(self): """ Test method "is_leaf". """ heap = min_heap.MinHeap([100, 36, 25, 19, 17, 7, 3, 2, 1]) t_1 = heap.is_leaf(0) == False t_2 = heap.is_leaf(1) == False t_3 = heap.is_leaf(2) == False t_4 = heap.is_leaf(3) == False t_5 = heap.is_leaf(4) == True t_6 = heap.is_leaf(5) == True t_7 = heap.is_leaf(6) == True t_8 = heap.is_leaf(7) == True t_9 = heap.is_leaf(8) == True test = t_1 and t_2 and t_3 and t_4 and t_5 and t_6 and t_7 and t_8 and t_9 self.assertTrue(test)
def test_minheap_len(self): """ Test operator "len". """ heap = min_heap.MinHeap([100, 36, 25, 19, 17, 7, 3, 2, 1]) self.assertEqual(9, len(heap))
def test_minheap_is_empty(self): """ Test method "is_empty". """ heap = min_heap.MinHeap() self.assertTrue(heap.is_empty())
def test_minheap_equal(self): """ Test operator "equal". """ heap = min_heap.MinHeap([1, 2, 3, 17, 19, 36, 7, 25, 100]) self.assertEqual(heap, self.heap1)