class BipartitenessTest(unittest.TestCase):
def setUp(self):
self.graph = Graph()
g = self.graph
g.add_edge(1, 2)
g.add_edge(1, 4)
g.add_edge(1, 6)
g.add_edge(3, 2)
g.add_edge(3, 4)
g.add_edge(3, 6)
g.add_edge(5, 2)
g.add_edge(5, 4)
g.add_edge(5, 6)
def tearDown(self):
del self.graph
def test_is_bipartite_graph(self):
self.assertEqual(is_bipartite(self.graph),
({1, 3, 5}, {2, 4, 6}))
def test_is_bipartite_not_bipartite_graph(self):
self.graph.add_edge(1, 3)
self.assertEqual(is_bipartite(self.graph), None)
self.graph.remove_edge(1, 3)
def test_is_balanced_bipartite(self):
self.assertTrue(is_balanced_bipartite(self.graph))
def test_is_balanced_bipartite_not_balanced(self):
self.graph.add_edge(1, 100)
self.assertFalse(is_balanced_bipartite(self.graph))
self.graph.remove_edge(1, 100)
def test_is_biregular(self):
self.assertTrue(is_biregular(self.graph))
def test_is_biregular_not_biregular_graph(self):
self.graph.add_edge(1, 100)
self.assertFalse(is_biregular(self.graph))
self.graph.remove_edge(1, 100)
class ShortestPathsTest(unittest.TestCase):
def setUp(self):
self.positive_graph = Graph()
pg = self.positive_graph
pg.add_edge(1, 2, w=5)
pg.add_edge(1, 3, w=29)
pg.add_edge(1, 6, w=70)
pg.add_edge(2, 3, w=10)
pg.add_edge(2, 4, w=15)
pg.add_edge(3, 4, w=51)
pg.add_edge(4, 5, w=6)
pg.add_edge(3, 6, w=10)
self.positive_digraph = DiGraph()
pdig = self.positive_digraph
pdig.add_edge(1, 2, w=5)
pdig.add_edge(1, 3, w=29)
pdig.add_edge(1, 6, w=70)
pdig.add_edge(2, 3, w=10)
pdig.add_edge(2, 4, w=15)
pdig.add_edge(3, 4, w=51)
pdig.add_edge(4, 5, w=6)
pdig.add_edge(3, 6, w=10)
def tearDown(self):
del self.positive_digraph
del self.positive_graph
def test_unweighted_shortest_paths_graph(self):
self.assertEqual(
unweighted_shortest_paths(self.positive_graph, 1, 2),
({1: None, 2: 1, 3: 1, 4: 3, 5: 4, 6: 1},
{1: 0, 2: 2, 3: 2, 4: 4, 5: 6, 6: 2}))
def test_unweighted_shortest_paths_graph_missing_node(self):
with self.assertRaises(NodeNotFound):
unweighted_shortest_paths(self.positive_graph, 999)
def test_unweighted_shortest_paths_digraph(self):
self.assertEqual(
unweighted_shortest_paths(self.positive_digraph, 1),
({1: None, 2: 1, 3: 1, 4: 3, 5: 4, 6: 1},
{1: 0, 2: 1, 3: 1, 4: 2, 5: 3, 6: 1}))
def test_unweighted_shortest_paths_digraph_missing_node(self):
with self.assertRaises(NodeNotFound):
unweighted_shortest_paths(self.positive_digraph, 999)
def test_bellman_ford_graph(self):
self.assertEqual(
shortest_paths_from(self.positive_graph, 1, weight_attribute='w'),
({1: None, 2: 1, 3: 2, 4: 2, 5: 4, 6: 3},
{1: 0, 2: 5, 3: 15, 4: 20, 5: 26, 6: 25}))
def test_bellman_ford_graph_missing_node(self):
with self.assertRaises(NodeNotFound):
shortest_paths_from(self.positive_graph, 999)
def test_bellman_ford_graph_negative_edges(self):
self.positive_graph.add_edge(1, 100, w=-1)
with self.assertRaises(NegativeCycle):
shortest_paths_from(self.positive_graph, 1, weight_attribute='w')
self.positive_graph.remove_edge(1, 100)
def test_bellman_ford_digraph(self):
self.assertEqual(
shortest_paths_from(
self.positive_digraph, 1, weight_attribute='w'),
({1: None, 2: 1, 3: 2, 4: 2, 5: 4, 6: 3},
{1: 0, 2: 5, 3: 15, 4: 20, 5: 26, 6: 25}))
def test_bellman_ford_digraph_missing_node(self):
with self.assertRaises(NodeNotFound):
shortest_paths_from(self.positive_digraph, 999)
def test_bellman_ford_digraph_negative_edges(self):
g = DiGraph()
g.add_edge(1, 2, w=7)
g.add_edge(1, 4, w=6)
g.add_edge(4, 5, w=5)
g.add_edge(5, 4, w=-2)
g.add_edge(2, 3, w=9)
g.add_edge(2, 5, w=-3)
g.add_edge(4, 2, w=8)
g.add_edge(4, 3, w=-4)
g.add_edge(3, 1, w=7)
g.add_edge(3, 5, w=7)
self.assertEqual(shortest_paths_from(g, 1, weight_attribute='w'),
({1: None, 2: 1, 3: 4, 4: 5, 5: 2},
{1: 0, 2: 7, 3: -2, 4: 2, 5: 4}))
def test_bellman_ford_digraph_negative_cycle(self):
self.positive_digraph.add_edge(2, 1, w=-6)
with self.assertRaises(NegativeCycle):
shortest_paths_from(
self.positive_digraph, 1, weight_attribute='w')
self.positive_digraph.remove_edge(2, 1)
def test_dijkstra_graph(self):
self.assertEqual(
dijkstra(self.positive_graph, 1, weight_attribute='w'),
({1: None, 2: 1, 3: 2, 4: 2, 5: 4, 6: 3},
{1: 0, 2: 5, 3: 15, 4: 20, 5: 26, 6: 25}))
def test_dijkstra_graph_missing_node(self):
with self.assertRaises(NodeNotFound):
dijkstra(self.positive_graph, 999)
def test_dijkstra_digraph(self):
self.assertEqual(
dijkstra(self.positive_digraph, 1, weight_attribute='w'),
({1: None, 2: 1, 3: 2, 4: 2, 5: 4, 6: 3},
{1: 0, 2: 5, 3: 15, 4: 20, 5: 26, 6: 25}))
def test_dijkstra_digraph_missing_node(self):
with self.assertRaises(NodeNotFound):
dijkstra(self.positive_digraph, 999)
class EulerianTest(unittest.TestCase):
def setUp(self):
self.graph = Graph()
g = self.graph
g.add_edge(1, 9)
g.add_edge(9, 6)
g.add_edge(6, 1)
g.add_edge(1, 2)
g.add_edge(2, 4)
g.add_edge(4, 3)
g.add_edge(3, 2)
g.add_edge(2, 8)
g.add_edge(1, 8)
g.add_edge(8, 5)
g.add_edge(5, 7)
g.add_edge(7, 8)
self.digraph = DiGraph()
dig = self.digraph
dig.add_edge(1, 2)
dig.add_edge(2, 5)
dig.add_edge(2, 3)
dig.add_edge(5, 3)
dig.add_edge(3, 5)
dig.add_edge(5, 6)
dig.add_edge(6, 3)
dig.add_edge(3, 4)
dig.add_edge(4, 2)
dig.add_edge(3, 7)
dig.add_edge(7, 8)
dig.add_edge(8, 1)
def tearDown(self):
del self.digraph
del self.graph
def test_is_eulerain_graph(self):
self.assertTrue(is_eulerian(self.graph))
def test_is_eulerian_digraph(self):
self.assertTrue(is_eulerian(self.digraph))
def test_find_eulerian_cycle_graph(self):
self.assertEqual(find_eulerian_cycle(self.graph, 1),
[1, 8, 5, 7, 8, 2, 3, 4, 2, 1, 9, 6, 1])
def test_find_eulerian_cycle_graph_missing_node(self):
with self.assertRaises(NodeNotFound):
find_eulerian_cycle(self.graph, 999)
def test_find_eulerian_cycle_not_eulerian_graph(self):
self.graph.add_edge(101, 102)
self.assertEqual(find_eulerian_cycle(self.graph, 1), None)
self.graph.remove_edge(101, 102)
def test_find_eulerian_cycle_digraph(self):
self.assertEqual(find_eulerian_cycle(self.digraph, 1),
[1, 2, 3, 4, 2, 5, 3, 5, 6, 3, 7, 8, 1])
def test_find_eulerian_cycle_digraph_missing_node(self):
with self.assertRaises(NodeNotFound):
find_eulerian_cycle(self.digraph, 999)
def test_find_eulerian_cycle_not_eulerian_digraph(self):
self.digraph.add_edge(101, 102)
self.assertEqual(find_eulerian_cycle(self.digraph, 1), None)
self.digraph.remove_edge(101, 102)
