class BasicGraph(unittest.TestCase):
def setUp(self):
self.g = Graph()
self.v1 = Vertex(1, 0)
self.v2 = Vertex(2, 0)
self.v3 = Vertex(3, 0)
self.v4 = Vertex(4, 0)
self.g.add_vert(self.v1)
self.g.add_vert(self.v2)
self.g.add_vert(self.v3)
self.g.add_vert(self.v4)
self.g.add_edge(self.v1.id, self.v2.id)
self.g.add_edge(self.v1.id, self.v3.id)
self.g.add_edge(self.v2.id, self.v3.id)
self.g.add_edge(self.v3.id, self.v4.id)
# Sanity check
self.assertEqual(self.g.get_vert_count(), 4)
self.assertEqual(self.g.get_edge_count(), 4)
self.assertTrue(self.g.has_vert(self.v1.id))
self.assertTrue(self.g.has_vert(self.v2.id))
self.assertTrue(self.g.has_vert(self.v3.id))
self.assertTrue(self.g.has_vert(self.v4.id))
self.assertTrue(self.g.has_edge(self.v1.id, self.v2.id))
self.assertTrue(self.g.has_edge(self.v1.id, self.v3.id))
self.assertTrue(self.g.has_edge(self.v2.id, self.v3.id))
self.assertTrue(self.g.has_edge(self.v3.id, self.v4.id))
self.assertFalse(self.g.has_edge(self.v2.id, self.v4.id))
self.assertEqual(self.g.get_vert(self.v1.id).color, 0)
self.assertEqual(self.g.get_vert(self.v2.id).color, 0)
self.assertEqual(self.g.get_vert(self.v3.id).color, 0)
self.assertEqual(self.g.get_vert(self.v4.id).color, 0)
self.assertEqual(self.g.neighbors(self.v1.id), {self.v2, self.v3})
self.assertEqual(self.g.neighbors(self.v2.id), {self.v3, self.v1})
self.assertEqual(self.g.neighbors(self.v3.id),
{self.v1, self.v2, self.v4})
self.assertEqual(self.g.neighbors(self.v4.id), {self.v3})
def test_0_add_vert_normal(self):
new_vert = Vertex(5, 0)
self.g.add_vert(new_vert)
self.assertEqual(self.g.get_vert_count(), 5)
self.assertTrue(self.g.has_vert(new_vert.id))
self.assertEqual(self.g.neighbors(new_vert.id), set())
def test_1_add_vert_already_in(self):
v1_copy = Vertex(1, 0)
with self.assertRaises(ValueError):
self.g.add_vert(v1_copy)
v1_copy = Vertex(1, 1) # Same id, different color
with self.assertRaises(ValueError):
# Should also err; Vertex equality and hashing is based only on id.
self.g.add_vert(v1_copy)
self.assertEqual(self.g.get_vert_count(), 4)
def test_2_add_edge(self):
new_vert = Vertex(5, 0)
self.g.add_vert(new_vert)
self.g.add_edge(self.v4.id, new_vert.id)
self.assertEqual(self.g.get_vert_count(), 5)
self.assertEqual(self.g.get_edge_count(), 5)
self.assertTrue(self.g.has_vert(new_vert.id))
self.assertTrue(self.g.has_edge(new_vert.id, self.v4.id))
self.assertEqual(self.g.neighbors(new_vert.id), {self.v4})
self.g.add_edge(self.v4.id, self.v1.id)
self.assertEqual(self.g.get_edge_count(), 6)
self.assertTrue(self.g.has_edge(self.v1.id, self.v4.id))
self.assertEqual(self.g.neighbors(self.v4.id),
{new_vert, self.v1, self.v3})
# Edge to self
self.g.add_edge(new_vert.id, new_vert.id)
self.assertEqual(self.g.get_edge_count(), 7)
self.assertTrue(self.g.has_edge(new_vert.id, new_vert.id))
self.assertEqual(self.g.neighbors(new_vert.id), {new_vert, self.v4})
def test_3_add_edge_already_in(self):
with self.assertRaises(ValueError):
self.g.add_edge(self.v3.id, self.v2.id)
self.assertEqual(self.g.get_edge_count(), 4)
# Edge to self
new_vert = Vertex(5, 0)
self.g.add_vert(new_vert)
self.g.add_edge(new_vert.id, new_vert.id)
with self.assertRaises(ValueError):
self.g.add_edge(new_vert.id, new_vert.id)
self.assertEqual(self.g.get_edge_count(), 5)
self.assertTrue(self.g.has_edge(new_vert.id, new_vert.id))
def test_4_add_edge_missing_vert(self):
new_vert = Vertex(5, 0)
with self.assertRaises(KeyError):
self.g.add_edge(self.v1.id, new_vert.id)
self.assertEqual(self.g.get_edge_count(), 4)
self.assertFalse(self.g.has_edge(self.v1.id, new_vert.id))
def test_5_add_edge_missing_verts(self):
new_vert_1 = Vertex(5, 0)
new_vert_2 = Vertex(6, 0)
with self.assertRaises(KeyError):
self.g.add_edge(new_vert_1.id, new_vert_2.id)
self.assertEqual(self.g.get_edge_count(), 4)
self.assertFalse(self.g.has_edge(new_vert_1.id, new_vert_2.id))
def test_6_del_vert(self):
self.g.del_vert(self.v1.id)
self.assertFalse(self.g.has_vert(self.v1.id))
self.assertTrue(self.g.has_vert(self.v2.id))
self.assertTrue(self.g.has_vert(self.v3.id))
self.assertTrue(self.g.has_vert(self.v4.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v2.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v3.id))
self.assertTrue(self.g.has_edge(self.v2.id, self.v3.id))
self.assertTrue(self.g.has_edge(self.v3.id, self.v4.id))
self.assertEqual(self.g.get_vert_count(), 3)
self.assertEqual(self.g.get_edge_count(), 2)
with self.assertRaises(KeyError):
self.g.neighbors(self.v1.id)
self.assertEqual(self.g.neighbors(self.v2.id), {self.v3})
self.assertEqual(self.g.neighbors(self.v3.id), {self.v2, self.v4})
self.assertEqual(self.g.neighbors(self.v4.id), {self.v3})
v2_copy = Vertex(2, 1) # Same id, different color
self.g.del_vert(v2_copy.id)
self.assertFalse(self.g.has_vert(self.v1.id))
self.assertFalse(self.g.has_vert(self.v2.id))
self.assertTrue(self.g.has_vert(self.v3.id))
self.assertTrue(self.g.has_vert(self.v4.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v2.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v3.id))
self.assertFalse(self.g.has_edge(self.v2.id, self.v3.id))
self.assertTrue(self.g.has_edge(self.v3.id, self.v4.id))
self.assertEqual(self.g.get_vert_count(), 2)
self.assertEqual(self.g.get_edge_count(), 1)
with self.assertRaises(KeyError):
self.g.neighbors(self.v1.id)
with self.assertRaises(KeyError):
self.g.neighbors(self.v2.id)
self.assertEqual(self.g.neighbors(self.v3.id), {self.v4})
self.assertEqual(self.g.neighbors(self.v4.id), {self.v3})
def test_7_del_vert_missing(self):
new_vert = Vertex(5, 0)
with self.assertRaises(KeyError):
self.g.del_vert(new_vert.id)
self.assertEqual(self.g.get_vert_count(), 4)
self.assertEqual(self.g.get_edge_count(), 4)
def test_8_del_edge(self):
self.g.del_edge(self.v1.id, self.v2.id)
self.assertTrue(self.g.has_vert(self.v1.id))
self.assertTrue(self.g.has_vert(self.v2.id))
self.assertTrue(self.g.has_vert(self.v3.id))
self.assertTrue(self.g.has_vert(self.v4.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v2.id))
self.assertTrue(self.g.has_edge(self.v1.id, self.v3.id))
self.assertTrue(self.g.has_edge(self.v2.id, self.v3.id))
self.assertTrue(self.g.has_edge(self.v3.id, self.v4.id))
self.assertEqual(self.g.get_vert_count(), 4)
self.assertEqual(self.g.get_edge_count(), 3)
self.assertEqual(self.g.neighbors(self.v1.id), {self.v3})
self.assertEqual(self.g.neighbors(self.v2.id), {self.v3})
self.assertEqual(self.g.neighbors(self.v3.id),
{self.v4, self.v1, self.v2})
self.assertEqual(self.g.neighbors(self.v4.id), {self.v3})
self.g.del_edge(self.v3.id, self.v1.id) # Isolate v1
self.assertTrue(self.g.has_vert(self.v1.id))
self.assertTrue(self.g.has_vert(self.v2.id))
self.assertTrue(self.g.has_vert(self.v3.id))
self.assertTrue(self.g.has_vert(self.v4.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v2.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v3.id))
self.assertTrue(self.g.has_edge(self.v2.id, self.v3.id))
self.assertTrue(self.g.has_edge(self.v3.id, self.v4.id))
self.assertEqual(self.g.get_vert_count(), 4)
self.assertEqual(self.g.get_edge_count(), 2)
self.assertEqual(self.g.neighbors(self.v1.id), set())
self.assertEqual(self.g.neighbors(self.v2.id), {self.v3})
self.assertEqual(self.g.neighbors(self.v3.id), {self.v4, self.v2})
self.assertEqual(self.g.neighbors(self.v4.id), {self.v3})
def test_9_del_edge_missing(self):
with self.assertRaises(ValueError):
self.g.del_edge(self.v1.id, self.v4.id)
self.assertEqual(self.g.get_vert_count(), 4)
self.assertEqual(self.g.get_edge_count(), 4)
def test_10_del_all_vertices(self):
self.g.del_vert(self.v1.id)
self.g.del_vert(self.v2.id)
self.g.del_vert(self.v3.id)
self.g.del_vert(self.v4.id)
self.assertFalse(self.g.has_vert(self.v1.id))
self.assertFalse(self.g.has_vert(self.v2.id))
self.assertFalse(self.g.has_vert(self.v3.id))
self.assertFalse(self.g.has_vert(self.v4.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v2.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v3.id))
self.assertFalse(self.g.has_edge(self.v2.id, self.v3.id))
self.assertFalse(self.g.has_edge(self.v3.id, self.v4.id))
self.assertEqual(self.g.get_vert_count(), 0)
self.assertEqual(self.g.get_edge_count(), 0)
with self.assertRaises(KeyError):
self.g.neighbors(self.v1.id)
with self.assertRaises(KeyError):
self.g.neighbors(self.v2.id)
with self.assertRaises(KeyError):
self.g.neighbors(self.v3.id)
with self.assertRaises(KeyError):
self.g.neighbors(self.v4.id)
def test_13_del_all_edges(self):
self.g.del_edge(self.v1.id, self.v2.id)
self.g.del_edge(self.v1.id, self.v3.id)
self.g.del_edge(self.v2.id, self.v3.id)
self.g.del_edge(self.v3.id, self.v4.id)
self.assertTrue(self.g.has_vert(self.v1.id))
self.assertTrue(self.g.has_vert(self.v2.id))
self.assertTrue(self.g.has_vert(self.v3.id))
self.assertTrue(self.g.has_vert(self.v4.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v2.id))
self.assertFalse(self.g.has_edge(self.v1.id, self.v3.id))
self.assertFalse(self.g.has_edge(self.v2.id, self.v3.id))
self.assertFalse(self.g.has_edge(self.v3.id, self.v4.id))
self.assertEqual(self.g.get_vert_count(), 4)
self.assertEqual(self.g.get_edge_count(), 0)
self.assertEqual(self.g.neighbors(self.v1.id), set())
self.assertEqual(self.g.neighbors(self.v2.id), set())
self.assertEqual(self.g.neighbors(self.v3.id), set())
self.assertEqual(self.g.neighbors(self.v4.id), set())
def test_16_neighbors(self):
v5 = Vertex(5, 0)
v6 = Vertex(6, 0)
self.g.add_vert(v5)
self.assertEqual(self.g.neighbors(v5.id), set())
self.g.add_vert(v6)
self.g.add_edge(v5.id, v6.id)
self.assertEqual(self.g.neighbors(v5.id), {v6})
self.assertEqual(self.g.neighbors(v6.id), {v5})
def test_LoadGoodXML_0_normal(self):
correct_g = Graph()
v1 = Vertex("1", 0)
v2 = Vertex("2", 0)
v3 = Vertex("3", 0)
v4 = Vertex("4", 0)
v5 = Vertex("5", 0)
correct_g.add_vert(v1)
correct_g.add_vert(v2)
correct_g.add_vert(v3)
correct_g.add_vert(v4)
correct_g.add_vert(v5)
correct_g.add_edge(v1.id, v2.id)
correct_g.add_edge(v1.id, v3.id)
correct_g.add_edge(v2.id, v3.id)
correct_g.add_edge(v3.id, v4.id)
# Sanity check
self.assertEqual(correct_g.get_vert_count(), 5)
self.assertEqual(correct_g.get_edge_count(), 4)
self.assertTrue(correct_g.has_vert(v1.id))
self.assertTrue(correct_g.has_vert(v2.id))
self.assertTrue(correct_g.has_vert(v3.id))
self.assertTrue(correct_g.has_vert(v4.id))
self.assertTrue(correct_g.has_vert(v5.id))
self.assertTrue(correct_g.has_edge(v1.id, v2.id))
self.assertTrue(correct_g.has_edge(v1.id, v3.id))
self.assertTrue(correct_g.has_edge(v2.id, v3.id))
self.assertTrue(correct_g.has_edge(v3.id, v4.id))
self.assertFalse(correct_g.has_edge(v2.id, v4.id))
self.assertEqual(correct_g.get_vert(v1.id).color, 0)
self.assertEqual(correct_g.get_vert(v2.id).color, 0)
self.assertEqual(correct_g.get_vert(v3.id).color, 0)
self.assertEqual(correct_g.get_vert(v4.id).color, 0)
self.assertEqual(correct_g.get_vert(v5.id).color, 0)
self.assertEqual(correct_g.neighbors(v1.id), {v2, v3})
self.assertEqual(correct_g.neighbors(v2.id), {v3, v1})
self.assertEqual(correct_g.neighbors(v3.id), {v1, v2, v4})
self.assertEqual(correct_g.neighbors(v4.id), {v3})
self.assertEqual(correct_g.neighbors(v5.id), set())
# Parse XML file
parsed_g = load_graph("LoadGoodXML_0_normal.xml")
# g1 == g2 if they have same edges and same vertices by id
# (even if vertices differ otherwise)
self.assertTrue(parsed_g == correct_g)
self.assertEqual(parsed_g.get_vert(v1.id).color, "black")
self.assertEqual(parsed_g.get_vert(v2.id).color, "black")
self.assertEqual(parsed_g.get_vert(v3.id).color, "black")
self.assertEqual(parsed_g.get_vert(v4.id).color, "black")
self.assertEqual(parsed_g.get_vert(v5.id).color, "black")
# Modify edge or vert inventory to break equality
correct_g.del_edge("1", "2")
self.assertTrue(parsed_g != correct_g)