def test_search_on_a_tree_containing_given_value_should_return_node_with_the_value():
object_under_test = BinarySearchTree()
object_under_test.insert(8)
result = object_under_test.search(8)
assert result.value == 8
def test_searching_for_a_value_which_node_is_not_a_leaf_should_return_node_pointing_to_other_node():
object_under_test = BinarySearchTree()
object_under_test.insert(2)
object_under_test.insert(8)
result = object_under_test.search(2)
assert result.right.value == 8
def test_given_elements_then_traverse_preorder_should_return_elements_in_preorder_with_parents_first(
input_elements, expected_output
):
object_under_test = BinarySearchTree()
for ele in input_elements:
object_under_test.insert(value=ele)
assert expected_output == object_under_test.traverse_preorder()
def test_insert_element_less_than_root(self):
bst = BinarySearchTree()
bst.insert(5)
bst.insert(3)
assert bst.root.key == 5
assert bst.root.left.key == 3
assert bst.root.left.left is None
assert bst.root.left.right is None
assert bst.root.right is None
def test_deleting_node_with_only_left_child_hould_replace_the_node_with_the_only_child():
object_under_test = BinarySearchTree()
object_under_test.insert(55)
object_under_test.insert(44)
object_under_test.insert(33)
object_under_test.delete(44)
assert [55, 33] == object_under_test.traverse_preorder()
def test_deleting_node_with_two_children_should_replace_the_node_with_successor():
object_under_test = BinarySearchTree()
object_under_test.insert(44)
object_under_test.insert(33)
object_under_test.insert(55)
object_under_test.delete(44)
assert [55, 33] == object_under_test.traverse_preorder()
def test_deleting_left_leaf_should_cause_tree_to_lose_the_leaf():
object_under_test = BinarySearchTree()
object_under_test.insert(44)
object_under_test.insert(33)
object_under_test.insert(55)
object_under_test.delete(33)
assert [44, 55] == object_under_test.traverse_preorder()
def test_deleting_only_node_should_leave_the_tree_empty():
object_under_test = BinarySearchTree()
object_under_test.insert(22)
object_under_test.delete(22)
assert not object_under_test.traverse_preorder()
def test_insert_element_larger_than_root(self):
bst = BinarySearchTree()
bst.insert(5)
bst.insert(10)
assert bst.root.key == 5
assert bst.root.right.key == 10
assert bst.root.right.left is None
assert bst.root.right.right is None
assert bst.root.left is None
def test_insert_pathological(self):
bst = BinarySearchTree()
bst.insert(1)
bst.insert(2)
bst.insert(3)
bst.insert(4)
assert bst.root.key == 1
assert bst.root.right.key == 2
assert bst.root.right.right.key == 3
assert bst.root.right.right.right.key == 4
def test_inserting_duplicated_value_should_raise_an_error():
object_under_test = BinarySearchTree()
duplicated_elem = 8
object_under_test.insert(duplicated_elem)
with pytest.raises(DuplicatedValueInTreeError) as err:
object_under_test.insert(duplicated_elem)
assert f"{duplicated_elem}" in str(err)
def test_deleting_nonexistent_value_should_raise():
object_under_test = BinarySearchTree()
object_under_test.insert(44)
nonexistent_value = 22
with pytest.raises(ValueNotFoundInTreeError) as err:
object_under_test.delete(nonexistent_value)
assert f"{nonexistent_value}" in str(err)
def test_insert_element_left_and_right_of_root(self):
bst = BinarySearchTree()
bst.insert(5)
bst.insert(3)
bst.insert(10)
assert bst.root.key == 5
assert bst.root.left.key == 3
assert bst.root.left.left is None
assert bst.root.left.right is None
assert bst.root.right.key == 10
assert bst.root.right.left is None
assert bst.root.right.right is None
def test_given_empty_tree_then_is_empty_should_return_true():
assert BinarySearchTree().is_empty()
def test_initialization(self):
bst = BinarySearchTree()
assert isinstance(bst, BinarySearchTree)
def test_search_on_empty_tree_returns_none():
object_under_test = BinarySearchTree()
assert object_under_test.search(8) is None
def tree_factory():
"""
Build this tree:
10
/ \
5 15
/ \ / \
1 7 12 20
"""
bst = BinarySearchTree()
bst.insert(10)
bst.insert(5)
bst.insert(1)
bst.insert(7)
bst.insert(15)
bst.insert(12)
bst.insert(20)
return bst
def test_given_empty_tree_then_is_empty_should_return_false():
object_under_test = BinarySearchTree()
object_under_test.insert(15)
assert not object_under_test.is_empty()
def test_insert_first_element(self):
bst = BinarySearchTree()
bst.insert(5)
assert bst.root.key == 5
assert bst.root.left is None
assert bst.root.right is None
def test_find(self): bst = BinarySearchTree() bst.insert(4) bst.insert(3) bst.insert(2) bst.insert(1) bst.insert(5) bst.insert(6) bst.insert(7) self.assertEqual(bst.find(1), True) self.assertEqual(bst.find(7), True) self.assertEqual(bst.find(8), False) self.assertEqual(bst.find(0), False)
def test_postorder(self): bst = BinarySearchTree() postorder = [1, 2, 3, 7, 6, 5, 4] bst.insert(4) bst.insert(3) bst.insert(2) bst.insert(1) bst.insert(5) bst.insert(6) bst.insert(7) self.assertEqual(self.compare(bst.postorder(), postorder), True)
def test_insert(self): bst = BinarySearchTree() self.assertEqual(bst.get_size(), 0) bst.insert(4) bst.insert(3) bst.insert(5) self.assertEqual(bst.get_size(), 3) self.assertEqual(bst.get_root().get_data(), 4) self.assertEqual(bst.get_root().get_left_child().get_data(), 3) self.assertEqual(bst.get_root().get_right_child().get_data(), 5)
def test_inorder(self): bst = BinarySearchTree() inorder = [1, 2, 3, 4, 5, 6, 7] bst.insert(4) bst.insert(3) bst.insert(2) bst.insert(1) bst.insert(5) bst.insert(6) bst.insert(7) self.assertEqual(self.compare(bst.inorder(), inorder), True)
def test_preorder(self): bst = BinarySearchTree() preorder = [4, 3, 2, 1, 5, 6, 7] bst.insert(4) bst.insert(3) bst.insert(2) bst.insert(1) bst.insert(5) bst.insert(6) bst.insert(7) self.assertEqual(self.compare(bst.preorder(), preorder), True)
