wehub-resource-sync
123 lines
3.9 KiB
Python
123 lines
3.9 KiB
Python
import unittest
|
|
|
|
import easygraph as eg
|
|
|
|
|
|
class TestEasyGraph(unittest.TestCase):
|
|
def setUp(self):
|
|
self.G = eg.Graph()
|
|
|
|
def test_add_single_node(self):
|
|
self.G.add_node(1)
|
|
self.assertIn(1, self.G.nodes)
|
|
|
|
def test_add_multiple_nodes(self):
|
|
self.G.add_nodes([2, 3, 4])
|
|
for node in [2, 3, 4]:
|
|
self.assertIn(node, self.G.nodes)
|
|
|
|
def test_add_node_with_attributes(self):
|
|
self.G.add_node("node", color="red")
|
|
self.assertEqual(self.G.nodes["node"]["color"], "red")
|
|
|
|
def test_add_single_edge(self):
|
|
self.G.add_edge(1, 2)
|
|
self.assertTrue(self.G.has_edge(1, 2))
|
|
self.assertTrue(self.G.has_edge(2, 1))
|
|
|
|
def test_add_edge_with_weight(self):
|
|
self.G.add_edge("a", "b", weight=10)
|
|
self.assertEqual(self.G["a"]["b"]["weight"], 10)
|
|
|
|
def test_add_edges(self):
|
|
self.G.add_edges([(1, 2), (2, 3)], edges_attr=[{"weight": 5}, {"weight": 6}])
|
|
self.assertEqual(self.G[1][2]["weight"], 5)
|
|
self.assertEqual(self.G[2][3]["weight"], 6)
|
|
|
|
def test_remove_node(self):
|
|
self.G.add_node(10)
|
|
self.G.remove_node(10)
|
|
self.assertNotIn(10, self.G.nodes)
|
|
|
|
def test_remove_edge(self):
|
|
self.G.add_edge(1, 2)
|
|
self.G.remove_edge(1, 2)
|
|
self.assertFalse(self.G.has_edge(1, 2))
|
|
|
|
def test_neighbors(self):
|
|
self.G.add_edges([(1, 2), (1, 3)])
|
|
neighbors = list(self.G.neighbors(1))
|
|
self.assertIn(2, neighbors)
|
|
self.assertIn(3, neighbors)
|
|
|
|
def test_subgraph(self):
|
|
self.G.add_edges([(1, 2), (2, 3), (3, 4)])
|
|
subG = self.G.nodes_subgraph([2, 3])
|
|
self.assertIn(2, subG.nodes)
|
|
self.assertIn(3, subG.nodes)
|
|
self.assertTrue(subG.has_edge(2, 3))
|
|
self.assertFalse(subG.has_edge(3, 4))
|
|
|
|
def test_ego_subgraph(self):
|
|
self.G.add_edges([(1, 2), (2, 3), (2, 4)])
|
|
ego = self.G.ego_subgraph(2)
|
|
self.assertIn(2, ego.nodes)
|
|
self.assertIn(1, ego.nodes)
|
|
self.assertIn(3, ego.nodes)
|
|
self.assertIn(4, ego.nodes)
|
|
|
|
def test_to_index_node_graph(self):
|
|
self.G.add_edges([("a", "b"), ("b", "c")])
|
|
G_index, index_of_node, node_of_index = self.G.to_index_node_graph()
|
|
self.assertEqual(len(G_index.nodes), 3)
|
|
self.assertTrue(all(isinstance(k, int) for k in G_index.nodes))
|
|
|
|
def test_directed_conversion(self):
|
|
self.G.add_edge(1, 2)
|
|
H = self.G.to_directed()
|
|
self.assertTrue(H.is_directed())
|
|
self.assertTrue(H.has_edge(1, 2))
|
|
self.assertTrue(H.has_edge(2, 1))
|
|
|
|
def test_clone_graph(self):
|
|
self.G.add_edges([(1, 2), (2, 3)])
|
|
G_clone = self.G.copy()
|
|
self.assertTrue(G_clone.has_edge(1, 2))
|
|
self.assertTrue(G_clone.has_edge(2, 3))
|
|
|
|
def test_degree(self):
|
|
self.G.add_edge(1, 2, weight=5)
|
|
deg = self.G.degree()
|
|
self.assertEqual(deg[1], 5)
|
|
self.assertEqual(deg[2], 5)
|
|
|
|
def test_size(self):
|
|
self.G.add_edges([(1, 2), (2, 3)])
|
|
self.assertEqual(self.G.size(), 2)
|
|
|
|
def test_edge_weight_default(self):
|
|
self.G.add_edge(4, 5)
|
|
self.assertEqual(self.G[4][5].get("weight", 1), 1)
|
|
|
|
def test_node_index_mappings(self):
|
|
self.G.add_nodes([10, 20, 30])
|
|
index2node = self.G.index2node
|
|
node_index = self.G.node_index
|
|
for i, node in index2node.items():
|
|
self.assertEqual(node_index[node], i)
|
|
|
|
def test_graph_order(self):
|
|
self.G.add_nodes([1, 2, 3])
|
|
self.assertEqual(self.G.order(), 3)
|
|
|
|
def test_graph_size_with_weight(self):
|
|
self.G.add_edges([(1, 2), (2, 3)], edges_attr=[{"weight": 4}, {"weight": 6}])
|
|
self.assertEqual(self.G.size(weight="weight"), 10.0)
|
|
|
|
def test_clear_cache(self):
|
|
self.G.add_edge(1, 2)
|
|
_ = self.G.edges
|
|
self.assertIn("edge", self.G.cache)
|
|
self.G._clear_cache()
|
|
self.assertEqual(len(self.G.cache), 0)
|