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)
