« back to all changes in this revision
Viewing changes to testing/lazytest.py
- browse files at revision 304
- compare with another revision
- download diff
- download tarball
- view history from revision 304
- Committer: loafman
- Date: 2008-09-09 19:57:46 UTC
- Revision ID: vcs-imports@canonical.com-20080909195746-9rbllpdu8ngitq2n
Untabify all files. To compare against previous
versions use 'cvs diff -w' or 'diff -w'.
versions use 'cvs diff -w' or 'diff -w'.
- files modified:
- CHANGELOG
added
removed
testing/lazytest.py
6
6
config.setup()
7
7
8
8
class Iterators(unittest.TestCase):
9
one_to_100 = lambda s: iter(range(1, 101))
10
evens = lambda s: iter(range(2, 101, 2))
11
odds = lambda s: iter(range(1, 100, 2))
12
empty = lambda s: iter([])
13
14
def __init__(self, *args):
15
apply (unittest.TestCase.__init__, (self,) + args)
16
self.falseerror = self.falseerror_maker()
17
self.trueerror = self.trueerror_maker()
18
self.emptygen = self.emptygen_maker()
19
self.typeerror = self.typeerror_maker()
20
self.nameerror = self.nameerror_maker()
21
22
def falseerror_maker(self):
23
yield None
24
yield 0
25
yield []
26
raise Exception
27
28
def trueerror_maker(self):
29
yield 1
30
yield "hello"
31
yield (2, 3)
32
raise Exception
33
34
def nameerror_maker(self):
35
if 0: yield 1
36
raise NameError
37
38
def typeerror_maker(self):
39
yield 1
40
yield 2
41
raise TypeError
42
43
def alwayserror(self, x):
44
raise Exception
45
46
def emptygen_maker(self):
47
if 0: yield 1
9
one_to_100 = lambda s: iter(range(1, 101))
10
evens = lambda s: iter(range(2, 101, 2))
11
odds = lambda s: iter(range(1, 100, 2))
12
empty = lambda s: iter([])
13
14
def __init__(self, *args):
15
apply (unittest.TestCase.__init__, (self,) + args)
16
self.falseerror = self.falseerror_maker()
17
self.trueerror = self.trueerror_maker()
18
self.emptygen = self.emptygen_maker()
19
self.typeerror = self.typeerror_maker()
20
self.nameerror = self.nameerror_maker()
21
22
def falseerror_maker(self):
23
yield None
24
yield 0
25
yield []
26
raise Exception
27
28
def trueerror_maker(self):
29
yield 1
30
yield "hello"
31
yield (2, 3)
32
raise Exception
33
34
def nameerror_maker(self):
35
if 0: yield 1
36
raise NameError
37
38
def typeerror_maker(self):
39
yield 1
40
yield 2
41
raise TypeError
42
43
def alwayserror(self, x):
44
raise Exception
45
46
def emptygen_maker(self):
47
if 0: yield 1
48
48
49
49
50
50
class IterEqualTestCase(Iterators):
51
"""Tests for iter_equal function"""
52
def testEmpty(self):
53
"""Empty iterators should be equal"""
54
assert Iter.equal(self.empty(), iter([]))
55
56
def testNormal(self):
57
"""See if normal iterators are equal"""
58
assert Iter.equal(iter((1,2,3)), iter((1,2,3)))
59
assert Iter.equal(self.odds(), iter(range(1, 100, 2)))
60
assert Iter.equal(iter((1,2,3)), iter(range(1, 4)))
61
62
def testNormalInequality(self):
63
"""See if normal unequals work"""
64
assert not Iter.equal(iter((1,2,3)), iter((1,2,4)))
65
assert not Iter.equal(self.odds(), iter(["hello", "there"]))
66
67
def testGenerators(self):
68
"""equals works for generators"""
69
def f():
70
yield 1
71
yield "hello"
72
def g():
73
yield 1
74
yield "hello"
75
assert Iter.equal(f(), g())
76
77
def testLength(self):
78
"""Differently sized iterators"""
79
assert not Iter.equal(iter((1,2,3)), iter((1,2)))
80
assert not Iter.equal(iter((1,2)), iter((1,2,3)))
51
"""Tests for iter_equal function"""
52
def testEmpty(self):
53
"""Empty iterators should be equal"""
54
assert Iter.equal(self.empty(), iter([]))
55
56
def testNormal(self):
57
"""See if normal iterators are equal"""
58
assert Iter.equal(iter((1,2,3)), iter((1,2,3)))
59
assert Iter.equal(self.odds(), iter(range(1, 100, 2)))
60
assert Iter.equal(iter((1,2,3)), iter(range(1, 4)))
61
62
def testNormalInequality(self):
63
"""See if normal unequals work"""
64
assert not Iter.equal(iter((1,2,3)), iter((1,2,4)))
65
assert not Iter.equal(self.odds(), iter(["hello", "there"]))
66
67
def testGenerators(self):
68
"""equals works for generators"""
69
def f():
70
yield 1
71
yield "hello"
72
def g():
73
yield 1
74
yield "hello"
75
assert Iter.equal(f(), g())
76
77
def testLength(self):
78
"""Differently sized iterators"""
79
assert not Iter.equal(iter((1,2,3)), iter((1,2)))
80
assert not Iter.equal(iter((1,2)), iter((1,2,3)))
81
81
82
82
83
83
class FilterTestCase(Iterators):
84
"""Tests for lazy_filter function"""
85
def testEmpty(self):
86
"""empty iterators -> empty iterators"""
87
assert Iter.empty(Iter.filter(self.alwayserror,
88
self.empty())), \
89
"Filtering an empty iterator should result in empty iterator"
90
91
def testNum1(self):
92
"""Test numbers 1 - 100 #1"""
93
assert Iter.equal(Iter.filter(lambda x: x % 2 == 0,
94
self.one_to_100()),
95
self.evens())
96
assert Iter.equal(Iter.filter(lambda x: x % 2,
97
self.one_to_100()),
98
self.odds())
99
100
def testError(self):
101
"""Should raise appropriate error"""
102
i = Iter.filter(lambda x: x, self.falseerror_maker())
103
self.assertRaises(Exception, i.next)
84
"""Tests for lazy_filter function"""
85
def testEmpty(self):
86
"""empty iterators -> empty iterators"""
87
assert Iter.empty(Iter.filter(self.alwayserror,
88
self.empty())), \
89
"Filtering an empty iterator should result in empty iterator"
90
91
def testNum1(self):
92
"""Test numbers 1 - 100 #1"""
93
assert Iter.equal(Iter.filter(lambda x: x % 2 == 0,
94
self.one_to_100()),
95
self.evens())
96
assert Iter.equal(Iter.filter(lambda x: x % 2,
97
self.one_to_100()),
98
self.odds())
99
100
def testError(self):
101
"""Should raise appropriate error"""
102
i = Iter.filter(lambda x: x, self.falseerror_maker())
103
self.assertRaises(Exception, i.next)
104
104
105
105
106
106
class MapTestCase(Iterators):
107
"""Test mapping of iterators"""
108
def testNumbers(self):
109
"""1 to 100 * 2 = 2 to 200"""
110
assert Iter.equal(Iter.map(lambda x: 2*x, self.one_to_100()),
111
iter(range(2, 201, 2)))
112
113
def testShortcut(self):
114
"""Map should go in order"""
115
def f(x):
116
if x == "hello":
117
raise NameError
118
i = Iter.map(f, self.trueerror_maker())
119
i.next()
120
self.assertRaises(NameError, i.next)
121
122
def testEmpty(self):
123
"""Map of an empty iterator is empty"""
124
assert Iter.empty(Iter.map(lambda x: x, iter([])))
107
"""Test mapping of iterators"""
108
def testNumbers(self):
109
"""1 to 100 * 2 = 2 to 200"""
110
assert Iter.equal(Iter.map(lambda x: 2*x, self.one_to_100()),
111
iter(range(2, 201, 2)))
112
113
def testShortcut(self):
114
"""Map should go in order"""
115
def f(x):
116
if x == "hello":
117
raise NameError
118
i = Iter.map(f, self.trueerror_maker())
119
i.next()
120
self.assertRaises(NameError, i.next)
121
122
def testEmpty(self):
123
"""Map of an empty iterator is empty"""
124
assert Iter.empty(Iter.map(lambda x: x, iter([])))
125
125
126
126
127
127
class CatTestCase(Iterators):
128
"""Test concatenation of iterators"""
129
def testEmpty(self):
130
"""Empty + empty = empty"""
131
assert Iter.empty(Iter.cat(iter([]), iter([])))
132
133
def testNumbers(self):
134
"""1 to 50 + 51 to 100 = 1 to 100"""
135
assert Iter.equal(Iter.cat(iter(range(1, 51)), iter(range(51, 101))),
136
self.one_to_100())
137
138
def testShortcut(self):
139
"""Process iterators in order"""
140
i = Iter.cat(self.typeerror_maker(), self.nameerror_maker())
141
i.next()
142
i.next()
143
self.assertRaises(TypeError, i.next)
128
"""Test concatenation of iterators"""
129
def testEmpty(self):
130
"""Empty + empty = empty"""
131
assert Iter.empty(Iter.cat(iter([]), iter([])))
132
133
def testNumbers(self):
134
"""1 to 50 + 51 to 100 = 1 to 100"""
135
assert Iter.equal(Iter.cat(iter(range(1, 51)), iter(range(51, 101))),
136
self.one_to_100())
137
138
def testShortcut(self):
139
"""Process iterators in order"""
140
i = Iter.cat(self.typeerror_maker(), self.nameerror_maker())
141
i.next()
142
i.next()
143
self.assertRaises(TypeError, i.next)
144
144
145
145
146
146
class AndOrTestCase(Iterators):
147
"""Test And and Or"""
148
def testEmpty(self):
149
"""And() -> true, Or() -> false"""
150
assert Iter.And(self.empty())
151
assert not Iter.Or(self.empty())
152
153
def testAndShortcut(self):
154
"""And should return if any false"""
155
assert Iter.And(self.falseerror_maker()) is None
156
157
def testOrShortcut(self):
158
"""Or should return if any true"""
159
assert Iter.Or(self.trueerror_maker()) == 1
160
161
def testNormalAnd(self):
162
"""And should go through true iterators, picking last"""
163
assert Iter.And(iter([1,2,3,4])) == 4
164
self.assertRaises(Exception, Iter.And, self.trueerror_maker())
165
166
def testNormalOr(self):
167
"""Or goes through false iterators, picking last"""
168
assert Iter.Or(iter([0, None, []])) == []
169
self.assertRaises(Exception, Iter.Or, self.falseerror_maker())
147
"""Test And and Or"""
148
def testEmpty(self):
149
"""And() -> true, Or() -> false"""
150
assert Iter.And(self.empty())
151
assert not Iter.Or(self.empty())
152
153
def testAndShortcut(self):
154
"""And should return if any false"""
155
assert Iter.And(self.falseerror_maker()) is None
156
157
def testOrShortcut(self):
158
"""Or should return if any true"""
159
assert Iter.Or(self.trueerror_maker()) == 1
160
161
def testNormalAnd(self):
162
"""And should go through true iterators, picking last"""
163
assert Iter.And(iter([1,2,3,4])) == 4
164
self.assertRaises(Exception, Iter.And, self.trueerror_maker())
165
166
def testNormalOr(self):
167
"""Or goes through false iterators, picking last"""
168
assert Iter.Or(iter([0, None, []])) == []
169
self.assertRaises(Exception, Iter.Or, self.falseerror_maker())
170
170
171
171
172
172
class FoldingTest(Iterators):
173
"""Test folding operations"""
174
def f(self, x, y): return x + y
175
176
def testEmpty(self):
177
"""Folds of empty iterators should produce defaults"""
178
assert Iter.foldl(self.f, 23, self.empty()) == 23
179
assert Iter.foldr(self.f, 32, self.empty()) == 32
180
181
def testAddition(self):
182
"""Use folds to sum lists"""
183
assert Iter.foldl(self.f, 0, self.one_to_100()) == 5050
184
assert Iter.foldr(self.f, 0, self.one_to_100()) == 5050
185
186
def testLargeAddition(self):
187
"""Folds on 10000 element iterators"""
188
assert Iter.foldl(self.f, 0, iter(range(1, 10001))) == 50005000
189
self.assertRaises(RuntimeError,
190
Iter.foldr, self.f, 0, iter(range(1, 10001)))
191
192
def testLen(self):
193
"""Use folds to calculate length of lists"""
194
assert Iter.foldl(lambda x, y: x+1, 0, self.evens()) == 50
195
assert Iter.foldr(lambda x, y: y+1, 0, self.odds()) == 50
173
"""Test folding operations"""
174
def f(self, x, y): return x + y
175
176
def testEmpty(self):
177
"""Folds of empty iterators should produce defaults"""
178
assert Iter.foldl(self.f, 23, self.empty()) == 23
179
assert Iter.foldr(self.f, 32, self.empty()) == 32
180
181
def testAddition(self):
182
"""Use folds to sum lists"""
183
assert Iter.foldl(self.f, 0, self.one_to_100()) == 5050
184
assert Iter.foldr(self.f, 0, self.one_to_100()) == 5050
185
186
def testLargeAddition(self):
187
"""Folds on 10000 element iterators"""
188
assert Iter.foldl(self.f, 0, iter(range(1, 10001))) == 50005000
189
self.assertRaises(RuntimeError,
190
Iter.foldr, self.f, 0, iter(range(1, 10001)))
191
192
def testLen(self):
193
"""Use folds to calculate length of lists"""
194
assert Iter.foldl(lambda x, y: x+1, 0, self.evens()) == 50
195
assert Iter.foldr(lambda x, y: y+1, 0, self.odds()) == 50
196
196
197
197
class MultiplexTest(Iterators):
198
def testSingle(self):
199
"""Test multiplex single stream"""
200
i_orig = self.one_to_100()
201
i2_orig = self.one_to_100()
202
i = Iter.multiplex(i_orig, 1)[0]
203
assert Iter.equal(i, i2_orig)
204
205
def testTrible(self):
206
"""Test splitting iterator into three"""
207
counter = [0]
208
def ff(x): counter[0] += 1
209
i_orig = self.one_to_100()
210
i2_orig = self.one_to_100()
211
i1, i2, i3 = Iter.multiplex(i_orig, 3, ff)
212
assert Iter.equal(i1, i2)
213
assert Iter.equal(i3, i2_orig)
214
assert counter[0] == 100, counter
215
216
def testDouble(self):
217
"""Test splitting into two..."""
218
i1, i2 = Iter.multiplex(self.one_to_100(), 2)
219
assert Iter.equal(i1, self.one_to_100())
220
assert Iter.equal(i2, self.one_to_100())
198
def testSingle(self):
199
"""Test multiplex single stream"""
200
i_orig = self.one_to_100()
201
i2_orig = self.one_to_100()
202
i = Iter.multiplex(i_orig, 1)[0]
203
assert Iter.equal(i, i2_orig)
204
205
def testTrible(self):
206
"""Test splitting iterator into three"""
207
counter = [0]
208
def ff(x): counter[0] += 1
209
i_orig = self.one_to_100()
210
i2_orig = self.one_to_100()
211
i1, i2, i3 = Iter.multiplex(i_orig, 3, ff)
212
assert Iter.equal(i1, i2)
213
assert Iter.equal(i3, i2_orig)
214
assert counter[0] == 100, counter
215
216
def testDouble(self):
217
"""Test splitting into two..."""
218
i1, i2 = Iter.multiplex(self.one_to_100(), 2)
219
assert Iter.equal(i1, self.one_to_100())
220
assert Iter.equal(i2, self.one_to_100())
221
221
222
222
223
223
class ITRBadder(ITRBranch):
224
def start_process(self, index):
225
self.total = 0
226
227
def end_process(self):
228
if self.base_index:
229
summand = self.base_index[-1]
230
#print "Adding ", summand
231
self.total += summand
232
233
def branch_process(self, subinstance):
234
#print "Adding subinstance ", subinstance.total
235
self.total += subinstance.total
224
def start_process(self, index):
225
self.total = 0
226
227
def end_process(self):
228
if self.base_index:
229
summand = self.base_index[-1]
230
#print "Adding ", summand
231
self.total += summand
232
233
def branch_process(self, subinstance):
234
#print "Adding subinstance ", subinstance.total
235
self.total += subinstance.total
236
236
237
237
class ITRBadder2(ITRBranch):
238
def start_process(self, index):
239
self.total = 0
240
241
def end_process(self):
242
#print "Adding ", self.base_index
243
self.total += reduce(lambda x,y: x+y, self.base_index, 0)
244
245
def can_fast_process(self, index):
246
if len(index) == 3: return 1
247
else: return None
248
249
def fast_process(self, index):
250
self.total += index[0] + index[1] + index[2]
251
252
def branch_process(self, subinstance):
253
#print "Adding branch ", subinstance.total
254
self.total += subinstance.total
238
def start_process(self, index):
239
self.total = 0
240
241
def end_process(self):
242
#print "Adding ", self.base_index
243
self.total += reduce(lambda x,y: x+y, self.base_index, 0)
244
245
def can_fast_process(self, index):
246
if len(index) == 3: return 1
247
else: return None
248
249
def fast_process(self, index):
250
self.total += index[0] + index[1] + index[2]
251
252
def branch_process(self, subinstance):
253
#print "Adding branch ", subinstance.total
254
self.total += subinstance.total
255
255
256
256
class TreeReducerTest(unittest.TestCase):
257
def setUp(self):
258
self.i1 = [(), (1,), (2,), (3,)]
259
self.i2 = [(0,), (0,1), (0,1,0), (0,1,1), (0,2), (0,2,1), (0,3)]
260
261
self.i1a = [(), (1,)]
262
self.i1b = [(2,), (3,)]
263
self.i2a = [(0,), (0,1), (0,1,0)]
264
self.i2b = [(0,1,1), (0,2)]
265
self.i2c = [(0,2,1), (0,3)]
266
267
def testTreeReducer(self):
268
"""testing IterTreeReducer"""
269
itm = IterTreeReducer(ITRBadder, [])
270
for index in self.i1:
271
val = itm(index)
272
assert val, (val, index)
273
itm.Finish()
274
assert itm.root_branch.total == 6, itm.root_branch.total
275
276
itm2 = IterTreeReducer(ITRBadder2, [])
277
for index in self.i2:
278
val = itm2(index)
279
if index == (): assert not val
280
else: assert val
281
itm2.Finish()
282
assert itm2.root_branch.total == 12, itm2.root_branch.total
283
284
def testTreeReducerState(self):
285
"""Test saving and recreation of an IterTreeReducer"""
286
itm1a = IterTreeReducer(ITRBadder, [])
287
for index in self.i1a:
288
val = itm1a(index)
289
assert val, index
290
itm1b = pickle.loads(pickle.dumps(itm1a))
291
for index in self.i1b:
292
val = itm1b(index)
293
assert val, index
294
itm1b.Finish()
295
assert itm1b.root_branch.total == 6, itm1b.root_branch.total
296
297
itm2a = IterTreeReducer(ITRBadder2, [])
298
for index in self.i2a:
299
val = itm2a(index)
300
if index == (): assert not val
301
else: assert val
302
itm2b = pickle.loads(pickle.dumps(itm2a))
303
for index in self.i2b:
304
val = itm2b(index)
305
if index == (): assert not val
306
else: assert val
307
itm2c = pickle.loads(pickle.dumps(itm2b))
308
for index in self.i2c:
309
val = itm2c(index)
310
if index == (): assert not val
311
else: assert val
312
itm2c.Finish()
313
assert itm2c.root_branch.total == 12, itm2c.root_branch.total
257
def setUp(self):
258
self.i1 = [(), (1,), (2,), (3,)]
259
self.i2 = [(0,), (0,1), (0,1,0), (0,1,1), (0,2), (0,2,1), (0,3)]
260
261
self.i1a = [(), (1,)]
262
self.i1b = [(2,), (3,)]
263
self.i2a = [(0,), (0,1), (0,1,0)]
264
self.i2b = [(0,1,1), (0,2)]
265
self.i2c = [(0,2,1), (0,3)]
266
267
def testTreeReducer(self):
268
"""testing IterTreeReducer"""
269
itm = IterTreeReducer(ITRBadder, [])
270
for index in self.i1:
271
val = itm(index)
272
assert val, (val, index)
273
itm.Finish()
274
assert itm.root_branch.total == 6, itm.root_branch.total
275
276
itm2 = IterTreeReducer(ITRBadder2, [])
277
for index in self.i2:
278
val = itm2(index)
279
if index == (): assert not val
280
else: assert val
281
itm2.Finish()
282
assert itm2.root_branch.total == 12, itm2.root_branch.total
283
284
def testTreeReducerState(self):
285
"""Test saving and recreation of an IterTreeReducer"""
286
itm1a = IterTreeReducer(ITRBadder, [])
287
for index in self.i1a:
288
val = itm1a(index)
289
assert val, index
290
itm1b = pickle.loads(pickle.dumps(itm1a))
291
for index in self.i1b:
292
val = itm1b(index)
293
assert val, index
294
itm1b.Finish()
295
assert itm1b.root_branch.total == 6, itm1b.root_branch.total
296
297
itm2a = IterTreeReducer(ITRBadder2, [])
298
for index in self.i2a:
299
val = itm2a(index)
300
if index == (): assert not val
301
else: assert val
302
itm2b = pickle.loads(pickle.dumps(itm2a))
303
for index in self.i2b:
304
val = itm2b(index)
305
if index == (): assert not val
306
else: assert val
307
itm2c = pickle.loads(pickle.dumps(itm2b))
308
for index in self.i2c:
309
val = itm2c(index)
310
if index == (): assert not val
311
else: assert val
312
itm2c.Finish()
313
assert itm2c.root_branch.total == 12, itm2c.root_branch.total
314
314
315
315
316
316
if __name__ == "__main__":
317
unittest.main()
317
unittest.main()
Loggerhead is a web-based interface for Breezy
Version: 2.0.1