← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python-networkx/trusty-proposed

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Cyril Brulebois
  • Date: 2009-02-28 13:36:24 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090228133624-9l5rwi1ftlzc7b0l
http://bugs.debian.org/517065
* Upload to unstable now that lenny is released (yay).
* Fix FTBFS with python-support 0.90.3: no longer rely on its internal
  behaviour, and xnow set tests/test.py executable right after “setup.py
  install” (Closes: #517065).
* Drop executable bits from bz2 files.
* Update Vcs-* fields: move from DPMT's svn to collab-maint's git.
* Remote DPMT from Uploaders, following Piotr Ożarowski's request.

Show diffs side-by-side

added added

removed removed

Lines of Context:
networkx/classes/tests/test_digraph.py
 
1
#!/usr/bin/env python
 
2
import copy
 
3
import unittest
 
4
from nose.tools import *
 
5
import networkx
 
6
from test_graph import TestGraph
 
7
 
 
8
class TestDiGraph(TestGraph):
 
9
 
 
10
    def setUp(self):
 
11
        self.Graph=networkx.DiGraph
 
12
        # build K3
 
13
        self.k3adj={0: {1: 1, 2: 1}, 1: {0: 1, 2: 1}, 2: {0: 1, 1: 1}}
 
14
        self.k3edges=[(0, 1), (0, 2), (1, 2)]
 
15
        self.k3nodes=[0, 1, 2]
 
16
        self.K3=self.Graph()
 
17
        self.K3.adj=self.k3adj
 
18
        self.K3.succ=self.k3adj
 
19
        self.K3.pred=copy.deepcopy(self.k3adj)
 
20
 
 
21
 
 
22
    def test_data_input(self):
 
23
        G=self.Graph(data={1:[2],2:[1]}, name="test")
 
24
        assert_equal(G.name,"test")
 
25
        assert_equal(sorted(G.adj.items()),[(1, {2: 1}), (2, {1: 1})])
 
26
        assert_equal(sorted(G.succ.items()),[(1, {2: 1}), (2, {1: 1})])
 
27
        assert_equal(sorted(G.pred.items()),[(1, {2: 1}), (2, {1: 1})])
 
28
 
 
29
 
 
30
    def test_add_edge(self):
 
31
        G=self.Graph()
 
32
        G.add_edge(0,1)
 
33
        assert_equal(G.adj,{0: {1: 1}, 1: {}})
 
34
        assert_equal(G.succ,{0: {1: 1}, 1: {}})
 
35
        assert_equal(G.pred,{0: {}, 1: {0:1}})
 
36
        G=self.Graph()
 
37
        G.add_edge(*(0,1))
 
38
        assert_equal(G.adj,{0: {1: 1}, 1: {}})
 
39
        assert_equal(G.succ,{0: {1: 1}, 1: {}})
 
40
        assert_equal(G.pred,{0: {}, 1: {0:1}})
 
41
 
 
42
    
 
43
    def test_add_edges_from(self):
 
44
        G=self.Graph()
 
45
        G.add_edges_from([(0,1)])
 
46
        assert_equal(G.adj,{0: {1: 1}, 1: {}})
 
47
        assert_equal(G.succ,{0: {1: 1}, 1: {}})
 
48
        assert_equal(G.pred,{0: {}, 1: {0:1}})
 
49
 
 
50
 
 
51
    def test_remove_edge(self):
 
52
        G=self.K3
 
53
        G.remove_edge(0,1)
 
54
        assert_equal(G.succ,{0:{2:1},1:{0:1,2:1},2:{0:1,1:1}})        
 
55
        assert_equal(G.pred,{0:{1:1, 2:1}, 1:{2:1}, 2:{0:1,1: 1}})
 
56
        assert_raises((KeyError,networkx.NetworkXError), G.remove_edge,-1,0)
 
57
 
 
58
 
 
59
    def test_remove_edges_from(self):
 
60
        G=self.K3
 
61
        G.remove_edges_from([(0,1)])
 
62
        assert_equal(G.succ,{0:{2:1},1:{0:1,2:1},2:{0:1,1:1}})        
 
63
        assert_equal(G.pred,{0:{1:1, 2:1}, 1:{2:1}, 2:{0:1,1: 1}})
 
64
        G.remove_edges_from([(0,0)]) # silent fail
 
65
 
 
66
 
 
67
    def test_copy(self):
 
68
        G=self.K3
 
69
        H=G.copy()
 
70
        assert_equal(G.succ,H.succ)
 
71
        assert_equal(G.pred,H.pred)
 
72
        H=G.__class__(G) # just copy
 
73
        assert_equal(G.succ,H.succ)
 
74
        assert_equal(G.pred,H.pred)
 
75
 
 
76
    def test_to_directed(self):
 
77
        G=self.K3
 
78
        H=networkx.DiGraph(G)
 
79
        assert_equal(G.pred,H.pred)
 
80
        assert_equal(G.succ,H.succ)
 
81
        H=G.to_directed()
 
82
        assert_equal(G.pred,H.pred)
 
83
        assert_equal(G.succ,H.succ)
 
84
 
 
85
    def test_to_undirected(self):
 
86
        # this test only works because it is a complete graph.  need more tests.
 
87
        G=self.K3
 
88
        H=networkx.Graph(G)
 
89
        assert_equal(G.adj,H.adj)
 
90
        H=G.to_undirected()
 
91
        assert_equal(G.adj,H.adj)
 
92
 
 
93
    def test_has_successor(self):
 
94
        G=self.K3
 
95
        assert_equal(G.has_successor(0,1),True)
 
96
        assert_equal(G.has_successor(0,-1),False)
 
97
 
 
98
    def test_successors(self):
 
99
        G=self.K3
 
100
        assert_equal(sorted(G.successors(0)),[1,2])
 
101
        assert_raises((KeyError,networkx.NetworkXError), G.successors,-1)
 
102
 
 
103
    def test_successors_iter(self):
 
104
        G=self.K3
 
105
        assert_equal(sorted(G.successors_iter(0)),[1,2])
 
106
        assert_raises((KeyError,networkx.NetworkXError), G.successors_iter,-1)
 
107
 
 
108
    def test_has_predecessor(self):
 
109
        G=self.K3
 
110
        assert_equal(G.has_predecessor(0,1),True)
 
111
        assert_equal(G.has_predecessor(0,-1),False)
 
112
 
 
113
    def test_predecessors(self):
 
114
        G=self.K3
 
115
        assert_equal(sorted(G.predecessors(0)),[1,2])
 
116
        assert_raises((KeyError,networkx.NetworkXError), G.predecessors,-1)
 
117
 
 
118
    def test_predecessors_iter(self):
 
119
        G=self.K3
 
120
        assert_equal(sorted(G.predecessors_iter(0)),[1,2])
 
121
        assert_raises((KeyError,networkx.NetworkXError), G.predecessors_iter,-1)
 
122
 
 
123
 
 
124
    def test_edges(self):
 
125
        G=self.K3
 
126
        assert_equal(sorted(G.edges()),[(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
127
        assert_equal(sorted(G.edges(0)),[(0,1),(0,2)])
 
128
        assert_raises((KeyError,networkx.NetworkXError), G.neighbors,-1)
 
129
 
 
130
    def test_edges_iter(self):
 
131
        G=self.K3
 
132
        assert_equal(sorted(G.edges()),[(0,1),(0,2),(1,0),(1,2),(2,0),(2,1)])
 
133
        assert_equal(sorted(G.edges_iter(0)),[(0,1),(0,2)])
 
134
        assert_raises((KeyError,networkx.NetworkXError), G.neighbors_iter,-1)
 
135
 
 
136
 
 
137
    def test_degree(self):
 
138
        G=self.K3
 
139
        assert_equal(G.degree(),[4,4,4])
 
140
        assert_equal(G.degree(with_labels=True),{0:4,1:4,2:4})
 
141
        assert_equal(G.degree(0),4)
 
142
        assert_equal(G.degree(0,with_labels=True),{0:4})
 
143
        assert_raises((KeyError,networkx.NetworkXError), G.degree,-1)
 
144
 
 
145
    def test_degree_iter(self):
 
146
        G=self.K3
 
147
        assert_equal(list(G.degree_iter()),[(0,4),(1,4),(2,4)])
 
148
        assert_equal(dict(G.degree_iter()),{0:4,1:4,2:4})
 
149
        assert_equal(list(G.degree_iter(0)),[(0,4)])
 
150
 
 
151
 
 
152
    def test_in_degree(self):
 
153
        G=self.K3
 
154
        assert_equal(G.in_degree(),[2,2,2])
 
155
        assert_equal(G.in_degree(with_labels=True),{0:2,1:2,2:2})
 
156
        assert_equal(G.in_degree(0),2)
 
157
        assert_equal(G.in_degree(0,with_labels=True),{0:2})
 
158
        assert_raises((KeyError,networkx.NetworkXError), G.in_degree,-1)
 
159
 
 
160
    def test_in_degree_iter(self):
 
161
        G=self.K3
 
162
        assert_equal(list(G.in_degree_iter()),[(0,2),(1,2),(2,2)])
 
163
        assert_equal(dict(G.in_degree_iter()),{0:2,1:2,2:2})
 
164
        assert_equal(list(G.in_degree_iter(0)),[(0,2)])
 
165
 
 
166
    def test_out_degree(self):
 
167
        G=self.K3
 
168
        assert_equal(G.out_degree(),[2,2,2])
 
169
        assert_equal(G.out_degree(with_labels=True),{0:2,1:2,2:2})
 
170
        assert_equal(G.out_degree(0),2)
 
171
        assert_equal(G.out_degree(0,with_labels=True),{0:2})
 
172
        assert_raises((KeyError,networkx.NetworkXError), G.out_degree,-1)
 
173
 
 
174
    def test_out_degree_iter(self):
 
175
        G=self.K3
 
176
        assert_equal(list(G.out_degree_iter()),[(0,2),(1,2),(2,2)])
 
177
        assert_equal(dict(G.out_degree_iter()),{0:2,1:2,2:2})
 
178
        assert_equal(list(G.out_degree_iter(0)),[(0,2)])
 
179
 
 
180
 
 
181
    def test_size(self):
 
182
        G=self.K3
 
183
        assert_equal(G.size(),6)
 
184
        assert_equal(G.number_of_edges(),6)
 
185