def testAddNodeInvalidDuplicatePath(self, is_iterative): """Tests correct operation behavior for duplicated node path.""" child = add_node.AddNodeOp()(self.n, { 'path': [(tree.TreeNode.LEFT, 'child-id')], 'data': 'some-data', 'is_iterative': is_iterative, }) with self.assertRaises(ValueError): add_node.AddNodeOp()(self.n, { 'path': [(tree.TreeNode.LEFT, 'child-id')], 'data': 'some-data', 'is_iterative': is_iterative, })
def testPrevNodeMaxSubtree(self, unused_update_cache): """Tests in-order tree traversal with a right subtree.""" child = add_node.AddNodeOp()(self.n, { 'path': [(tree.TreeNode.LEFT, 'child-id')], 'data': 'some-data', }) grandchild = add_node.AddNodeOp()( child, { 'path': [(tree.TreeNode.RIGHT, 'grandchild-id')], 'data': 'some-data', }) prev = prev_node.PrevNodeOp()(self.n) self.assertEqual(prev, grandchild)
def testNextNodeMinSubtree(self, unused_update_cache): """Tests in-order tree traversal with left subtree.""" child = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.RIGHT, 'child-id')], 'data': 'some-data', }) grandchild = add_node.AddNodeOp()( child, { 'path': [(tree.TreeNode.LEFT, 'grandchild-id')], 'data': 'some-data', }) next = next_node.NextNodeOp()(self.n) self.assertEqual(next, grandchild)
def testNextNodeIdempotency(self, unused_update_cache): """Tests that the TreeNode is actually caching a NextNode call.""" sibling_a = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.RIGHT, 'sibling-a')], 'data': 'some-data', }) sibling_b = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.RIGHT, 'sibling-b')], 'data': 'some-data', }) next = next_node.NextNodeOp()(sibling_a) self.assertEqual(next, sibling_b) self.assertEqual(next, next_node.NextNodeOp()(sibling_a))
def testPrevNodeIdempotency(self, unused_update_cache): """Tests that the TreeNode is actually caching a PrevNode call.""" sibling_a = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.LEFT, 'sibling-a')], 'data': 'some-data', }) sibling_b = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.LEFT, 'sibling-b')], 'data': 'some-data', }) prev = prev_node.PrevNodeOp()(sibling_b) self.assertEqual(prev, sibling_a) self.assertEqual(prev, prev_node.PrevNodeOp()(sibling_b))
def testAddNodeInvalidNullPath(self, is_iterative): """Tests correct operation behavior when no path is provided.""" with self.assertRaises(ValueError): add_node.AddNodeOp()(self.n, { 'path': [], 'data': 'some-data', 'is_iterative': is_iterative, })
def testNextNodeSibling(self, unused_update_cache): """Tests getting a sibling node is implemented.""" sibling_a = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.RIGHT, 'sibling-a')], 'data': 'some-data', }) sibling_b = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.RIGHT, 'sibling-b')], 'data': 'some-data', }) next = next_node.NextNodeOp()(sibling_a) self.assertEqual(next, sibling_b) self.assertEqual(sibling_a.metadata['next'], sibling_b) self.assertNotIn('next', sibling_b.metadata)
def testPrevNodeSibling(self, unused_update_cache): """Tests getting a sibling node is implemented.""" sibling_a = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.LEFT, 'sibling-a')], 'data': 'some-data', }) sibling_b = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.LEFT, 'sibling-b')], 'data': 'some-data', }) prev = prev_node.PrevNodeOp()(sibling_b) self.assertEqual(prev, sibling_a) self.assertEqual(sibling_b.metadata['prev'], sibling_a) self.assertNotIn('prev', sibling_a.metadata)
def testPrevNodeBegin(self, unused_update_cache): """Tests that getting prev node from start of a tree raises an error.""" child = add_node.AddNodeOp()(self.n, { 'path': [(tree.TreeNode.LEFT, 'child-id')], 'data': 'some-data', }) with self.assertRaises(StopIteration): prev_node.PrevNodeOp()(child)
def testNextNodeParent(self, unused_update_cache): """Tests in-order tree traversal when parent is next node.""" child = add_node.AddNodeOp()(self.n, { 'path': [(tree.TreeNode.LEFT, 'child-id')], 'data': 'some-data', }) next = next_node.NextNodeOp()(child) self.assertEqual(next, self.n)
def testPrevNodeParent(self, unused_update_cache): """Tests in-order tree traversal when parent is prev node.""" child = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.RIGHT, 'child-id')], 'data': 'some-data', }) prev = prev_node.PrevNodeOp()(child) self.assertEqual(prev, self.n)
def testAddNodeUpdateCacheLastNode(self, is_iterative): """Tests newly added last leaf nodes update neighbor nodes.""" child = add_node.AddNodeOp()(self.n, { 'path': [(tree.TreeNode.RIGHT, 'child-id')], 'data': 'some-data', 'is_iterative': is_iterative, }) self.assertEqual(child.metadata['prev'], self.n) self.assertEqual(self.n.metadata['next'], child)
def testAddNodeNested(self, is_iterative): """Tests adding nested node.""" child = add_node.AddNodeOp()(self.n, { 'path': [(tree.TreeNode.LEFT, 'child-id')], 'data': 'some-data', 'is_iterative': is_iterative, }) grandchild = add_node.AddNodeOp()(self.n, { 'path': [(tree.TreeNode.LEFT, 'child-id'), (tree.TreeNode.LEFT, 'grandchild-id')], 'data': 'some-data', 'is_iterative': is_iterative, }) self.assertEqual(len(child.children[tree.TreeNode.LEFT]), 1) self.assertIn('grandchild-id', child.children[tree.TreeNode.LEFT]) self.assertEqual(child.children[tree.TreeNode.LEFT]['grandchild-id'], grandchild) self.assertEqual(grandchild.data, 'some-data') self.assertEqual(grandchild.id, 'grandchild-id')
def testNextNodeEnd(self, unused_update_cache): """Tests that getting next node from end of a tree raises an error.""" child = add_node.AddNodeOp()( self.n, { 'path': [(tree.TreeNode.RIGHT, 'child-id')], 'data': 'some-data', }) with self.assertRaises(StopIteration): next_node.NextNodeOp()(child)
def testGetNestedPath(self, is_iterative): root = tree.TreeNode((None, 'root-id'), 'some-data') child = add_node.AddNodeOp()(root, { 'path': [(tree.TreeNode.LEFT, 'child-id')], 'data': 'some-data', }) self.assertEqual( get_path.GetPathOp()(child, { 'is_iterative': is_iterative, }), [(None, 'root-id'), (tree.TreeNode.LEFT, 'child-id')])
def testAddNodeValid(self, is_iterative): """Tests expected behavior of general AddNodeOp case.""" child = add_node.AddNodeOp()(self.n, { 'path': [(tree.TreeNode.LEFT, 'child-id')], 'data': 'some-data', 'is_iterative': is_iterative, }) self.assertEqual(len(self.n.children[tree.TreeNode.LEFT]), 1) self.assertIn('child-id', self.n.children[tree.TreeNode.LEFT]) self.assertEqual(self.n.children[tree.TreeNode.LEFT]['child-id'], child) self.assertEqual(child.data, 'some-data') self.assertEqual(child.id, 'child-id')
def testAddNodeValueMultithreaded(self, is_iterative): """Tests expected behavior of multiple messages in flight.""" n_threads = 1000 threads = [] t_ids = ['child-id-%04d' % t_id for t_id in xrange(n_threads)] for t_id in xrange(n_threads): t = threading.Thread(target=add_node.AddNodeOp(), args=(self.n, { 'path': [(tree.TreeNode.LEFT, t_ids[t_id])], 'data': 'some-data', 'is_iterative': is_iterative, })) threads.append(t) t.start() for t in threads: t.join() self.assertEqual(len(self.n.children[tree.TreeNode.LEFT]), n_threads) self.assertEqual(len(self.n.children[tree.TreeNode.RIGHT]), 0) self.assertEqual(list(self.n.children[tree.TreeNode.LEFT].keys()), t_ids)