def test_bfs_succesors(self):
dag = retworkx.PyDAG()
node_a = dag.add_node(0)
node_b = dag.add_child(node_a, 1, {})
node_c = dag.add_child(node_b, 2, {})
node_d = dag.add_child(node_c, 3, {})
node_e = dag.add_child(node_d, 4, {})
node_f = dag.add_child(node_e, 5, {})
dag.add_child(node_f, 6, {})
node_h = dag.add_child(node_c, 7, {})
node_i = dag.add_child(node_h, 8, {})
node_j = dag.add_child(node_i, 9, {})
dag.add_child(node_j, 10, {})
res = {n: sorted(s) for n, s in retworkx.bfs_successors(dag, node_b)}
expected = {
1: [2],
2: [3, 7],
3: [4],
4: [5],
5: [6],
7: [8],
8: [9],
9: [10]
}
self.assertEqual(expected, res)
self.assertEqual([(7, [8]), (8, [9]), (9, [10])],
list(retworkx.bfs_successors(dag, node_h)))
def test_many_children(self):
dag = retworkx.PyDAG()
node_a = dag.add_node('a')
for i in range(10):
dag.add_child(node_a, {'numeral': i}, {'edge': i})
res = retworkx.bfs_successors(dag, node_a)
self.assertEqual([('a', [{
'numeral': 9
}, {
'numeral': 8
}, {
'numeral': 7
}, {
'numeral': 6
}, {
'numeral': 5
}, {
'numeral': 4
}, {
'numeral': 3
}, {
'numeral': 2
}, {
'numeral': 1
}, {
'numeral': 0
}])], list(res))
def test_bfs_successors_sequence(self):
dag = retworkx.PyDAG()
node_a = dag.add_node(0)
node_b = dag.add_child(node_a, 1, {})
node_c = dag.add_child(node_b, 2, {})
node_d = dag.add_child(node_c, 3, {})
node_e = dag.add_child(node_d, 4, {})
node_f = dag.add_child(node_e, 5, {})
dag.add_child(node_f, 6, {})
node_h = dag.add_child(node_c, 7, {})
node_i = dag.add_child(node_h, 8, {})
node_j = dag.add_child(node_i, 9, {})
dag.add_child(node_j, 10, {})
res = retworkx.bfs_successors(dag, node_b)
expected = [
(1, [2]),
(2, [7, 3]),
(7, [8]),
(3, [4]),
(8, [9]),
(4, [5]),
(9, [10]),
(5, [6]),
]
for index, expected_value in enumerate(expected):
self.assertEqual((res[index][0], res[index][1]), expected_value)
def test_single_successor(self):
dag = retworkx.PyDAG()
node_a = dag.add_node('a')
node_b = dag.add_child(node_a, 'b', {'a': 1})
node_c = dag.add_child(node_b, 'c', {'a': 2})
dag.add_child(node_c, 'd', {'a': 1})
res = retworkx.bfs_successors(dag, node_b)
self.assertEqual([('b', ['c']), ('c', ['d'])], list(res))
def test_single_successor(self):
dag = retworkx.PyDAG()
node_a = dag.add_node("a")
node_b = dag.add_child(node_a, "b", {"a": 1})
node_c = dag.add_child(node_b, "c", {"a": 2})
dag.add_child(node_c, "d", {"a": 1})
res = retworkx.bfs_successors(dag, node_b)
self.assertEqual([("b", ["c"]), ("c", ["d"])], res)
def test_bfs_successors_sequence_negative_index(self):
dag = retworkx.PyDAG()
node_a = dag.add_node(0)
node_b = dag.add_child(node_a, 1, {})
node_c = dag.add_child(node_b, 2, {})
node_d = dag.add_child(node_c, 3, {})
node_e = dag.add_child(node_d, 4, {})
node_f = dag.add_child(node_e, 5, {})
dag.add_child(node_f, 6, {})
node_h = dag.add_child(node_c, 7, {})
node_i = dag.add_child(node_h, 8, {})
node_j = dag.add_child(node_i, 9, {})
dag.add_child(node_j, 10, {})
res = retworkx.bfs_successors(dag, node_b)
self.assertEqual((5, [6]), res[-1])
self.assertEqual((4, [5]), res[-3])
def test_bfs_successors_sequence_invalid_index(self):
dag = retworkx.PyDAG()
node_a = dag.add_node(0)
node_b = dag.add_child(node_a, 1, {})
node_c = dag.add_child(node_b, 2, {})
node_d = dag.add_child(node_c, 3, {})
node_e = dag.add_child(node_d, 4, {})
node_f = dag.add_child(node_e, 5, {})
dag.add_child(node_f, 6, {})
node_h = dag.add_child(node_c, 7, {})
node_i = dag.add_child(node_h, 8, {})
node_j = dag.add_child(node_i, 9, {})
dag.add_child(node_j, 10, {})
res = retworkx.bfs_successors(dag, node_b)
with self.assertRaises(IndexError):
res[8]
def test_bfs_successors_sequence_stop_iterator(self):
dag = retworkx.PyDAG()
node_a = dag.add_node(0)
node_b = dag.add_child(node_a, 1, {})
node_c = dag.add_child(node_b, 2, {})
node_d = dag.add_child(node_c, 3, {})
node_e = dag.add_child(node_d, 4, {})
node_f = dag.add_child(node_e, 5, {})
dag.add_child(node_f, 6, {})
node_h = dag.add_child(node_c, 7, {})
node_i = dag.add_child(node_h, 8, {})
node_j = dag.add_child(node_i, 9, {})
dag.add_child(node_j, 10, {})
res = iter(retworkx.bfs_successors(dag, node_b))
for _ in range(8):
next(res)
with self.assertRaises(StopIteration):
next(res)
def test_many_children(self):
dag = retworkx.PyDAG()
node_a = dag.add_node("a")
for i in range(10):
dag.add_child(node_a, {"numeral": i}, {"edge": i})
res = retworkx.bfs_successors(dag, node_a)
self.assertEqual(
[(
"a",
[
{
"numeral": 9
},
{
"numeral": 8
},
{
"numeral": 7
},
{
"numeral": 6
},
{
"numeral": 5
},
{
"numeral": 4
},
{
"numeral": 3
},
{
"numeral": 2
},
{
"numeral": 1
},
{
"numeral": 0
},
],
)],
res,
)
def test__ne__invalid_type(self):
with self.assertRaises(TypeError):
retworkx.bfs_successors(self.dag, 0) != ['a']
def test__ne__different_length(self):
self.assertTrue(
retworkx.bfs_successors(self.dag, 0) != [('a', ['b']), ('b',
['c'])])
def test_ne_not_match_inner(self):
self.assertTrue(retworkx.bfs_successors(self.dag, 0) != [('a', ['c'])])
def test__ne__not_match(self):
self.assertTrue(retworkx.bfs_successors(self.dag, 0) != [('b', ['c'])])
def test__ne__different_length(self):
self.assertTrue(
retworkx.bfs_successors(self.dag, 0) != [("a", ["b"]), ("b",
["c"])])
def test__eq__invalid_type(self):
with self.assertRaises(TypeError):
retworkx.bfs_successors(self.dag, 0) == ["a"]
def test__eq__match(self):
self.assertTrue(retworkx.bfs_successors(self.dag, 0) == [('a', ['b'])])
def test_hash_invalid_type(self):
self.dag.add_child(0, [1, 2, 3], 'edgy')
res = retworkx.bfs_successors(self.dag, 0)
with self.assertRaises(TypeError):
hash(res)
def test_hash(self):
res = retworkx.bfs_successors(self.dag, 0)
hash_res = hash(res)
self.assertIsInstance(hash_res, int)
# Assert hash is stable
self.assertEqual(hash_res, hash(res))
def test_str(self):
res = retworkx.bfs_successors(self.dag, 0)
self.assertEqual("BFSSuccessors[(a, [b])]", str(res))
def test_pickle(self):
bfs = retworkx.bfs_successors(self.dag, 0)
bfs_pickle = pickle.dumps(bfs)
bfs_copy = pickle.loads(bfs_pickle)
self.assertEqual(bfs, bfs_copy)
def test_deepcopy(self):
bfs = retworkx.bfs_successors(self.dag, 0)
bfs_copy = copy.deepcopy(bfs)
self.assertEqual(bfs, bfs_copy)
def test__gt__not_implemented(self):
with self.assertRaises(NotImplementedError):
retworkx.bfs_successors(self.dag, 0) > [('b', ['c'])]
def test__ne__match(self):
self.assertFalse(
retworkx.bfs_successors(self.dag, 0) != [("a", ["b"])])
def test__eq__different_length(self):
self.assertFalse(
retworkx.bfs_successors(self.dag, 0) == [('a', ['b']), ('b',
['c'])])
def test__eq__different_length(self):
self.assertFalse(
retworkx.bfs_successors(self.dag, 0) == [("a", ["b"]), ("b",
["c"])])
def test__ne__match(self):
self.assertFalse(
retworkx.bfs_successors(self.dag, 0) != [('a', ['b'])])
def test__eq__not_match(self):
self.assertFalse(
retworkx.bfs_successors(self.dag, 0) == [('b', ['c'])])
def test__ne__not_match(self):
self.assertTrue(retworkx.bfs_successors(self.dag, 0) != [("b", ["c"])])
def bfs_successors(self, node):
"""
Returns an iterator of tuples of (DAGNode, [DAGNodes]) where the DAGNode is the current node
and [DAGNode] is its successors in BFS order.
"""
return iter(rx.bfs_successors(self._multi_graph, node._node_id))
def test_eq_not_match_inner(self):
self.assertFalse(
retworkx.bfs_successors(self.dag, 0) == [('a', ['c'])])