def test_is_right_child(self):
a = _BSTNode(3)
b = _BSTNode(4)
a.right = b
b.parent = a
self.assertFalse(b.is_left_child())
self.assertTrue(b.is_right_child())
def test_comparison_when_values_are_of_different_types(self):
a = _BSTNode(12)
b = _BSTNode(14)
with self.assertRaises(TypeError):
a < b
with self.assertRaises(TypeError):
a >= b
def test_set_both_children(self):
a = _BSTNode(12)
a.left = _BSTNode(11)
a.right = _BSTNode(13)
self.assertEqual(a.count(), 3)
self.assertTrue(a.has_children())
self.assertFalse(a.has_one_child())
self.assertTrue(a.has_two_children())
def test_set_right_child(self):
a = _BSTNode(12)
b = _BSTNode(28)
a.right = b
self.assertIs(a.right, b)
self.assertEqual(a.count(), 2)
self.assertIsNone(b.parent)
self.assertTrue(a.has_children())
self.assertTrue(a.has_one_child())
self.assertFalse(a.has_two_children())
def test_set_parent(self):
a = _BSTNode(12)
b = _BSTNode(14)
b.parent = a
self.assertIs(b.parent, a)
self.assertEqual(a.count(), 1)
self.assertIsNone(a.parent)
self.assertIsNone(a.left)
self.assertIsNone(a.right)
# If we just set the parent of a node
# the parent does NOT automatically have children.
self.assertFalse(a.has_children())
self.assertFalse(a.has_one_child())
self.assertFalse(a.has_two_children())
def test_when_no_parent(self):
n = _BSTNode(12)
self.assertRaises(AttributeError, n.is_left_child)
self.assertRaises(AttributeError, n.is_right_child)
self.assertIsNone(n.sibling)
self.assertIsNone(n.grandparent)
self.assertIsNone(n.uncle)
def test_create_default(self):
n = _BSTNode(12)
self.assertEqual(n.key, 12)
self.assertIsNone(n.left)
self.assertIsNone(n.right)
self.assertIsNone(n.parent)
self.assertEqual(n.count(), 1)
def test_uncle(self):
n = _BSTNode(12)
p = _BSTNode(14)
g = _BSTNode(28)
n.parent = p
p.left = n
p.parent = g
g.right = p
self.assertIsNotNone(n.parent)
self.assertIsNotNone(n.grandparent)
self.assertIsNone(n.sibling)
self.assertIsNone(n.uncle)
u = _BSTNode(7)
g.left = u
u.parent = g
self.assertIsNotNone(n.uncle)
self.assertIs(n.uncle, u)
def test_grandparent(self):
a = _BSTNode(12)
b = _BSTNode(14)
c = _BSTNode(28)
self.assertIsNone(a.grandparent)
self.assertIsNone(b.grandparent)
self.assertIsNone(c.grandparent)
b.left = a
a.parent = b
self.assertIsNone(a.grandparent)
c.right = b
b.parent = c
self.assertIsNone(b.grandparent)
self.assertIsNotNone(b.parent)
self.assertIsNone(c.grandparent)
self.assertIsNotNone(a.grandparent)
self.assertIs(a.grandparent, c)
def test_sibling(self):
p = _BSTNode(12)
l = _BSTNode(14)
r = _BSTNode(28)
self.assertIsNone(r.sibling)
self.assertIsNone(l.sibling)
p.left = l
p.right = r
l.parent = p
r.parent = p
self.assertIs(l.sibling, r)
self.assertIs(r.sibling, l)
# Without the parent pointers to its children,
# we can't determine if the children are siblings.
p.left = None
self.assertIsNone(r.sibling)
self.assertIsNone(l.sibling)
def test_when_no_children(self):
n = _BSTNode(12)
self.assertFalse(n.has_children())
self.assertFalse(n.has_one_child())
self.assertFalse(n.has_two_children())