Esempio n. 1
0
    def test_add_node(self):
        with self.assertRaises(GraphTypeError):
            Graph(5)

        graph = Graph()
        with self.assertRaises(GraphElementError):
            graph.add_node(None)
        self.assertTrue(graph.size == 0)
        graph.add_node(1)
        graph.add_node(5.5)
        graph.add_node("string")
        self.assertEqual(len(graph), 3, "Wrong add_node implementation")
        self.assertEqual(graph.nodes(), {1, 5.5, "string"},
                         "Wrong add_node implementation")

        graph = Graph(int)
        with self.assertRaises(GraphTypeError):
            graph.add_node(5.0)
        self.assertEqual(len(graph.edges()), 5,
                         "Wrong number of edges at initialization")
        for i in range(100):
            graph.add_node(i * 2)
        self.assertEqual(len(graph.edges()), 160,
                         "Wrong add_node implementation")
        graph.add_node(2)
        self.assertEqual(len(graph), 100, "Wrong add_node implementation")
        graph.add_node(1)
        self.assertEqual(len(graph), 101, "Wrong add_node implementation")
        graph.remove_node(1)
Esempio n. 2
0
    def test_edges(self):
        graph = Graph(int, directed=True)
        for node in range(5):
            graph.add_node(node)
        edges = graph.edges()
        for l in edges:
            self.assertEqual(l, [None] * 5, "Wrong edges implementation")

        graph.add_edge(0, 1)
        graph.add_edge(1, 2)
        edges = graph.edges()
        self.assertEqual(edges[0][1], 1, "Wrong edges implementation")
        self.assertEqual(edges[1][0], None, "Wrong edges implementation")
        self.assertEqual(edges[2][1], None, "Wrong edges implementation")
        self.assertEqual(edges[1][2], 1, "Wrong edges implementation")
        edges.append([])
        self.assertNotEqual(graph.edges(), edges, "Wrong edges implementation")
Esempio n. 3
0
    def test_remove_edge(self):
        graph = Graph()
        with self.assertRaises(GraphElementError):
            graph.remove_edge(1, 9)

        for node in [1, 1.1, "1", False]:
            graph.add_node(node)

        graph.add_edge(1, 1.1)
        graph.add_edge("1", False)

        with self.assertRaises(GraphElementError):
            graph.add_edge(5, 5)

        self.assertTrue(graph.contains_edge(1, 1.1))
        graph.remove_edge(1.1, 1)
        self.assertFalse(graph.contains_edge(1.1, 1),
                         "Wrong remove_edge implementation")
        self.assertEqual(graph.edges_of(1), [],
                         "Wrong remove_edge implementation")

        graph = Graph(float, directed=True, oriented=True)
        for node in range(0, 101, 1):
            graph.add_node(node / 3)

        with self.assertRaises(GraphTypeError):
            graph.remove_edge(1, 2)
        with self.assertRaises(GraphElementError):
            graph.remove_edge(105.2, 205.2)
        with self.assertRaises(GraphEdgeError):
            graph.remove_edge(10.0, 20.0)

        graph.add_edge(10.0, 20.0)
        graph.add_edge(20.0, 30.0)

        self.assertTrue(graph.contains_edge(20.0, 30.0))
        graph.remove_edge(20.0, 30.0)
        self.assertFalse(graph.contains_edge(20.0, 30.0),
                         "Wrong remove_edge implementation")

        self.assertEqual(graph.edges_of(20.0), [],
                         "Wrong remove_edge implementation")

        self.assertEqual(len(graph.edges()), 160,
                         "Wrong remove_edge implementation")