예제 #1
0
 def test_get_closest_nodes_noRecursion(self):
     rt = TreeRoutingTable(node_id=1)
     target = 2**160 - 5
     for node_id in [2, 4, 8, 2**158, 2**159]:
         rt.offer_node(generate_node(node_id))
     closest_nodes = rt.get_closest_nodes(target, 2)
     self.assertEquals(map(extract_id, closest_nodes), [2**159, 2**158])
예제 #2
0
 def test_split_invalidNodeID(self):
     k = KBucket(range_min=0, range_max=16, maxsize=2)
     tnode = _TreeNode(k)
     rt = TreeRoutingTable(node_id=122)
     rt.active_kbuckets.append(tnode.kbucket)
     # 122 doesnt fit in [0, 16)
     split_correctly = rt._split(tnode)
     self.assertFalse(split_correctly)
예제 #3
0
 def test_split_invalidNotSplittable(self):
     # KBucket is too small to split
     k = KBucket(range_min=0, range_max=4, maxsize=2)
     tnode = _TreeNode(k)
     rt = TreeRoutingTable(node_id=2)
     rt.active_kbuckets.append(tnode.kbucket)
     split_correctly = rt._split(tnode)
     self.assertFalse(split_correctly)
예제 #4
0
 def test_split_invalidNotLeaf(self):
     k = KBucket(range_min=0, range_max=32, maxsize=2)
     tnode = _TreeNode(k)
     rt = TreeRoutingTable(node_id=12)
     rt.active_kbuckets.append(tnode.kbucket)
     split_correctly = rt._split(tnode)
     self.assertTrue(split_correctly)
     # Treenode has already been split (so it isnt a leaf)
     split_correctly = rt._split(tnode)
     self.assertFalse(split_correctly)
예제 #5
0
 def test_get_closest_nodes_multiLevelRecursion(self):
     rt = TreeRoutingTable(node_id=2**160-1)
     target = 1
     rand_list = testing_data.random_one_hundred_IDs
     dist = lambda x, y: x ^ y
     rand_list.sort(key = lambda ID: dist(ID, target))
     expectedIDs = rand_list[:constants.k]
     for ID in rand_list:
         rt.offer_node(generate_node(ID))
     closest_nodes = rt.get_closest_nodes(target)
     self.assertEquals(expectedIDs, map(extract_id, closest_nodes))
예제 #6
0
 def test_split_validNormal(self):
     k = KBucket(range_min=0, range_max=32, maxsize=2)
     tnode = _TreeNode(k)
     tnode.kbucket.offer_node(generate_node(11))
     tnode.kbucket.offer_node(generate_node(22))
     rt = TreeRoutingTable(node_id=17)
     rt.active_kbuckets.append(tnode.kbucket)
     split_correctly = rt._split(tnode)
     self.assertTrue(split_correctly)
     self.assertEquals(1, len(tnode.lchild.kbucket.get_nodes()))
     self.assertEquals(1, len(tnode.rchild.kbucket.get_nodes()))
     self.assertFalse(tnode.is_leaf())
예제 #7
0
 def test_offer_node_remove_node_get_node_sixteenNodes(self):
     # Note: It is important to choose
     # a proper clustering of the node IDs for the
     # routing table to accept the nodes
     rt = TreeRoutingTable(node_id=1)
     # 2**160 / 2**156 == 2**4 == 16
     # Insert nodes (offer_node)
     for node_id in range(0, 2**160, 2**156):
         node_accepted = rt.offer_node(generate_node(node_id + 1))
         self.assertTrue(node_accepted)
     self.assertEquals(16, len(nodes_in_rt(rt)))
     for node in nodes_in_rt(rt):
         # Retrieve nodes (get_node)
         n = rt.get_node(node.node_id)
         self.assertEquals(node, n)
         # Remove nodes (remove_node)
         node_removed = rt.remove_node(node)
         self.assertTrue(node_removed)
     self.assertEquals(0, len(nodes_in_rt(rt)))
예제 #8
0
 def test_offer_node_properNumKBuckets(self):
     rt = TreeRoutingTable(node_id=1)
     # range(2, 9) generates 7 numbers
     for node_id in range(2, 9):
         rt.offer_node(generate_node(node_id))
     rt.offer_node(generate_node(2**158))
     rt.offer_node(generate_node(2**159))
     self.assertEquals(2, len(rt.get_kbuckets()))
예제 #9
0
 def test_get_closest_nodes_oneLevelRecursion(self):
     rt = TreeRoutingTable(node_id=1)
     target = 2**160 - 5
     # 7 nodes close to the target
     for node_id in node_id_sequence(2**150, 2**157, 2):
         rt.offer_node(generate_node(node_id))
     # 1 node close to our node id
     rt.offer_node(generate_node(5))
     closest_nodes = rt.get_closest_nodes(target)
     expectedIDs = node_id_sequence(2**150, 2**157, 2)
     expectedIDs.append(5)
     expectedIDs.sort(key = lambda ID: ID ^ target)
     self.assertEquals(len(expectedIDs), len(closest_nodes))
     self.assertEquals(expectedIDs, map(extract_id, closest_nodes))
예제 #10
0
 def stopProtocol(self):
     TreeRoutingTable.persist_routing_table()
예제 #11
0
 def test_offer_node_oneNode(self):
     rt = TreeRoutingTable(node_id=2**16)
     node_accepted = rt.offer_node(generate_node(15))
     self.assertTrue(node_accepted)