← Back to branch summary

~ubuntu-branches/ubuntu/utopic/python-networkx/utopic

« back to all changes in this revision

Viewing changes to networkx/classes/tests/test_multidigraph.py

  • Committer: Bazaar Package Importer
  • Author(s): Cyril Brulebois
  • Date: 2009-11-23 15:44:34 UTC
  • mfrom: (1.2.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20091123154434-ellm2ut3a4edf9wh
Tags: 1.0~rc1~svn1492-1
http://bugs.debian.org/549996
http://bugs.debian.org/539942
* New upstream snapshot, past 1.0~rc1, as requested by Yaroslav
  Halchenko (Closes: #549996).
* Refresh patch accordingly:
   + debian/patches/10_doc_relocation.
* Get rid of extra LICENSE.txt file in /usr/share/doc.
* Use dh_compress -Xexamples/ to avoid compressing examples, thanks to
  Sandro Tosi (Closes: #539942).
* Bump Standards-Version from 3.8.0 to 3.8.3 (no changes needed).

Show diffs side-by-side

added added

removed removed

Lines of Context:
networkx/classes/tests/test_multidigraph.py
5
5
import networkx
6
6
from test_multigraph import TestMultiGraph
7
7
 
8
 
 
9
8
class TestMultiDiGraph(TestMultiGraph):
10
9
    def setUp(self):
11
10
        self.Graph=networkx.MultiDiGraph
12
11
        # build K3
13
 
        self.k3adj={0: {1: [1], 2: [1]}, 
14
 
                    1: {0: [1], 2: [1]}, 
15
 
                    2: {0: [1], 1: [1]}}
16
12
        self.k3edges=[(0, 1), (0, 2), (1, 2)]
17
13
        self.k3nodes=[0, 1, 2]
18
14
        self.K3=self.Graph()
19
 
        self.K3.adj=self.k3adj
20
 
        self.K3.pred=copy.deepcopy(self.k3adj)
21
 
        self.K3.succ=self.k3adj
22
 
 
23
 
 
24
 
    def test_data_input(self):
25
 
        G=self.Graph(data={1:[2],2:[1]}, name="test")
26
 
        assert_equal(G.name,"test")
27
 
        assert_equal(sorted(G.adj.items()),[(1, {2: [1]}), (2, {1: [1]})])
28
 
        assert_equal(sorted(G.succ.items()),[(1, {2: [1]}), (2, {1: [1]})])
29
 
        assert_equal(sorted(G.pred.items()),[(1, {2: [1]}), (2, {1: [1]})])
 
15
        self.K3.adj={0:{},1:{},2:{}}
 
16
        self.K3.succ=self.K3.adj
 
17
        self.K3.pred={0:{},1:{},2:{}}
 
18
        for u in self.k3nodes:
 
19
            for v in self.k3nodes:
 
20
                if u==v: continue
 
21
                d={0:{}}
 
22
                self.K3.succ[u][v]=d
 
23
                self.K3.pred[v][u]=d
 
24
        self.K3.adj=self.K3.succ
 
25
        self.K3.edge=self.K3.adj
 
26
        self.K3.node={}
 
27
        self.K3.node[0]={}
 
28
        self.K3.node[1]={}
 
29
        self.K3.node[2]={}
 
30
 
 
31
 
 
32
 
 
33
#     def test_data_input(self):
 
34
#         G=self.Graph(data={1:[2],2:[1]}, name="test")
 
35
#         assert_equal(G.name,"test")
 
36
#         assert_equal(sorted(G.adj.items()),[(1, {2: [1]}), (2, {1: [1]})])
 
37
#         assert_equal(sorted(G.succ.items()),[(1, {2: [1]}), (2, {1: [1]})])
 
38
#         assert_equal(sorted(G.pred.items()),[(1, {2: [1]}), (2, {1: [1]})])
30
39
 
31
40
 
32
41
    def test_add_edge(self):
33
42
        G=self.Graph()
34
43
        G.add_edge(0,1)
35
 
        assert_equal(G.adj,{0: {1: [1]}, 1: {}})
36
 
        assert_equal(G.succ,{0: {1: [1]}, 1: {}})
37
 
        assert_equal(G.pred,{0: {}, 1: {0:[1]}})
 
44
        assert_equal(G.adj,{0: {1: {0:{}}}, 1: {}})
 
45
        assert_equal(G.succ,{0: {1: {0:{}}}, 1: {}})
 
46
        assert_equal(G.pred,{0: {}, 1: {0:{0:{}}}})
38
47
        G=self.Graph()
39
48
        G.add_edge(*(0,1))
40
 
        assert_equal(G.adj,{0: {1: [1]}, 1: {}})
41
 
        assert_equal(G.succ,{0: {1: [1]}, 1: {}})
42
 
        assert_equal(G.pred,{0: {}, 1: {0:[1]}})
43
 
 
44
 
 
45
 
    
 
49
        assert_equal(G.adj,{0: {1: {0:{}}}, 1: {}})
 
50
        assert_equal(G.succ,{0: {1: {0:{}}}, 1: {}})
 
51
        assert_equal(G.pred,{0: {}, 1: {0:{0:{}}}})
 
52
 
 
53
 
 
54
 
46
55
    def test_add_edges_from(self):
47
56
        G=self.Graph()
48
 
        G.add_edges_from([(0,1)])
49
 
        assert_equal(G.adj,{0: {1: [1]}, 1: {}})
50
 
        assert_equal(G.succ,{0: {1: [1]}, 1: {}})
51
 
        assert_equal(G.pred,{0: {}, 1: {0:[1]}})
 
57
        G.add_edges_from([(0,1),(0,1,{'weight':3})])
 
58
        assert_equal(G.adj,{0: {1: {0:{},1:{'weight':3}}}, 1: {}})
 
59
        assert_equal(G.succ,{0: {1: {0:{},1:{'weight':3}}}, 1: {}})
 
60
        assert_equal(G.pred,{0: {}, 1: {0:{0:{},1:{'weight':3}}}})
 
61
 
 
62
        G.add_edges_from([(0,1),(0,1,{'weight':3})],weight=2)
 
63
        assert_equal(G.succ,{0: {1: {0:{},
 
64
                                     1:{'weight':3},
 
65
                                     2:{'weight':2},
 
66
                                     3:{'weight':3}}}, 
 
67
                             1: {}})
 
68
        assert_equal(G.pred,{0: {}, 1: {0:{0:{},1:{'weight':3},
 
69
                                           2:{'weight':2},
 
70
                                           3:{'weight':3}}}})
 
71
 
 
72
        assert_raises(networkx.NetworkXError, G.add_edges_from,[(0,)])  # too few in tuple
 
73
        assert_raises(networkx.NetworkXError, G.add_edges_from,[(0,1,2,3,4)])  # too many in tuple
 
74
        assert_raises(TypeError, G.add_edges_from,[0])  # not a tuple
52
75
 
53
76
 
54
77
    def test_remove_edge(self):
55
78
        G=self.K3
56
79
        G.remove_edge(0,1)
57
 
        assert_equal(G.succ,{0:{2:[1]},1:{0:[1],2:[1]},2:{0:[1],1:[1]}})        
58
 
        assert_equal(G.pred,{0:{1:[1], 2:[1]}, 1:{2:[1]}, 2:{0:[1],1:[1]}})
59
 
        assert_raises((KeyError,networkx.NetworkXError), G.remove_edge,-1,0)
60
 
 
 
80
        assert_equal(G.succ,{0:{2:{0:{}}},
 
81
                             1:{0:{0:{}},2:{0:{}}},
 
82
                             2:{0:{0:{}},1:{0:{}}}})        
 
83
        assert_equal(G.pred,{0:{1:{0:{}}, 2:{0:{}}}, 
 
84
                             1:{2:{0:{}}}, 
 
85
                             2:{0:{0:{}},1:{0:{}}}})
 
86
        assert_raises((KeyError,networkx.NetworkXError), G.remove_edge,-1,0)
 
87
 
 
88
    def test_remove_multiedge(self):
 
89
        G=self.K3
 
90
        G.add_edge(0,1,key='parallel edge')
 
91
        G.remove_edge(0,1,key='parallel edge')
 
92
        assert_equal(G.adj,{0: {1: {0:{}}, 2: {0:{}}}, 
 
93
                           1: {0: {0:{}}, 2: {0:{}}},
 
94
                           2: {0: {0:{}}, 1: {0:{}}}})
 
95
 
 
96
        assert_equal(G.succ,{0: {1: {0:{}}, 2: {0:{}}}, 
 
97
                           1: {0: {0:{}}, 2: {0:{}}},
 
98
                           2: {0: {0:{}}, 1: {0:{}}}})
 
99
 
 
100
        assert_equal(G.pred,{0:{1: {0:{}},2:{0:{}}},
 
101
                             1:{0:{0:{}},2:{0:{}}},
 
102
                             2:{0:{0:{}},1:{0:{}}}})
 
103
        G.remove_edge(0,1)
 
104
        assert_equal(G.succ,{0:{2:{0:{}}},
 
105
                             1:{0:{0:{}},2:{0:{}}},
 
106
                             2:{0:{0:{}},1:{0:{}}}})        
 
107
        assert_equal(G.pred,{0:{1:{0:{}}, 2:{0:{}}}, 
 
108
                             1:{2:{0:{}}}, 
 
109
                             2:{0:{0:{}},1:{0:{}}}})
 
110
        assert_raises((KeyError,networkx.NetworkXError), G.remove_edge,-1,0)
61
111
 
62
112
    def test_remove_edges_from(self):
63
113
        G=self.K3
64
114
        G.remove_edges_from([(0,1)])
65
 
        assert_equal(G.succ,{0:{2:[1]},1:{0:[1],2:[1]},2:{0:[1],1:[1]}})        
66
 
        assert_equal(G.pred,{0:{1:[1], 2:[1]}, 1:{2:[1]}, 2:{0:[1],1:[1]}})
 
115
        assert_equal(G.succ,{0:{2:{0:{}}},
 
116
                             1:{0:{0:{}},2:{0:{}}},
 
117
                             2:{0:{0:{}},1:{0:{}}}})        
 
118
        assert_equal(G.pred,{0:{1:{0:{}}, 2:{0:{}}}, 
 
119
                             1:{2:{0:{}}}, 
 
120
                             2:{0:{0:{}},1:{0:{}}}})
67
121
        G.remove_edges_from([(0,0)]) # silent fail
68
122
 
69
123
 
70
124
    def test_edges(self):
71
125
        G=self.K3
 
126
        print self.K3.adj
72
127
        assert_equal(sorted(G.edges()),[(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
73
128
        assert_equal(sorted(G.edges(0)),[(0,1),(0,2)])
 
129
        assert_raises((KeyError,networkx.NetworkXError), G.edges,-1)
 
130
 
 
131
    def test_edges_data(self):
 
132
        G=self.K3
 
133
        assert_equal(sorted(G.edges(data=True)),
 
134
                     [(0,1,{}),(0,2,{}),(1,0,{}),(1,2,{}),(2,0,{}),(2,1,{})])
 
135
        assert_equal(sorted(G.edges(0,data=True)),[(0,1,{}),(0,2,{})])
74
136
        assert_raises((KeyError,networkx.NetworkXError), G.neighbors,-1)
75
137
 
76
138
 
77
139
    def test_edges_iter(self):
78
140
        G=self.K3
79
 
        assert_equal(sorted(G.edges()),[(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
141
        assert_equal(sorted(G.edges_iter()),
 
142
                     [(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
80
143
        assert_equal(sorted(G.edges_iter(0)),[(0,1),(0,2)])
81
 
        assert_raises((KeyError,networkx.NetworkXError), G.neighbors_iter,-1)
82
 
        G.add_edge(0,1,2)
83
 
        assert_equal(sorted(G.edges(data=True)),[(0,1,1),(0,1,2),(0,2,1),(1,0,1),(1,2,1),(2,0,1),(2,1,1)])
84
 
 
85
 
 
86
 
    def test_copy(self):
87
 
        G=self.K3
88
 
        H=G.copy()
89
 
        assert_equal(G.succ,H.succ)
90
 
        assert_equal(G.pred,H.pred)
91
 
 
92
 
    def test_to_directed(self):
93
 
        G=self.K3
94
 
        H=networkx.MultiDiGraph(G)
95
 
        assert_equal(G.pred,H.pred)
96
 
        assert_equal(G.succ,H.succ)
97
 
        H=G.to_directed()
98
 
        assert_equal(G.pred,H.pred)
99
 
        assert_equal(G.succ,H.succ)
 
144
        G.add_edge(0,1)
 
145
        assert_equal(sorted(G.edges_iter()),
 
146
                     [(0,1),(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
147
 
 
148
 
 
149
 
 
150
    def test_out_edges(self):
 
151
        G=self.K3
 
152
        assert_equal(sorted(G.out_edges()),
 
153
                     [(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
154
        assert_equal(sorted(G.out_edges(0)),[(0,1),(0,2)])
 
155
        assert_raises((KeyError,networkx.NetworkXError), G.out_edges,-1)
 
156
 
 
157
 
 
158
    def test_out_edges_iter(self):
 
159
        G=self.K3
 
160
        assert_equal(sorted(G.out_edges_iter()),
 
161
                     [(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
162
        assert_equal(sorted(G.out_edges_iter(0)),[(0,1),(0,2)])
 
163
        G.add_edge(0,1,2)
 
164
        assert_equal(sorted(G.out_edges_iter()),
 
165
                     [(0,1),(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
166
 
 
167
    def test_in_edges(self):
 
168
        G=self.K3
 
169
        assert_equal(sorted(G.in_edges()),
 
170
                     [(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
171
        assert_equal(sorted(G.in_edges(0)),[(1,0),(2,0)])
 
172
        assert_raises((KeyError,networkx.NetworkXError), G.in_edges,-1)
 
173
        G.add_edge(0,1,2)
 
174
        assert_equal(sorted(G.in_edges()),
 
175
                     [(0,1),(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
176
 
 
177
 
 
178
 
 
179
    def test_in_edges_iter(self):
 
180
        G=self.K3
 
181
        assert_equal(sorted(G.in_edges_iter()),
 
182
                     [(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
183
        assert_equal(sorted(G.in_edges_iter(0)),[(1,0),(2,0)])
 
184
        G.add_edge(0,1,2)
 
185
        assert_equal(sorted(G.in_edges_iter()),
 
186
                     [(0,1),(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
187
 
 
188
    def is_shallow(self,H,G):
 
189
        # graph
 
190
        assert_equal(G.graph['foo'],H.graph['foo'])
 
191
        G.graph['foo'].append(1)
 
192
        assert_equal(G.graph['foo'],H.graph['foo'])
 
193
        # node
 
194
        assert_equal(G.node[0]['foo'],H.node[0]['foo'])
 
195
        G.node[0]['foo'].append(1)
 
196
        assert_equal(G.node[0]['foo'],H.node[0]['foo'])
 
197
        # edge
 
198
        assert_equal(G[1][2][0]['foo'],H[1][2][0]['foo'])
 
199
        G[1][2][0]['foo'].append(1)
 
200
        assert_equal(G[1][2][0]['foo'],H[1][2][0]['foo'])
 
201
 
 
202
    def is_deep(self,H,G):
 
203
        # graph
 
204
        assert_equal(G.graph['foo'],H.graph['foo'])
 
205
        G.graph['foo'].append(1)
 
206
        assert_not_equal(G.graph['foo'],H.graph['foo'])
 
207
        # node
 
208
        assert_equal(G.node[0]['foo'],H.node[0]['foo'])
 
209
        G.node[0]['foo'].append(1)
 
210
        assert_not_equal(G.node[0]['foo'],H.node[0]['foo'])
 
211
        # edge
 
212
        assert_equal(G[1][2][0]['foo'],H[1][2][0]['foo'])
 
213
        G[1][2][0]['foo'].append(1)
 
214
        assert_not_equal(G[1][2][0]['foo'],H[1][2][0]['foo'])
100
215
 
101
216
    def test_to_undirected(self):
 
217
        # MultiDiGraph -> MultiGraph changes number of edges so it is 
 
218
        # not a copy operation... use is_shallow, not is_shallow_copy
102
219
        G=self.K3
 
220
        self.add_attributes(G)
103
221
        H=networkx.MultiGraph(G)
104
 
        assert_equal(G.adj,H.adj)
 
222
        self.is_shallow(H,G)
 
223
        H=G.to_undirected()
 
224
        self.is_deep(H,G)
105
225
 
106
226
    def test_has_successor(self):
107
227
        G=self.K3