def test_edge_to_vertice(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
self.assertEqual(vertice2, edge.to_vertice())
def add_edge(self, v1, v2, weight=0):
"""Adds an edge to this graph only if that edge does not already
exist. In our interpretation of the program, this means an undirected
edge. Furthermore, only edges containing vertices that actually
exist in the graph are acceptable.
Note that since this is an undirected graph, adding an edge with
either vertice as v1 or v2 will be the same edge. Adding an edge is
also idempotent, and will also connect the vertices.
Args:
v1(str): The name of one of the vertices in the edge
v2(str): The name of the other vertice in the edge.
weight(int): the weight of the graph, which is non-negative
Raises:
ValueError: if the edge in question contains vertices that do
not exist in the graph
ValueError: if the weight is negative"""
if v1 not in self.__vertices or v2 not in self.__vertices:
raise ValueError("Vertice contained in edge not in graph")
vertice_one = self.__vertices[v1]
vertice_two = self.__vertices[v2]
edge = Edge(vertice_one, vertice_two, weight)
edge.connect_vertices()
self.__edges[self.__edge_key.format(v1, v2)] = edge
def test_edge_disconnection_single_connection(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
vertice1.add_neighbor(vertice2)
self.assertTrue(edge.connected())
self.assertTrue(vertice1.is_neighbor(vertice2))
edge.disconnect_vertices()
self.assertFalse(vertice1.is_neighbor(vertice2))
def test_edge_disconnection_single_connection_other_way(self):
"""Should be equivalent to previous test"""
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
vertice2.add_neighbor(vertice1)
self.assertTrue(edge.connected())
self.assertTrue(vertice2.is_neighbor(vertice1))
edge.disconnect_vertices()
self.assertFalse(vertice2.is_neighbor(vertice1))
def test_single_direction_connection_to_both_connected(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
vertice1.add_neighbor(vertice2)
edge = Edge(vertice1, vertice2)
self.assertTrue(edge.connected())
self.assertTrue(vertice1.is_neighbor(vertice2))
self.assertFalse(vertice2.is_neighbor(vertice1))
edge.connect_vertices()
self.assertTrue(vertice1.is_neighbor(vertice2))
self.assertTrue(vertice2.is_neighbor(vertice1))
def test_single_direction_connection_both_connected_other_way(self):
"""This should be equivalent as the previous test"""
vertice1 = Vertice("one")
vertice2 = Vertice("two")
vertice2.add_neighbor(vertice1)
edge = Edge(vertice1, vertice2)
self.assertTrue(edge.connected())
self.assertFalse(vertice1.is_neighbor(vertice2))
self.assertTrue(vertice2.is_neighbor(vertice1))
edge.connect_vertices()
self.assertTrue(vertice1.is_neighbor(vertice2))
self.assertTrue(vertice2.is_neighbor(vertice1))
def test_neighbor_linked_connect(self):
"""Single directional connections should return true for the
edge connected() function"""
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
self.assertFalse(vertice1.is_neighbor(vertice2))
self.assertFalse(vertice2.is_neighbor(vertice1))
self.assertFalse(edge.connected())
vertice1.add_neighbor(vertice2)
self.assertTrue(vertice1.is_neighbor(vertice2))
self.assertFalse(vertice2.is_neighbor(vertice1))
self.assertTrue(edge.connected())
def test_push_edges(self):
v1 = Vertice("one")
v2 = Vertice("two")
edge1 = Edge(v1, v2)
edge2 = Edge(v2, v1)
p = PriorityQueue()
self.assertTrue(p.is_empty())
self.assertEqual(0, len(p))
p.push(edge1)
self.assertFalse(p.is_empty())
self.assertEqual(1, len(p))
p.push(edge2)
self.assertEqual(2, len(p))
def test_edge_linking_idempotency(self):
"""Multiple connections should be simply idempotent."""
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
self.assertFalse(edge.connected())
edge.connect_vertices()
self.assertTrue(edge.connected())
edge.connect_vertices()
self.assertTrue(edge.connected())
self.assertTrue(vertice1.is_neighbor(vertice2))
self.assertTrue(vertice2.is_neighbor(vertice1))
def test_simple_extraction(self):
"""Extracting the min from two edges should result in the minimum
of the two edges being extracted"""
v1 = Vertice("one")
v2 = Vertice("two")
edge1 = Edge(v1, v2, 0)
edge2 = Edge(v1, v2, 1)
p = PriorityQueue()
p.push(edge1)
p.push(edge2)
self.assertEqual(2, len(p))
self.assertEqual(edge1, p.extract_min())
self.assertEqual(1, len(p))
self.assertEqual(edge2, p.extract_min())
self.assertTrue(p.is_empty())
def test_push_same_edge(self):
v1 = Vertice("one")
v2 = Vertice("two")
edge = Edge(v1, v2)
p = PriorityQueue()
p.push(edge)
p.push(edge)
p.push(edge)
self.assertFalse(p.is_empty())
self.assertEqual(3, len(p))
def test_symbolic_edge_linking(self):
"""When an edge is created, it should not physically link the two edges
within initialization"""
vertice1 = Vertice("one")
vertice2 = Vertice("two")
self.assertFalse(vertice1.is_neighbor(vertice2))
self.assertFalse(vertice2.is_neighbor(vertice1))
Edge(vertice1, vertice2)
self.assertFalse(vertice1.is_neighbor(vertice2))
self.assertFalse(vertice2.is_neighbor(vertice1))
def test_multi_extraction(self):
v1 = Vertice("one")
v2 = Vertice("two")
edge1 = Edge(v1, v2, 0)
edge2 = Edge(v1, v2, 0)
edge3 = Edge(v1, v2, 1)
edge4 = Edge(v1, v2, 1)
p = PriorityQueue()
p.push(edge1)
p.push(edge2)
p.push(edge3)
p.push(edge4)
# we are less interested in the exact edges themselves
# but rather the weight to justify the priority queue
self.assertEqual(0, p.extract_min().weight())
self.assertEqual(0, p.extract_min().weight())
self.assertEqual(1, p.extract_min().weight())
self.assertEqual(1, p.extract_min().weight())
self.assertTrue(p.is_empty())
def test_simple_connect(self):
"""Ensure that the connection function works with simple connections"""
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
self.assertFalse(vertice1.is_neighbor(vertice2))
self.assertFalse(vertice2.is_neighbor(vertice1))
self.assertFalse(edge.connected())
edge.connect_vertices()
self.assertTrue(edge.connected())
self.assertTrue(vertice1.is_neighbor(vertice2))
self.assertTrue(vertice2.is_neighbor(vertice1))
def test_custom_edge_weight(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2, 5)
self.assertEqual(5, edge.weight())
def test_edge_disconnect_idempotency(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
edge.connect_vertices()
self.assertTrue(edge.connected())
edge.disconnect_vertices()
self.assertFalse(edge.connected())
edge.disconnect_vertices()
self.assertFalse(edge.connected())
def test_default_edge_weight(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
self.assertEqual(0, edge.weight())
