def test_graph_algorithms_shortest_path_v0_v6(self):
        """
        Test of shortest path algorithm.
        """
        ref = graph_path.GraphPath(self.graph2)

        # Reference vertices are added in reverse order
        # in order to make comparison easier.
        ref.add_vertex(self.v6_g2)
        ref.add_vertex(self.v1_g2)
        ref.add_vertex(self.v0_g2)

        e01 = graph_edge.DirectedWeightedGraphEdge(self.graph2, self.v0_g2,
                                                   self.v1_g2, 7)
        e16 = graph_edge.DirectedWeightedGraphEdge(self.graph2, self.v1_g2,
                                                   self.v6_g2, 3)

        # Reference edges are added in reverse order
        # in order to make comparison easier.
        ref.add_edge(e16)
        ref.add_edge(e01)

        res = graph_algorithms.GraphAlgorithms.shortest_path(
            self.graph2, self.v0_g2, self.v6_g2)
        self.assertEqual(ref, res)
    def test_directed_weighted_graph_classify_edges_acyclic(self):
        """
        Test graph classification for directed weighted acyclic graph.
        """
        # Create a directed weighted acyclic graph

        a_graph = graph.DirectedWeightedGraph(4)
        vertex1 = graph_vertex.UnWeightedGraphVertex(a_graph, 'A')
        vertex2 = graph_vertex.UnWeightedGraphVertex(a_graph, 'B')
        vertex3 = graph_vertex.UnWeightedGraphVertex(a_graph, 'C')
        vertex4 = graph_vertex.UnWeightedGraphVertex(a_graph, 'D')

        a_graph.add_vertex(vertex1)
        a_graph.add_vertex(vertex2)
        a_graph.add_vertex(vertex3)
        a_graph.add_vertex(vertex4)

        a_graph.add_edge(vertex1, vertex2, 10)
        a_graph.add_edge(vertex2, vertex3, 20)
        a_graph.add_edge(vertex2, vertex4, 30)

        res = a_graph.classify_edges().get_edges()
        ref = dfs_edge_classification.DFSEdgeClassification(
            a_graph).get_edges()
        e12 = graph_edge.DirectedWeightedGraphEdge(a_graph, vertex1, vertex2,
                                                   10)
        e23 = graph_edge.DirectedWeightedGraphEdge(a_graph, vertex2, vertex3,
                                                   20)
        e24 = graph_edge.DirectedWeightedGraphEdge(a_graph, vertex2, vertex4,
                                                   30)
        ref[e12] = graph_edge.EdgeClassification.TREE_EDGE
        ref[e23] = graph_edge.EdgeClassification.TREE_EDGE
        ref[e24] = graph_edge.EdgeClassification.TREE_EDGE
        self.assertEqual(res, ref)
    def test_graph_algorithms_dijkstra_v6(self):
        """
        Test of Dijkstras algorithm.
        """
        e60 = graph_edge.DirectedWeightedGraphEdge(self.graph2, self.v6_g2,
                                                   self.v0_g2, 7)
        e01 = graph_edge.DirectedWeightedGraphEdge(self.graph2, self.v0_g2,
                                                   self.v1_g2, 7)
        e12 = graph_edge.DirectedWeightedGraphEdge(self.graph2, self.v1_g2,
                                                   self.v2_g2, 2)
        e23 = graph_edge.DirectedWeightedGraphEdge(self.graph2, self.v2_g2,
                                                   self.v3_g2, 2)
        e64 = graph_edge.DirectedWeightedGraphEdge(self.graph2, self.v6_g2,
                                                   self.v4_g2, 1)
        e45 = graph_edge.DirectedWeightedGraphEdge(self.graph2, self.v4_g2,
                                                   self.v5_g2, 6)

        elem0 = entry.Entry(True, 7, self.v6_g2, e60)
        elem1 = entry.Entry(True, 14, self.v0_g2, e01)
        elem2 = entry.Entry(True, 16, self.v1_g2, e12)
        elem3 = entry.Entry(True, 18, self.v2_g2, e23)
        elem4 = entry.Entry(True, 1, self.v6_g2, e64)
        elem5 = entry.Entry(True, 7, self.v4_g2, e45)
        elem6 = entry.Entry(True, 0, None, None)

        ref = array_list.ArrayList(self.graph2.get_number_of_vertices())
        ref[0] = elem0
        ref[1] = elem1
        ref[2] = elem2
        ref[3] = elem3
        ref[4] = elem4
        ref[5] = elem5
        ref[6] = elem6
        res = graph_algorithms.GraphAlgorithms.dijkstras_algorithm(
            self.graph2, self.v6_g2)
        self.assertEqual(ref, res)
    def setUp(self):
        # Create directed weighted graph Cormen page 596.
        self.graph1 = graph.DirectedWeightedGraph(5)

        self.v1_g1 = graph_vertex.UnWeightedGraphVertex(self.graph1, 'S')
        self.v2_g1 = graph_vertex.UnWeightedGraphVertex(self.graph1, 'T')
        self.v3_g1 = graph_vertex.UnWeightedGraphVertex(self.graph1, 'X')
        self.v4_g1 = graph_vertex.UnWeightedGraphVertex(self.graph1, 'Y')
        self.v5_g1 = graph_vertex.UnWeightedGraphVertex(self.graph1, 'Z')

        self.graph1.add_vertex(self.v1_g1)
        self.graph1.add_vertex(self.v2_g1)
        self.graph1.add_vertex(self.v3_g1)
        self.graph1.add_vertex(self.v4_g1)
        self.graph1.add_vertex(self.v5_g1)

        self.e12 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v1_g1, self.v2_g1, 10)
        self.e14 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v1_g1, self.v4_g1, 5)
        self.e23 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v2_g1, self.v3_g1, 1)
        self.e24 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v2_g1, self.v4_g1, 2)
        self.e35 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v3_g1, self.v5_g1, 4)
        self.e42 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v4_g1, self.v2_g1, 3)
        self.e43 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v4_g1, self.v3_g1, 9)
        self.e45 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v4_g1, self.v5_g1, 2)
        self.e53 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v5_g1, self.v3_g1, 6)
        self.e51 = graph_edge.DirectedWeightedGraphEdge(
            self.graph1, self.v5_g1, self.v1_g1, 7)

        self.graph1.add_edge(self.v1_g1, self.v2_g1, 10)  # (S -> T, 10)
        self.graph1.add_edge(self.v1_g1, self.v4_g1, 5)  # (S -> Y, 5)
        self.graph1.add_edge(self.v2_g1, self.v3_g1, 1)  # (T -> X, 1)
        self.graph1.add_edge(self.v2_g1, self.v4_g1, 2)  # (T -> Y, 2)
        self.graph1.add_edge(self.v3_g1, self.v5_g1, 4)  # (X -> Z, 4)
        self.graph1.add_edge(self.v4_g1, self.v2_g1, 3)  # (Y -> T, 3)
        self.graph1.add_edge(self.v4_g1, self.v3_g1, 9)  # (Y -> X, 9)
        self.graph1.add_edge(self.v4_g1, self.v5_g1, 2)  # (Y -> Z, 2)
        self.graph1.add_edge(self.v5_g1, self.v3_g1, 6)  # (Z -> X, 6)
        self.graph1.add_edge(self.v5_g1, self.v1_g1, 7)  # (Z -> S, 7)

        # Create directed unweighted acyclic graph Bruno R. Preiss - Java - page 563.
        self.graph2 = graph.DirectedWeightedGraph(9)

        self.v0_g2 = graph_vertex.UnWeightedGraphVertex(self.graph2, 'a')
        self.v1_g2 = graph_vertex.UnWeightedGraphVertex(self.graph2, 'b')
        self.v2_g2 = graph_vertex.UnWeightedGraphVertex(self.graph2, 'c')
        self.v3_g2 = graph_vertex.UnWeightedGraphVertex(self.graph2, 'd')
        self.v4_g2 = graph_vertex.UnWeightedGraphVertex(self.graph2, 'e')
        self.v5_g2 = graph_vertex.UnWeightedGraphVertex(self.graph2, 'f')
        self.v6_g2 = graph_vertex.UnWeightedGraphVertex(self.graph2, 'g')
        self.v7_g2 = graph_vertex.UnWeightedGraphVertex(self.graph2, 'h')
        self.v8_g2 = graph_vertex.UnWeightedGraphVertex(self.graph2, 'i')

        self.graph2.add_vertex(self.v0_g2)
        self.graph2.add_vertex(self.v1_g2)
        self.graph2.add_vertex(self.v2_g2)
        self.graph2.add_vertex(self.v3_g2)
        self.graph2.add_vertex(self.v4_g2)
        self.graph2.add_vertex(self.v5_g2)
        self.graph2.add_vertex(self.v6_g2)
        self.graph2.add_vertex(self.v7_g2)
        self.graph2.add_vertex(self.v8_g2)

        self.e01_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v0_g2, self.v1_g2, 10)
        self.e02_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v0_g2, self.v2_g2, 11)
        self.e04_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v0_g2, self.v4_g2, 12)
        self.e13_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v1_g2, self.v3_g2, 13)
        self.e14_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v1_g2, self.v4_g2, 14)
        self.e27_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v2_g2, self.v7_g2, 15)
        self.e25_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v2_g2, self.v5_g2, 16)
        self.e36_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v3_g2, self.v6_g2, 17)
        self.e46_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v4_g2, self.v6_g2, 18)
        self.e48_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v4_g2, self.v8_g2, 19)
        self.e47_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v4_g2, self.v7_g2, 20)
        self.e57_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v5_g2, self.v7_g2, 21)
        self.e68_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v6_g2, self.v8_g2, 22)
        self.e78_g2 = graph_edge.DirectedWeightedGraphEdge(
            self.graph2, self.v7_g2, self.v8_g2, 23)

        self.graph2.add_edge(self.v0_g2, self.v1_g2, 10)  # a -> b
        self.graph2.add_edge(self.v0_g2, self.v2_g2, 11)  # a -> c
        self.graph2.add_edge(self.v0_g2, self.v4_g2, 12)  # a -> e
        self.graph2.add_edge(self.v1_g2, self.v3_g2, 13)  # b -> d
        self.graph2.add_edge(self.v1_g2, self.v4_g2, 14)  # b -> e
        self.graph2.add_edge(self.v2_g2, self.v7_g2, 15)  # c -> h
        self.graph2.add_edge(self.v2_g2, self.v5_g2, 16)  # c -> f
        self.graph2.add_edge(self.v3_g2, self.v6_g2, 17)  # d -> g
        self.graph2.add_edge(self.v4_g2, self.v6_g2, 18)  # e -> g
        self.graph2.add_edge(self.v4_g2, self.v8_g2, 19)  # e -> i
        self.graph2.add_edge(self.v4_g2, self.v7_g2, 20)  # e -> h
        self.graph2.add_edge(self.v5_g2, self.v7_g2, 21)  # f -> h
        self.graph2.add_edge(self.v6_g2, self.v8_g2, 22)  # g -> i
        self.graph2.add_edge(self.v7_g2, self.v8_g2, 24)  # h -> i