def test_simple(self):
        # 1 -[10]-> 2
        # 2 -[20]-> 3

        graph = MatrixGraph()
        graph.add_edge(Edge(1, 1, 2, 10))
        graph.add_edge(Edge(1, 2, 1, 20))

        pred = [
            [None, 1, 2],
            [None, None, 2],
            [None, None, None]
        ]

        self.assertListEqual(reconstruct_path(pred, 1, 1, graph), [])
        self.assertListEqual(reconstruct_path(pred, 1, 2, graph), [1, 2])
        self.assertListEqual(reconstruct_path(pred, 1, 3, graph), [1, 2, 3])
        self.assertListEqual(reconstruct_path(pred, 2, 1, graph), [])
        self.assertListEqual(reconstruct_path(pred, 2, 2, graph), [])
        self.assertListEqual(reconstruct_path(pred, 2, 3, graph), [2, 3])
        self.assertListEqual(reconstruct_path(pred, 3, 1, graph), [])
        self.assertListEqual(reconstruct_path(pred, 3, 2, graph), [])
        self.assertListEqual(reconstruct_path(pred, 3, 3, graph), [])
Esempio n. 2
0
 def setUp(self):
     self.g = MatrixGraph()
Esempio n. 3
0
class MatrixGraphTest(GraphTest):
    def setUp(self):
        self.g = MatrixGraph()

    def test_add_vertex_once(self):
        self.g.add_vertex(self.v1)
        self.assertListEqual([self.v1], self.g.vertices)
        self.assertListEqual([[None]], self.g.matrix)

    def test_add_vertex_twice(self):
        self.g.add_vertex(self.v1)
        self.g.add_vertex(self.v2)
        self.assertListEqual([self.v1, self.v2], self.g.vertices)
        self.assertListEqual([[None, None], [None, None]], self.g.matrix)

    def test_delete_vertex(self):
        self.g.add_vertex(self.v1)
        self.g.add_vertex(self.v2)
        self.g.delete_vertex(self.v1)
        self.assertListEqual([self.v2], self.g.vertices)
        self.assertListEqual([[None]], self.g.matrix)

    def test_add_edge(self):
        self.g.add_edge(self.e1)
        self.assertListEqual(self.g.vertices, [self.v1, self.v2])
        self.assertListEqual(self.g.matrix, [[None, self.e1], [None, None]])

    def test_delete_edge(self):
        self.g.add_edge(self.e1)
        self.g.delete_edge(self.e1)
        self.assertListEqual(self.g.vertices, [self.v1, self.v2])
        self.assertListEqual(self.g.matrix, [[None, None], [None, None]])

    def test_delete_edge_one_remaining(self):
        if settings.INTEGER_VERTICES:
            return
        self.g.add_edge(self.e1)
        self.g.add_edge(self.e2)
        self.g.delete_edge(self.e2)
        self.assertListEqual(self.g.vertices, [self.v1, self.v2])
        self.assertListEqual(self.g.matrix, [[None, self.e1], [None, None]])

    def test_get_neighbors(self):
        self.g.add_edge(self.e1)
        self.g.add_vertex(self.v3)
        self.assertListEqual(self.g.get_neighbors(self.v1), [self.v2])
        self.assertListEqual(self.g.get_neighbors(self.v3), [])

    def test_get_neighbors_exhaustive(self):
        self.g.add_edge(self.e1)
        self.g.add_edge(self.e2)
        self.g.add_edge(self.e3)
        self.g.add_vertex(self.v3)
        self.assertListEqual(self.g.get_neighbors(self.v1), [self.v2])
        self.assertListEqual(self.g.get_neighbors(self.v2), [self.v1])
        self.assertListEqual(self.g.get_neighbors(self.v3), [])
        self.assertListEqual(self.g.get_neighbors(self.v4), [self.v5])
        self.assertListEqual(self.g.get_neighbors(self.v5), [self.v4])

    def test_get_incoming_edges(self):
        self.g.add_edge(self.e1)
        self.g.add_edge(self.e2)
        self.assertListEqual(self.g.get_incoming_edges(self.v2), [self.e1])

    def test_get_outgoing_edges(self):
        self.g.add_edge(self.e1)
        self.g.add_edge(self.e2)
        self.assertListEqual(self.g.get_outgoing_edges(self.v2), [self.e2])

    def test_get_edge(self):
        self.g.add_edge(self.e1)
        self.assertEqual(self.g.get_edge(self.E1_LABEL), self.e1)

    def test_get_edges_count(self):
        self.assertEqual(self.g.get_edges_count(), 0)
        self.g.add_edge(self.e1)
        self.assertEqual(self.g.get_edges_count(), 1)
        self.g.add_edge(self.e2)
        self.assertEqual(self.g.get_edges_count(), 2)

    def test_is_neighbors(self):
        self.g.add_edge(self.e1)
        self.g.add_vertex(self.v3)
        self.assertTrue(self.g.is_neighbors(self.v1, self.v2))
        self.assertTrue(self.g.is_neighbors(self.v2, self.v1))
        self.assertFalse(self.g.is_neighbors(self.v3, self.v1))
        self.assertFalse(self.g.is_neighbors(self.v3, self.v2))

    def test_acceptance(self):
        read_graph('../../data/graf.txt', self.g)
        control_sum = sum([e.weight for e in self.g.get_edges() if e.vertex_from < e.vertex_to])
        self.assertEqual(control_sum, 4790)