2 Tests common to tuple, list and UserList.UserList
9 # This is used for checking the constructor (here and in test_deque.py)
16 'Sequence using __getitem__'
17 def __init__(self
, seqn
):
19 def __getitem__(self
, i
):
23 'Sequence using iterator protocol'
24 def __init__(self
, seqn
):
30 if self
.i
>= len(self
.seqn
): raise StopIteration
36 'Sequence using iterator protocol defined with a generator'
37 def __init__(self
, seqn
):
45 'Missing __getitem__ and __iter__'
46 def __init__(self
, seqn
):
50 if self
.i
>= len(self
.seqn
): raise StopIteration
56 'Iterator missing next()'
57 def __init__(self
, seqn
):
64 'Test propagation of exceptions'
65 def __init__(self
, seqn
):
75 def __init__(self
, seqn
):
82 from itertools
import chain
, imap
84 'Test multiple tiers of iterators'
85 return chain(imap(lambda x
:x
, iterfunc(IterGen(Sequence(seqn
)))))
87 class CommonTest(unittest
.TestCase
):
88 # The type to be tested
91 def test_constructors(self
):
97 u0
= self
.type2test(l0
)
98 u1
= self
.type2test(l1
)
99 u2
= self
.type2test(l2
)
101 uu
= self
.type2test(u
)
102 uu0
= self
.type2test(u0
)
103 uu1
= self
.type2test(u1
)
104 uu2
= self
.type2test(u2
)
106 v
= self
.type2test(tuple(u
))
108 def __init__(self
, initseq
):
109 self
.__data
= initseq
111 return len(self
.__data
)
112 def __getitem__(self
, i
):
113 return self
.__data
[i
]
115 v0
= self
.type2test(s
)
116 self
.assertEqual(len(v0
), len(s
))
118 s
= "this is also a sequence"
119 vv
= self
.type2test(s
)
120 self
.assertEqual(len(vv
), len(s
))
122 # Create from various iteratables
123 for s
in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
124 for g
in (Sequence
, IterFunc
, IterGen
,
125 itermulti
, iterfunc
):
126 self
.assertEqual(self
.type2test(g(s
)), self
.type2test(s
))
127 self
.assertEqual(self
.type2test(IterFuncStop(s
)), self
.type2test())
128 self
.assertEqual(self
.type2test(c
for c
in "123"), self
.type2test("123"))
129 self
.assertRaises(TypeError, self
.type2test
, IterNextOnly(s
))
130 self
.assertRaises(TypeError, self
.type2test
, IterNoNext(s
))
131 self
.assertRaises(ZeroDivisionError, self
.type2test
, IterGenExc(s
))
133 def test_truth(self
):
134 self
.assert_(not self
.type2test())
135 self
.assert_(self
.type2test([42]))
137 def test_getitem(self
):
138 u
= self
.type2test([0, 1, 2, 3, 4])
139 for i
in xrange(len(u
)):
140 self
.assertEqual(u
[i
], i
)
141 self
.assertEqual(u
[long(i
)], i
)
142 for i
in xrange(-len(u
), -1):
143 self
.assertEqual(u
[i
], len(u
)+i
)
144 self
.assertEqual(u
[long(i
)], len(u
)+i
)
145 self
.assertRaises(IndexError, u
.__getitem
__, -len(u
)-1)
146 self
.assertRaises(IndexError, u
.__getitem
__, len(u
))
147 self
.assertRaises(ValueError, u
.__getitem
__, slice(0,10,0))
150 self
.assertRaises(IndexError, u
.__getitem
__, 0)
151 self
.assertRaises(IndexError, u
.__getitem
__, -1)
153 self
.assertRaises(TypeError, u
.__getitem
__)
155 a
= self
.type2test([10, 11])
156 self
.assertEqual(a
[0], 10)
157 self
.assertEqual(a
[1], 11)
158 self
.assertEqual(a
[-2], 10)
159 self
.assertEqual(a
[-1], 11)
160 self
.assertRaises(IndexError, a
.__getitem
__, -3)
161 self
.assertRaises(IndexError, a
.__getitem
__, 3)
163 def test_getslice(self
):
165 u
= self
.type2test(l
)
167 self
.assertEqual(u
[0:0], self
.type2test())
168 self
.assertEqual(u
[1:2], self
.type2test([1]))
169 self
.assertEqual(u
[-2:-1], self
.type2test([3]))
170 self
.assertEqual(u
[-1000:1000], u
)
171 self
.assertEqual(u
[1000:-1000], self
.type2test([]))
172 self
.assertEqual(u
[:], u
)
173 self
.assertEqual(u
[1:None], self
.type2test([1, 2, 3, 4]))
174 self
.assertEqual(u
[None:3], self
.type2test([0, 1, 2]))
177 self
.assertEqual(u
[::], u
)
178 self
.assertEqual(u
[::2], self
.type2test([0, 2, 4]))
179 self
.assertEqual(u
[1::2], self
.type2test([1, 3]))
180 self
.assertEqual(u
[::-1], self
.type2test([4, 3, 2, 1, 0]))
181 self
.assertEqual(u
[::-2], self
.type2test([4, 2, 0]))
182 self
.assertEqual(u
[3::-2], self
.type2test([3, 1]))
183 self
.assertEqual(u
[3:3:-2], self
.type2test([]))
184 self
.assertEqual(u
[3:2:-2], self
.type2test([3]))
185 self
.assertEqual(u
[3:1:-2], self
.type2test([3]))
186 self
.assertEqual(u
[3:0:-2], self
.type2test([3, 1]))
187 self
.assertEqual(u
[::-100], self
.type2test([4]))
188 self
.assertEqual(u
[100:-100:], self
.type2test([]))
189 self
.assertEqual(u
[-100:100:], u
)
190 self
.assertEqual(u
[100:-100:-1], u
[::-1])
191 self
.assertEqual(u
[-100:100:-1], self
.type2test([]))
192 self
.assertEqual(u
[-100L:100L:2L], self
.type2test([0, 2, 4]))
194 # Test extreme cases with long ints
195 a
= self
.type2test([0,1,2,3,4])
196 self
.assertEqual(a
[ -pow(2,128L): 3 ], self
.type2test([0,1,2]))
197 self
.assertEqual(a
[ 3: pow(2,145L) ], self
.type2test([3,4]))
199 self
.assertRaises(TypeError, u
.__getslice
__)
201 def test_contains(self
):
202 u
= self
.type2test([0, 1, 2])
205 for i
in min(u
)-1, max(u
)+1:
206 self
.assert_(i
not in u
)
208 self
.assertRaises(TypeError, u
.__contains
__)
210 def test_contains_fake(self
):
212 # Sequences must use rich comparison against each item
213 # (unless "is" is true, or an earlier item answered)
214 # So instances of AllEq must be found in all non-empty sequences.
215 def __eq__(self
, other
):
217 __hash__
= None # Can't meet hash invariant requirements
218 self
.assert_(AllEq() not in self
.type2test([]))
219 self
.assert_(AllEq() in self
.type2test([1]))
221 def test_contains_order(self
):
222 # Sequences must test in-order. If a rich comparison has side
223 # effects, these will be visible to tests against later members.
224 # In this test, the "side effect" is a short-circuiting raise.
225 class DoNotTestEq(Exception):
228 def __eq__(self
, other
):
231 checkfirst
= self
.type2test([1, StopCompares()])
232 self
.assert_(1 in checkfirst
)
233 checklast
= self
.type2test([StopCompares(), 1])
234 self
.assertRaises(DoNotTestEq
, checklast
.__contains
__, 1)
237 self
.assertEqual(len(self
.type2test()), 0)
238 self
.assertEqual(len(self
.type2test([])), 0)
239 self
.assertEqual(len(self
.type2test([0])), 1)
240 self
.assertEqual(len(self
.type2test([0, 1, 2])), 3)
242 def test_minmax(self
):
243 u
= self
.type2test([0, 1, 2])
244 self
.assertEqual(min(u
), 0)
245 self
.assertEqual(max(u
), 2)
247 def test_addmul(self
):
248 u1
= self
.type2test([0])
249 u2
= self
.type2test([0, 1])
250 self
.assertEqual(u1
, u1
+ self
.type2test())
251 self
.assertEqual(u1
, self
.type2test() + u1
)
252 self
.assertEqual(u1
+ self
.type2test([1]), u2
)
253 self
.assertEqual(self
.type2test([-1]) + u1
, self
.type2test([-1, 0]))
254 self
.assertEqual(self
.type2test(), u2
*0)
255 self
.assertEqual(self
.type2test(), 0*u2
)
256 self
.assertEqual(self
.type2test(), u2
*0L)
257 self
.assertEqual(self
.type2test(), 0L*u2
)
258 self
.assertEqual(u2
, u2
*1)
259 self
.assertEqual(u2
, 1*u2
)
260 self
.assertEqual(u2
, u2
*1L)
261 self
.assertEqual(u2
, 1L*u2
)
262 self
.assertEqual(u2
+u2
, u2
*2)
263 self
.assertEqual(u2
+u2
, 2*u2
)
264 self
.assertEqual(u2
+u2
, u2
*2L)
265 self
.assertEqual(u2
+u2
, 2L*u2
)
266 self
.assertEqual(u2
+u2
+u2
, u2
*3)
267 self
.assertEqual(u2
+u2
+u2
, 3*u2
)
269 class subclass(self
.type2test
):
271 u3
= subclass([0, 1])
272 self
.assertEqual(u3
, u3
*1)
273 self
.assert_(u3
is not u3
*1)
276 u
= self
.type2test([0, 1])
277 u
+= self
.type2test()
278 self
.assertEqual(u
, self
.type2test([0, 1]))
279 u
+= self
.type2test([2, 3])
280 self
.assertEqual(u
, self
.type2test([0, 1, 2, 3]))
281 u
+= self
.type2test([4, 5])
282 self
.assertEqual(u
, self
.type2test([0, 1, 2, 3, 4, 5]))
284 u
= self
.type2test("spam")
285 u
+= self
.type2test("eggs")
286 self
.assertEqual(u
, self
.type2test("spameggs"))
289 u
= self
.type2test([0, 1])
291 self
.assertEqual(u
, self
.type2test([0, 1, 0, 1, 0, 1]))
293 def test_getitemoverwriteiter(self
):
294 # Verify that __getitem__ overrides are not recognized by __iter__
295 class T(self
.type2test
):
296 def __getitem__(self
, key
):
297 return str(key
) + '!!!'
298 self
.assertEqual(iter(T((1,2))).next(), 1)
300 def test_repeat(self
):
303 for n
in xrange(-3, 5):
304 self
.assertEqual(self
.type2test(s
*n
), self
.type2test(s
)*n
)
305 self
.assertEqual(self
.type2test(s
)*(-4), self
.type2test([]))
306 self
.assertEqual(id(s
), id(s
*1))
308 def test_bigrepeat(self
):
310 if sys
.maxint
<= 2147483647:
311 x
= self
.type2test([0])
313 self
.assertRaises(MemoryError, x
.__mul
__, 2**16)
314 if hasattr(x
, '__imul__'):
315 self
.assertRaises(MemoryError, x
.__imul
__, 2**16)
317 def test_subscript(self
):
318 a
= self
.type2test([10, 11])
319 self
.assertEqual(a
.__getitem
__(0L), 10)
320 self
.assertEqual(a
.__getitem
__(1L), 11)
321 self
.assertEqual(a
.__getitem
__(-2L), 10)
322 self
.assertEqual(a
.__getitem
__(-1L), 11)
323 self
.assertRaises(IndexError, a
.__getitem
__, -3)
324 self
.assertRaises(IndexError, a
.__getitem
__, 3)
325 self
.assertEqual(a
.__getitem
__(slice(0,1)), self
.type2test([10]))
326 self
.assertEqual(a
.__getitem
__(slice(1,2)), self
.type2test([11]))
327 self
.assertEqual(a
.__getitem
__(slice(0,2)), self
.type2test([10, 11]))
328 self
.assertEqual(a
.__getitem
__(slice(0,3)), self
.type2test([10, 11]))
329 self
.assertEqual(a
.__getitem
__(slice(3,5)), self
.type2test([]))
330 self
.assertRaises(ValueError, a
.__getitem
__, slice(0, 10, 0))
331 self
.assertRaises(TypeError, a
.__getitem
__, 'x')
333 def test_count(self
):
334 a
= self
.type2test([0, 1, 2])*3
335 self
.assertEqual(a
.count(0), 3)
336 self
.assertEqual(a
.count(1), 3)
337 self
.assertEqual(a
.count(3), 0)
339 self
.assertRaises(TypeError, a
.count
)
341 class BadExc(Exception):
345 def __eq__(self
, other
):
350 self
.assertRaises(BadExc
, a
.count
, BadCmp())
352 def test_index(self
):
353 u
= self
.type2test([0, 1])
354 self
.assertEqual(u
.index(0), 0)
355 self
.assertEqual(u
.index(1), 1)
356 self
.assertRaises(ValueError, u
.index
, 2)
358 u
= self
.type2test([-2, -1, 0, 0, 1, 2])
359 self
.assertEqual(u
.count(0), 2)
360 self
.assertEqual(u
.index(0), 2)
361 self
.assertEqual(u
.index(0, 2), 2)
362 self
.assertEqual(u
.index(-2, -10), 0)
363 self
.assertEqual(u
.index(0, 3), 3)
364 self
.assertEqual(u
.index(0, 3, 4), 3)
365 self
.assertRaises(ValueError, u
.index
, 2, 0, -10)
367 self
.assertRaises(TypeError, u
.index
)
369 class BadExc(Exception):
373 def __eq__(self
, other
):
378 a
= self
.type2test([0, 1, 2, 3])
379 self
.assertRaises(BadExc
, a
.index
, BadCmp())
381 a
= self
.type2test([-2, -1, 0, 0, 1, 2])
382 self
.assertEqual(a
.index(0), 2)
383 self
.assertEqual(a
.index(0, 2), 2)
384 self
.assertEqual(a
.index(0, -4), 2)
385 self
.assertEqual(a
.index(-2, -10), 0)
386 self
.assertEqual(a
.index(0, 3), 3)
387 self
.assertEqual(a
.index(0, -3), 3)
388 self
.assertEqual(a
.index(0, 3, 4), 3)
389 self
.assertEqual(a
.index(0, -3, -2), 3)
390 self
.assertEqual(a
.index(0, -4*sys
.maxint
, 4*sys
.maxint
), 2)
391 self
.assertRaises(ValueError, a
.index
, 0, 4*sys
.maxint
,-4*sys
.maxint
)
392 self
.assertRaises(ValueError, a
.index
, 2, 0, -10)