Mercurial > repos > shellac > sam_consensus_v3
comparison env/lib/python3.9/site-packages/networkx/classes/tests/test_digraph.py @ 0:4f3585e2f14b draft default tip
"planemo upload commit 60cee0fc7c0cda8592644e1aad72851dec82c959"
author | shellac |
---|---|
date | Mon, 22 Mar 2021 18:12:50 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:4f3585e2f14b |
---|---|
1 import pytest | |
2 | |
3 import networkx as nx | |
4 from networkx.testing import assert_nodes_equal | |
5 from .test_graph import BaseGraphTester, BaseAttrGraphTester | |
6 from .test_graph import TestGraph as _TestGraph | |
7 from .test_graph import TestEdgeSubgraph as _TestGraphEdgeSubgraph | |
8 | |
9 | |
10 class BaseDiGraphTester(BaseGraphTester): | |
11 def test_has_successor(self): | |
12 G = self.K3 | |
13 assert G.has_successor(0, 1) | |
14 assert not G.has_successor(0, -1) | |
15 | |
16 def test_successors(self): | |
17 G = self.K3 | |
18 assert sorted(G.successors(0)) == [1, 2] | |
19 with pytest.raises(nx.NetworkXError): | |
20 G.successors(-1) | |
21 | |
22 def test_has_predecessor(self): | |
23 G = self.K3 | |
24 assert G.has_predecessor(0, 1) | |
25 assert not G.has_predecessor(0, -1) | |
26 | |
27 def test_predecessors(self): | |
28 G = self.K3 | |
29 assert sorted(G.predecessors(0)) == [1, 2] | |
30 with pytest.raises(nx.NetworkXError): | |
31 G.predecessors(-1) | |
32 | |
33 def test_edges(self): | |
34 G = self.K3 | |
35 assert sorted(G.edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)] | |
36 assert sorted(G.edges(0)) == [(0, 1), (0, 2)] | |
37 assert sorted(G.edges([0, 1])) == [(0, 1), (0, 2), (1, 0), (1, 2)] | |
38 with pytest.raises(nx.NetworkXError): | |
39 G.edges(-1) | |
40 | |
41 def test_out_edges(self): | |
42 G = self.K3 | |
43 assert sorted(G.out_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)] | |
44 assert sorted(G.out_edges(0)) == [(0, 1), (0, 2)] | |
45 with pytest.raises(nx.NetworkXError): | |
46 G.out_edges(-1) | |
47 | |
48 def test_out_edges_dir(self): | |
49 G = self.P3 | |
50 assert sorted(G.out_edges()) == [(0, 1), (1, 2)] | |
51 assert sorted(G.out_edges(0)) == [(0, 1)] | |
52 assert sorted(G.out_edges(2)) == [] | |
53 | |
54 def test_out_edges_data(self): | |
55 G = nx.DiGraph([(0, 1, {"data": 0}), (1, 0, {})]) | |
56 assert sorted(G.out_edges(data=True)) == [(0, 1, {"data": 0}), (1, 0, {})] | |
57 assert sorted(G.out_edges(0, data=True)) == [(0, 1, {"data": 0})] | |
58 assert sorted(G.out_edges(data="data")) == [(0, 1, 0), (1, 0, None)] | |
59 assert sorted(G.out_edges(0, data="data")) == [(0, 1, 0)] | |
60 | |
61 def test_in_edges_dir(self): | |
62 G = self.P3 | |
63 assert sorted(G.in_edges()) == [(0, 1), (1, 2)] | |
64 assert sorted(G.in_edges(0)) == [] | |
65 assert sorted(G.in_edges(2)) == [(1, 2)] | |
66 | |
67 def test_in_edges_data(self): | |
68 G = nx.DiGraph([(0, 1, {"data": 0}), (1, 0, {})]) | |
69 assert sorted(G.in_edges(data=True)) == [(0, 1, {"data": 0}), (1, 0, {})] | |
70 assert sorted(G.in_edges(1, data=True)) == [(0, 1, {"data": 0})] | |
71 assert sorted(G.in_edges(data="data")) == [(0, 1, 0), (1, 0, None)] | |
72 assert sorted(G.in_edges(1, data="data")) == [(0, 1, 0)] | |
73 | |
74 def test_degree(self): | |
75 G = self.K3 | |
76 assert sorted(G.degree()) == [(0, 4), (1, 4), (2, 4)] | |
77 assert dict(G.degree()) == {0: 4, 1: 4, 2: 4} | |
78 assert G.degree(0) == 4 | |
79 assert list(G.degree(iter([0]))) == [(0, 4)] # run through iterator | |
80 | |
81 def test_in_degree(self): | |
82 G = self.K3 | |
83 assert sorted(G.in_degree()) == [(0, 2), (1, 2), (2, 2)] | |
84 assert dict(G.in_degree()) == {0: 2, 1: 2, 2: 2} | |
85 assert G.in_degree(0) == 2 | |
86 assert list(G.in_degree(iter([0]))) == [(0, 2)] # run through iterator | |
87 | |
88 def test_out_degree(self): | |
89 G = self.K3 | |
90 assert sorted(G.out_degree()) == [(0, 2), (1, 2), (2, 2)] | |
91 assert dict(G.out_degree()) == {0: 2, 1: 2, 2: 2} | |
92 assert G.out_degree(0) == 2 | |
93 assert list(G.out_degree(iter([0]))) == [(0, 2)] | |
94 | |
95 def test_size(self): | |
96 G = self.K3 | |
97 assert G.size() == 6 | |
98 assert G.number_of_edges() == 6 | |
99 | |
100 def test_to_undirected_reciprocal(self): | |
101 G = self.Graph() | |
102 G.add_edge(1, 2) | |
103 assert G.to_undirected().has_edge(1, 2) | |
104 assert not G.to_undirected(reciprocal=True).has_edge(1, 2) | |
105 G.add_edge(2, 1) | |
106 assert G.to_undirected(reciprocal=True).has_edge(1, 2) | |
107 | |
108 def test_reverse_copy(self): | |
109 G = nx.DiGraph([(0, 1), (1, 2)]) | |
110 R = G.reverse() | |
111 assert sorted(R.edges()) == [(1, 0), (2, 1)] | |
112 R.remove_edge(1, 0) | |
113 assert sorted(R.edges()) == [(2, 1)] | |
114 assert sorted(G.edges()) == [(0, 1), (1, 2)] | |
115 | |
116 def test_reverse_nocopy(self): | |
117 G = nx.DiGraph([(0, 1), (1, 2)]) | |
118 R = G.reverse(copy=False) | |
119 assert sorted(R.edges()) == [(1, 0), (2, 1)] | |
120 with pytest.raises(nx.NetworkXError): | |
121 R.remove_edge(1, 0) | |
122 | |
123 def test_reverse_hashable(self): | |
124 class Foo: | |
125 pass | |
126 | |
127 x = Foo() | |
128 y = Foo() | |
129 G = nx.DiGraph() | |
130 G.add_edge(x, y) | |
131 assert_nodes_equal(G.nodes(), G.reverse().nodes()) | |
132 assert [(y, x)] == list(G.reverse().edges()) | |
133 | |
134 | |
135 class BaseAttrDiGraphTester(BaseDiGraphTester, BaseAttrGraphTester): | |
136 def test_edges_data(self): | |
137 G = self.K3 | |
138 all_edges = [ | |
139 (0, 1, {}), | |
140 (0, 2, {}), | |
141 (1, 0, {}), | |
142 (1, 2, {}), | |
143 (2, 0, {}), | |
144 (2, 1, {}), | |
145 ] | |
146 assert sorted(G.edges(data=True)) == all_edges | |
147 assert sorted(G.edges(0, data=True)) == all_edges[:2] | |
148 assert sorted(G.edges([0, 1], data=True)) == all_edges[:4] | |
149 with pytest.raises(nx.NetworkXError): | |
150 G.edges(-1, True) | |
151 | |
152 def test_in_degree_weighted(self): | |
153 G = self.K3.copy() | |
154 G.add_edge(0, 1, weight=0.3, other=1.2) | |
155 assert sorted(G.in_degree(weight="weight")) == [(0, 2), (1, 1.3), (2, 2)] | |
156 assert dict(G.in_degree(weight="weight")) == {0: 2, 1: 1.3, 2: 2} | |
157 assert G.in_degree(1, weight="weight") == 1.3 | |
158 assert sorted(G.in_degree(weight="other")) == [(0, 2), (1, 2.2), (2, 2)] | |
159 assert dict(G.in_degree(weight="other")) == {0: 2, 1: 2.2, 2: 2} | |
160 assert G.in_degree(1, weight="other") == 2.2 | |
161 assert list(G.in_degree(iter([1]), weight="other")) == [(1, 2.2)] | |
162 | |
163 def test_out_degree_weighted(self): | |
164 G = self.K3.copy() | |
165 G.add_edge(0, 1, weight=0.3, other=1.2) | |
166 assert sorted(G.out_degree(weight="weight")) == [(0, 1.3), (1, 2), (2, 2)] | |
167 assert dict(G.out_degree(weight="weight")) == {0: 1.3, 1: 2, 2: 2} | |
168 assert G.out_degree(0, weight="weight") == 1.3 | |
169 assert sorted(G.out_degree(weight="other")) == [(0, 2.2), (1, 2), (2, 2)] | |
170 assert dict(G.out_degree(weight="other")) == {0: 2.2, 1: 2, 2: 2} | |
171 assert G.out_degree(0, weight="other") == 2.2 | |
172 assert list(G.out_degree(iter([0]), weight="other")) == [(0, 2.2)] | |
173 | |
174 | |
175 class TestDiGraph(BaseAttrDiGraphTester, _TestGraph): | |
176 """Tests specific to dict-of-dict-of-dict digraph data structure""" | |
177 | |
178 def setup_method(self): | |
179 self.Graph = nx.DiGraph | |
180 # build dict-of-dict-of-dict K3 | |
181 ed1, ed2, ed3, ed4, ed5, ed6 = ({}, {}, {}, {}, {}, {}) | |
182 self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed3, 2: ed4}, 2: {0: ed5, 1: ed6}} | |
183 self.k3edges = [(0, 1), (0, 2), (1, 2)] | |
184 self.k3nodes = [0, 1, 2] | |
185 self.K3 = self.Graph() | |
186 self.K3._adj = self.K3._succ = self.k3adj | |
187 self.K3._pred = {0: {1: ed3, 2: ed5}, 1: {0: ed1, 2: ed6}, 2: {0: ed2, 1: ed4}} | |
188 self.K3._node = {} | |
189 self.K3._node[0] = {} | |
190 self.K3._node[1] = {} | |
191 self.K3._node[2] = {} | |
192 | |
193 ed1, ed2 = ({}, {}) | |
194 self.P3 = self.Graph() | |
195 self.P3._adj = {0: {1: ed1}, 1: {2: ed2}, 2: {}} | |
196 self.P3._succ = self.P3._adj | |
197 self.P3._pred = {0: {}, 1: {0: ed1}, 2: {1: ed2}} | |
198 self.P3._node = {} | |
199 self.P3._node[0] = {} | |
200 self.P3._node[1] = {} | |
201 self.P3._node[2] = {} | |
202 | |
203 def test_data_input(self): | |
204 G = self.Graph({1: [2], 2: [1]}, name="test") | |
205 assert G.name == "test" | |
206 assert sorted(G.adj.items()) == [(1, {2: {}}), (2, {1: {}})] | |
207 assert sorted(G.succ.items()) == [(1, {2: {}}), (2, {1: {}})] | |
208 assert sorted(G.pred.items()) == [(1, {2: {}}), (2, {1: {}})] | |
209 | |
210 def test_add_edge(self): | |
211 G = self.Graph() | |
212 G.add_edge(0, 1) | |
213 assert G.adj == {0: {1: {}}, 1: {}} | |
214 assert G.succ == {0: {1: {}}, 1: {}} | |
215 assert G.pred == {0: {}, 1: {0: {}}} | |
216 G = self.Graph() | |
217 G.add_edge(*(0, 1)) | |
218 assert G.adj == {0: {1: {}}, 1: {}} | |
219 assert G.succ == {0: {1: {}}, 1: {}} | |
220 assert G.pred == {0: {}, 1: {0: {}}} | |
221 | |
222 def test_add_edges_from(self): | |
223 G = self.Graph() | |
224 G.add_edges_from([(0, 1), (0, 2, {"data": 3})], data=2) | |
225 assert G.adj == {0: {1: {"data": 2}, 2: {"data": 3}}, 1: {}, 2: {}} | |
226 assert G.succ == {0: {1: {"data": 2}, 2: {"data": 3}}, 1: {}, 2: {}} | |
227 assert G.pred == {0: {}, 1: {0: {"data": 2}}, 2: {0: {"data": 3}}} | |
228 | |
229 with pytest.raises(nx.NetworkXError): | |
230 G.add_edges_from([(0,)]) # too few in tuple | |
231 with pytest.raises(nx.NetworkXError): | |
232 G.add_edges_from([(0, 1, 2, 3)]) # too many in tuple | |
233 with pytest.raises(TypeError): | |
234 G.add_edges_from([0]) # not a tuple | |
235 | |
236 def test_remove_edge(self): | |
237 G = self.K3.copy() | |
238 G.remove_edge(0, 1) | |
239 assert G.succ == {0: {2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}} | |
240 assert G.pred == {0: {1: {}, 2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}} | |
241 with pytest.raises(nx.NetworkXError): | |
242 G.remove_edge(-1, 0) | |
243 | |
244 def test_remove_edges_from(self): | |
245 G = self.K3.copy() | |
246 G.remove_edges_from([(0, 1)]) | |
247 assert G.succ == {0: {2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}} | |
248 assert G.pred == {0: {1: {}, 2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}} | |
249 G.remove_edges_from([(0, 0)]) # silent fail | |
250 | |
251 def test_clear(self): | |
252 G = self.K3 | |
253 G.graph["name"] = "K3" | |
254 G.clear() | |
255 assert list(G.nodes) == [] | |
256 assert G.succ == {} | |
257 assert G.pred == {} | |
258 assert G.graph == {} | |
259 | |
260 def test_clear_edges(self): | |
261 G = self.K3 | |
262 G.graph["name"] = "K3" | |
263 nodes = list(G.nodes) | |
264 G.clear_edges() | |
265 assert list(G.nodes) == nodes | |
266 expected = {0: {}, 1: {}, 2: {}} | |
267 assert G.succ == expected | |
268 assert G.pred == expected | |
269 assert list(G.edges) == [] | |
270 assert G.graph["name"] == "K3" | |
271 | |
272 | |
273 class TestEdgeSubgraph(_TestGraphEdgeSubgraph): | |
274 """Unit tests for the :meth:`DiGraph.edge_subgraph` method.""" | |
275 | |
276 def setup_method(self): | |
277 # Create a doubly-linked path graph on five nodes. | |
278 G = nx.DiGraph(nx.path_graph(5)) | |
279 # Add some node, edge, and graph attributes. | |
280 for i in range(5): | |
281 G.nodes[i]["name"] = f"node{i}" | |
282 G.edges[0, 1]["name"] = "edge01" | |
283 G.edges[3, 4]["name"] = "edge34" | |
284 G.graph["name"] = "graph" | |
285 # Get the subgraph induced by the first and last edges. | |
286 self.G = G | |
287 self.H = G.edge_subgraph([(0, 1), (3, 4)]) | |
288 | |
289 def test_pred_succ(self): | |
290 """Test that nodes are added to predecessors and successors. | |
291 | |
292 For more information, see GitHub issue #2370. | |
293 | |
294 """ | |
295 G = nx.DiGraph() | |
296 G.add_edge(0, 1) | |
297 H = G.edge_subgraph([(0, 1)]) | |
298 assert list(H.predecessors(0)) == [] | |
299 assert list(H.successors(0)) == [1] | |
300 assert list(H.predecessors(1)) == [0] | |
301 assert list(H.successors(1)) == [] |