def test_remove_non_existent_neighbor(self):
vertice = Vertice("one")
try:
vertice.remove_neighbor(Vertice("non existent"))
self.fail("Should not be able to remove a non existent vertice")
except ValueError as e:
self.assertEqual("Neighbor does not exist to remove", str(e))
def test_vertice_given_bad_neighbor(self):
try:
v = Vertice("some node")
v.add_neighbor(None)
self.fail("Should fail if the given neighbor is empty")
except ValueError as e:
self.assertEqual("Given invalid neighbor", str(e))
def test_edge_to_vertice(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
self.assertEqual(vertice2, edge.to_vertice())
def test_vertice_given_self_neighbor(self):
"""We define giving oneself as a neighbor as a potential cycle and
remove it, enforcing a simple graph in our maze instead."""
try:
v = Vertice("self referential")
v.add_neighbor(v)
self.fail("Should not allow self referential neighboring")
except ValueError as e:
self.assertEqual("Vertice cannot become it's own neighbor", str(e))
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_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_is_neighbor(self):
"""Testing directional behavior of vertices."""
vertice1 = Vertice("one")
vertice2 = Vertice("two")
self.assertFalse(vertice1.is_neighbor(vertice2))
self.assertFalse(vertice2.is_neighbor(vertice1))
vertice1.add_neighbor(vertice2)
self.assertTrue(vertice1.is_neighbor(vertice2))
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_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_remove_vertice_with_same_name_as_neighbor(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
vertice1.add_neighbor(vertice2)
try:
vertice1.remove_neighbor(Vertice("two"))
self.fail("A vertice with the same name does not "
"count as the same neighbor")
except ValueError as e:
self.assertEqual("Given vertice "
"is not the actual vertice neighbor", str(e))
def add_vertice(self, vertice_name):
"""Adds a given vertice into the graph. The vertice must be a new
object and should also have a unique name identifying the vertice.
Args:
vertice_name(str): the name of the new vertice to add
Raises:
ValueError: if another vertice exists in the graph with the same
name as the given vertice"""
if self.contains_vertice(vertice_name):
raise ValueError("Vertice already in the graph")
self.__vertices[vertice_name] = Vertice(vertice_name)
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_vertice_given_duplicate(self):
"""Duplicate neighbors are considered illegal behavior"""
vertice1 = Vertice("one")
vertice2 = Vertice("two")
vertice1.add_neighbor(vertice2)
try:
vertice1.add_neighbor(vertice2)
self.fail("Should not be able to add a duplicate neighbor")
except ValueError as e:
self.assertEqual("Attempting to add duplicate neighbor", str(e))
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_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_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_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_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_remove_single_neighbor_one_direction(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
vertice1.add_neighbor(vertice2)
self.assertTrue(vertice1.is_neighbor(vertice2))
self.assertFalse(vertice2.is_neighbor(vertice1))
vertice1.remove_neighbor(vertice2)
self.assertFalse(vertice1.is_neighbor(vertice2))
self.assertFalse(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_default_edge_weight(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
edge = Edge(vertice1, vertice2)
self.assertEqual(0, edge.weight())
def test_adding_neighbors_to_vertice(self):
"""Adding neighbors should be directional, only."""
vertice1 = Vertice("one")
vertice2 = Vertice("two")
vertice3 = Vertice("three")
self.assertEqual([], vertice1.neighbors())
self.assertEqual([], vertice2.neighbors())
self.assertEqual([], vertice3.neighbors())
# should be directional
vertice1.add_neighbor(vertice2)
self.assertEqual([vertice2], vertice1.neighbors())
self.assertEqual([], vertice2.neighbors())
# other vertices should also not experience side effects
vertice1.add_neighbor(vertice3)
self.assertEqual(2, len(vertice1.neighbors()))
self.assertTrue(vertice2 in vertice1.neighbors())
self.assertTrue(vertice3 in vertice1.neighbors())
self.assertEqual([], vertice2.neighbors())
self.assertEqual([], vertice3.neighbors())
vertice2.add_neighbor(vertice1)
self.assertEqual(2, len(vertice1.neighbors()))
self.assertTrue(vertice2 in vertice1.neighbors())
self.assertTrue(vertice3 in vertice1.neighbors())
self.assertEqual(1, len(vertice2.neighbors()))
self.assertTrue(vertice1 in vertice2.neighbors())
self.assertEqual([], vertice3.neighbors())
def test_name(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
self.assertEqual("one", vertice1.name())
self.assertEqual("two", vertice2.name())
def test_remove_single_neighbor_multiple_neighbors(self):
vertice1 = Vertice("one")
vertice2 = Vertice("two")
vertice3 = Vertice("three")
vertice1.add_neighbor(vertice2)
vertice1.add_neighbor(vertice3)
self.assertTrue(vertice1.is_neighbor(vertice2))
self.assertTrue(vertice1.is_neighbor(vertice3))
vertice1.remove_neighbor(vertice2)
self.assertFalse(vertice1.is_neighbor(vertice2))
self.assertTrue(vertice1.is_neighbor(vertice3))
def test_vertice_with_null_name(self):
try:
Vertice("")
self.fail("Vertice constructor should fail with null string")
except ValueError as e:
self.assertEqual("Given null name in vertice", str(e))
