コード例 #1
0
    def test_pruning(self):
        graph = dep_finder.Graph(
            cvface={'mog'},
            dlib={'mog'},
            cvperson={'mog'},
            sphinx={},
            extras={'cvface', 'dlib', 'mog', 'cvperson', 'sphinx'},
            subsense={})
        sub_graph = dep_finder.prune_graph('subsense', graph)
        self.assertEqual({'subsense'}, sub_graph.get_node_set())
        self.assertEqual(set(), sub_graph.get_edges())

        sub_graph = dep_finder.prune_graph('sphinx', graph)
        self.assertEqual({'extras', 'sphinx'}, sub_graph.get_node_set())
        self.assertEqual({('extras', 'sphinx')}, sub_graph.get_edges())

        sub_graph = dep_finder.prune_graph('cvface', graph)
        self.assertEqual({'extras', 'cvface'}, sub_graph.get_node_set())
        self.assertEqual({('extras', 'cvface')}, sub_graph.get_edges())

        sub_graph = dep_finder.prune_graph('mog', graph)
        self.assertEqual({'mog', 'cvface', 'dlib', 'cvperson', 'extras'},
                         sub_graph.get_node_set())
        expected_edges = {('extras', 'cvface'), ('extras', 'dlib'),
                          ('extras', 'cvperson'), ('extras', 'mog'),
                          ('cvface', 'mog'), ('dlib', 'mog'),
                          ('cvperson', 'mog')}
        self.assertEqual(expected_edges, sub_graph.get_edges())
コード例 #2
0
 def test_disconnected_graph2(self):
     graph = dep_finder.Graph(D={'E', 'G'},
                              E={'F', 'M'},
                              F={'H'},
                              M={'J'},
                              I={})
     expected = ['G', 'H', 'F', 'I', 'J', 'M', 'E', 'D']
     actual = dep_finder.topo_sort(graph)
     self.assertEqual(expected, actual)
コード例 #3
0
    def test_topo_sort2(self):
        graph = dep_finder.Graph(Q={'B', 'C', 'E'},
                                 B={'D'},
                                 C={'D'},
                                 D={'E', 'F', 'G', 'A'})

        expected = ['A', 'E', 'F', 'G', 'D', 'B', 'C', 'Q']
        actual = dep_finder.topo_sort(graph)
        self.assertEqual(expected, actual)
コード例 #4
0
    def test_pruning2(self):
        graph = dep_finder.Graph(D={'E', 'G'},
                                 E={'F', 'M'},
                                 F={'H'},
                                 M={'J'},
                                 I={})
        terminal_node = 'F'
        sub_graph = dep_finder.prune_graph(terminal_node, graph)
        nodes = sub_graph.get_node_set()

        self.assertEqual(3, len(nodes))
        self.assertEqual({'D', 'E', 'F'}, nodes)
        expected_edges = {('D', 'E'), ('E', 'F')}
        self.assertEqual(expected_edges, sub_graph.get_edges())
コード例 #5
0
 def test_error_when_graph_has_cycle(self):
     graph = dep_finder.Graph(A={'B', 'C', 'E'},
                              B={'D'},
                              C={'D'},
                              D={'A', 'E', 'F', 'G'})
     self.assertRaises(SystemExit, dep_finder.topo_sort, graph)
コード例 #6
0
 def test_simple_topo_sort(self):
     graph = dep_finder.Graph(O={'LL', 'E'}, E={'H'})
     expected = ['H', 'E', 'LL', 'O']
     actual = dep_finder.topo_sort(graph)
     self.assertEqual(expected, actual)