def main():
tree = BinaryTree(5)
print(tree)
tree + 3
print(tree)
tree + 7
print(tree)
tree + 1
print(tree)
print(repr(tree))
def buildTree():
r = BinaryTree('a')
r.insertLeft('b')
l = r.getLeftChild()
l.insertRight('d')
r.insertRight('c')
ri = r.getRightChild()
ri.insertLeft('e')
ri.insertRight('f')
return r
def setUp(self):
self.bst = BinaryTree()
class TestBinaryWithDuplicates(unittest.TestCase):
def setUp(self):
self.bst = BinaryTree()
def tearDown(self):
self.bst = None
def test_duplicate(self):
self.bst.add(88)
self.bst.add(88)
self.assertTrue(88 in self.bst)
self.bst.remove(88)
self.assertTrue(88 in self.bst)
self.bst.remove(88)
self.assertFalse(88 in self.bst)
def test_range(self):
match = [1, 5, 2, 6, 3, 7, 9, 8]
for _ in match:
self.bst.add(_)
self.assertEqual(1, self.bst.getMin())
self.assertEqual(9, self.bst.getMax())
def test_iter(self):
match = [1, 5, 2, 6, 3, 7, 9, 8]
for _ in match:
self.bst.add(_)
compare = list(iter(self.bst))
self.assertEqual(sorted(match), compare)
def test_trial(self):
num = 1000
values = list(range(num))
random.shuffle(values)
for _ in values:
self.bst.add(_)
for _ in range(num):
t = min(self.bst)
self.bst.remove(t)
self.assertFalse(t in self.bst)
def test_init(self):
result = BinaryTree(5)
self.assertEqual(len(result), 1)
self.assertEqual(result.root.data, 5)
self.assertEqual(result.root.left, None)
self.assertEqual(result.root.right, None)
def test_add(self):
result = BinaryTree(5)
result + 3
self.assertEqual(len(result), 2)
def setUp(self):
self.tree = BinaryTree()
class BinaryTreeTest(unittest.TestCase):
def setUp(self):
self.tree = BinaryTree()
def test_root_node(self):
""" a tree with a single node will have a root node with no children """
self.tree.insert(6)
self.assertEqual(str(self.tree.rootNode), str(6))
def test_root_node_with_children(self):
self.tree.insert(6)
self.tree.insert(3) # should become rootNode's left child
self.tree.insert(8) # should become rootNode's right child
self.assertEqual(str(self.tree.rootNode.left_child), str(3))
self.assertEqual(str(self.tree.rootNode.right_child), str(8))
def populate_tree(self):
self.tree.insert(6)
self.tree.insert(3)
self.tree.insert(8)
self.tree.insert(5)
self.tree.insert(2)
self.tree.insert(7)
self.tree.insert(11)
def test_tree_with_three_levels(self):
self.populate_tree()
self.assertEqual(str(self.tree.rootNode.left_child.right_child), str(5))
self.assertEqual(str(self.tree.rootNode.left_child.left_child), str(2))
self.assertEqual(str(self.tree.rootNode.right_child.left_child), str(7))
self.assertEqual(str(self.tree.rootNode.right_child.right_child), str(11))
def test_tree_with_duplicate_value_insert(self):
""" in the case of an insertion tie comparison test, child node becomes
the right_child node of the parent with the same value.
"""
self.tree.insert(6)
self.tree.insert(3)
self.tree.insert(8)
self.tree.insert(8)
self.tree.insert(10)
self.assertEqual(str(self.tree.rootNode.right_child.right_child), str(8))
# further nesting here.
self.assertEqual(str(self.tree.rootNode.right_child.right_child.right_child), str(10))
def test_search(self):
self.populate_tree()
self.assertEqual(str(self.tree.search(6)), str(self.tree.rootNode))
self.assertEqual(str(self.tree.search(3)), str(self.tree.rootNode.left_child))
self.assertEqual(str(self.tree.search(2)), str(self.tree.rootNode.left_child.left_child))
self.assertEqual(str(self.tree.search(5)), str(self.tree.rootNode.left_child.right_child))
self.assertEqual(str(self.tree.search(8)), str(self.tree.rootNode.right_child))
def test_search_for_nonexistent_node(self):
self.populate_tree()
self.assertEqual(self.tree.search(77), None)
@unittest.skip("not completed yet")
def test_inorder_tree_walk(self):
self.populate_tree()
self.assertEqual(self.tree.inorder_tree_walk(), [2,3,5,6,7,8,11])
def test_inorder_tree_walk_empty_tree(self):
self.assertEqual(self.tree.inorder_tree_walk(), [])
