class TestNodeCover3(unittest.TestCase): def setUp(self): self.N = 6 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(4, 5)] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_borie_node_cover(self): algorithm = BorieNodeCover(self.G) algorithm.run() expected1 = set([1, 2, 4]) expected2 = set([1, 3, 4]) expected3 = set([0, 2, 4]) expected4 = set([1, 3, 5]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.node_cover, expected3) # Testing cover. for edge in self.G.iteredges(): self.assertTrue(edge.source in algorithm.node_cover or edge.target in algorithm.node_cover) def test_tree_node_cover1(self): algorithm = TreeNodeCover1(self.G) algorithm.run() expected1 = set([1, 2, 4]) expected2 = set([1, 3, 4]) expected3 = set([0, 2, 4]) expected4 = set([1, 3, 5]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.node_cover, expected2) # Testing cover. for edge in self.G.iteredges(): self.assertTrue(edge.source in algorithm.node_cover or edge.target in algorithm.node_cover) def test_tree_node_cover2(self): algorithm = TreeNodeCover2(self.G) algorithm.run() expected1 = set([1, 2, 4]) expected2 = set([1, 3, 4]) expected3 = set([0, 2, 4]) expected4 = set([1, 3, 5]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.node_cover, expected2) # Testing cover. for edge in self.G.iteredges(): self.assertTrue(edge.source in algorithm.node_cover or edge.target in algorithm.node_cover) def tearDown(self): pass
class TestNodeColoring(unittest.TestCase): def setUp(self): self.N = 6 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [ Edge(0, 1), Edge(0, 3), Edge(1, 3), Edge(1, 4), Edge(1, 2), Edge(2, 4), Edge(2, 5), Edge(3, 4), Edge(4, 5) ] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_brooks_node_coloring(self): algorithm = BrooksNodeColoring(self.G) algorithm.run() for node in self.G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in self.G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) #print algorithm.color all_colors = set(algorithm.color[node] for node in self.G.iternodes()) self.assertEqual(len(all_colors), 4) def test_brooks_node_coloring_regular(self): # Buduje graf 4-regularny planarny z Delta=4. # Graf jest 3-connected, dlatego algorytm dziala. self.G.add_edge(Edge(0, 2)) self.G.add_edge(Edge(3, 5)) self.G.add_edge(Edge(0, 5)) algorithm = BrooksNodeColoring(self.G) algorithm.run() for node in self.G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in self.G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) #print algorithm.color all_colors = set(algorithm.color[node] for node in self.G.iternodes()) self.assertEqual(len(all_colors), 3) # best def test_exceptions(self): self.assertRaises(ValueError, BrooksNodeColoring, Graph(5, directed=True)) def tearDown(self): pass
class TestIndependentSet1(unittest.TestCase): def setUp(self): self.N = 7 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [ Edge(0, 1), Edge(0, 3), Edge(1, 2), Edge(1, 4), Edge(2, 5), Edge(2, 6) ] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_borie_iset(self): algorithm = BorieIndependentSet(self.G) algorithm.run() expected1 = set([3, 4, 5, 6]) expected2 = set([0, 4, 5, 6]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.independent_set, expected2) # Testing iset. for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) def test_tree_iset1(self): algorithm = TreeIndependentSet1(self.G) algorithm.run() expected1 = set([3, 4, 5, 6]) expected2 = set([0, 4, 5, 6]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.independent_set, expected1) # Testing iset. for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) def test_tree_iset2(self): algorithm = TreeIndependentSet2(self.G) algorithm.run() expected1 = set([3, 4, 5, 6]) expected2 = set([0, 4, 5, 6]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.independent_set, expected1) # Testing iset. for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) def tearDown(self): pass
class TestIndependentSet3(unittest.TestCase): def setUp(self): self.N = 6 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(4, 5)] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_borie_iset(self): algorithm = BorieIndependentSet(self.G) algorithm.run() expected1 = set([0, 2, 5]) expected2 = set([0, 3, 5]) expected3 = set([0, 2, 4]) expected4 = set([1, 3, 5]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.independent_set, expected3) # Testing iset. for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) def test_tree_iset1(self): algorithm = TreeIndependentSet1(self.G) algorithm.run() expected1 = set([0, 2, 5]) expected2 = set([0, 3, 5]) expected3 = set([0, 2, 4]) expected4 = set([1, 3, 5]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.independent_set, expected1) # Testing iset. for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) def test_tree_iset2(self): algorithm = TreeIndependentSet2(self.G) algorithm.run() expected1 = set([0, 2, 5]) expected2 = set([0, 3, 5]) expected3 = set([0, 2, 4]) expected4 = set([1, 3, 5]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.independent_set, expected1) # Testing iset. for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) def tearDown(self): pass
class TestIndependentSet(unittest.TestCase): def setUp(self): self.N = 6 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [ Edge(0, 1), Edge(0, 3), Edge(1, 3), Edge(1, 4), Edge(1, 2), Edge(2, 5), Edge(3, 4), Edge(4, 5)] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_us_independent_set1(self): algorithm = UnorderedSequentialIndependentSet1(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) self.assertEqual(algorithm.cardinality, len(algorithm.independent_set)) #print algorithm.independent_set def test_us_independent_set2(self): algorithm = UnorderedSequentialIndependentSet2(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) self.assertEqual(algorithm.cardinality, len(algorithm.independent_set)) #print algorithm.independent_set def test_us_independent_set3(self): algorithm = UnorderedSequentialIndependentSet3(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(algorithm.independent_set[edge.source] and algorithm.independent_set[edge.target]) cardinality = sum(1 for node in self.G if algorithm.independent_set[node]) self.assertEqual(algorithm.cardinality, cardinality) #print algorithm.independent_set def test_exceptions(self): self.assertRaises(ValueError, UnorderedSequentialIndependentSet1, Graph(5, directed=True)) self.assertRaises(ValueError, UnorderedSequentialIndependentSet2, Graph(5, directed=True)) self.assertRaises(ValueError, UnorderedSequentialIndependentSet3, Graph(5, directed=True)) def tearDown(self): pass
class TestNodeCover(unittest.TestCase): def setUp(self): self.N = 5 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [Edge(0, 1), Edge(0, 2), Edge(1, 2), Edge(1, 3), Edge(1, 4)] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() node1 = Node(0, 1, "edge") node2 = Node(0, 2, "edge") node3 = Node(2, 1, "edge") node4 = Node(1, 3, "edge") node5 = Node(1, 4, "edge") node6 = Node(0, 1, "series", node2, node3) node7 = Node(0, 1, "parallel", node1, node6) node8 = Node(0, 1, "jackknife", node7, node4) node9 = Node(0, 1, "jackknife", node8, node5) self.root = node9 def test_spgraph_node_cover(self): algorithm = SPGraphNodeCover(self.G, self.root) algorithm.run() expected1 = set([0, 1]) expected2 = set([1, 2]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.node_cover, expected2) # Testing cover. for edge in self.G.iteredges(): self.assertTrue(edge.source in algorithm.node_cover or edge.target in algorithm.node_cover) def test_sptree_node_cover(self): algorithm = SPTreeNodeCover(self.root) algorithm.run() expected1 = set([0, 1]) expected2 = set([1, 2]) self.assertEqual(algorithm.cardinality, len(expected1)) self.assertEqual(algorithm.node_cover, expected2) # Testing cover. for edge in self.G.iteredges(): self.assertTrue(edge.source in algorithm.node_cover or edge.target in algorithm.node_cover) def tearDown(self): pass
def test_wheel5(self): N = 5 G = Graph(N, False) edges = [ Edge(0, 1), Edge(0, 2), Edge(0, 3), Edge(0, 4), Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(4, 1) ] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) algorithm = HalinNodeColoring(G, outer=set([1, 2, 3, 4])) algorithm.run() #print "wheel5 outer", algorithm.outer #print "wheel5 cycle", algorithm.cycle parent = {0: None, 1: 0, 2: 0, 3: 0, 4: 0} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
def test_halin8c(self): N = 8 G = Graph(N, False) edges = [ Edge(0, 1), Edge(0, 5), Edge(0, 7), Edge(1, 2), Edge(1, 7), Edge(2, 3), Edge(2, 6), Edge(3, 4), Edge(3, 6), Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7) ] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) algorithm = HalinNodeColoring(G, outer=set([0, 1, 2, 3, 4, 5])) algorithm.run() #print "halin8c outer", algorithm.outer parent = {0: 7, 1: 7, 2: 6, 3: 6, 4: 6, 5: 6, 6: None, 7: 6} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
def test_3prism(self): N = 6 G = Graph(N, False) edges = [ Edge(0, 1), Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(4, 5), Edge(0, 5), Edge(1, 4), Edge(2, 0), Edge(3, 5) ] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) #print "3prism" algorithm = HalinNodeColoring(G, outer=set([0, 2, 3, 5])) #algorithm = HalinNodeColoring(G, outer=set([0, 1, 4, 5])) #algorithm = HalinNodeColoring(G, outer=set([1, 2, 3, 4])) algorithm.run() #print "3prism outer", algorithm.outer parent = {0: 1, 1: None, 2: 1, 3: 4, 4: 1, 5: 4} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
def test_halin16(self): N = 16 G = Graph(N, False) edges = [Edge(0, 1), Edge(0, 2), Edge(0, 15), Edge(1, 2), Edge(1, 6), Edge(2, 3), Edge(3, 4), Edge(3, 5), Edge(4, 5), Edge(4, 10), Edge(5, 6), Edge(6, 7), Edge(7, 8), Edge(7, 15), Edge(8, 9), Edge(8, 13), Edge(9, 10), Edge(9, 11), Edge(10, 11), Edge(11, 12), Edge(12, 13), Edge(12, 14), Edge(13, 14), Edge(14, 15)] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) #print "halin16" algorithm = HalinNodeColoring(G, outer=set([0, 2, 3, 4, 10, 11, 12, 14, 15])) algorithm.run() #print "halin16 outer", algorithm.outer parent = {0: 1, 1: None, 2: 1, 3: 5, 4: 5, 5: 6, 6: 1, 7: 6, 8: 7, 9: 8, 10: 9, 11: 9, 12: 13, 13: 8, 14: 13, 15: 7} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
def test_frucht12(self): N = 10 G = Graph(N, False) edges = [Edge(0, 1), Edge(0, 4), Edge(0, 11), Edge(1, 2), Edge(1, 10), Edge(2, 3), Edge(2, 7), Edge(3, 4), Edge(3, 5), Edge(4, 5), Edge(5, 6), Edge(6, 7), Edge(6, 8), Edge(7, 8), Edge(8, 9), Edge(9, 10), Edge(9, 11), Edge(10, 11)] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) #print "frucht12" algorithm = HalinNodeColoring(G, outer=set([0, 4, 5, 6, 8, 9, 11])) algorithm.run() #print "frucht12 outer", algorithm.outer parent = {0: 1, 1: None, 2: 1, 3: 2, 4: 3, 5: 3, 6: 7, 7: 2, 8: 7, 9: 10, 10: 1, 11: 10} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
class TestNodeColoring(unittest.TestCase): def setUp(self): self.N = 6 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [ Edge(0, 1), Edge(0, 3), Edge(1, 3), Edge(1, 4), Edge(1, 2), Edge(2, 4), Edge(2, 5), Edge(3, 4), Edge(4, 5)] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_us_node_coloring(self): algorithm = UnorderedSequentialNodeColoring(self.G) algorithm.run() for node in self.G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in self.G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) #print algorithm.color all_colors = set(algorithm.color[node] for node in self.G.iternodes()) self.assertEqual(len(all_colors), 4) def test_exceptions(self): self.assertRaises(ValueError, UnorderedSequentialNodeColoring, Graph(5, directed=True)) def tearDown(self): pass
class TestEdgeColoring(unittest.TestCase): def setUp(self): self.N = 6 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [ Edge(0, 1), Edge(0, 3), Edge(1, 3), Edge(1, 4), Edge(1, 2), Edge(2, 4), Edge(2, 5), Edge(3, 4), Edge(4, 5) ] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_rs_edge_coloring(self): algorithm = RandomSequentialEdgeColoring(self.G) algorithm.run() for edge in self.G.iteredges(): self.assertNotEqual(algorithm.color[edge], None) for node in self.G.iternodes(): color_set = set() for edge in self.G.iteroutedges(node): if edge.source > edge.target: color_set.add(algorithm.color[~edge]) else: color_set.add(algorithm.color[edge]) self.assertEqual(len(color_set), self.G.degree(node)) #print ( algorithm.color ) #algorithm.show_colors() all_colors = set(algorithm.color[edge] for edge in self.G.iteredges()) self.assertTrue(len(all_colors) in set([4, 5, 6, 7])) def test_exceptions(self): self.assertRaises(ValueError, RandomSequentialEdgeColoring, Graph(5, directed=True)) def tearDown(self): pass
def test_frucht12(self): N = 10 G = Graph(N, False) edges = [ Edge(0, 1), Edge(0, 4), Edge(0, 11), Edge(1, 2), Edge(1, 10), Edge(2, 3), Edge(2, 7), Edge(3, 4), Edge(3, 5), Edge(4, 5), Edge(5, 6), Edge(6, 7), Edge(6, 8), Edge(7, 8), Edge(8, 9), Edge(9, 10), Edge(9, 11), Edge(10, 11) ] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) #print "frucht12" algorithm = HalinNodeColoring(G, outer=set([0, 4, 5, 6, 8, 9, 11])) algorithm.run() #print "frucht12 outer", algorithm.outer parent = { 0: 1, 1: None, 2: 1, 3: 2, 4: 3, 5: 3, 6: 7, 7: 2, 8: 7, 9: 10, 10: 1, 11: 10 } self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
def test_halin11(self): N = 11 G = Graph(N, False) edges = [ Edge(0, 1), Edge(0, 2), Edge(0, 10), Edge(1, 2), Edge(1, 5), Edge(2, 3), Edge(3, 4), Edge(3, 9), Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7), Edge(7, 8), Edge(7, 9), Edge(8, 9), Edge(8, 10), Edge(9, 10) ] # E=17 for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) algorithm = HalinNodeColoring(G, outer=set([0, 1, 5, 6, 7, 8, 10])) algorithm.run() #print "halin11 outer", algorithm.outer parent = { 0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 4, 6: 4, 7: 9, 8: 9, 9: 3, 10: 9 } self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
class TestEdgeColoring(unittest.TestCase): def setUp(self): self.N = 6 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [ Edge(0, 1), Edge(0, 3), Edge(1, 3), Edge(1, 4), Edge(1, 2), Edge(2, 4), Edge(2, 5), Edge(3, 4), Edge(4, 5)] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_ntl_edge_coloring(self): algorithm = NTLEdgeColoring(self.G) algorithm.run() for edge in self.G.iteredges(): self.assertNotEqual(algorithm.color[edge], None) for node in self.G.iternodes(): color_set = set() for edge in self.G.iteroutedges(node): if edge.source > edge.target: color_set.add(algorithm.color[~edge]) else: color_set.add(algorithm.color[edge]) self.assertEqual(len(color_set), self.G.degree(node)) #print algorithm.color all_colors = set(algorithm.color[edge] for edge in self.G.iteredges()) self.assertEqual(len(all_colors), 5) def test_exceptions(self): self.assertRaises(ValueError, NTLEdgeColoring, Graph(5, directed=True)) def tearDown(self): pass
def test_halin8c(self): N = 8 G = Graph(N, False) edges = [Edge(0, 1), Edge(0, 5), Edge(0, 7), Edge(1, 2), Edge(1, 7), Edge(2, 3), Edge(2, 6), Edge(3, 4), Edge(3, 6), Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(6, 7)] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) algorithm = HalinNodeColoring(G, outer=set([0, 1, 2, 3, 4, 5])) algorithm.run() #print "halin8c outer", algorithm.outer parent = {0: 7, 1: 7, 2: 6, 3: 6, 4: 6, 5: 6, 6: None, 7: 6} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
def test_wheel5(self): N = 5 G = Graph(N, False) edges = [Edge(0, 1), Edge(0, 2), Edge(0, 3), Edge(0, 4), Edge(1, 2), Edge(2, 3), Edge(3, 4), Edge(4, 1)] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) algorithm = HalinNodeColoring(G, outer=set([1, 2, 3, 4])) algorithm.run() #print "wheel5 outer", algorithm.outer #print "wheel5 cycle", algorithm.cycle parent = {0: None, 1: 0, 2: 0, 3: 0, 4: 0} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
def test_halin7(self): N = 7 G = Graph(N, False) edges = [Edge(0, 1), Edge(0, 2), Edge(0, 6), Edge(1, 2), Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 5), Edge(4, 5), Edge(4, 6), Edge(5, 6)] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) algorithm = HalinNodeColoring(G, outer=set([0, 2, 3, 5, 6])) algorithm.run() #print "halin7 outer", algorithm.outer parent = {0: 1, 1: None, 2: 1, 3: 4, 4: 1, 5: 4, 6: 4} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
class TestNodeColoring2(unittest.TestCase): def setUp(self): self.N = 8 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [ Edge(0, 1), Edge(0, 2), Edge(0, 7), Edge(1, 2), Edge(1, 3), Edge(2, 3), Edge(3, 4), Edge(4, 5), Edge(4, 6), Edge(5, 6), Edge(5, 7), Edge(6, 7) ] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_brooks_node_coloring_regular(self): algorithm = BrooksNodeColoring(self.G) algorithm.run() for node in self.G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in self.G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) #print algorithm.color all_colors = set(algorithm.color[node] for node in self.G.iternodes()) self.assertEqual(len(all_colors), 3) def tearDown(self): pass
class TestIndependentSet(unittest.TestCase): def setUp(self): self.N = 6 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [ Edge(0, 1), Edge(0, 3), Edge(1, 3), Edge(1, 4), Edge(1, 2), Edge(2, 5), Edge(3, 4), Edge(4, 5) ] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_backtracking_independent_set(self): algorithm = BacktrackingIndependentSet(self.G) algorithm.run() # znajduje najlepszy set([0, 4, 2]) for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) self.assertEqual(algorithm.cardinality, len(algorithm.independent_set)) self.assertEqual(algorithm.cardinality, 3) self.assertEqual(algorithm.current_set, set()) #print algorithm.independent_set def test_exceptions(self): self.assertRaises(ValueError, BacktrackingIndependentSet, Graph(5, directed=True)) def tearDown(self): pass
def test_halin10k(self): N = 10 G = Graph(N, False) edges = [Edge(0, 1), Edge(0, 2), Edge(0, 9), Edge(1, 2), Edge(1, 4), Edge(2, 3), Edge(3, 4), Edge(3, 8), Edge(4, 5), Edge(5, 6), Edge(5, 7), Edge(6, 7), Edge(6, 9), Edge(7, 8), Edge(8, 9)] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) algorithm = HalinNodeColoring(G, outer=set([0, 1, 4, 5, 6, 9])) algorithm.run() #print "halin10k outer", algorithm.outer parent = {0: 2, 1: 2, 2: None, 3: 2, 4: 3, 5: 7, 6: 7, 7: 8, 8: 3, 9: 8} self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)
class TestGraphUndirected(unittest.TestCase): def setUp(self): self.N = 4 # number of nodes self.G = Graph(self.N) self.nodes = ["A", "B", "C", "D"] self.edges = [ Edge("A", "B", 2), Edge("B", "C", 4), Edge("C", "A", 6), Edge("C", "D", 3), Edge("D", "B", 5) ] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_undirected(self): self.assertFalse(self.G.is_directed()) self.assertEqual(self.G.v(), self.N) self.assertEqual(self.G.e(), 5) self.G.del_node("B") self.assertEqual(self.G.v(), 3) self.assertEqual(self.G.e(), 2) def test_iteredges(self): inedges_B = list(self.G.iterinedges("B")) outedges_B = list(self.G.iteroutedges("B")) #print inedges_B, outedges_B self.assertEqual(len(inedges_B), 3) self.assertEqual(len(outedges_B), 3) def test_iteredges_connected(self): start_edge = next(self.G.iteredges()) A = set([start_edge.source, start_edge.target]) for edge in self.G.iteredges_connected(start_edge): B = set([edge.source, edge.target]) self.assertTrue(len(A & B) > 0) A.update(B) #print ( A ) def test_copy(self): T = self.G.copy() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(edge)) def test_transpose(self): T = self.G.transpose() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(~edge)) def test_complement(self): T = self.G.complement() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.N * (self.N - 1) / 2 - self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertFalse(self.G.has_edge(edge)) for edge in self.G.iteredges(): self.assertFalse(T.has_edge(edge)) def test_subgraph(self): T = self.G.subgraph(["A", "B", "C"]) self.assertEqual(T.v(), 3) self.assertEqual(T.e(), 3) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(edge)) def test_degree(self): self.assertEqual(self.G.degree("A"), 2) self.assertEqual(self.G.degree("B"), 3) self.assertEqual(self.G.degree("C"), 3) self.assertEqual(self.G.degree("D"), 2) def test_add_graph_undirected(self): T = Graph(self.N) for node in self.nodes: T.add_node(node) T.add_edge(Edge("A", "D", 9)) self.assertEqual(T.v(), self.N) self.assertEqual(T.e(), 1) self.G.add_graph(T) self.assertEqual(self.G.v(), self.N) self.assertEqual(self.G.e(), 6) def test_load_save(self): name1 = "undirected_graph.txt" name2 = "undirected_graph.lgl" name3 = "undirected_graph.ncol" self.G.save(name1) self.G.save_lgl(name2) self.G.save_ncol(name3) T = Graph.load(name1) self.assertEqual(self.G, T) def tearDown(self): pass
class TestGraphDirected(unittest.TestCase): def setUp(self): self.N = 4 # number of nodes self.G = Graph(self.N, directed=True) self.nodes = ["A", "B", "C", "D"] self.edges = [ Edge("A", "B", 2), Edge("B", "C", 4), Edge("C", "A", 6), Edge("C", "D", 3), Edge("D", "B", 5) ] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_directed(self): self.assertTrue(self.G.is_directed()) self.assertEqual(self.G.v(), self.N) self.assertEqual(self.G.e(), 5) self.G.del_node("B") self.assertEqual(self.G.v(), 3) self.assertEqual(self.G.e(), 2) def test_cmp(self): T = Graph(self.N) self.assertFalse(T == self.G, "directed and undirected graphs") T = Graph(self.N, directed=True) for node in ["A", "B", "C", "X"]: T.add_node(node) self.assertFalse(T == self.G, "nodes are different") T.del_node("X") self.assertFalse(T == self.G, "numbers of nodes are different") T.add_node("D") T.add_edge(Edge("A", "B", 2)) T.add_edge(Edge("B", "C", 4)) T.add_edge(Edge("C", "A", 6)) T.add_edge(Edge("C", "D", 3)) self.assertFalse(T == self.G, "edge numbers are different") T.add_edge(Edge("D", "B", 7)) self.assertFalse(T == self.G, "edge weights are different") T.del_edge(Edge("D", "B", 7)) T.add_edge(Edge("B", "D", 5)) self.assertFalse(T == self.G, "edge directions are different") T.del_edge(Edge("B", "D", 5)) T.add_edge(Edge("D", "B", 5)) self.assertTrue(T == self.G, "graphs are the same") def test_iteredges(self): inedges_B = list(self.G.iterinedges("B")) outedges_B = list(self.G.iteroutedges("B")) #print inedges_B, outedges_B self.assertEqual(len(inedges_B), 2) self.assertEqual(len(outedges_B), 1) def test_copy(self): T = self.G.copy() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(edge)) def test_transpose(self): T = self.G.transpose() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(~edge)) def test_complement(self): T = self.G.complement() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.N * (self.N - 1) - self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertFalse(self.G.has_edge(edge)) for edge in self.G.iteredges(): self.assertFalse(T.has_edge(edge)) def test_subgraph(self): T = self.G.subgraph(["A", "B", "C"]) self.assertEqual(T.v(), 3) self.assertEqual(T.e(), 3) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(edge)) def test_add_graph_directed(self): T = Graph(self.N, directed=True) for node in self.nodes: T.add_node(node) T.add_edge(Edge("A", "D", 9)) self.assertEqual(T.v(), self.N) self.assertEqual(T.e(), 1) self.G.add_graph(T) self.assertEqual(self.G.v(), self.N) self.assertEqual(self.G.e(), 6) def test_degree(self): self.assertEqual(self.G.indegree("A"), 1) self.assertEqual(self.G.indegree("B"), 2) self.assertEqual(self.G.indegree("C"), 1) self.assertEqual(self.G.indegree("D"), 1) self.assertEqual(self.G.outdegree("A"), 1) self.assertEqual(self.G.outdegree("B"), 1) self.assertEqual(self.G.outdegree("C"), 2) self.assertEqual(self.G.outdegree("D"), 1) def test_exceptions(self): self.assertRaises(ValueError, self.G.add_edge, Edge("A", "A", 1)) self.assertRaises(ValueError, self.G.add_edge, Edge("A", "B", 2)) self.assertRaises(ValueError, self.G.degree, "A") def tearDown(self): pass
class TestIndependentSet(unittest.TestCase): def setUp(self): self.N = 6 self.G = Graph(self.N) self.nodes = range(self.N) self.edges = [ Edge(0, 1), Edge(0, 3), Edge(1, 3), Edge(1, 4), Edge(1, 2), Edge(2, 5), Edge(3, 4), Edge(4, 5) ] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_ll_independent_set1(self): algorithm = LargestLastIndependentSet1(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) self.assertEqual(algorithm.cardinality, len(algorithm.independent_set)) #print algorithm.independent_set def test_ll_independent_set2(self): algorithm = LargestLastIndependentSet2(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(algorithm.independent_set[edge.source] and algorithm.independent_set[edge.target]) cardinality = sum(1 for node in self.G if algorithm.independent_set[node]) self.assertEqual(algorithm.cardinality, cardinality) #print algorithm.independent_set def test_ll_independent_set3(self): algorithm = LargestLastIndependentSet3(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) self.assertEqual(algorithm.cardinality, len(algorithm.independent_set)) #print algorithm.independent_set def test_ll_independent_set4(self): algorithm = LargestLastIndependentSet4(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(algorithm.independent_set[edge.source] and algorithm.independent_set[edge.target]) cardinality = sum(1 for node in self.G if algorithm.independent_set[node]) self.assertEqual(algorithm.cardinality, cardinality) #print algorithm.independent_set def test_ll_independent_set5(self): algorithm = LargestLastIndependentSet5(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) self.assertEqual(algorithm.cardinality, len(algorithm.independent_set)) #print algorithm.independent_set def test_ll_independent_set6(self): algorithm = LargestLastIndependentSet6(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) self.assertEqual(algorithm.cardinality, len(algorithm.independent_set)) #print algorithm.independent_set def test_ll_independent_set7(self): algorithm = LargestLastIndependentSet7(self.G) #algorithm.run() # przypadkiem znajduje najlepsze rozwiazanie algorithm.run(3) # znajduje set([2, 3]) for edge in self.G.iteredges(): self.assertFalse(edge.source in algorithm.independent_set and edge.target in algorithm.independent_set) self.assertEqual(algorithm.cardinality, len(algorithm.independent_set)) #print algorithm.independent_set def test_exceptions(self): self.assertRaises(ValueError, LargestLastIndependentSet1, Graph(5, directed=True)) self.assertRaises(ValueError, LargestLastIndependentSet2, Graph(5, directed=True)) self.assertRaises(ValueError, LargestLastIndependentSet3, Graph(5, directed=True)) self.assertRaises(ValueError, LargestLastIndependentSet4, Graph(5, directed=True)) self.assertRaises(ValueError, LargestLastIndependentSet5, Graph(5, directed=True)) self.assertRaises(ValueError, LargestLastIndependentSet6, Graph(5, directed=True)) self.assertRaises(ValueError, LargestLastIndependentSet7, Graph(5, directed=True)) def tearDown(self): pass
class TestGraphUndirected(unittest.TestCase): def setUp(self): self.N = 4 # number of nodes self.G = Graph(self.N) self.nodes = ["A", "B", "C", "D"] self.edges = [ Edge("A", "B", 2), Edge("B", "C", 4), Edge("C", "A", 6), Edge("C", "D", 3), Edge("D", "B", 5)] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_undirected(self): self.assertFalse(self.G.is_directed()) self.assertEqual(self.G.v(), self.N) self.assertEqual(self.G.e(), 5) self.G.del_node("B") self.assertEqual(self.G.v(), 3) self.assertEqual(self.G.e(), 2) def test_iteredges(self): inedges_B = list(self.G.iterinedges("B")) outedges_B = list(self.G.iteroutedges("B")) #print inedges_B, outedges_B self.assertEqual(len(inedges_B), 3) self.assertEqual(len(outedges_B), 3) def test_copy(self): T = self.G.copy() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(edge)) def test_transpose(self): T = self.G.transpose() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(~edge)) def test_complement(self): T = self.G.complement() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.N*(self.N-1)/2 - self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertFalse(self.G.has_edge(edge)) for edge in self.G.iteredges(): self.assertFalse(T.has_edge(edge)) def test_subgraph(self): T = self.G.subgraph(["A", "B", "C"]) self.assertEqual(T.v(), 3) self.assertEqual(T.e(), 3) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(edge)) def test_degree(self): self.assertEqual(self.G.degree("A"), 2) self.assertEqual(self.G.degree("B"), 3) self.assertEqual(self.G.degree("C"), 3) self.assertEqual(self.G.degree("D"), 2) def test_add_graph_undirected(self): T = Graph(self.N) for node in self.nodes: T.add_node(node) T.add_edge(Edge("A", "D", 9)) self.assertEqual(T.v(), self.N) self.assertEqual(T.e(), 1) self.G.add_graph(T) self.assertEqual(self.G.v(), self.N) self.assertEqual(self.G.e(), 6) def test_load_save(self): name1 = "undirected_graph.txt" name2 = "undirected_graph.lgl" name3 = "undirected_graph.ncol" self.G.save(name1) self.G.save_lgl(name2) self.G.save_ncol(name3) T = Graph.load(name1) self.assertEqual(self.G, T) def tearDown(self): pass
class TestGraphDirected(unittest.TestCase): def setUp(self): self.N = 4 # number of nodes self.G = Graph(self.N, directed=True) self.nodes = ["A", "B", "C", "D"] self.edges = [ Edge("A", "B", 2), Edge("B", "C", 4), Edge("C", "A", 6), Edge("C", "D", 3), Edge("D", "B", 5)] for node in self.nodes: self.G.add_node(node) for edge in self.edges: self.G.add_edge(edge) #self.G.show() def test_directed(self): self.assertTrue(self.G.is_directed()) self.assertEqual(self.G.v(), self.N) self.assertEqual(self.G.e(), 5) self.G.del_node("B") self.assertEqual(self.G.v(), 3) self.assertEqual(self.G.e(), 2) def test_cmp(self): T = Graph(self.N) self.assertFalse(T == self.G, "directed and undirected graphs") T = Graph(self.N, directed=True) for node in ["A", "B", "C", "X"]: T.add_node(node) self.assertFalse(T == self.G, "nodes are different") T.del_node("X") self.assertFalse(T == self.G, "numbers of nodes are different") T.add_node("D") T.add_edge(Edge("A", "B", 2)) T.add_edge(Edge("B", "C", 4)) T.add_edge(Edge("C", "A", 6)) T.add_edge(Edge("C", "D", 3)) self.assertFalse(T == self.G, "edge numbers are different") T.add_edge(Edge("D", "B", 7)) self.assertFalse(T == self.G, "edge weights are different") T.del_edge(Edge("D", "B", 7)) T.add_edge(Edge("B", "D", 5)) self.assertFalse(T == self.G, "edge directions are different") T.del_edge(Edge("B", "D", 5)) T.add_edge(Edge("D", "B", 5)) self.assertTrue(T == self.G, "graphs are the same") def test_iteredges(self): inedges_B = list(self.G.iterinedges("B")) outedges_B = list(self.G.iteroutedges("B")) #print inedges_B, outedges_B self.assertEqual(len(inedges_B), 2) self.assertEqual(len(outedges_B), 1) def test_copy(self): T = self.G.copy() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(edge)) def test_transpose(self): T = self.G.transpose() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(~edge)) def test_complement(self): T = self.G.complement() self.assertEqual(T.v(), self.G.v()) self.assertEqual(T.e(), self.N*(self.N-1) - self.G.e()) for node in T.iternodes(): self.assertTrue(self.G.has_node(node)) for edge in T.iteredges(): self.assertFalse(self.G.has_edge(edge)) for edge in self.G.iteredges(): self.assertFalse(T.has_edge(edge)) def test_subgraph(self): T = self.G.subgraph(["A", "B", "C"]) self.assertEqual(T.v(), 3) self.assertEqual(T.e(), 3) for edge in T.iteredges(): self.assertTrue(self.G.has_edge(edge)) def test_add_graph_directed(self): T = Graph(self.N, directed=True) for node in self.nodes: T.add_node(node) T.add_edge(Edge("A", "D", 9)) self.assertEqual(T.v(), self.N) self.assertEqual(T.e(), 1) self.G.add_graph(T) self.assertEqual(self.G.v(), self.N) self.assertEqual(self.G.e(), 6) def test_degree(self): self.assertEqual(self.G.indegree("A"), 1) self.assertEqual(self.G.indegree("B"), 2) self.assertEqual(self.G.indegree("C"), 1) self.assertEqual(self.G.indegree("D"), 1) self.assertEqual(self.G.outdegree("A"), 1) self.assertEqual(self.G.outdegree("B"), 1) self.assertEqual(self.G.outdegree("C"), 2) self.assertEqual(self.G.outdegree("D"), 1) def test_exceptions(self): self.assertRaises(ValueError, self.G.add_edge, Edge("A", "A", 1)) self.assertRaises(ValueError, self.G.add_edge, Edge("A", "B", 2)) self.assertRaises(ValueError, self.G.degree, "A") def tearDown(self): pass
def test_halin16(self): N = 16 G = Graph(N, False) edges = [ Edge(0, 1), Edge(0, 2), Edge(0, 15), Edge(1, 2), Edge(1, 6), Edge(2, 3), Edge(3, 4), Edge(3, 5), Edge(4, 5), Edge(4, 10), Edge(5, 6), Edge(6, 7), Edge(7, 8), Edge(7, 15), Edge(8, 9), Edge(8, 13), Edge(9, 10), Edge(9, 11), Edge(10, 11), Edge(11, 12), Edge(12, 13), Edge(12, 14), Edge(13, 14), Edge(14, 15) ] for node in range(N): G.add_node(node) for edge in edges: G.add_edge(edge) #print "halin16" algorithm = HalinNodeColoring(G, outer=set( [0, 2, 3, 4, 10, 11, 12, 14, 15])) algorithm.run() #print "halin16 outer", algorithm.outer parent = { 0: 1, 1: None, 2: 1, 3: 5, 4: 5, 5: 6, 6: 1, 7: 6, 8: 7, 9: 8, 10: 9, 11: 9, 12: 13, 13: 8, 14: 13, 15: 7 } self.assertEqual(algorithm.parent, parent) for node in G.iternodes(): self.assertNotEqual(algorithm.color[node], None) for edge in G.iteredges(): self.assertNotEqual(algorithm.color[edge.source], algorithm.color[edge.target]) all_colors = set(algorithm.color[node] for node in G.iternodes()) self.assertEqual(len(all_colors), 3)