def test_add_entry(self):
leaf = make_leaf_node(d_int, [1], 3)
leaf.add_entry(mtree.Entry(2))
self.assertEqual(entries_to_objs(leaf.entries), set([1, 2]))
leaf.add_entry(mtree.Entry(3))
self.assertEqual(entries_to_objs(leaf.entries), set([1, 2, 3]))
self.assertRaises(ValueError, leaf.add_entry, mtree.Entry(4))
def test_covering_radius_for(self):
tree = MTree(d_int)
internal = mtree.InternalNode(tree)
internal.add_entry(mtree.Entry(1, None, 1))
internal.add_entry(mtree.Entry(8, None, 2))
self.assertEqual(internal.covering_radius_for(0), 10)
self.assertEqual(internal.covering_radius_for(10), 10)
self.assertEqual(internal.covering_radius_for(1), 9)
self.assertEqual(internal.covering_radius_for(11), 11)
def make_two_leaves_and_one_internal(d, routing1, leaf_objs1, routing2,
leaf_objs2):
tree = make_leaf_and_internal_node(d, routing1, leaf_objs1).mtree
internal = tree.root
entry2 = mtree.Entry(routing2)
leaf2 = mtree.LeafNode(tree, internal, entry2)
leaf2.entries = set(
map(lambda o: mtree.Entry(o, d(o, routing2)), leaf_objs2))
entry2.subtree = leaf2
entry2.radius = leaf2.covering_radius_for(routing2)
internal.add_entry(entry2)
return internal
def test_split(self):
leaf = make_leaf_node(d_int, [1, 3, 5, 7], 4)
tree = leaf.mtree
mtree.split(leaf, mtree.Entry(9), d_int)
all_objs = [1, 3, 5, 7, 9]
internal = tree.root
self.assertTrue(isinstance(internal, mtree.InternalNode))
self.assertTrue(internal.parent_node is None)
self.assertTrue(internal.parent_entry is None)
self.assertEqual(len(internal.entries), 2)
for e in internal.entries:
self.assertTrue(e.obj in all_objs)
self.assertTrue(e.distance_to_parent is None)
self.assertFalse(e.subtree is None)
def leafs(entries):
g = (e for e in entries)
return (next(g).subtree, next(g).subtree)
leaf1, leaf2 = leafs(internal.entries)
self.assertTrue(leaf == leaf1 or leaf == leaf2)
self.assertTrue(isinstance(leaf1, mtree.LeafNode))
self.assertTrue(isinstance(leaf2, mtree.LeafNode))
self.assertEqual(leaf1.parent_node, internal)
self.assertEqual(leaf1.parent_node, internal)
self.assertTrue(leaf1.parent_entry in internal.entries)
self.assertTrue(leaf2.parent_entry in internal.entries)
self.assertEqual(len(leaf1) + len(leaf2), 5)
self.assertEqual(sorted(node_objs(leaf1) + node_objs(leaf2)), all_objs)
def test_init(self):
tree = MTree(d_int)
parent_node = mtree.InternalNode(tree)
parent_entry = mtree.Entry(1)
leaf = mtree.LeafNode(tree, parent_node, parent_entry, None)
self.assertEqual(leaf.d, d_int)
self.assertEqual(leaf.mtree, tree)
self.assertEqual(leaf.parent_node, parent_node)
self.assertEqual(leaf.parent_entry, parent_entry)
self.assertEqual(leaf.entries, set())
def make_leaf_and_internal_node(d, routing_object, leaf_objs=[]):
"""Creates an mtree with one leaf node which has one parent.
This is not a tree which would happen in reality: there should be at least
two nodes connected to a parent.
"""
tree = MTree(d)
tree.size = len(leaf_objs)
leaf = tree.root
internal = mtree.InternalNode(tree)
tree.root = internal
leaf.parent_node = internal
#entry of leaf in the root
leaf_entry = mtree.Entry(routing_object, None,
leaf.covering_radius_for(routing_object), leaf)
internal.add_entry(leaf_entry)
leaf.parent_entry = leaf_entry
leaf.entries = set(
map(lambda o: mtree.Entry(o, d(o, routing_object)), leaf_objs))
return leaf
def test_Entry_creation(self):
e = mtree.Entry(1, 2, 3, 4)
self.assertEqual(e.obj, 1)
self.assertEqual(e.distance_to_parent, 2)
self.assertEqual(e.radius, 3)
self.assertEqual(e.subtree, 4)