def test_traversing_up_from_top_reset(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
expected = 1
zipper = Zipper.from_tree(initial)
result = zipper.up()
self.assertIsNone(result)
result = zipper.reset().value()
self.assertEqual(result, expected)
def test_set_right_with_subtree(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
expected = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 6,
"left": {
"value": 7,
"left": None,
"right": None
},
"right": {
"value": 8,
"left": None,
"right": None
},
},
}
zipper = Zipper.from_tree(initial)
result = zipper.set_right({
"value": 6,
"left": {
"value": 7,
"left": None,
"right": None
},
"right": {
"value": 8,
"left": None,
"right": None
},
}).to_tree()
self.assertEqual(result, expected)
def test_set_left_with_leaf(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {"value": 3, "left": None, "right": None},
},
"right": {"value": 4, "left": None, "right": None},
}
expected = {
"value": 1,
"left": {
"value": 2,
"left": {"value": 5, "left": None, "right": None},
"right": {"value": 3, "left": None, "right": None},
},
"right": {"value": 4, "left": None, "right": None},
}
zipper = Zipper.from_tree(initial)
result = (
zipper.left().set_left({"value": 5, "left": None, "right": None}).to_tree()
)
self.assertEqual(result, expected)
def test_dead_end(self):
t1, _, _, _ = self.create_trees()
zipper = Zipper.from_tree(t1)
# I think this shouldn't be None as one might want to insert a node here!
# self.assertIsNone(zipper.left().left())
# I think the following makes more sense:
with self.assertRaises(AttributeError):
zipper.left().left().left()
def test_different_paths_to_same_zipper(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
result = Zipper.from_tree(initial).left().up().right().to_tree()
final = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
expected = Zipper.from_tree(final).right().to_tree()
self.assertEqual(result, expected)
def test_left_right_and_value(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {"value": 3, "left": None, "right": None},
},
"right": {"value": 4, "left": None, "right": None},
}
zipper = Zipper.from_tree(initial)
result = zipper.left().right().value()
self.assertEqual(result, 3)
def test_dead_end(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {"value": 3, "left": None, "right": None},
},
"right": {"value": 4, "left": None, "right": None},
}
zipper = Zipper.from_tree(initial)
result = zipper.left().left()
self.assertIsNone(result)
def test_traversing_up_from_top(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {"value": 3, "left": None, "right": None},
},
"right": {"value": 4, "left": None, "right": None},
}
zipper = Zipper.from_tree(initial)
result = zipper.up()
self.assertIsNone(result)
def test_tree_from_deep_focus(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
expected = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
zipper = Zipper.from_tree(initial)
result = zipper.left().right().to_tree()
self.assertEqual(result, expected)
def test_data_is_retained(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
expected = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
zipper = Zipper.from_tree(initial)
result = zipper.to_tree()
self.assertEqual(result, expected)
def test_set_value_after_traversing_up(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
expected = {
"value": 1,
"left": {
"value": 5,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
zipper = Zipper.from_tree(initial)
result = zipper.left().right().up().set_value(5).to_tree()
self.assertEqual(result, expected)
def test_test_ability_to_descend_multiple_levels_and_return(self):
initial = {
"value": 1,
"left": {
"value": 2,
"left": None,
"right": {
"value": 3,
"left": None,
"right": None
},
},
"right": {
"value": 4,
"left": None,
"right": None
},
}
zipper = Zipper.from_tree(initial)
result = zipper.left().right().up().up().value()
self.assertEqual(result, 1)
def test_data_is_retained(self):
t1, _, _, _ = create_trees()
zipper = Zipper.from_tree(t1)
tree = zipper.to_tree()
self.assertEqual(tree, t1)
def test_left_and_right_value(self):
t1, _, _, _ = create_trees()
zipper = Zipper.from_tree(t1)
self.assertEqual(zipper.left().right().value(), 3)
def test_dead_end(self):
t1, _, _, _ = create_trees()
zipper = Zipper.from_tree(t1)
self.assertIsNone(zipper.left().left())
def test_tree_from_deep_focus(self):
t1, _, _, _ = create_trees()
zipper = Zipper.from_tree(t1)
self.assertEqual(zipper.left().right().to_tree(), t1)
def test_set_value(self):
t1, t2, _, _ = create_trees()
zipper = Zipper.from_tree(t1)
updatedZipper = zipper.left().set_value(5)
tree = updatedZipper.to_tree()
self.assertEqual(tree, t2)
def test_set_left_with_value(self):
t1, _, t3, _ = create_trees()
zipper = Zipper.from_tree(t1)
updatedZipper = zipper.left().set_left(leaf(5))
tree = updatedZipper.to_tree()
self.assertEqual(tree, t3)
def test_set_right_to_none(self):
t1, _, _, t4 = create_trees()
zipper = Zipper.from_tree(t1)
updatedZipper = zipper.left().set_right(None)
tree = updatedZipper.to_tree()
self.assertEqual(tree, t4)
def test_different_paths_to_same_zipper(self):
t1, _, _, _ = create_trees()
zipper = Zipper.from_tree(t1)
self.assertEqual(zipper.left().up().right().to_tree(),
zipper.right().to_tree())