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())
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_e_size(self):
graph = DiGraph()
graph.add_node(1)
graph.add_node(2)
graph.add_edge(1, 2, 2)
assert graph.e_size() == 1, 'count number of edges incorrectly'
graph.add_edge(2, 1, 2)
assert graph.e_size(
) == 2, 'after adding a new edge, number of edges is incorrect'
def test_add_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)
self.assertFalse(g0.add_edge(3, 12, 2)) # added an edge between noedes that not exist
self.assertEqual(10, g0.e_size())
self.assertEqual(20, g0.get_mc())
self.assertFalse(g0.add_edge(0, 9, 3)) # added exited edge
self.assertEqual(10, g0.e_size())
self.assertEqual(20, g0.get_mc())
self.assertFalse(g0.add_edge(2, 2, 1)) # added edge between node to itself
def test_e_size(self):
g = DiGraph()
self.assertEqual(0, g.e_size())
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(4, g.e_size())
g.remove_edge(4, 1)
self.assertEqual(3, g.e_size())
def graph_creator(v, e) -> DiGraph:
g = DiGraph()
for n in range(v):
g.add_node(n)
for i in range(0, v):
for j in range(1, v):
if g.e_size() < e:
g.add_edge(i, j, 10)
if g.e_size() >= e:
break
return g
def test_remove_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)
self.assertEqual(graph.e_size(), 2)
self.assertEqual(graph.v_size(), 3)
graph.remove_node(1)
self.assertEqual(graph.e_size(), 0)
self.assertEqual(graph.v_size(), 2)
self.assertEqual(graph.get_all_v().get(1), None)
self.assertEqual(graph.get_all_v(), {2: NodeData(2), 3: NodeData(3)})
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 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_empty_graph(self):
graph = DiGraph()
self.assertTrue(graph.get_mc() == 0)
self.assertTrue(graph.e_size() == 0)
self.assertTrue(graph.v_size() == 0)
self.assertFalse(graph.remove_node(1), "The node does not exist!")
self.assertFalse(graph.remove_edge(1, 2), "The edge already exist!")
def test_edge_size(self):
graph = DiGraph()
for i in range(5):
graph.add_node(i)
weight_dict = {"0": 3.4, "1": 3.5, "2": 5.4, "3": 3.1, "4": 4.5}
conn_dict = {"0": 1, "1": 2, "2": 3, "3": 4, "4": 0}
for k in graph.get_all_v().keys():
graph.add_edge(k, conn_dict[str(k)], weight_dict[str(k)])
self.assertEqual(graph.e_size(), 5)
graph.add_edge(0, 1, 3.5)
self.assertEqual(graph.e_size(), 5)
for k in range(0, 5, 2):
graph.remove_edge(k, conn_dict[str(k)])
self.assertEqual(graph.e_size(), 2)
graph.remove_edge(0, 1)
self.assertEqual(graph.e_size(), 2)
def test_extremeCases(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_node(6)
graph.add_edge(1, 3, 6)
graph.add_edge(3, 4, 10)
graph.add_edge(4, 2, 5)
graph.add_edge(2, 1, 10)
graph.add_edge(2, 1, 10)
graph.add_edge(2, 1, 10.9)
algo = GraphAlgo(graph)
self.assertEquals(11, graph.get_mc())
graph.remove_node(2)
self.assertEquals(5, graph.v_size())
self.assertEquals(2, graph.e_size())
self.assertFalse(graph.remove_node(2))
self.assertEquals(16, algo.shortest_path(1, 4)[0])
self.assertEquals((float('inf'), []), algo.shortest_path(1, 2))
self.assertEquals(12, graph.get_mc())
def test_e_size(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)
self.assertEqual(10, g0.e_size())
def test_remove_edge(self):
graph = DiGraph()
is_remove_edge = graph.remove_edge(
1, 2) # tried to remove edge that not exist in the graph
self.assertFalse(
is_remove_edge
) # is_remove_edge is false because tried to remove edge that not exist
self.assertTrue(graph.e_size() == 0)
graph.add_edge(
1, 2, 30
) # tried to connect node1 to node2 and the nodes that not exist in the graph
graph.add_node(1)
is_remove_edge = graph.remove_edge(
1,
2) # tried to connect node1 to node2 and the node2 that not exist
self.assertFalse(
is_remove_edge
) # is_remove_edge is false because tried to remove edge that node2 not exist
self.assertTrue(graph.e_size() == 0)
graph.add_node(2)
graph.add_edge(1, 2, 30)
graph.add_edge(1, 2, 30)
self.assertTrue(graph.e_size() == 1)
graph.add_edge(2, 1, 30)
self.assertTrue(graph.e_size() == 2)
is_remove_edge = graph.remove_edge(1, 2)
self.assertTrue(is_remove_edge) # remove edge 1->2
self.assertTrue(graph.e_size() == 1)
is_remove_edge = graph.remove_edge(
1, 2) # tried remove edge that not exist
self.assertFalse(is_remove_edge)
self.assertTrue(graph.e_size() == 1)
is_remove_edge = graph.remove_edge(2, 1) # remove edge 2->1
self.assertTrue(is_remove_edge) # remove edge 1->2
self.assertTrue(graph.e_size() == 0)
def test_removeEdge(self):
g0 = DiGraph()
node0 = NodeData(0, (0, 1, 2))
node1 = NodeData(1, (2.4, 7.1, 3.5))
g0.add_node(node0.getkey())
g0.add_node(node1.getkey())
g0.add_edge(node0.getkey(), node1.getkey(), 7)
g0.remove_edge(node0.getkey(), node1.getkey())
self.assertEqual(g0.e_size(), 1)
def test_remove(self):
graph = DiGraph()
graph.add_node(1, (1, 2, 3)) # add node check
graph.add_node(2, (2, 3, 4))
graph.add_node(3, (5, 4, 6))
graph.add_node(4, (3, 4, 6))
graph.add_edge(1, 2, 3)
graph.add_edge(2, 3, 3)
graph.add_edge(3, 4, 3)
graph.add_edge(4, 1, 3)
self.assertEqual(graph.v_size(), 4, "have only 4 nodes!!")
self.assertEqual(graph.e_size(), 4, "have only 4 nodes!!")
graph.remove_node(1)
self.assertTrue(graph.v_size() == 3)
self.assertTrue(graph.e_size() == 2)
graph.remove_node(1)
self.assertTrue(graph.get_mc() == 11,
"add - 8 times, remove 1- node 2- edges")
def test_add_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,(1,2,0)))
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.assertFalse(graph.add_edge(-2, 1, 0))
self.assertFalse(graph.add_edge(3, 3, 0))
self.assertEqual(graph.e_size(), 4)
self.assertEqual(graph.v_size(), 4)
self.assertFalse(graph.add_edge(0, 3, -10))
self.assertFalse(graph.add_edge(0, 2, 20))
self.assertEqual(graph.e_size(), 4)
def graph_random(seed: int, v_size: int, e_size: int):
g = DiGraph()
random.seed(seed)
pos = [(random.random(), random.random(), random.random())] * v_size
for i in range(v_size):
g.add_node(i, (pos[i][0], pos[i][1], pos[i][2]))
while g.e_size() != e_size:
g.add_edge(random.randint(0, v_size), random.randint(0, v_size),
random.random())
return g
def test_get_graph(self):
graph = DiGraph()
graph_algo = GraphAlgo(graph)
self.assertEqual(graph.e_size(), 0)
self.assertEqual(graph.v_size(), 0)
self.assertEqual(graph_algo.connected_components(), [])
self.assertTrue(graph_algo.save_to_json('../data/hello'))
self.assertTrue((graph_algo.load_from_json('../data/hello')))
self.assertEqual(graph_algo.get_graph().e_size(), 0)
self.assertEqual(graph_algo.get_graph().v_size(), 0)
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_load_from_json(self):
self.assertTrue(self.algorithms.load_from_json("../data/A0"))
graph_loaded = DiGraph()
graph_loaded.add_node(0, (35.18753053591606, 32.10378225882353, 0.0))
graph_loaded.add_node(1, (35.18958953510896, 32.10785303529412, 0.0))
graph_loaded.add_node(2, (35.19341035835351, 32.10610841680672, 0.0))
graph_loaded.add_node(3, (35.197528356739305, 32.1053088, 0.0))
graph_loaded.add_node(4, (35.2016888087167, 32.10601755126051, 0.0))
graph_loaded.add_node(5, (35.20582803389831, 32.10625380168067, 0.0))
graph_loaded.add_node(6, (35.20792948668281, 32.10470908739496, 0.0))
graph_loaded.add_node(7, (35.20746249717514, 32.10254648739496, 0.0))
graph_loaded.add_node(8, (35.20319591121872, 32.1031462, 0.0))
graph_loaded.add_node(9, (35.19597880064568, 32.10154696638656, 0.0))
graph_loaded.add_node(10, (35.18910131880549, 32.103618700840336, 0.0))
graph_loaded.add_edge(0, 1, 1.4004465106761335)
graph_loaded.add_edge(0, 10, 1.4620268165085584)
graph_loaded.add_edge(1, 0, 1.8884659521433524)
graph_loaded.add_edge(1, 2, 1.7646903245689283)
graph_loaded.add_edge(2, 1, 1.7155926739282625)
graph_loaded.add_edge(2, 3, 1.1435447583365383)
graph_loaded.add_edge(3, 2, 1.0980094622804095)
graph_loaded.add_edge(3, 4, 1.4301580756736283)
graph_loaded.add_edge(4, 3, 1.4899867265011255)
graph_loaded.add_edge(4, 5, 1.9442789961315767)
graph_loaded.add_edge(5, 4, 1.4622464066335845)
graph_loaded.add_edge(5, 6, 1.160662656360925)
graph_loaded.add_edge(6, 5, 1.6677173820549975)
graph_loaded.add_edge(6, 7, 1.3968360163668776)
graph_loaded.add_edge(7, 6, 1.0176531013725074)
graph_loaded.add_edge(7, 8, 1.354895648936991)
graph_loaded.add_edge(8, 7, 1.6449953452844968)
graph_loaded.add_edge(8, 9, 1.8526880332753517)
graph_loaded.add_edge(9, 8, 1.4575484853801393)
graph_loaded.add_edge(9, 10, 1.022651770039933)
graph_loaded.add_edge(10, 0, 1.1761238717867548)
graph_loaded.add_edge(10, 9, 1.0887225789883779)
self.assertEqual(self.algorithms.get_graph().v_size(),
graph_loaded.v_size())
self.assertEqual(self.algorithms.get_graph().e_size(),
graph_loaded.e_size())
self.assertEqual(self.algorithms.get_graph().get_mc(),
graph_loaded.get_mc())
self.assertListEqual(self.algorithms.get_graph().edges,
graph_loaded.edges)
self.assertEqual(self.algorithms.get_graph().get_all_v().keys(),
graph_loaded.get_all_v().keys())
self.assertEqual(self.algorithms.get_graph().adjacency.keys(),
graph_loaded.adjacency.keys())
self.assertNotEqual(self.algorithms.get_graph(), graph_loaded)
self.assertEqual(str(self.algorithms.get_graph().vertices),
str(graph_loaded.vertices))
self.assertEqual(str(self.algorithms.get_graph().adjacency),
str(graph_loaded.adjacency))
def test_remove_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(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.assertTrue(graph.remove_node(0))
self.assertEqual(graph.v_size(), 3)
self.assertEqual(graph.e_size(), 2)
self.assertTrue(graph.add_node(0))
self.assertEqual(graph.v_size(), 4)
self.assertEqual(graph.e_size(), 2)
self.assertTrue(graph.remove_node(2))
self.assertEqual(graph.v_size(), 3)
self.assertEqual(graph.e_size(), 0)
self.assertEqual(graph.get_mc(), 15)
def test_load(self): # test the loading from files
g = DiGraph()
ga = GraphAlgo(g)
# load large graph
self.assertTrue(
ga.load_from_json(
"C:\\Users\\User\\PycharmProjects\\Ex3\\Data\\A5"))
g = ga.get_graph()
# check values
self.assertEqual(g.v_size(), 48)
self.assertEqual(g.e_size(), 166)
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_remove_node(self):
g = DiGraph()
self.assertEqual(0, g.v_size())
self.assertEqual(0, g.e_size())
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(4, g.v_size())
self.assertEqual(4, g.e_size())
self.assertTrue(g.remove_node(1))
self.assertEqual(3, g.v_size())
self.assertEqual(2, g.e_size())
# try to remove non exist node
self.assertFalse(g.remove_node(1))
self.assertEqual(3, g.v_size())
def test_empty_graph(self):
graph = DiGraph()
graph_algo = GraphAlgo(graph)
self.assertEqual(graph.v_size(), 0)
self.assertEqual(graph.e_size(), 0)
self.assertEqual(graph_algo.shortest_path(0, 0), (None, []))
self.assertEqual(graph_algo.connected_component(1), [])
self.assertEqual(graph_algo.connected_components(), [])
self.assertTrue(graph_algo.save_to_json('../data/empty_graph'))
self.assertTrue((graph_algo.load_from_json('../data/empty_graph')))
self.assertEqual(graph_algo.get_graph().v_size(), 0)
self.assertEqual(graph_algo.get_graph().e_size(), 0)
def test_edgeSize(self):
graph = DiGraph()
ran = 1000
graph.add_node(0)
graph.add_node(1)
graph.add_node(2)
graph.add_node(3)
for i in range(ran):
if i > 3:
graph.add_node(i)
graph.add_edge(i, i - 1, i - 1)
graph.add_edge(i, i - 2, i - 2)
graph.add_edge(i, i - 3, i - 3)
graph.add_edge(i, i - 4, i - 4)
x = (ran - 4) * 4
self.assertEqual(x, graph.e_size())
for i in range(ran):
if i > 3:
graph.remove_edge(i, i - 1)
y = x - (ran - 4)
self.assertEqual(y, graph.e_size())
def test_add(self): # chek add node and add edge
graph = DiGraph()
graph.add_node(1, (1, 2, 3)) #add node check
graph.add_node(2, (2, 3, 4))
graph.add_node(3, (5, 4, 6))
graph.add_node(4, (3, 4, 6))
self.assertTrue(4 == graph.v_size())
self.assertTrue(0 == graph.e_size())
graph.add_node(1, (2, 3, 4))
self.assertTrue(4 == graph.v_size())
graph.add_edge(1, 2, 3)
graph.add_edge(2, 3, 3)
graph.add_edge(3, 4, 3)
graph.add_edge(4, 1, 3)
self.assertTrue(4 == graph.e_size())
self.assertTrue(8 == graph.get_mc())
graph.add_edge(1, 2, 4)
self.assertTrue(8 == graph.get_mc(), "you add exist edge!")
self.assertTrue(4 == graph.e_size(), "you add exist edge!")
graph.add_edge(1, 2, -5)
self.assertTrue(8 == graph.get_mc(), "you add exist edge!")
self.assertTrue(4 == graph.e_size(), "you add exist edge!")
def test_add_node(self):
graph = DiGraph()
for i in range(4):
graph.add_node(i)
graph.add_edge(0, 1, 1)
graph.add_edge(1, 2, 2)
graph.add_edge(2, 0, 3)
graph.add_edge(3, 0, 7)
self.assertEqual(4, graph.v_size())
self.assertEqual(8, graph.get_mc())
graph.add_edge(3, 0, 5)
self.assertEqual(9, graph.get_mc())
graph.add_edge(3, 0, 5)
self.assertEqual(9, graph.get_mc())
self.assertEqual(4, graph.e_size())
graph.remove_node(0)
self.assertEqual(3, graph.v_size())
self.assertEqual(1, graph.e_size())
self.assertTrue(graph.remove_edge(1, 2))
self.assertEqual(0, graph.e_size())
self.assertEqual(3, graph.v_size())
self.assertFalse(graph.remove_edge(8, 9))
def test_add_edge(self):
g = DiGraph()
g.add_node(1)
g.add_node(2)
g.add_node(3)
g.add_node(4)
self.assertTrue(g.add_edge(1, 2, 3))
self.assertTrue(g.add_edge(2, 3, 2))
self.assertTrue(g.add_edge(3, 4, 3))
self.assertTrue(g.add_edge(4, 1, 2.5))
self.assertEqual(4, g.e_size())
self.assertTrue(g.add_edge(1, 4, 0.5))
self.assertEqual(5, g.e_size())
# try to add an edge with non exist nodes
self.assertFalse(g.add_edge(5, 10, 1.5))
# try to add an edge with weight < 0
self.assertFalse(g.add_edge(3, 2, -1))
# try to add an edge from node to himself
self.assertFalse(g.add_edge(2, 2, 1))
# try to add an edge that one of the nodes not exist
self.assertFalse(g.add_edge(1, 10, 2))
self.assertEqual(5, g.e_size())
