def test_delete_2_works_on_node_with_one_right_child_left_side():
"""Test the delete_2 method deletes a node with a right child."""
from bst import BST
tree = BST([10, 6, 8, 9, 12, 16, 14])
tree.delete_2(6)
in_order_gen = tree.in_order()
assert [n for n in in_order_gen] == [8, 9, 10, 12, 14, 16]
def test_add(self):
bst = BST()
bst.add(10)
assert bst.root.val == 10
assert bst.is_empty() is False
assert bst.size == 1
assert bst.levels == 1
assert bst.serialize() == '10'
assert bst.level_order() == [[10]]
assert bst.pre_order() == [10]
assert bst.in_order() == [10]
assert bst.post_order() == [10]
assert bst == BST(serialize='10')
bst.add(1)
assert bst.root.val == 10
assert bst.is_empty() is False
assert bst.size == 2
assert bst.levels == 2
assert bst.serialize() == '10,1,#'
assert bst.level_order() == [[10], [1]]
assert bst.pre_order() == [10, 1]
assert bst.in_order() == [1, 10]
assert bst.post_order() == [1, 10]
bst.add(20)
assert bst.root.val == 10
assert bst.is_empty() is False
assert bst.size == 3
assert bst.levels == 2
assert bst.serialize() == '10,1,20'
assert bst.level_order() == [[10], [1, 20]]
assert bst.pre_order() == [10, 1, 20]
assert bst.in_order() == [1, 10, 20]
assert bst.post_order() == [1, 20, 10]
bst.add(5)
bst.add(15)
assert bst.root.val == 10
assert bst.is_empty() is False
assert bst.size == 5
assert bst.levels == 3
assert bst.serialize() == '10,1,20,#,5,15,#'
assert bst.level_order() == [[10], [1, 20], [5, 15]]
assert bst.pre_order() == [10, 1, 5, 20, 15]
assert bst.in_order() == [1, 5, 10, 15, 20]
assert bst.post_order() == [5, 1, 15, 20, 10]
def test_in_order_sample_tree():
"""Check for the correct output of iot on a sample tree."""
tree = BST(SAMPLE_TREE)
gen = tree.in_order()
output = []
for i in range(10):
output.append(next(gen))
assert output == [1, 10, 11, 12, 16, 20, 27, 28, 30, 42]
def test_in_order_right_imba():
"""Check for the correct output of iot on a right-imbalanced tree."""
tree = BST(RIGHT_IMBALANCED)
gen = tree.in_order()
output = []
for i in range(6):
output.append(next(gen))
assert output == [1, 2, 3, 4, 5, 6]
def test_in_order_solo():
"""Test running in-order on a tree with one Node."""
from bst import BST
b = BST([20])
in_ord = b.in_order()
in_ord_list = []
for ii in in_ord:
in_ord_list.append(ii)
assert in_ord_list == [20]
def test_in_order_empty():
"""Test an empty Node returns empty list."""
from bst import BST
b = BST()
in_ord = b.in_order()
in_ord_list = []
for ii in in_ord:
in_ord_list.append(ii)
assert in_ord_list == []
def test_delete_2():
b = BST()
a = [17, 31, 9, 4, 2, 7, 18, 1, 13, 55, 8, 16, 21, 32]
for el in a:
b.insert(el)
assert b._root._data == a[0]
b.delete_node(a[4])
a.pop(4)
tester = []
for i in b.in_order(b._root):
tester.append(i._data)
assert tester == sorted(a)
def test_empty_tree(self):
bst = BST()
assert bst.root is None
assert bst.is_empty() is True
assert bst.size == 0
assert bst.levels == 0
assert bst.__repr__() == "BST(serialize='')"
assert bst.serialize() == ''
assert bst.level_order() == []
assert bst.pre_order() == []
assert bst.in_order() == []
assert bst.post_order() == []
assert bst == BST()
class SymbolTable:
def __init__(self):
self.__bst = BST()
def add(self, value):
return self.__bst.add(value)
def get(self, value):
return self.__bst.find(value)
def getRoot(self):
return self.__bst.getRoot()
def setRoot(self, root):
return self.__bst.setRoot(root)
def getPosition(self, value):
return self.__bst.findPosition(value)
def getIndex(self, value):
return self.__bst.findIndex(value)
def __str__(self):
return self.__bst.in_order()
def test_in_order_traversal():
"""Returns a generator of values in the tree using in-order traversal"""
import types
bintree = BST()
with pytest.raises(TypeError):
bintree.in_order(1) # No args/kwargs
with pytest.raises(TypeError):
bintree.in_order(None)
assert isinstance(bintree.in_order(), types.GeneratorType)
testlist = []
for i in xrange(30):
testval = random.random()
bintree.insert(testval)
testlist.append(testval)
assert bintree.size() == 30
ordered_generator = bintree.in_order()
testlist.sort()
for number in ordered_generator:
assert number == testlist.pop(0)
def test_in_order_traversal_empty_bst():
'''Test appropreat error when in order is called on nothing.'''
bst = BST()
with pytest.raises(StopIteration) as message:
next(bst.in_order())
assert "Nothing to traverse." in str(message)
