def test_all_out_edges_of_node(self):
graph = DiGraph()
tuple0 = (0, 30, 2)
tuple1 = (50, 50, 50)
node0 = NodeData(0, tuple0) # node: key=0 tuple=(0, 30, 2)
node1 = NodeData(1, tuple0) # node: key=1 tuple=(0, 30, 2)
node2 = NodeData(2, tuple1) # node: key=2 tuple=(50, 50, 50)
node3 = NodeData(3, tuple1) # node: key=3 tuple=(50, 50, 50)
graph.add_node(node0.get_key(), tuple0) # add node0
self.assertEqual({}, graph.all_out_edges_of_node(
node0.get_key())) # check the list In empty
graph.add_node(node1.get_key(), tuple0) # add node1
graph.add_node(node2.get_key(), tuple1) # add node2
graph.add_node(node3.get_key(), tuple1) # add node3
graph.add_edge(node1.get_key(), node0.get_key(), 10) # connect 1->0
graph.add_edge(node1.get_key(), node2.get_key(), 15) # connect 1->2
graph.add_edge(node1.get_key(), node3.get_key(), 20) # connect 1->2
ans_list_keys = [node0.get_key(), node2.get_key(), node3.get_key()]
for i in graph.all_out_edges_of_node(node1.get_key()).keys():
self.assertIn(i, ans_list_keys)
graph.remove_node(node2.get_key()) # remove node2
graph.remove_node(node3.get_key()) # remove node3
ans_list_keys = [node0.get_key()]
for i in ans_list_keys:
self.assertIn(i,
graph.all_out_edges_of_node(node1.get_key()).keys())
def test_add_node1(self):
graph = DiGraph()
graph.add_node(1)
graph.add_node(2)
graph.add_node(3)
graph.add_node(4)
graph.add_node(5)
graph.add_edge(1, 2, 3)
graph.add_edge(2, 3, 4)
graph.add_edge(3, 4, 10)
graph.add_edge(4, 3, 1)
graph.add_edge(3, 5, 7)
graph.add_edge(5, 1, 1)
graph.add_edge(1, 5, 2)
self.assertEqual(12, graph.get_mc())
self.assertEqual(5, graph.v_size())
self.assertEqual(7, graph.e_size())
keys = [1, 2, 3, 4, 5]
self.assertEqual(keys, list(graph.get_all_v().keys()))
self.assertEqual({2: 4, 4: 1}, graph.all_in_edges_of_node(3))
self.assertEqual({4: 10, 5: 7}, graph.all_out_edges_of_node(3))
graph.remove_edge(5, 1)
self.assertEqual(6, graph.e_size())
self.assertEqual(0, len(graph.all_out_edges_of_node(5)))
self.assertEqual(13, graph.get_mc())
graph.remove_node(3)
self.assertEqual(4, graph.v_size())
self.assertEqual(2, graph.e_size())
self.assertEqual(0, len(graph.all_out_edges_of_node(4)))
self.assertEqual(14, graph.get_mc())
def test_all_edges(self):
G = DiGraph()
G.add_node(0)
G.add_node(1)
G.add_node(2)
G.add_edge(0, 1, 10)
G.add_edge(2, 1, 10)
self.assertEqual(len(G.all_in_edges_of_node(1)), 2)
self.assertEqual(len(G.all_out_edges_of_node(1)), 0)
self.assertEqual(len(G.all_in_edges_of_node(0)), 0)
self.assertEqual(len(G.all_out_edges_of_node(0)), 1)
def test_all_out_edges_of_node(self):
graph = DiGraph()
self.assertTrue(graph.add_node(0))
self.assertTrue(graph.add_node(1))
self.assertTrue(graph.add_node(2))
self.assertTrue(graph.add_node(3))
self.assertTrue(graph.add_edge(1, 2, 0))
self.assertTrue(graph.add_edge(2, 1, 1))
edge = graph.all_out_edges_of_node(1)
self.assertEqual(edge[2], 0)
edge = graph.all_out_edges_of_node(2)
self.assertEqual(edge[1], 1)
def test_all_out_edges_of_node(self):
g = DiGraph()
g.add_node(1)
g.add_node(2)
g.add_node(3)
g.add_node(4)
g.add_edge(1, 2, 3)
g.add_edge(2, 3, 2)
g.add_edge(3, 4, 3)
g.add_edge(4, 1, 2.5)
self.assertEqual({2: 3}, g.all_out_edges_of_node(1))
g.add_edge(1, 4, 1)
self.assertEqual({2: 3, 4: 1}, g.all_out_edges_of_node(1))
def test_remove_edge(self):
graph = DiGraph()
graph.add_node(1)
graph.add_node(2)
graph.add_node(3)
graph.add_edge(1, 2, 1)
graph.add_edge(1, 3, 1)
self.assertEqual(graph.all_in_edges_of_node(2).get(1), 1)
self.assertEqual(graph.all_out_edges_of_node(1).get(2), 1)
graph.remove_edge(1, 2)
self.assertEqual(graph.all_in_edges_of_node(2).get(1), None)
self.assertEqual(graph.all_out_edges_of_node(1).get(2), None)
self.assertEqual(graph.e_size(), 1)
def test_add_edge(self):
g = self.graphCreator(20)
assert 20 == g.v_size()
g.add_edge(0, 1, 5)
assert g.all_in_edges_of_node(1).get(0) == 5
g.add_edge(0, 1, 2)
assert g.all_in_edges_of_node(1).get(0) == 5
g.add_edge(0, 2, 2)
g.add_edge(0, 3, 7)
g.add_edge(1, 2, 4.23)
assert False == g.add_edge(1, 4, -15)
assert False == g.add_edge(1, 2, 2)
g = self.graphCreator1(20, 20)
e = 20
if g.add_edge(4, 5, 15):
e += 1
assert g.e_size() == e
g.all_out_edges_of_node(4).get(5) == 15
g.all_in_edges_of_node(5).get(4) == 15
print("done")
if g.add_edge(4, 6, 9.5):
e += 1
assert g.e_size() == e
assert g.all_out_edges_of_node(4).get(6) == 9.5
g.all_in_edges_of_node(6).get(4) == 9.5
print("done")
g = DiGraph()
g.add_node(0)
g.add_edge(0, 0, 1)
assert 0 == g.e_size()
assert g.all_out_edges_of_node(0).get(0) == None
def graph_nx(self, graph: DiGraph):
g = nx.DiGraph()
for i in graph.get_all_v().keys():
g.add_node(i)
for n, w in graph.all_out_edges_of_node(i).items():
g.add_edge(i, n, weight=w)
return g
def check0():
"""
This function tests the naming (main methods of the DiGraph class, as defined in GraphInterface.
:return:
"""
g = DiGraph() # creates an empty directed graph
for n in range(4):
g.add_node(n)
g.add_edge(0, 1, 1)
g.add_edge(1, 0, 1.1)
g.add_edge(1, 2, 1.3)
g.add_edge(2, 3, 1.1)
g.add_edge(1, 3, 1.9)
g.remove_edge(1, 3)
g.add_edge(1, 3, 10)
print(g) # prints the __repr__ (func output)
print(g.get_all_v()) # prints a dict with all the graph's vertices.
print(g.all_in_edges_of_node(1))
print(g.all_out_edges_of_node(1))
g_algo = GraphAlgo(g)
g_algo.save_to_json('graph.json')
g_algo2 = GraphAlgo()
g_algo2.load_from_json('graph.json')
g_algo2.save_to_json('graphAlgo2.json')
print(g_algo.shortest_path(0, 3))
g_algo.plot_graph()
def test_v_e_size_removes_and_add(self):
graph = DiGraph()
self.assertEqual(False, self.graph.add_edge(1, 7, -1))
self.assertEqual(0, graph.e_size())
self.assertEqual(0, graph.v_size())
self.assertEqual(0, graph.get_mc())
self.assertEqual(False, graph.remove_edge(1, 3))
self.assertEqual({}, graph.all_out_edges_of_node(3))
self.assertEqual({}, graph.all_in_edges_of_node(3))
self.assertEqual(14, self.graph.v_size())
self.assertEqual(24, self.graph.e_size())
self.assertEqual(38, self.graph.get_mc())
self.assertEqual(True, self.graph.remove_node(4))
self.assertEqual(39, self.graph.get_mc())
self.assertEqual(True, self.graph.remove_edge(1, 2))
self.graph.remove_edge(11, 10)
self.assertEqual(False, self.graph.remove_node(15))
self.assertEqual(False, self.graph.remove_node(0))
self.assertEqual(False, self.graph.remove_node(-1))
self.assertEqual(False, self.graph.remove_edge(11, 11))
self.assertEqual(False, self.graph.remove_edge(6, 5))
self.assertEqual(17, self.graph.e_size())
self.assertEqual(13, self.graph.v_size())
self.graph.add_node(99)
self.assertEqual(14, self.graph.v_size())
self.graph.add_edge(99, 10, 5)
self.graph.add_edge(99, 5, 5)
self.graph.add_edge(99, 10, 5)
self.graph.add_edge(99, 99, 5)
self.graph.add_edge(10, 99, 5)
self.graph.add_edge(10, 99, 5)
self.assertEqual(20, self.graph.e_size())
self.assertEqual(45, self.graph.get_mc())
def test_all_out_edges_of_node(self):
graph = DiGraph()
for i in range(0, 20):
graph.add_node(i)
for i in range(0, 10):
graph.add_edge(i, i + 1, 2)
for i in graph.all_in_edges_of_node(10):
self.assertTrue(10 in graph.all_out_edges_of_node(i))
class TestDiGraph(TestCase):
def setUp(self) -> None:
self.g = DiGraph()
for i in range(5):
self.g.add_node(i)
self.g.add_edge(1, 2, 1)
self.g.add_edge(1, 3, 1)
self.g.add_edge(1, 4, 1)
self.g.add_edge(2, 1, 1)
self.g.add_edge(2, 0, 1.5)
self.g.add_edge(3, 1, 1)
self.g.add_edge(4, 0, 4.8)
self.g.add_edge(4, 2, 1)
def test_v_size(self):
self.assertEqual(5, self.g.v_size())
def test_e_size(self):
self.assertEqual(8, self.g.e_size())
def test_get_mc(self):
self.assertEqual(13, self.g.get_mc())
def test_add_edge(self):
self.assertFalse(self.g.add_edge(9, 5, 0.35))
self.assertTrue(self.g.add_edge(0, 2, 0.93))
def test_add_node(self):
self.assertFalse(self.g.add_node(0))
self.assertTrue(self.g.add_node(5))
self.assertFalse(self.g.add_node(5))
def test_remove_node(self):
self.assertFalse(self.g.remove_node(6))
self.assertTrue(self.g.remove_node(4))
self.assertEqual(5, self.g.e_size())
def test_remove_edge(self):
self.assertFalse(self.g.remove_edge(0, 7))
self.assertTrue(self.g.remove_edge(1, 2))
self.assertEqual(7, self.g.e_size())
def test_all_in_edges_of_node(self):
self.assertEqual({2: 1.5, 4: 4.8}, self.g.all_in_edges_of_node(0))
def test_all_out_edges_of_node(self):
self.assertEqual({2: 1, 3: 1, 4: 1}, self.g.all_out_edges_of_node(1))
def test_get_all_v(self):
self.assertEqual(5, len(self.g.get_all_v()))
d = {
0: self.g.get_all_v()[0],
1: self.g.get_all_v()[1],
2: self.g.get_all_v()[2],
3: self.g.get_all_v()[3],
4: self.g.get_all_v()[4]
}
self.assertEqual(d, self.g.get_all_v())
def test_all_out_edges_of_node(self):
graph = DiGraph()
self.assertTrue(graph.add_node(2))
self.assertTrue(graph.add_node(3))
self.assertTrue(graph.add_node(4))
self.assertTrue(graph.add_edge(2, 3, 0))
self.assertTrue(graph.add_edge(3, 4, 1))
edge = graph.all_out_edges_of_node(3)
self.assertEqual(edge[3], 1)
def rereverseGraph(self, g: DiGraph) -> GraphInterface:
gr = DiGraph()
for n in g.get_all_v().values():
gr.add_node(n.getKey(), n.getLocation())
for n in g.get_all_v().values():
for e in g.all_out_edges_of_node(n.getKey()).items(
): # return tuple of pair (other node id, weight))
gr.add_edge(e[0], n.getKey(), e[1])
return gr
def test_all_out_edges_of_node(self):
g0 = DiGraph()
for i in range(0, 10):
g0.add_node(i)
g0.add_edge(4, 3, 1)
g0.add_edge(4, 2, 1)
g0.add_edge(2, 4, 1)
g0.add_edge(1, 2, 1)
g0.add_edge(5, 3, 1)
g0.add_edge(4, 5, 1)
temp = g0.all_out_edges_of_node(4)
self.assertEqual(3, len(g0.all_out_edges_of_node(4)))
g0.add_edge(4, 6, 1)
self.assertEqual(4, len(g0.all_out_edges_of_node(4)))
g0.add_edge(4, 6, 1) # already existed
self.assertEqual(4, len(g0.all_out_edges_of_node(4)))
g0.remove_edge(4, 6) # check if this dict updates after removing edge
self.assertEqual(3, len(g0.all_out_edges_of_node(4)))
def test_remove_edge(self):
graph = DiGraph()
self.assertTrue(graph.add_node(0))
self.assertTrue(graph.add_node(1))
self.assertTrue(graph.add_node(2))
self.assertTrue(graph.add_node(3))
self.assertTrue(graph.add_edge(0, 1, 0))
self.assertTrue(graph.add_edge(0, 2, 0))
self.assertTrue(graph.add_edge(1, 2, 0))
self.assertTrue(graph.add_edge(2, 1, 1))
self.assertEqual(len(graph.all_out_edges_of_node(0)), 2)
self.assertTrue(graph.remove_edge(0, 2))
self.assertFalse(graph.remove_edge(0, 2))
self.assertEqual(len(graph.all_out_edges_of_node(0)), 1)
self.assertEqual(graph.v_size(), 4)
self.assertEqual(graph.e_size(), 3)
self.assertTrue(graph.remove_edge(0, 1))
self.assertIsNone(graph.all_out_edges_of_node(0))
self.assertEqual(graph.get_mc(), 10)
def test_remove_edge(self):
g0 = DiGraph()
for i in range(0, 10):
g0.add_node(i)
for i in range(0, 10):
g0.add_edge(i, 9 - i, 0.2)
g0.remove_edge(0, 9)
self.assertEqual(9, g0.e_size())
self.assertEqual(21, g0.get_mc())
self.assertFalse(9 in g0.all_out_edges_of_node(0).keys())
def test_all_out_edges_of_node(self):
graph = DiGraph()
graph.add_node(0)
graph.add_node(1)
graph.add_node(2)
graph.add_node(3)
graph.add_edge(0, 1, 5)
graph.add_edge(1, 2, 3)
graph.add_edge(2, 0, 1)
graph.add_edge(2, 1, 4)
graph.add_edge(2, 3, 3)
graph.add_edge(3, 2, 2)
edges_out = graph.all_out_edges_of_node(0)
self.assertEqual(len(edges_out.values()), 1,
"the number of the edges that in to the node 1")
graph.remove_node(1)
edges_out = graph.all_out_edges_of_node(0)
self.assertEqual(len(edges_out.values()), 0,
"the new number of the edges that in to the node 1")
def check():
"""
This function tests the naming (main methods of the DiGraph class, as defined in GraphInterface.
:return:
"""
g = DiGraph() # creates an empty directed graph
for n in range(100):
g.add_node(n)
b = g.add_node(1)
print("add test (false):" + str(b)) # should return false
g.add_edge(0, 1, 1)
g.add_edge(1, 0, 1.1)
g.add_edge(1, 2, 1.3)
g.add_edge(2, 3, 1.1)
g.add_edge(1, 3, 1.9)
b = g.add_edge(1, 3, 10)
print("add update weight (false): ", b)
b = g.remove_edge(1, 3)
print("remove (true): " + str(b)) # should return true
b = g.add_edge(1, 3, 10)
print("add after remove (true): ", b)
b = g.remove_node(2)
print("remove node (true): ", b)
b = g.remove_node(12)
print("remove node that doesnt exist(false): ", b)
b = g.add_edge(2, 3, 1.5)
print("add edge of node that doesnt exist (false): ", b)
b = g.add_edge(3, 2, 1.5)
print("add edge of node that doesnt exist (false): ", b)
b = g.add_edge(3, 3, 1.5)
print("add edge of node that doesnt exist (false): ", b)
b = g.add_edge(3, 13, 1.5)
print("add edge of node that doesnt exist (false): ", b)
print(g) # prints the __repr__ (func output)
print(g.get_all_v()) # prints a dict with all the graph's vertices.
print(g.all_in_edges_of_node(1))
print(g.all_out_edges_of_node(1))
"""
def test_all_out_edges_of_node(self):
g = DiGraph()
g.add_node(1)
g.add_node(2)
g.add_node(3)
g.add_node(4)
g.add_edge(1, 2, 3.3)
g.add_edge(2, 1, 4.4)
g.add_edge(3, 2, 4.4)
g.add_edge(2, 4, 4.4)
self.assertEqual(g.all_out_edges_of_node(2), {1: 4.4, 4: 4.4})
def test_remove_edge(self):
graph = DiGraph()
self.assertTrue(graph.add_node(3))
self.assertTrue(graph.add_node(4))
self.assertTrue(graph.add_node(5))
self.assertTrue(graph.add_node(6))
self.assertTrue(graph.add_node(7))
self.assertTrue(graph.add_edge(6, 5, 1))
self.assertTrue(graph.add_edge(5, 6, 0))
self.assertTrue(graph.add_edge(4, 5, 0))
self.assertTrue(graph.add_edge(4, 6, 0))
self.assertEqual(len(graph.all_out_edges_of_node(4)), 2)
self.assertTrue(graph.remove_edge(4, 6))
self.assertFalse(graph.remove_edge(4, 6))
self.assertFalse(graph.remove_edge(4, 6))
self.assertEqual(len(graph.all_out_edges_of_node(4)), 1)
self.assertEqual(graph.v_size(), 5)
self.assertEqual(graph.e_size(), 3)
self.assertTrue(graph.remove_edge(4, 5))
self.assertEqual(graph.get_mc(), 11)
def bfs(self, node_id: int, graph: DiGraph):
q = Queue()
n = graph.nodedict[node_id]
q.put(n)
n.set_tag(1)
while not q.empty():
node = q.get()
if node.key in graph.edgedict:
for key, w in graph.all_out_edges_of_node(node.key).items():
curr = graph.nodedict[key]
if curr.tag == 0:
q.put(curr)
curr.set_tag(1)
def test_all_out_edges_of_node(self):
graph = DiGraph()
graph.add_node(1)
graph.add_node(2)
graph.add_node(3)
graph.add_edge(1, 2, 1)
graph.add_edge(1, 3, 1)
graph.add_edge(2, 1, 1)
graph.add_edge(2, 3, 1)
edges_in = graph.all_out_edges_of_node(1)
self.assertEqual(len(edges_in.values()), 2, 'not all nodes returned')
self.assertEqual(edges_in.get(2), 1, 'Doesn\'t contain all edges')
self.assertEqual(edges_in.get(3), 1, 'Doesn\'t contain all edges')
def test_get_all_funcs(self):
graph = DiGraph()
self.assertEqual({}, graph.all_in_edges_of_node(1))
self.assertEqual({}, graph.all_out_edges_of_node(1))
self.assertEqual([], list(graph.get_all_v().keys()))
self.assertEqual([], list(self.graph.all_out_edges_of_node(15)))
self.assertEqual([], list(self.graph.all_in_edges_of_node(15)))
self.assertEqual({1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}, self.graph.get_all_v().keys())
self.assertEqual({1, 9, 13}, self.graph.all_in_edges_of_node(5).keys())
self.assertEqual({3, 7, 4}, self.graph.all_in_edges_of_node(9).keys())
self.assertEqual([], list(self.graph.all_in_edges_of_node(1).keys()))
self.assertEqual({2, 5}, self.graph.all_out_edges_of_node(1).keys())
self.graph.remove_node(5)
self.assertEqual({1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14}, self.graph.get_all_v().keys())
def test_all_out_edges_of_nodes(self):
graph = DiGraph()
for i in range(10):
graph.add_node(i)
graph.add_edge(1, 2, 1.2)
graph.add_edge(1, 3, 1.2)
graph.add_edge(1, 4, 1.2)
graph.add_edge(1, 5, 1.2)
graph.add_edge(1, 5, 1.2)
graph.add_edge(9, 1, 14.0)
graph.add_edge(9, 1, 14.0)
graph.add_edge(8, 1, 15.0)
self.assertEqual(4, len(graph.all_out_edges_of_node(1)))
def test_add_edge(self):
graph = DiGraph()
for i in range(1, 11):
graph.add_node(i)
graph.add_edge(1, 2, 5)
graph.add_edge(1, 8, 4)
graph.add_edge(9, 10, 0)
graph.add_edge(5, 2, 3)
self.assertEqual(4, graph.e_size())
self.assertFalse(graph.add_edge(1, 100, 4))
self.assertEqual(2, len(graph.all_out_edges_of_node(1)))
self.assertEqual(0, len(graph.all_out_edges_of_node(4)))
graph.remove_edge(1, 8)
self.assertEqual(3, graph.e_size())
self.assertEqual(1, len(graph.all_out_edges_of_node(1)))
graph.remove_node(9)
self.assertEqual(2, graph.e_size())
self.assertEqual(0, len(graph.all_out_edges_of_node(10)))
self.assertFalse(graph.add_edge(1, 2, -9))
self.assertFalse(graph.add_edge(1, 4, -9))
self.assertEqual(2, graph.e_size())# If the weight is negative then the number of ribs does not change.
self.assertEqual(16, graph.get_mc())
def test_add_edge(self):
graph = DiGraph()
graph.add_node(1)
graph.add_node(2)
graph.add_edge(1, 2, 1)
self.assertEqual(graph.all_in_edges_of_node(2).get(1), 1, "yalla")
self.assertEqual(graph.all_out_edges_of_node(1).get(2), 1, "yalla")
graph.add_edge(1, 2, 1)
self.assertEqual(
graph.all_out_edges_of_node(1).get(2), 1,
"failed in add duplicate test")
self.assertEqual(
graph.all_in_edges_of_node(2).get(1), 1,
"failed in add duplicate test")
self.assertEqual(graph.e_size(), 1, "failed in add duplicate test")
graph.add_edge(1, 1, 1)
self.assertEqual(
graph.all_out_edges_of_node(1).get(1), None,
"failed in add duplicate test")
self.assertEqual(
graph.all_in_edges_of_node(1).get(1), None,
"failed in add duplicate test")
self.assertEqual(graph.e_size(), 1, "failed in add duplicate test")
def test_all_out_edges_of_node(self):
graph = DiGraph()
edges_list_tuple = []
for i in range(5):
graph.add_node(i)
for s in graph.get_all_v().keys():
for d in graph.get_all_v().keys():
w = random.random()
graph.add_edge(s, d, w)
edges_list_tuple.append((s, d, w))
for v in graph.get_all_v().keys():
edges_list = [(s, d, w) for s, d, w in edges_list_tuple
if d != s and s == v]
edge_dict = graph.all_out_edges_of_node(v)
for s, d, w in edges_list:
self.assertEqual(edge_dict[d], w)
def test_remove_node(self):
g0 = DiGraph()
for i in range(0, 10):
g0.add_node(i)
g0.add_edge(4, 3, 1)
g0.add_edge(4, 2, 1)
g0.add_edge(2, 4, 1)
g0.add_edge(1, 2, 1)
g0.add_edge(5, 4, 1)
g0.add_edge(2, 5, 1)
g0.remove_node(4)
self.assertEqual(g0.get_all_v().get(4), None)
self.assertEqual(0, len(g0.all_out_edges_of_node(5)))
self.assertEqual(9, g0.v_size())
self.assertEqual(2, g0.e_size())
self.assertTrue(g0.remove_node(9))
self.assertIsNone(g0.get_all_v().get(9)) # remove node without neighbors
self.assertEqual(8, g0.v_size())
self.assertEqual(2, g0.e_size())
self.assertEqual(18, g0.get_mc())
def test_get_edges(self): # check for correct edges' dict values
graph = DiGraph()
for i in range(6):
graph.add_node(i)
graph.add_edge(0, 1, 1)
graph.add_edge(2, 1, 3)
graph.add_edge(3, 1, 4)
graph.add_edge(1, 2, 3)
graph.add_edge(1, 5, 6)
# estimated values
check_out = {2: 3, 5: 6}
edges_out = graph.all_out_edges_of_node(1)
check_in = {0: 1, 2: 3, 3: 4}
edges_in = graph.all_in_edges_of_node(1)
# check every dictionary values
for e in edges_out:
self.assertEqual(check_out[e], edges_out[e])
for e in edges_in:
self.assertEqual(check_in[e], edges_in[e])
