blob: 141791cf9e1e0c5a2a24f73bedd0f7c36118226b [file] [log] [blame]
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001import unittest
Benjamin Petersonee8712c2008-05-20 21:35:26 +00002from test import support
Raymond Hettinger96ef8112003-02-01 00:10:11 +00003from itertools import *
Antoine Pitrou26f82ef2014-04-29 12:13:46 +02004import weakref
Raymond Hettinger8a882a72009-02-12 12:08:18 +00005from decimal import Decimal
Raymond Hettingerde09acf2009-02-12 12:53:53 +00006from fractions import Fraction
Raymond Hettinger2012f172003-02-07 05:32:58 +00007import sys
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +00008import operator
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00009import random
Raymond Hettingera3e1ad22009-11-30 22:02:31 +000010import copy
11import pickle
Christian Heimesc3f30c42008-02-22 16:37:40 +000012from functools import reduce
Serhiy Storchaka2dae92a2013-12-09 17:45:57 +020013import sys
14import struct
Benjamin Petersonee8712c2008-05-20 21:35:26 +000015maxsize = support.MAX_Py_ssize_t
Guido van Rossum360e4b82007-05-14 22:51:27 +000016minsize = -maxsize-1
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +000017
Guido van Rossum801f0d72006-08-24 19:48:10 +000018def lzip(*args):
19 return list(zip(*args))
20
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +000021def onearg(x):
22 'Test function of one argument'
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +000023 return 2*x
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +000024
25def errfunc(*args):
26 'Test function that raises an error'
27 raise ValueError
28
29def gen3():
30 'Non-restartable source sequence'
31 for i in (0, 1, 2):
32 yield i
33
34def isEven(x):
35 'Test predicate'
36 return x%2==0
37
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +000038def isOdd(x):
39 'Test predicate'
40 return x%2==1
41
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +000042def tupleize(*args):
43 return args
44
45def irange(n):
46 for i in range(n):
47 yield i
48
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +000049class StopNow:
50 'Class emulating an empty iterable.'
51 def __iter__(self):
52 return self
Georg Brandla18af4e2007-04-21 15:47:16 +000053 def __next__(self):
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +000054 raise StopIteration
Raymond Hettinger96ef8112003-02-01 00:10:11 +000055
Raymond Hettinger02420702003-06-29 20:36:23 +000056def take(n, seq):
57 'Convenience function for partially consuming a long of infinite iterable'
58 return list(islice(seq, n))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +000059
Christian Heimes78644762008-03-04 23:39:23 +000060def prod(iterable):
61 return reduce(operator.mul, iterable, 1)
62
Christian Heimes380f7f22008-02-28 11:19:05 +000063def fact(n):
64 'Factorial'
Christian Heimes78644762008-03-04 23:39:23 +000065 return prod(range(1, n+1))
66
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +000067# root level methods for pickling ability
68def testR(r):
69 return r[0]
70
71def testR2(r):
72 return r[2]
73
74def underten(x):
75 return x<10
76
Serhiy Storchakabad12572014-12-15 14:03:42 +020077picklecopiers = [lambda s, proto=proto: pickle.loads(pickle.dumps(s, proto))
78 for proto in range(pickle.HIGHEST_PROTOCOL + 1)]
79
Raymond Hettinger96ef8112003-02-01 00:10:11 +000080class TestBasicOps(unittest.TestCase):
Raymond Hettinger482ba772010-12-01 22:48:00 +000081
Serhiy Storchakabad12572014-12-15 14:03:42 +020082 def pickletest(self, protocol, it, stop=4, take=1, compare=None):
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +000083 """Test that an iterator is the same after pickling, also when part-consumed"""
84 def expand(it, i=0):
85 # Recursively expand iterables, within sensible bounds
86 if i > 10:
87 raise RuntimeError("infinite recursion encountered")
88 if isinstance(it, str):
89 return it
90 try:
91 l = list(islice(it, stop))
92 except TypeError:
93 return it # can't expand it
94 return [expand(e, i+1) for e in l]
95
96 # Test the initial copy against the original
Serhiy Storchakabad12572014-12-15 14:03:42 +020097 dump = pickle.dumps(it, protocol)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +000098 i2 = pickle.loads(dump)
99 self.assertEqual(type(it), type(i2))
100 a, b = expand(it), expand(i2)
101 self.assertEqual(a, b)
102 if compare:
103 c = expand(compare)
104 self.assertEqual(a, c)
105
106 # Take from the copy, and create another copy and compare them.
107 i3 = pickle.loads(dump)
108 took = 0
109 try:
110 for i in range(take):
111 next(i3)
112 took += 1
113 except StopIteration:
114 pass #in case there is less data than 'take'
Serhiy Storchakabad12572014-12-15 14:03:42 +0200115 dump = pickle.dumps(i3, protocol)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000116 i4 = pickle.loads(dump)
117 a, b = expand(i3), expand(i4)
118 self.assertEqual(a, b)
119 if compare:
120 c = expand(compare[took:])
121 self.assertEqual(a, c);
122
Raymond Hettinger482ba772010-12-01 22:48:00 +0000123 def test_accumulate(self):
124 self.assertEqual(list(accumulate(range(10))), # one positional arg
Raymond Hettingerd8ff4652010-12-03 02:09:34 +0000125 [0, 1, 3, 6, 10, 15, 21, 28, 36, 45])
126 self.assertEqual(list(accumulate(iterable=range(10))), # kw arg
127 [0, 1, 3, 6, 10, 15, 21, 28, 36, 45])
Raymond Hettinger482ba772010-12-01 22:48:00 +0000128 for typ in int, complex, Decimal, Fraction: # multiple types
Raymond Hettingerd8ff4652010-12-03 02:09:34 +0000129 self.assertEqual(
130 list(accumulate(map(typ, range(10)))),
Raymond Hettinger482ba772010-12-01 22:48:00 +0000131 list(map(typ, [0, 1, 3, 6, 10, 15, 21, 28, 36, 45])))
Raymond Hettinger2d93e6e2010-12-03 02:33:53 +0000132 self.assertEqual(list(accumulate('abc')), ['a', 'ab', 'abc']) # works with non-numeric
Raymond Hettinger482ba772010-12-01 22:48:00 +0000133 self.assertEqual(list(accumulate([])), []) # empty iterable
Raymond Hettingerd8ff4652010-12-03 02:09:34 +0000134 self.assertEqual(list(accumulate([7])), [7]) # iterable of length one
Raymond Hettinger5d446132011-03-27 18:52:10 -0700135 self.assertRaises(TypeError, accumulate, range(10), 5, 6) # too many args
Raymond Hettinger482ba772010-12-01 22:48:00 +0000136 self.assertRaises(TypeError, accumulate) # too few args
Raymond Hettingerd8ff4652010-12-03 02:09:34 +0000137 self.assertRaises(TypeError, accumulate, x=range(10)) # unexpected kwd arg
Raymond Hettinger482ba772010-12-01 22:48:00 +0000138 self.assertRaises(TypeError, list, accumulate([1, []])) # args that don't add
139
Raymond Hettinger5d446132011-03-27 18:52:10 -0700140 s = [2, 8, 9, 5, 7, 0, 3, 4, 1, 6]
141 self.assertEqual(list(accumulate(s, min)),
142 [2, 2, 2, 2, 2, 0, 0, 0, 0, 0])
143 self.assertEqual(list(accumulate(s, max)),
144 [2, 8, 9, 9, 9, 9, 9, 9, 9, 9])
145 self.assertEqual(list(accumulate(s, operator.mul)),
146 [2, 16, 144, 720, 5040, 0, 0, 0, 0, 0])
147 with self.assertRaises(TypeError):
148 list(accumulate(s, chr)) # unary-operation
Serhiy Storchakabad12572014-12-15 14:03:42 +0200149 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
150 self.pickletest(proto, accumulate(range(10))) # test pickling
Raymond Hettinger5d446132011-03-27 18:52:10 -0700151
Raymond Hettinger61fe64d2003-02-23 04:40:07 +0000152 def test_chain(self):
Christian Heimesdd15f6c2008-03-16 00:07:10 +0000153
154 def chain2(*iterables):
155 'Pure python version in the docs'
156 for it in iterables:
157 for element in it:
158 yield element
159
160 for c in (chain, chain2):
161 self.assertEqual(list(c('abc', 'def')), list('abcdef'))
162 self.assertEqual(list(c('abc')), list('abc'))
163 self.assertEqual(list(c('')), [])
164 self.assertEqual(take(4, c('abc', 'def')), list('abcd'))
165 self.assertRaises(TypeError, list,c(2, 3))
Christian Heimesf16baeb2008-02-29 14:57:44 +0000166
167 def test_chain_from_iterable(self):
168 self.assertEqual(list(chain.from_iterable(['abc', 'def'])), list('abcdef'))
169 self.assertEqual(list(chain.from_iterable(['abc'])), list('abc'))
170 self.assertEqual(list(chain.from_iterable([''])), [])
171 self.assertEqual(take(4, chain.from_iterable(['abc', 'def'])), list('abcd'))
172 self.assertRaises(TypeError, list, chain.from_iterable([2, 3]))
Raymond Hettinger61fe64d2003-02-23 04:40:07 +0000173
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000174 def test_chain_reducible(self):
Serhiy Storchakabad12572014-12-15 14:03:42 +0200175 for oper in [copy.deepcopy] + picklecopiers:
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000176 it = chain('abc', 'def')
177 self.assertEqual(list(oper(it)), list('abcdef'))
178 self.assertEqual(next(it), 'a')
179 self.assertEqual(list(oper(it)), list('bcdef'))
180
181 self.assertEqual(list(oper(chain(''))), [])
182 self.assertEqual(take(4, oper(chain('abc', 'def'))), list('abcd'))
183 self.assertRaises(TypeError, list, oper(chain(2, 3)))
Serhiy Storchakabad12572014-12-15 14:03:42 +0200184 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
185 self.pickletest(proto, chain('abc', 'def'), compare=list('abcdef'))
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000186
Christian Heimes380f7f22008-02-28 11:19:05 +0000187 def test_combinations(self):
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000188 self.assertRaises(TypeError, combinations, 'abc') # missing r argument
Christian Heimes380f7f22008-02-28 11:19:05 +0000189 self.assertRaises(TypeError, combinations, 'abc', 2, 1) # too many arguments
Christian Heimes78644762008-03-04 23:39:23 +0000190 self.assertRaises(TypeError, combinations, None) # pool is not iterable
Christian Heimes380f7f22008-02-28 11:19:05 +0000191 self.assertRaises(ValueError, combinations, 'abc', -2) # r is negative
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000192
Serhiy Storchakabad12572014-12-15 14:03:42 +0200193 for op in [lambda a:a] + picklecopiers:
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000194 self.assertEqual(list(op(combinations('abc', 32))), []) # r > n
195
196 self.assertEqual(list(op(combinations('ABCD', 2))),
197 [('A','B'), ('A','C'), ('A','D'), ('B','C'), ('B','D'), ('C','D')])
198 testIntermediate = combinations('ABCD', 2)
199 next(testIntermediate)
200 self.assertEqual(list(op(testIntermediate)),
201 [('A','C'), ('A','D'), ('B','C'), ('B','D'), ('C','D')])
202
203 self.assertEqual(list(op(combinations(range(4), 3))),
204 [(0,1,2), (0,1,3), (0,2,3), (1,2,3)])
205 testIntermediate = combinations(range(4), 3)
206 next(testIntermediate)
207 self.assertEqual(list(op(testIntermediate)),
208 [(0,1,3), (0,2,3), (1,2,3)])
209
Christian Heimes78644762008-03-04 23:39:23 +0000210
211 def combinations1(iterable, r):
212 'Pure python version shown in the docs'
213 pool = tuple(iterable)
214 n = len(pool)
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000215 if r > n:
216 return
Christian Heimes78644762008-03-04 23:39:23 +0000217 indices = list(range(r))
218 yield tuple(pool[i] for i in indices)
219 while 1:
220 for i in reversed(range(r)):
221 if indices[i] != i + n - r:
222 break
223 else:
224 return
225 indices[i] += 1
226 for j in range(i+1, r):
227 indices[j] = indices[j-1] + 1
228 yield tuple(pool[i] for i in indices)
229
230 def combinations2(iterable, r):
231 'Pure python version shown in the docs'
232 pool = tuple(iterable)
233 n = len(pool)
234 for indices in permutations(range(n), r):
235 if sorted(indices) == list(indices):
236 yield tuple(pool[i] for i in indices)
237
Raymond Hettingereb508ad2009-01-27 09:35:21 +0000238 def combinations3(iterable, r):
239 'Pure python version from cwr()'
240 pool = tuple(iterable)
241 n = len(pool)
242 for indices in combinations_with_replacement(range(n), r):
243 if len(set(indices)) == r:
244 yield tuple(pool[i] for i in indices)
245
Christian Heimes78644762008-03-04 23:39:23 +0000246 for n in range(7):
Christian Heimes380f7f22008-02-28 11:19:05 +0000247 values = [5*x-12 for x in range(n)]
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000248 for r in range(n+2):
Christian Heimes380f7f22008-02-28 11:19:05 +0000249 result = list(combinations(values, r))
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000250 self.assertEqual(len(result), 0 if r>n else fact(n) / fact(r) / fact(n-r)) # right number of combs
Christian Heimes380f7f22008-02-28 11:19:05 +0000251 self.assertEqual(len(result), len(set(result))) # no repeats
252 self.assertEqual(result, sorted(result)) # lexicographic order
253 for c in result:
254 self.assertEqual(len(c), r) # r-length combinations
255 self.assertEqual(len(set(c)), r) # no duplicate elements
256 self.assertEqual(list(c), sorted(c)) # keep original ordering
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000257 self.assertTrue(all(e in values for e in c)) # elements taken from input iterable
Christian Heimesdd15f6c2008-03-16 00:07:10 +0000258 self.assertEqual(list(c),
259 [e for e in values if e in c]) # comb is a subsequence of the input iterable
Christian Heimes78644762008-03-04 23:39:23 +0000260 self.assertEqual(result, list(combinations1(values, r))) # matches first pure python version
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000261 self.assertEqual(result, list(combinations2(values, r))) # matches second pure python version
Raymond Hettingereb508ad2009-01-27 09:35:21 +0000262 self.assertEqual(result, list(combinations3(values, r))) # matches second pure python version
Christian Heimes78644762008-03-04 23:39:23 +0000263
Serhiy Storchakabad12572014-12-15 14:03:42 +0200264 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
265 self.pickletest(proto, combinations(values, r)) # test pickling
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000266
Benjamin Peterson4b40eeb2015-02-01 20:59:00 -0500267 @support.bigaddrspacetest
268 def test_combinations_overflow(self):
Serhiy Storchakadee948b2015-02-03 01:34:09 +0200269 with self.assertRaises((OverflowError, MemoryError)):
Benjamin Peterson4b40eeb2015-02-01 20:59:00 -0500270 combinations("AA", 2**29)
271
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000272 # Test implementation detail: tuple re-use
Alex Gaynore151d212011-07-17 16:21:30 -0700273 @support.impl_detail("tuple reuse is specific to CPython")
274 def test_combinations_tuple_reuse(self):
Christian Heimes78644762008-03-04 23:39:23 +0000275 self.assertEqual(len(set(map(id, combinations('abcde', 3)))), 1)
276 self.assertNotEqual(len(set(map(id, list(combinations('abcde', 3))))), 1)
277
Raymond Hettingerd07d9392009-01-27 04:20:44 +0000278 def test_combinations_with_replacement(self):
279 cwr = combinations_with_replacement
280 self.assertRaises(TypeError, cwr, 'abc') # missing r argument
281 self.assertRaises(TypeError, cwr, 'abc', 2, 1) # too many arguments
282 self.assertRaises(TypeError, cwr, None) # pool is not iterable
283 self.assertRaises(ValueError, cwr, 'abc', -2) # r is negative
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000284
Serhiy Storchakabad12572014-12-15 14:03:42 +0200285 for op in [lambda a:a] + picklecopiers:
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000286 self.assertEqual(list(op(cwr('ABC', 2))),
287 [('A','A'), ('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')])
288 testIntermediate = cwr('ABC', 2)
289 next(testIntermediate)
290 self.assertEqual(list(op(testIntermediate)),
291 [('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')])
292
Raymond Hettingerd07d9392009-01-27 04:20:44 +0000293
294 def cwr1(iterable, r):
295 'Pure python version shown in the docs'
296 # number items returned: (n+r-1)! / r! / (n-1)! when n>0
297 pool = tuple(iterable)
298 n = len(pool)
299 if not n and r:
300 return
301 indices = [0] * r
302 yield tuple(pool[i] for i in indices)
303 while 1:
304 for i in reversed(range(r)):
305 if indices[i] != n - 1:
306 break
307 else:
308 return
309 indices[i:] = [indices[i] + 1] * (r - i)
310 yield tuple(pool[i] for i in indices)
311
312 def cwr2(iterable, r):
313 'Pure python version shown in the docs'
314 pool = tuple(iterable)
315 n = len(pool)
316 for indices in product(range(n), repeat=r):
317 if sorted(indices) == list(indices):
318 yield tuple(pool[i] for i in indices)
319
320 def numcombs(n, r):
321 if not n:
322 return 0 if r else 1
323 return fact(n+r-1) / fact(r)/ fact(n-1)
324
325 for n in range(7):
326 values = [5*x-12 for x in range(n)]
327 for r in range(n+2):
328 result = list(cwr(values, r))
329
330 self.assertEqual(len(result), numcombs(n, r)) # right number of combs
331 self.assertEqual(len(result), len(set(result))) # no repeats
332 self.assertEqual(result, sorted(result)) # lexicographic order
333
334 regular_combs = list(combinations(values, r)) # compare to combs without replacement
335 if n == 0 or r <= 1:
Ezio Melottib3aedd42010-11-20 19:04:17 +0000336 self.assertEqual(result, regular_combs) # cases that should be identical
Raymond Hettingerd07d9392009-01-27 04:20:44 +0000337 else:
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000338 self.assertTrue(set(result) >= set(regular_combs)) # rest should be supersets of regular combs
Raymond Hettingerd07d9392009-01-27 04:20:44 +0000339
340 for c in result:
341 self.assertEqual(len(c), r) # r-length combinations
342 noruns = [k for k,v in groupby(c)] # combo without consecutive repeats
343 self.assertEqual(len(noruns), len(set(noruns))) # no repeats other than consecutive
344 self.assertEqual(list(c), sorted(c)) # keep original ordering
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000345 self.assertTrue(all(e in values for e in c)) # elements taken from input iterable
Raymond Hettingerd07d9392009-01-27 04:20:44 +0000346 self.assertEqual(noruns,
347 [e for e in values if e in c]) # comb is a subsequence of the input iterable
348 self.assertEqual(result, list(cwr1(values, r))) # matches first pure python version
349 self.assertEqual(result, list(cwr2(values, r))) # matches second pure python version
350
Serhiy Storchakabad12572014-12-15 14:03:42 +0200351 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
352 self.pickletest(proto, cwr(values,r)) # test pickling
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000353
Benjamin Peterson6f082292015-02-01 21:10:47 -0500354 @support.bigaddrspacetest
355 def test_combinations_with_replacement_overflow(self):
Serhiy Storchakadee948b2015-02-03 01:34:09 +0200356 with self.assertRaises((OverflowError, MemoryError)):
Benjamin Peterson6f082292015-02-01 21:10:47 -0500357 combinations_with_replacement("AA", 2**30)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000358
Benjamin Peterson6f082292015-02-01 21:10:47 -0500359 # Test implementation detail: tuple re-use
Alex Gaynore151d212011-07-17 16:21:30 -0700360 @support.impl_detail("tuple reuse is specific to CPython")
361 def test_combinations_with_replacement_tuple_reuse(self):
362 cwr = combinations_with_replacement
Raymond Hettingerd07d9392009-01-27 04:20:44 +0000363 self.assertEqual(len(set(map(id, cwr('abcde', 3)))), 1)
364 self.assertNotEqual(len(set(map(id, list(cwr('abcde', 3))))), 1)
365
Christian Heimes78644762008-03-04 23:39:23 +0000366 def test_permutations(self):
367 self.assertRaises(TypeError, permutations) # too few arguments
368 self.assertRaises(TypeError, permutations, 'abc', 2, 1) # too many arguments
Christian Heimesdd15f6c2008-03-16 00:07:10 +0000369 self.assertRaises(TypeError, permutations, None) # pool is not iterable
370 self.assertRaises(ValueError, permutations, 'abc', -2) # r is negative
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000371 self.assertEqual(list(permutations('abc', 32)), []) # r > n
Christian Heimesdd15f6c2008-03-16 00:07:10 +0000372 self.assertRaises(TypeError, permutations, 'abc', 's') # r is not an int or None
Christian Heimes78644762008-03-04 23:39:23 +0000373 self.assertEqual(list(permutations(range(3), 2)),
374 [(0,1), (0,2), (1,0), (1,2), (2,0), (2,1)])
375
376 def permutations1(iterable, r=None):
377 'Pure python version shown in the docs'
378 pool = tuple(iterable)
379 n = len(pool)
380 r = n if r is None else r
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000381 if r > n:
382 return
Christian Heimes78644762008-03-04 23:39:23 +0000383 indices = list(range(n))
384 cycles = list(range(n-r+1, n+1))[::-1]
385 yield tuple(pool[i] for i in indices[:r])
386 while n:
387 for i in reversed(range(r)):
388 cycles[i] -= 1
389 if cycles[i] == 0:
390 indices[i:] = indices[i+1:] + indices[i:i+1]
391 cycles[i] = n - i
392 else:
393 j = cycles[i]
394 indices[i], indices[-j] = indices[-j], indices[i]
395 yield tuple(pool[i] for i in indices[:r])
396 break
397 else:
398 return
399
400 def permutations2(iterable, r=None):
401 'Pure python version shown in the docs'
402 pool = tuple(iterable)
403 n = len(pool)
404 r = n if r is None else r
405 for indices in product(range(n), repeat=r):
406 if len(set(indices)) == r:
407 yield tuple(pool[i] for i in indices)
408
409 for n in range(7):
410 values = [5*x-12 for x in range(n)]
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000411 for r in range(n+2):
Christian Heimes78644762008-03-04 23:39:23 +0000412 result = list(permutations(values, r))
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000413 self.assertEqual(len(result), 0 if r>n else fact(n) / fact(n-r)) # right number of perms
Christian Heimes78644762008-03-04 23:39:23 +0000414 self.assertEqual(len(result), len(set(result))) # no repeats
415 self.assertEqual(result, sorted(result)) # lexicographic order
416 for p in result:
417 self.assertEqual(len(p), r) # r-length permutations
418 self.assertEqual(len(set(p)), r) # no duplicate elements
Benjamin Petersonc9c0f202009-06-30 23:06:06 +0000419 self.assertTrue(all(e in values for e in p)) # elements taken from input iterable
Christian Heimes78644762008-03-04 23:39:23 +0000420 self.assertEqual(result, list(permutations1(values, r))) # matches first pure python version
Raymond Hettinger5bad41e2009-01-08 21:01:54 +0000421 self.assertEqual(result, list(permutations2(values, r))) # matches second pure python version
Christian Heimes78644762008-03-04 23:39:23 +0000422 if r == n:
423 self.assertEqual(result, list(permutations(values, None))) # test r as None
424 self.assertEqual(result, list(permutations(values))) # test default r
425
Serhiy Storchakabad12572014-12-15 14:03:42 +0200426 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
427 self.pickletest(proto, permutations(values, r)) # test pickling
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000428
Benjamin Peterson0eaabf12015-02-01 21:34:07 -0500429 @support.bigaddrspacetest
430 def test_permutations_overflow(self):
Serhiy Storchakadee948b2015-02-03 01:34:09 +0200431 with self.assertRaises((OverflowError, MemoryError)):
Benjamin Peterson0eaabf12015-02-01 21:34:07 -0500432 permutations("A", 2**30)
Benjamin Peterson0eaabf12015-02-01 21:34:07 -0500433
Zachary Waredca807b2014-04-24 13:22:05 -0500434 @support.impl_detail("tuple reuse is specific to CPython")
Alex Gaynore151d212011-07-17 16:21:30 -0700435 def test_permutations_tuple_reuse(self):
Christian Heimesdd15f6c2008-03-16 00:07:10 +0000436 self.assertEqual(len(set(map(id, permutations('abcde', 3)))), 1)
Christian Heimes78644762008-03-04 23:39:23 +0000437 self.assertNotEqual(len(set(map(id, list(permutations('abcde', 3))))), 1)
Christian Heimes380f7f22008-02-28 11:19:05 +0000438
Raymond Hettingereb508ad2009-01-27 09:35:21 +0000439 def test_combinatorics(self):
440 # Test relationships between product(), permutations(),
441 # combinations() and combinations_with_replacement().
442
Raymond Hettingerda6bc522009-01-27 10:39:42 +0000443 for n in range(6):
444 s = 'ABCDEFG'[:n]
445 for r in range(8):
446 prod = list(product(s, repeat=r))
447 cwr = list(combinations_with_replacement(s, r))
448 perm = list(permutations(s, r))
449 comb = list(combinations(s, r))
Raymond Hettingereb508ad2009-01-27 09:35:21 +0000450
Raymond Hettingerda6bc522009-01-27 10:39:42 +0000451 # Check size
Ezio Melottib3aedd42010-11-20 19:04:17 +0000452 self.assertEqual(len(prod), n**r)
453 self.assertEqual(len(cwr), (fact(n+r-1) / fact(r)/ fact(n-1)) if n else (not r))
454 self.assertEqual(len(perm), 0 if r>n else fact(n) / fact(n-r))
455 self.assertEqual(len(comb), 0 if r>n else fact(n) / fact(r) / fact(n-r))
Raymond Hettingerda6bc522009-01-27 10:39:42 +0000456
457 # Check lexicographic order without repeated tuples
Ezio Melottib3aedd42010-11-20 19:04:17 +0000458 self.assertEqual(prod, sorted(set(prod)))
459 self.assertEqual(cwr, sorted(set(cwr)))
460 self.assertEqual(perm, sorted(set(perm)))
461 self.assertEqual(comb, sorted(set(comb)))
Raymond Hettingerda6bc522009-01-27 10:39:42 +0000462
463 # Check interrelationships
Ezio Melottib3aedd42010-11-20 19:04:17 +0000464 self.assertEqual(cwr, [t for t in prod if sorted(t)==list(t)]) # cwr: prods which are sorted
465 self.assertEqual(perm, [t for t in prod if len(set(t))==r]) # perm: prods with no dups
Raymond Hettingerda6bc522009-01-27 10:39:42 +0000466 self.assertEqual(comb, [t for t in perm if sorted(t)==list(t)]) # comb: perms that are sorted
467 self.assertEqual(comb, [t for t in cwr if len(set(t))==r]) # comb: cwrs without dups
468 self.assertEqual(comb, list(filter(set(cwr).__contains__, perm))) # comb: perm that is a cwr
469 self.assertEqual(comb, list(filter(set(perm).__contains__, cwr))) # comb: cwr that is a perm
470 self.assertEqual(comb, sorted(set(cwr) & set(perm))) # comb: both a cwr and a perm
Raymond Hettingereb508ad2009-01-27 09:35:21 +0000471
Raymond Hettinger6b3b0fc2009-01-26 02:56:58 +0000472 def test_compress(self):
Raymond Hettinger15a49502009-02-19 02:17:09 +0000473 self.assertEqual(list(compress(data='ABCDEF', selectors=[1,0,1,0,1,1])), list('ACEF'))
Raymond Hettinger6b3b0fc2009-01-26 02:56:58 +0000474 self.assertEqual(list(compress('ABCDEF', [1,0,1,0,1,1])), list('ACEF'))
475 self.assertEqual(list(compress('ABCDEF', [0,0,0,0,0,0])), list(''))
476 self.assertEqual(list(compress('ABCDEF', [1,1,1,1,1,1])), list('ABCDEF'))
477 self.assertEqual(list(compress('ABCDEF', [1,0,1])), list('AC'))
478 self.assertEqual(list(compress('ABC', [0,1,1,1,1,1])), list('BC'))
479 n = 10000
480 data = chain.from_iterable(repeat(range(6), n))
481 selectors = chain.from_iterable(repeat((0, 1)))
482 self.assertEqual(list(compress(data, selectors)), [1,3,5] * n)
483 self.assertRaises(TypeError, compress, None, range(6)) # 1st arg not iterable
484 self.assertRaises(TypeError, compress, range(6), None) # 2nd arg not iterable
485 self.assertRaises(TypeError, compress, range(6)) # too few args
486 self.assertRaises(TypeError, compress, range(6), None) # too many args
487
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000488 # check copy, deepcopy, pickle
Serhiy Storchakabad12572014-12-15 14:03:42 +0200489 for op in [lambda a:copy.copy(a), lambda a:copy.deepcopy(a)] + picklecopiers:
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000490 for data, selectors, result1, result2 in [
491 ('ABCDEF', [1,0,1,0,1,1], 'ACEF', 'CEF'),
492 ('ABCDEF', [0,0,0,0,0,0], '', ''),
493 ('ABCDEF', [1,1,1,1,1,1], 'ABCDEF', 'BCDEF'),
494 ('ABCDEF', [1,0,1], 'AC', 'C'),
495 ('ABC', [0,1,1,1,1,1], 'BC', 'C'),
496 ]:
497
498 self.assertEqual(list(op(compress(data=data, selectors=selectors))), list(result1))
499 self.assertEqual(list(op(compress(data, selectors))), list(result1))
500 testIntermediate = compress(data, selectors)
501 if result1:
502 next(testIntermediate)
503 self.assertEqual(list(op(testIntermediate)), list(result2))
504
505
Raymond Hettinger96ef8112003-02-01 00:10:11 +0000506 def test_count(self):
Guido van Rossum801f0d72006-08-24 19:48:10 +0000507 self.assertEqual(lzip('abc',count()), [('a', 0), ('b', 1), ('c', 2)])
508 self.assertEqual(lzip('abc',count(3)), [('a', 3), ('b', 4), ('c', 5)])
509 self.assertEqual(take(2, lzip('abc',count(3))), [('a', 3), ('b', 4)])
Guido van Rossum8ce8a782007-11-01 19:42:39 +0000510 self.assertEqual(take(2, zip('abc',count(-1))), [('a', -1), ('b', 0)])
511 self.assertEqual(take(2, zip('abc',count(-3))), [('a', -3), ('b', -2)])
Raymond Hettinger30729212009-02-12 06:28:27 +0000512 self.assertRaises(TypeError, count, 2, 3, 4)
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +0000513 self.assertRaises(TypeError, count, 'a')
Serhiy Storchaka8ddcf3a2016-09-10 09:49:24 +0300514 self.assertEqual(take(10, count(maxsize-5)),
Guido van Rossum8ce8a782007-11-01 19:42:39 +0000515 list(range(maxsize-5, maxsize+5)))
Serhiy Storchaka8ddcf3a2016-09-10 09:49:24 +0300516 self.assertEqual(take(10, count(-maxsize-5)),
Guido van Rossum8ce8a782007-11-01 19:42:39 +0000517 list(range(-maxsize-5, -maxsize+5)))
Serhiy Storchaka8ddcf3a2016-09-10 09:49:24 +0300518 self.assertEqual(take(3, count(3.25)), [3.25, 4.25, 5.25])
519 self.assertEqual(take(3, count(3.25-4j)), [3.25-4j, 4.25-4j, 5.25-4j])
520 self.assertEqual(take(3, count(Decimal('1.1'))),
521 [Decimal('1.1'), Decimal('2.1'), Decimal('3.1')])
522 self.assertEqual(take(3, count(Fraction(2, 3))),
523 [Fraction(2, 3), Fraction(5, 3), Fraction(8, 3)])
524 BIGINT = 1<<1000
525 self.assertEqual(take(3, count(BIGINT)), [BIGINT, BIGINT+1, BIGINT+2])
Raymond Hettinger4cda01e2004-09-28 04:45:28 +0000526 c = count(3)
527 self.assertEqual(repr(c), 'count(3)')
Georg Brandla18af4e2007-04-21 15:47:16 +0000528 next(c)
Raymond Hettinger4cda01e2004-09-28 04:45:28 +0000529 self.assertEqual(repr(c), 'count(4)')
Thomas Wouters89f507f2006-12-13 04:49:30 +0000530 c = count(-9)
531 self.assertEqual(repr(c), 'count(-9)')
Georg Brandla18af4e2007-04-21 15:47:16 +0000532 next(c)
533 self.assertEqual(next(c), -8)
Serhiy Storchaka8ddcf3a2016-09-10 09:49:24 +0300534 self.assertEqual(repr(count(10.25)), 'count(10.25)')
535 self.assertEqual(repr(count(10.0)), 'count(10.0)')
536 self.assertEqual(type(next(count(10.0))), float)
Christian Heimesa37d4c62007-12-04 23:02:19 +0000537 for i in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 10, sys.maxsize-5, sys.maxsize+5):
Serhiy Storchaka95949422013-08-27 19:40:23 +0300538 # Test repr
539 r1 = repr(count(i))
540 r2 = 'count(%r)'.__mod__(i)
Guido van Rossum8ce8a782007-11-01 19:42:39 +0000541 self.assertEqual(r1, r2)
Raymond Hettinger96ef8112003-02-01 00:10:11 +0000542
Raymond Hettingera3e1ad22009-11-30 22:02:31 +0000543 # check copy, deepcopy, pickle
544 for value in -3, 3, maxsize-5, maxsize+5:
545 c = count(value)
546 self.assertEqual(next(copy.copy(c)), value)
547 self.assertEqual(next(copy.deepcopy(c)), value)
Serhiy Storchakabad12572014-12-15 14:03:42 +0200548 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
549 self.pickletest(proto, count(value))
Raymond Hettingera3e1ad22009-11-30 22:02:31 +0000550
Kristjan Valur Jonsson35722a92011-03-30 11:04:28 +0000551 #check proper internal error handling for large "step' sizes
552 count(1, maxsize+5); sys.exc_info()
553
Raymond Hettinger30729212009-02-12 06:28:27 +0000554 def test_count_with_stride(self):
555 self.assertEqual(lzip('abc',count(2,3)), [('a', 2), ('b', 5), ('c', 8)])
Raymond Hettingereb13fdd2009-02-21 22:30:12 +0000556 self.assertEqual(lzip('abc',count(start=2,step=3)),
557 [('a', 2), ('b', 5), ('c', 8)])
558 self.assertEqual(lzip('abc',count(step=-1)),
559 [('a', 0), ('b', -1), ('c', -2)])
Serhiy Storchaka8ddcf3a2016-09-10 09:49:24 +0300560 self.assertRaises(TypeError, count, 'a', 'b')
Raymond Hettinger30729212009-02-12 06:28:27 +0000561 self.assertEqual(lzip('abc',count(2,0)), [('a', 2), ('b', 2), ('c', 2)])
562 self.assertEqual(lzip('abc',count(2,1)), [('a', 2), ('b', 3), ('c', 4)])
Raymond Hettinger9e8dbbc2009-02-14 04:21:49 +0000563 self.assertEqual(lzip('abc',count(2,3)), [('a', 2), ('b', 5), ('c', 8)])
Raymond Hettinger30729212009-02-12 06:28:27 +0000564 self.assertEqual(take(20, count(maxsize-15, 3)), take(20, range(maxsize-15, maxsize+100, 3)))
565 self.assertEqual(take(20, count(-maxsize-15, 3)), take(20, range(-maxsize-15,-maxsize+100, 3)))
Serhiy Storchaka8ddcf3a2016-09-10 09:49:24 +0300566 self.assertEqual(take(3, count(10, maxsize+5)),
567 list(range(10, 10+3*(maxsize+5), maxsize+5)))
568 self.assertEqual(take(3, count(2, 1.25)), [2, 3.25, 4.5])
Raymond Hettinger30729212009-02-12 06:28:27 +0000569 self.assertEqual(take(3, count(2, 3.25-4j)), [2, 5.25-4j, 8.5-8j])
Raymond Hettinger8a882a72009-02-12 12:08:18 +0000570 self.assertEqual(take(3, count(Decimal('1.1'), Decimal('.1'))),
571 [Decimal('1.1'), Decimal('1.2'), Decimal('1.3')])
Raymond Hettingerde09acf2009-02-12 12:53:53 +0000572 self.assertEqual(take(3, count(Fraction(2,3), Fraction(1,7))),
573 [Fraction(2,3), Fraction(17,21), Fraction(20,21)])
Serhiy Storchaka8ddcf3a2016-09-10 09:49:24 +0300574 BIGINT = 1<<1000
575 self.assertEqual(take(3, count(step=BIGINT)), [0, BIGINT, 2*BIGINT])
Raymond Hettinger30729212009-02-12 06:28:27 +0000576 self.assertEqual(repr(take(3, count(10, 2.5))), repr([10, 12.5, 15.0]))
577 c = count(3, 5)
578 self.assertEqual(repr(c), 'count(3, 5)')
579 next(c)
580 self.assertEqual(repr(c), 'count(8, 5)')
581 c = count(-9, 0)
582 self.assertEqual(repr(c), 'count(-9, 0)')
583 next(c)
584 self.assertEqual(repr(c), 'count(-9, 0)')
585 c = count(-9, -3)
586 self.assertEqual(repr(c), 'count(-9, -3)')
587 next(c)
588 self.assertEqual(repr(c), 'count(-12, -3)')
589 self.assertEqual(repr(c), 'count(-12, -3)')
590 self.assertEqual(repr(count(10.5, 1.25)), 'count(10.5, 1.25)')
591 self.assertEqual(repr(count(10.5, 1)), 'count(10.5)') # suppress step=1 when it's an int
592 self.assertEqual(repr(count(10.5, 1.00)), 'count(10.5, 1.0)') # do show float values lilke 1.0
Serhiy Storchaka8ddcf3a2016-09-10 09:49:24 +0300593 self.assertEqual(repr(count(10, 1.00)), 'count(10, 1.0)')
594 c = count(10, 1.0)
595 self.assertEqual(type(next(c)), int)
596 self.assertEqual(type(next(c)), float)
Raymond Hettinger30729212009-02-12 06:28:27 +0000597 for i in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 10, sys.maxsize-5, sys.maxsize+5):
598 for j in (-sys.maxsize-5, -sys.maxsize+5 ,-10, -1, 0, 1, 10, sys.maxsize-5, sys.maxsize+5):
Serhiy Storchaka95949422013-08-27 19:40:23 +0300599 # Test repr
600 r1 = repr(count(i, j))
Raymond Hettinger30729212009-02-12 06:28:27 +0000601 if j == 1:
Serhiy Storchaka95949422013-08-27 19:40:23 +0300602 r2 = ('count(%r)' % i)
Raymond Hettinger30729212009-02-12 06:28:27 +0000603 else:
Serhiy Storchaka95949422013-08-27 19:40:23 +0300604 r2 = ('count(%r, %r)' % (i, j))
Raymond Hettinger30729212009-02-12 06:28:27 +0000605 self.assertEqual(r1, r2)
Serhiy Storchakabad12572014-12-15 14:03:42 +0200606 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
607 self.pickletest(proto, count(i, j))
Raymond Hettinger30729212009-02-12 06:28:27 +0000608
Raymond Hettinger61fe64d2003-02-23 04:40:07 +0000609 def test_cycle(self):
Raymond Hettinger02420702003-06-29 20:36:23 +0000610 self.assertEqual(take(10, cycle('abc')), list('abcabcabca'))
Raymond Hettinger61fe64d2003-02-23 04:40:07 +0000611 self.assertEqual(list(cycle('')), [])
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +0000612 self.assertRaises(TypeError, cycle)
613 self.assertRaises(TypeError, cycle, 5)
614 self.assertEqual(list(islice(cycle(gen3()),10)), [0,1,2,0,1,2,0,1,2,0])
Raymond Hettinger61fe64d2003-02-23 04:40:07 +0000615
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000616 # check copy, deepcopy, pickle
617 c = cycle('abc')
618 self.assertEqual(next(c), 'a')
619 #simple copy currently not supported, because __reduce__ returns
620 #an internal iterator
621 #self.assertEqual(take(10, copy.copy(c)), list('bcabcabcab'))
622 self.assertEqual(take(10, copy.deepcopy(c)), list('bcabcabcab'))
Serhiy Storchakabad12572014-12-15 14:03:42 +0200623 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
624 self.assertEqual(take(10, pickle.loads(pickle.dumps(c, proto))),
625 list('bcabcabcab'))
626 next(c)
627 self.assertEqual(take(10, pickle.loads(pickle.dumps(c, proto))),
628 list('cabcabcabc'))
629 next(c)
630 next(c)
631 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
632 self.pickletest(proto, cycle('abc'))
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000633
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000634 def test_groupby(self):
635 # Check whether it accepts arguments correctly
636 self.assertEqual([], list(groupby([])))
637 self.assertEqual([], list(groupby([], key=id)))
638 self.assertRaises(TypeError, list, groupby('abc', []))
639 self.assertRaises(TypeError, groupby, None)
Raymond Hettinger4cda01e2004-09-28 04:45:28 +0000640 self.assertRaises(TypeError, groupby, 'abc', lambda x:x, 10)
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000641
642 # Check normal input
643 s = [(0, 10, 20), (0, 11,21), (0,12,21), (1,13,21), (1,14,22),
644 (2,15,22), (3,16,23), (3,17,23)]
645 dup = []
646 for k, g in groupby(s, lambda r:r[0]):
647 for elem in g:
648 self.assertEqual(k, elem[0])
649 dup.append(elem)
650 self.assertEqual(s, dup)
651
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000652 # Check normal pickled
Serhiy Storchakabad12572014-12-15 14:03:42 +0200653 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
654 dup = []
655 for k, g in pickle.loads(pickle.dumps(groupby(s, testR), proto)):
656 for elem in g:
657 self.assertEqual(k, elem[0])
658 dup.append(elem)
659 self.assertEqual(s, dup)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000660
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000661 # Check nested case
662 dup = []
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000663 for k, g in groupby(s, testR):
664 for ik, ig in groupby(g, testR2):
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000665 for elem in ig:
666 self.assertEqual(k, elem[0])
667 self.assertEqual(ik, elem[2])
668 dup.append(elem)
669 self.assertEqual(s, dup)
670
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000671 # Check nested and pickled
Serhiy Storchakabad12572014-12-15 14:03:42 +0200672 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
673 dup = []
674 for k, g in pickle.loads(pickle.dumps(groupby(s, testR), proto)):
675 for ik, ig in pickle.loads(pickle.dumps(groupby(g, testR2), proto)):
676 for elem in ig:
677 self.assertEqual(k, elem[0])
678 self.assertEqual(ik, elem[2])
679 dup.append(elem)
680 self.assertEqual(s, dup)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000681
682
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000683 # Check case where inner iterator is not used
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000684 keys = [k for k, g in groupby(s, testR)]
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000685 expectedkeys = set([r[0] for r in s])
686 self.assertEqual(set(keys), expectedkeys)
687 self.assertEqual(len(keys), len(expectedkeys))
688
689 # Exercise pipes and filters style
690 s = 'abracadabra'
691 # sort s | uniq
Raymond Hettinger64958a12003-12-17 20:43:33 +0000692 r = [k for k, g in groupby(sorted(s))]
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000693 self.assertEqual(r, ['a', 'b', 'c', 'd', 'r'])
694 # sort s | uniq -d
Raymond Hettinger64958a12003-12-17 20:43:33 +0000695 r = [k for k, g in groupby(sorted(s)) if list(islice(g,1,2))]
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000696 self.assertEqual(r, ['a', 'b', 'r'])
697 # sort s | uniq -c
Raymond Hettinger64958a12003-12-17 20:43:33 +0000698 r = [(len(list(g)), k) for k, g in groupby(sorted(s))]
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000699 self.assertEqual(r, [(5, 'a'), (2, 'b'), (1, 'c'), (1, 'd'), (2, 'r')])
700 # sort s | uniq -c | sort -rn | head -3
Raymond Hettinger64958a12003-12-17 20:43:33 +0000701 r = sorted([(len(list(g)) , k) for k, g in groupby(sorted(s))], reverse=True)[:3]
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000702 self.assertEqual(r, [(5, 'a'), (2, 'r'), (2, 'b')])
703
Georg Brandla18af4e2007-04-21 15:47:16 +0000704 # iter.__next__ failure
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000705 class ExpectedError(Exception):
706 pass
707 def delayed_raise(n=0):
708 for i in range(n):
709 yield 'yo'
710 raise ExpectedError
711 def gulp(iterable, keyp=None, func=list):
712 return [func(g) for k, g in groupby(iterable, keyp)]
713
Georg Brandla18af4e2007-04-21 15:47:16 +0000714 # iter.__next__ failure on outer object
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000715 self.assertRaises(ExpectedError, gulp, delayed_raise(0))
Georg Brandla18af4e2007-04-21 15:47:16 +0000716 # iter.__next__ failure on inner object
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000717 self.assertRaises(ExpectedError, gulp, delayed_raise(1))
718
Serhiy Storchakaa60c2fe2015-03-12 21:56:08 +0200719 # __eq__ failure
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000720 class DummyCmp:
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000721 def __eq__(self, dst):
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000722 raise ExpectedError
723 s = [DummyCmp(), DummyCmp(), None]
724
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000725 # __eq__ failure on outer object
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000726 self.assertRaises(ExpectedError, gulp, s, func=id)
Guido van Rossum47b9ff62006-08-24 00:41:19 +0000727 # __eq__ failure on inner object
Raymond Hettingerd25c1c62003-12-06 16:23:06 +0000728 self.assertRaises(ExpectedError, gulp, s)
729
730 # keyfunc failure
731 def keyfunc(obj):
732 if keyfunc.skip > 0:
733 keyfunc.skip -= 1
734 return obj
735 else:
736 raise ExpectedError
737
738 # keyfunc failure on outer object
739 keyfunc.skip = 0
740 self.assertRaises(ExpectedError, gulp, [None], keyfunc)
741 keyfunc.skip = 1
742 self.assertRaises(ExpectedError, gulp, [None, None], keyfunc)
743
Raymond Hettinger736c0ab2008-03-13 02:09:15 +0000744 def test_filter(self):
745 self.assertEqual(list(filter(isEven, range(6))), [0,2,4])
746 self.assertEqual(list(filter(None, [0,1,0,2,0])), [1,2])
747 self.assertEqual(list(filter(bool, [0,1,0,2,0])), [1,2])
748 self.assertEqual(take(4, filter(isEven, count())), [0,2,4,6])
749 self.assertRaises(TypeError, filter)
750 self.assertRaises(TypeError, filter, lambda x:x)
751 self.assertRaises(TypeError, filter, lambda x:x, range(6), 7)
752 self.assertRaises(TypeError, filter, isEven, 3)
753 self.assertRaises(TypeError, next, filter(range(6), range(6)))
Raymond Hettinger60eca932003-02-09 06:40:58 +0000754
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000755 # check copy, deepcopy, pickle
756 ans = [0,2,4]
757
758 c = filter(isEven, range(6))
759 self.assertEqual(list(copy.copy(c)), ans)
760 c = filter(isEven, range(6))
761 self.assertEqual(list(copy.deepcopy(c)), ans)
Serhiy Storchakabad12572014-12-15 14:03:42 +0200762 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
763 c = filter(isEven, range(6))
764 self.assertEqual(list(pickle.loads(pickle.dumps(c, proto))), ans)
765 next(c)
766 self.assertEqual(list(pickle.loads(pickle.dumps(c, proto))), ans[1:])
767 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
768 c = filter(isEven, range(6))
769 self.pickletest(proto, c)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000770
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000771 def test_filterfalse(self):
772 self.assertEqual(list(filterfalse(isEven, range(6))), [1,3,5])
773 self.assertEqual(list(filterfalse(None, [0,1,0,2,0])), [0,0,0])
774 self.assertEqual(list(filterfalse(bool, [0,1,0,2,0])), [0,0,0])
775 self.assertEqual(take(4, filterfalse(isEven, count())), [1,3,5,7])
776 self.assertRaises(TypeError, filterfalse)
777 self.assertRaises(TypeError, filterfalse, lambda x:x)
778 self.assertRaises(TypeError, filterfalse, lambda x:x, range(6), 7)
779 self.assertRaises(TypeError, filterfalse, isEven, 3)
780 self.assertRaises(TypeError, next, filterfalse(range(6), range(6)))
Serhiy Storchakabad12572014-12-15 14:03:42 +0200781 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
782 self.pickletest(proto, filterfalse(isEven, range(6)))
Raymond Hettinger96ef8112003-02-01 00:10:11 +0000783
Raymond Hettinger736c0ab2008-03-13 02:09:15 +0000784 def test_zip(self):
785 # XXX This is rather silly now that builtin zip() calls zip()...
786 ans = [(x,y) for x, y in zip('abc',count())]
Raymond Hettinger96ef8112003-02-01 00:10:11 +0000787 self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
Raymond Hettinger736c0ab2008-03-13 02:09:15 +0000788 self.assertEqual(list(zip('abc', range(6))), lzip('abc', range(6)))
789 self.assertEqual(list(zip('abcdef', range(3))), lzip('abcdef', range(3)))
790 self.assertEqual(take(3,zip('abcdef', count())), lzip('abcdef', range(3)))
791 self.assertEqual(list(zip('abcdef')), lzip('abcdef'))
792 self.assertEqual(list(zip()), lzip())
793 self.assertRaises(TypeError, zip, 3)
794 self.assertRaises(TypeError, zip, range(3), 3)
Raymond Hettinger736c0ab2008-03-13 02:09:15 +0000795 self.assertEqual([tuple(list(pair)) for pair in zip('abc', 'def')],
Guido van Rossum801f0d72006-08-24 19:48:10 +0000796 lzip('abc', 'def'))
Raymond Hettinger736c0ab2008-03-13 02:09:15 +0000797 self.assertEqual([pair for pair in zip('abc', 'def')],
Guido van Rossum801f0d72006-08-24 19:48:10 +0000798 lzip('abc', 'def'))
Alex Gaynore151d212011-07-17 16:21:30 -0700799
800 @support.impl_detail("tuple reuse is specific to CPython")
801 def test_zip_tuple_reuse(self):
Raymond Hettinger736c0ab2008-03-13 02:09:15 +0000802 ids = list(map(id, zip('abc', 'def')))
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +0000803 self.assertEqual(min(ids), max(ids))
Raymond Hettinger736c0ab2008-03-13 02:09:15 +0000804 ids = list(map(id, list(zip('abc', 'def'))))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +0000805 self.assertEqual(len(dict.fromkeys(ids)), len(ids))
Raymond Hettinger96ef8112003-02-01 00:10:11 +0000806
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000807 # check copy, deepcopy, pickle
808 ans = [(x,y) for x, y in copy.copy(zip('abc',count()))]
809 self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
810
811 ans = [(x,y) for x, y in copy.deepcopy(zip('abc',count()))]
812 self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
813
Serhiy Storchakabad12572014-12-15 14:03:42 +0200814 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
815 ans = [(x,y) for x, y in pickle.loads(pickle.dumps(zip('abc',count()), proto))]
816 self.assertEqual(ans, [('a', 0), ('b', 1), ('c', 2)])
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000817
Serhiy Storchakabad12572014-12-15 14:03:42 +0200818 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
819 testIntermediate = zip('abc',count())
820 next(testIntermediate)
821 ans = [(x,y) for x, y in pickle.loads(pickle.dumps(testIntermediate, proto))]
822 self.assertEqual(ans, [('b', 1), ('c', 2)])
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000823
Serhiy Storchakabad12572014-12-15 14:03:42 +0200824 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
825 self.pickletest(proto, zip('abc', count()))
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000826
Raymond Hettinger736c0ab2008-03-13 02:09:15 +0000827 def test_ziplongest(self):
Thomas Wouterscf297e42007-02-23 15:07:44 +0000828 for args in [
829 ['abc', range(6)],
830 [range(6), 'abc'],
831 [range(1000), range(2000,2100), range(3000,3050)],
832 [range(1000), range(0), range(3000,3050), range(1200), range(1500)],
833 [range(1000), range(0), range(3000,3050), range(1200), range(1500), range(0)],
834 ]:
Guido van Rossumc1f779c2007-07-03 08:25:58 +0000835 target = [tuple([arg[i] if i < len(arg) else None for arg in args])
836 for i in range(max(map(len, args)))]
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000837 self.assertEqual(list(zip_longest(*args)), target)
838 self.assertEqual(list(zip_longest(*args, **{})), target)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000839 target = [tuple((e is None and 'X' or e) for e in t) for t in target] # Replace None fills with 'X'
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000840 self.assertEqual(list(zip_longest(*args, **dict(fillvalue='X'))), target)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000841
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000842 self.assertEqual(take(3,zip_longest('abcdef', count())), list(zip('abcdef', range(3)))) # take 3 from infinite input
Thomas Wouterscf297e42007-02-23 15:07:44 +0000843
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000844 self.assertEqual(list(zip_longest()), list(zip()))
845 self.assertEqual(list(zip_longest([])), list(zip([])))
846 self.assertEqual(list(zip_longest('abcdef')), list(zip('abcdef')))
Guido van Rossumd8faa362007-04-27 19:54:29 +0000847
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000848 self.assertEqual(list(zip_longest('abc', 'defg', **{})),
Raymond Hettinger736c0ab2008-03-13 02:09:15 +0000849 list(zip(list('abc')+[None], 'defg'))) # empty keyword dict
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000850 self.assertRaises(TypeError, zip_longest, 3)
851 self.assertRaises(TypeError, zip_longest, range(3), 3)
Thomas Wouterscf297e42007-02-23 15:07:44 +0000852
853 for stmt in [
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000854 "zip_longest('abc', fv=1)",
855 "zip_longest('abc', fillvalue=1, bogus_keyword=None)",
Thomas Wouterscf297e42007-02-23 15:07:44 +0000856 ]:
857 try:
858 eval(stmt, globals(), locals())
859 except TypeError:
860 pass
861 else:
862 self.fail('Did not raise Type in: ' + stmt)
Guido van Rossumd8faa362007-04-27 19:54:29 +0000863
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000864 self.assertEqual([tuple(list(pair)) for pair in zip_longest('abc', 'def')],
Thomas Wouterscf297e42007-02-23 15:07:44 +0000865 list(zip('abc', 'def')))
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000866 self.assertEqual([pair for pair in zip_longest('abc', 'def')],
Thomas Wouterscf297e42007-02-23 15:07:44 +0000867 list(zip('abc', 'def')))
Alex Gaynore151d212011-07-17 16:21:30 -0700868
869 @support.impl_detail("tuple reuse is specific to CPython")
870 def test_zip_longest_tuple_reuse(self):
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000871 ids = list(map(id, zip_longest('abc', 'def')))
Thomas Wouterscf297e42007-02-23 15:07:44 +0000872 self.assertEqual(min(ids), max(ids))
Raymond Hettingerb0002d22008-03-13 01:41:43 +0000873 ids = list(map(id, list(zip_longest('abc', 'def'))))
Thomas Wouterscf297e42007-02-23 15:07:44 +0000874 self.assertEqual(len(dict.fromkeys(ids)), len(ids))
875
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000876 def test_zip_longest_pickling(self):
Serhiy Storchakabad12572014-12-15 14:03:42 +0200877 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
878 self.pickletest(proto, zip_longest("abc", "def"))
879 self.pickletest(proto, zip_longest("abc", "defgh"))
880 self.pickletest(proto, zip_longest("abc", "defgh", fillvalue=1))
881 self.pickletest(proto, zip_longest("", "defgh"))
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000882
Raymond Hettingerfc438512009-11-01 20:55:33 +0000883 def test_bug_7244(self):
884
885 class Repeater:
886 # this class is similar to itertools.repeat
887 def __init__(self, o, t, e):
888 self.o = o
889 self.t = int(t)
890 self.e = e
891 def __iter__(self): # its iterator is itself
892 return self
893 def __next__(self):
894 if self.t > 0:
895 self.t -= 1
896 return self.o
897 else:
898 raise self.e
899
900 # Formerly this code in would fail in debug mode
901 # with Undetected Error and Stop Iteration
902 r1 = Repeater(1, 3, StopIteration)
903 r2 = Repeater(2, 4, StopIteration)
904 def run(r1, r2):
905 result = []
906 for i, j in zip_longest(r1, r2, fillvalue=0):
907 with support.captured_output('stdout'):
908 print((i, j))
909 result.append((i, j))
910 return result
911 self.assertEqual(run(r1, r2), [(1,2), (1,2), (1,2), (0,2)])
912
913 # Formerly, the RuntimeError would be lost
914 # and StopIteration would stop as expected
915 r1 = Repeater(1, 3, RuntimeError)
916 r2 = Repeater(2, 4, StopIteration)
917 it = zip_longest(r1, r2, fillvalue=0)
918 self.assertEqual(next(it), (1, 2))
919 self.assertEqual(next(it), (1, 2))
920 self.assertEqual(next(it), (1, 2))
921 self.assertRaises(RuntimeError, next, it)
922
Christian Heimesc3f30c42008-02-22 16:37:40 +0000923 def test_product(self):
924 for args, result in [
Christian Heimes78644762008-03-04 23:39:23 +0000925 ([], [()]), # zero iterables
Christian Heimesc3f30c42008-02-22 16:37:40 +0000926 (['ab'], [('a',), ('b',)]), # one iterable
927 ([range(2), range(3)], [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2)]), # two iterables
928 ([range(0), range(2), range(3)], []), # first iterable with zero length
929 ([range(2), range(0), range(3)], []), # middle iterable with zero length
930 ([range(2), range(3), range(0)], []), # last iterable with zero length
931 ]:
932 self.assertEqual(list(product(*args)), result)
Christian Heimesf16baeb2008-02-29 14:57:44 +0000933 for r in range(4):
934 self.assertEqual(list(product(*(args*r))),
935 list(product(*args, **dict(repeat=r))))
Christian Heimesc3f30c42008-02-22 16:37:40 +0000936 self.assertEqual(len(list(product(*[range(7)]*6))), 7**6)
937 self.assertRaises(TypeError, product, range(6), None)
Christian Heimesdd15f6c2008-03-16 00:07:10 +0000938
939 def product1(*args, **kwds):
940 pools = list(map(tuple, args)) * kwds.get('repeat', 1)
941 n = len(pools)
942 if n == 0:
943 yield ()
944 return
945 if any(len(pool) == 0 for pool in pools):
946 return
947 indices = [0] * n
948 yield tuple(pool[i] for pool, i in zip(pools, indices))
949 while 1:
950 for i in reversed(range(n)): # right to left
951 if indices[i] == len(pools[i]) - 1:
952 continue
953 indices[i] += 1
954 for j in range(i+1, n):
955 indices[j] = 0
956 yield tuple(pool[i] for pool, i in zip(pools, indices))
957 break
958 else:
959 return
960
961 def product2(*args, **kwds):
962 'Pure python version used in docs'
963 pools = list(map(tuple, args)) * kwds.get('repeat', 1)
964 result = [[]]
965 for pool in pools:
966 result = [x+[y] for x in result for y in pool]
967 for prod in result:
968 yield tuple(prod)
969
Christian Heimesc3f30c42008-02-22 16:37:40 +0000970 argtypes = ['', 'abc', '', range(0), range(4), dict(a=1, b=2, c=3),
971 set('abcdefg'), range(11), tuple(range(13))]
972 for i in range(100):
973 args = [random.choice(argtypes) for j in range(random.randrange(5))]
Christian Heimes78644762008-03-04 23:39:23 +0000974 expected_len = prod(map(len, args))
975 self.assertEqual(len(list(product(*args))), expected_len)
Christian Heimesdd15f6c2008-03-16 00:07:10 +0000976 self.assertEqual(list(product(*args)), list(product1(*args)))
977 self.assertEqual(list(product(*args)), list(product2(*args)))
Christian Heimesc3f30c42008-02-22 16:37:40 +0000978 args = map(iter, args)
Christian Heimes78644762008-03-04 23:39:23 +0000979 self.assertEqual(len(list(product(*args))), expected_len)
Christian Heimesc3f30c42008-02-22 16:37:40 +0000980
Benjamin Peterson0eaabf12015-02-01 21:34:07 -0500981 @support.bigaddrspacetest
982 def test_product_overflow(self):
Serhiy Storchakadee948b2015-02-03 01:34:09 +0200983 with self.assertRaises((OverflowError, MemoryError)):
984 product(*(['ab']*2**5), repeat=2**25)
Benjamin Peterson0eaabf12015-02-01 21:34:07 -0500985
Alex Gaynore151d212011-07-17 16:21:30 -0700986 @support.impl_detail("tuple reuse is specific to CPython")
987 def test_product_tuple_reuse(self):
Christian Heimes90c3d9b2008-02-23 13:18:03 +0000988 self.assertEqual(len(set(map(id, product('abc', 'def')))), 1)
989 self.assertNotEqual(len(set(map(id, list(product('abc', 'def'))))), 1)
Christian Heimesc3f30c42008-02-22 16:37:40 +0000990
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +0000991 def test_product_pickling(self):
992 # check copy, deepcopy, pickle
993 for args, result in [
994 ([], [()]), # zero iterables
995 (['ab'], [('a',), ('b',)]), # one iterable
996 ([range(2), range(3)], [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2)]), # two iterables
997 ([range(0), range(2), range(3)], []), # first iterable with zero length
998 ([range(2), range(0), range(3)], []), # middle iterable with zero length
999 ([range(2), range(3), range(0)], []), # last iterable with zero length
1000 ]:
1001 self.assertEqual(list(copy.copy(product(*args))), result)
1002 self.assertEqual(list(copy.deepcopy(product(*args))), result)
Serhiy Storchakabad12572014-12-15 14:03:42 +02001003 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1004 self.pickletest(proto, product(*args))
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001005
Kristján Valur Jónsson102764a2015-09-12 15:20:54 +00001006 def test_product_issue_25021(self):
1007 # test that indices are properly clamped to the length of the tuples
1008 p = product((1, 2),(3,))
1009 p.__setstate__((0, 0x1000)) # will access tuple element 1 if not clamped
1010 self.assertEqual(next(p), (2, 3))
1011 # test that empty tuple in the list will result in an immediate StopIteration
1012 p = product((1, 2), (), (3,))
1013 p.__setstate__((0, 0, 0x1000)) # will access tuple element 1 if not clamped
1014 self.assertRaises(StopIteration, next, p)
1015
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001016 def test_repeat(self):
Raymond Hettingerf4bb7f22009-02-19 02:44:01 +00001017 self.assertEqual(list(repeat(object='a', times=3)), ['a', 'a', 'a'])
Guido van Rossum805365e2007-05-07 22:24:25 +00001018 self.assertEqual(lzip(range(3),repeat('a')),
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001019 [(0, 'a'), (1, 'a'), (2, 'a')])
Raymond Hettinger61fe64d2003-02-23 04:40:07 +00001020 self.assertEqual(list(repeat('a', 3)), ['a', 'a', 'a'])
Raymond Hettinger02420702003-06-29 20:36:23 +00001021 self.assertEqual(take(3, repeat('a')), ['a', 'a', 'a'])
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +00001022 self.assertEqual(list(repeat('a', 0)), [])
1023 self.assertEqual(list(repeat('a', -3)), [])
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001024 self.assertRaises(TypeError, repeat)
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +00001025 self.assertRaises(TypeError, repeat, None, 3, 4)
1026 self.assertRaises(TypeError, repeat, None, 'a')
Raymond Hettinger4cda01e2004-09-28 04:45:28 +00001027 r = repeat(1+0j)
1028 self.assertEqual(repr(r), 'repeat((1+0j))')
1029 r = repeat(1+0j, 5)
1030 self.assertEqual(repr(r), 'repeat((1+0j), 5)')
1031 list(r)
1032 self.assertEqual(repr(r), 'repeat((1+0j), 0)')
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001033
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001034 # check copy, deepcopy, pickle
1035 c = repeat(object='a', times=10)
1036 self.assertEqual(next(c), 'a')
1037 self.assertEqual(take(2, copy.copy(c)), list('a' * 2))
1038 self.assertEqual(take(2, copy.deepcopy(c)), list('a' * 2))
Serhiy Storchakabad12572014-12-15 14:03:42 +02001039 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1040 self.pickletest(proto, repeat(object='a', times=10))
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001041
Raymond Hettinger97d35552014-06-24 21:36:58 -07001042 def test_repeat_with_negative_times(self):
1043 self.assertEqual(repr(repeat('a', -1)), "repeat('a', 0)")
1044 self.assertEqual(repr(repeat('a', -2)), "repeat('a', 0)")
1045 self.assertEqual(repr(repeat('a', times=-1)), "repeat('a', 0)")
1046 self.assertEqual(repr(repeat('a', times=-2)), "repeat('a', 0)")
1047
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001048 def test_map(self):
1049 self.assertEqual(list(map(operator.pow, range(3), range(1,7))),
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001050 [0**1, 1**2, 2**3])
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001051 self.assertEqual(list(map(tupleize, 'abc', range(5))),
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001052 [('a',0),('b',1),('c',2)])
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001053 self.assertEqual(list(map(tupleize, 'abc', count())),
Raymond Hettinger02420702003-06-29 20:36:23 +00001054 [('a',0),('b',1),('c',2)])
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001055 self.assertEqual(take(2,map(tupleize, 'abc', count())),
Raymond Hettinger02420702003-06-29 20:36:23 +00001056 [('a',0),('b',1)])
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001057 self.assertEqual(list(map(operator.pow, [])), [])
1058 self.assertRaises(TypeError, map)
1059 self.assertRaises(TypeError, list, map(None, range(3), range(3)))
1060 self.assertRaises(TypeError, map, operator.neg)
1061 self.assertRaises(TypeError, next, map(10, range(5)))
1062 self.assertRaises(ValueError, next, map(errfunc, [4], [5]))
1063 self.assertRaises(TypeError, next, map(onearg, [4], [5]))
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001064
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001065 # check copy, deepcopy, pickle
1066 ans = [('a',0),('b',1),('c',2)]
1067
1068 c = map(tupleize, 'abc', count())
1069 self.assertEqual(list(copy.copy(c)), ans)
1070
1071 c = map(tupleize, 'abc', count())
1072 self.assertEqual(list(copy.deepcopy(c)), ans)
1073
Serhiy Storchakabad12572014-12-15 14:03:42 +02001074 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1075 c = map(tupleize, 'abc', count())
1076 self.pickletest(proto, c)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001077
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001078 def test_starmap(self):
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001079 self.assertEqual(list(starmap(operator.pow, zip(range(3), range(1,7)))),
1080 [0**1, 1**2, 2**3])
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001081 self.assertEqual(take(3, starmap(operator.pow, zip(count(), count(1)))),
Raymond Hettinger02420702003-06-29 20:36:23 +00001082 [0**1, 1**2, 2**3])
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +00001083 self.assertEqual(list(starmap(operator.pow, [])), [])
Christian Heimes679db4a2008-01-18 09:56:22 +00001084 self.assertEqual(list(starmap(operator.pow, [iter([4,5])])), [4**5])
1085 self.assertRaises(TypeError, list, starmap(operator.pow, [None]))
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +00001086 self.assertRaises(TypeError, starmap)
1087 self.assertRaises(TypeError, starmap, operator.pow, [(4,5)], 'extra')
Georg Brandla18af4e2007-04-21 15:47:16 +00001088 self.assertRaises(TypeError, next, starmap(10, [(4,5)]))
1089 self.assertRaises(ValueError, next, starmap(errfunc, [(4,5)]))
1090 self.assertRaises(TypeError, next, starmap(onearg, [(4,5)]))
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001091
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001092 # check copy, deepcopy, pickle
1093 ans = [0**1, 1**2, 2**3]
1094
1095 c = starmap(operator.pow, zip(range(3), range(1,7)))
1096 self.assertEqual(list(copy.copy(c)), ans)
1097
1098 c = starmap(operator.pow, zip(range(3), range(1,7)))
1099 self.assertEqual(list(copy.deepcopy(c)), ans)
1100
Serhiy Storchakabad12572014-12-15 14:03:42 +02001101 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1102 c = starmap(operator.pow, zip(range(3), range(1,7)))
1103 self.pickletest(proto, c)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001104
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001105 def test_islice(self):
1106 for args in [ # islice(args) should agree with range(args)
1107 (10, 20, 3),
1108 (10, 3, 20),
1109 (10, 20),
1110 (10, 3),
1111 (20,)
1112 ]:
Guido van Rossum805365e2007-05-07 22:24:25 +00001113 self.assertEqual(list(islice(range(100), *args)),
1114 list(range(*args)))
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001115
1116 for args, tgtargs in [ # Stop when seqn is exhausted
1117 ((10, 110, 3), ((10, 100, 3))),
1118 ((10, 110), ((10, 100))),
1119 ((110,), (100,))
1120 ]:
Guido van Rossum805365e2007-05-07 22:24:25 +00001121 self.assertEqual(list(islice(range(100), *args)),
1122 list(range(*tgtargs)))
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001123
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00001124 # Test stop=None
Guido van Rossum805365e2007-05-07 22:24:25 +00001125 self.assertEqual(list(islice(range(10), None)), list(range(10)))
1126 self.assertEqual(list(islice(range(10), None, None)), list(range(10)))
1127 self.assertEqual(list(islice(range(10), None, None, None)), list(range(10)))
1128 self.assertEqual(list(islice(range(10), 2, None)), list(range(2, 10)))
1129 self.assertEqual(list(islice(range(10), 1, None, 2)), list(range(1, 10, 2)))
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00001130
Raymond Hettingerfdf3bd62005-03-27 20:11:44 +00001131 # Test number of items consumed SF #1171417
1132 it = iter(range(10))
Guido van Rossum805365e2007-05-07 22:24:25 +00001133 self.assertEqual(list(islice(it, 3)), list(range(3)))
1134 self.assertEqual(list(it), list(range(3, 10)))
Raymond Hettingerfdf3bd62005-03-27 20:11:44 +00001135
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00001136 # Test invalid arguments
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001137 ra = range(10)
1138 self.assertRaises(TypeError, islice, ra)
1139 self.assertRaises(TypeError, islice, ra, 1, 2, 3, 4)
1140 self.assertRaises(ValueError, islice, ra, -5, 10, 1)
1141 self.assertRaises(ValueError, islice, ra, 1, -5, -1)
1142 self.assertRaises(ValueError, islice, ra, 1, 10, -1)
1143 self.assertRaises(ValueError, islice, ra, 1, 10, 0)
1144 self.assertRaises(ValueError, islice, ra, 'a')
1145 self.assertRaises(ValueError, islice, ra, 'a', 1)
1146 self.assertRaises(ValueError, islice, ra, 1, 'a')
1147 self.assertRaises(ValueError, islice, ra, 'a', 1, 1)
1148 self.assertRaises(ValueError, islice, ra, 1, 'a', 1)
Guido van Rossum360e4b82007-05-14 22:51:27 +00001149 self.assertEqual(len(list(islice(count(), 1, 10, maxsize))), 1)
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001150
Raymond Hettinger69b34bf2010-11-30 02:49:29 +00001151 # Issue #10323: Less islice in a predictable state
1152 c = count()
1153 self.assertEqual(list(islice(c, 1, 3, 50)), [1])
1154 self.assertEqual(next(c), 3)
1155
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001156 # check copy, deepcopy, pickle
1157 for args in [ # islice(args) should agree with range(args)
1158 (10, 20, 3),
1159 (10, 3, 20),
1160 (10, 20),
1161 (10, 3),
1162 (20,)
1163 ]:
1164 self.assertEqual(list(copy.copy(islice(range(100), *args))),
1165 list(range(*args)))
1166 self.assertEqual(list(copy.deepcopy(islice(range(100), *args))),
1167 list(range(*args)))
Serhiy Storchakabad12572014-12-15 14:03:42 +02001168 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1169 self.pickletest(proto, islice(range(100), *args))
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001170
Antoine Pitrou26f82ef2014-04-29 12:13:46 +02001171 # Issue #21321: check source iterator is not referenced
1172 # from islice() after the latter has been exhausted
1173 it = (x for x in (1, 2))
1174 wr = weakref.ref(it)
1175 it = islice(it, 1)
1176 self.assertIsNotNone(wr())
1177 list(it) # exhaust the iterator
Benjamin Peterson8e163512014-08-24 18:07:28 -05001178 support.gc_collect()
Antoine Pitrou26f82ef2014-04-29 12:13:46 +02001179 self.assertIsNone(wr())
1180
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001181 def test_takewhile(self):
1182 data = [1, 3, 5, 20, 2, 4, 6, 8]
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001183 self.assertEqual(list(takewhile(underten, data)), [1, 3, 5])
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +00001184 self.assertEqual(list(takewhile(underten, [])), [])
1185 self.assertRaises(TypeError, takewhile)
1186 self.assertRaises(TypeError, takewhile, operator.pow)
1187 self.assertRaises(TypeError, takewhile, operator.pow, [(4,5)], 'extra')
Georg Brandla18af4e2007-04-21 15:47:16 +00001188 self.assertRaises(TypeError, next, takewhile(10, [(4,5)]))
1189 self.assertRaises(ValueError, next, takewhile(errfunc, [(4,5)]))
Raymond Hettinger4cda01e2004-09-28 04:45:28 +00001190 t = takewhile(bool, [1, 1, 1, 0, 0, 0])
1191 self.assertEqual(list(t), [1, 1, 1])
Georg Brandla18af4e2007-04-21 15:47:16 +00001192 self.assertRaises(StopIteration, next, t)
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001193
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001194 # check copy, deepcopy, pickle
1195 self.assertEqual(list(copy.copy(takewhile(underten, data))), [1, 3, 5])
1196 self.assertEqual(list(copy.deepcopy(takewhile(underten, data))),
1197 [1, 3, 5])
Serhiy Storchakabad12572014-12-15 14:03:42 +02001198 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1199 self.pickletest(proto, takewhile(underten, data))
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001200
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001201 def test_dropwhile(self):
1202 data = [1, 3, 5, 20, 2, 4, 6, 8]
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001203 self.assertEqual(list(dropwhile(underten, data)), [20, 2, 4, 6, 8])
Raymond Hettinger7c2bb5b2003-05-03 05:59:48 +00001204 self.assertEqual(list(dropwhile(underten, [])), [])
1205 self.assertRaises(TypeError, dropwhile)
1206 self.assertRaises(TypeError, dropwhile, operator.pow)
1207 self.assertRaises(TypeError, dropwhile, operator.pow, [(4,5)], 'extra')
Georg Brandla18af4e2007-04-21 15:47:16 +00001208 self.assertRaises(TypeError, next, dropwhile(10, [(4,5)]))
1209 self.assertRaises(ValueError, next, dropwhile(errfunc, [(4,5)]))
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001210
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001211 # check copy, deepcopy, pickle
1212 self.assertEqual(list(copy.copy(dropwhile(underten, data))), [20, 2, 4, 6, 8])
1213 self.assertEqual(list(copy.deepcopy(dropwhile(underten, data))),
1214 [20, 2, 4, 6, 8])
Serhiy Storchakabad12572014-12-15 14:03:42 +02001215 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1216 self.pickletest(proto, dropwhile(underten, data))
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001217
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001218 def test_tee(self):
Raymond Hettingerad983e72003-11-12 14:32:26 +00001219 n = 200
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001220
1221 a, b = tee([]) # test empty iterator
1222 self.assertEqual(list(a), [])
1223 self.assertEqual(list(b), [])
1224
1225 a, b = tee(irange(n)) # test 100% interleaved
Guido van Rossum801f0d72006-08-24 19:48:10 +00001226 self.assertEqual(lzip(a,b), lzip(range(n), range(n)))
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001227
1228 a, b = tee(irange(n)) # test 0% interleaved
Guido van Rossum805365e2007-05-07 22:24:25 +00001229 self.assertEqual(list(a), list(range(n)))
1230 self.assertEqual(list(b), list(range(n)))
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001231
1232 a, b = tee(irange(n)) # test dealloc of leading iterator
Guido van Rossum805365e2007-05-07 22:24:25 +00001233 for i in range(100):
Georg Brandla18af4e2007-04-21 15:47:16 +00001234 self.assertEqual(next(a), i)
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001235 del a
Guido van Rossum805365e2007-05-07 22:24:25 +00001236 self.assertEqual(list(b), list(range(n)))
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001237
1238 a, b = tee(irange(n)) # test dealloc of trailing iterator
Guido van Rossum805365e2007-05-07 22:24:25 +00001239 for i in range(100):
Georg Brandla18af4e2007-04-21 15:47:16 +00001240 self.assertEqual(next(a), i)
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001241 del b
Guido van Rossum805365e2007-05-07 22:24:25 +00001242 self.assertEqual(list(a), list(range(100, n)))
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001243
Guido van Rossum805365e2007-05-07 22:24:25 +00001244 for j in range(5): # test randomly interleaved
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001245 order = [0]*n + [1]*n
1246 random.shuffle(order)
1247 lists = ([], [])
1248 its = tee(irange(n))
1249 for i in order:
Georg Brandla18af4e2007-04-21 15:47:16 +00001250 value = next(its[i])
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001251 lists[i].append(value)
Guido van Rossum805365e2007-05-07 22:24:25 +00001252 self.assertEqual(lists[0], list(range(n)))
1253 self.assertEqual(lists[1], list(range(n)))
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001254
Raymond Hettingerad983e72003-11-12 14:32:26 +00001255 # test argument format checking
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001256 self.assertRaises(TypeError, tee)
1257 self.assertRaises(TypeError, tee, 3)
1258 self.assertRaises(TypeError, tee, [1,2], 'x')
Raymond Hettingerad983e72003-11-12 14:32:26 +00001259 self.assertRaises(TypeError, tee, [1,2], 3, 'x')
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001260
Raymond Hettingerad983e72003-11-12 14:32:26 +00001261 # tee object should be instantiable
1262 a, b = tee('abc')
1263 c = type(a)('def')
1264 self.assertEqual(list(c), list('def'))
Raymond Hettingerf0c5aec2003-10-26 14:25:56 +00001265
Raymond Hettingerad983e72003-11-12 14:32:26 +00001266 # test long-lagged and multi-way split
Guido van Rossum805365e2007-05-07 22:24:25 +00001267 a, b, c = tee(range(2000), 3)
1268 for i in range(100):
Georg Brandla18af4e2007-04-21 15:47:16 +00001269 self.assertEqual(next(a), i)
Guido van Rossum805365e2007-05-07 22:24:25 +00001270 self.assertEqual(list(b), list(range(2000)))
1271 self.assertEqual([next(c), next(c)], list(range(2)))
1272 self.assertEqual(list(a), list(range(100,2000)))
1273 self.assertEqual(list(c), list(range(2,2000)))
Raymond Hettingerad983e72003-11-12 14:32:26 +00001274
Raymond Hettinger4cda01e2004-09-28 04:45:28 +00001275 # test values of n
1276 self.assertRaises(TypeError, tee, 'abc', 'invalid')
Thomas Wouters89f507f2006-12-13 04:49:30 +00001277 self.assertRaises(ValueError, tee, [], -1)
Guido van Rossum805365e2007-05-07 22:24:25 +00001278 for n in range(5):
Raymond Hettinger4cda01e2004-09-28 04:45:28 +00001279 result = tee('abc', n)
1280 self.assertEqual(type(result), tuple)
1281 self.assertEqual(len(result), n)
Guido van Rossumc1f779c2007-07-03 08:25:58 +00001282 self.assertEqual([list(x) for x in result], [list('abc')]*n)
Raymond Hettinger4cda01e2004-09-28 04:45:28 +00001283
Raymond Hettingerad983e72003-11-12 14:32:26 +00001284 # tee pass-through to copyable iterator
1285 a, b = tee('abc')
1286 c, d = tee(a)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00001287 self.assertTrue(a is c)
Raymond Hettingerad983e72003-11-12 14:32:26 +00001288
Raymond Hettinger4cda01e2004-09-28 04:45:28 +00001289 # test tee_new
1290 t1, t2 = tee('abc')
1291 tnew = type(t1)
1292 self.assertRaises(TypeError, tnew)
1293 self.assertRaises(TypeError, tnew, 10)
1294 t3 = tnew(t1)
Benjamin Petersonc9c0f202009-06-30 23:06:06 +00001295 self.assertTrue(list(t1) == list(t2) == list(t3) == list('abc'))
Raymond Hettingerf0c5aec2003-10-26 14:25:56 +00001296
Raymond Hettingera9f60922004-10-17 16:40:14 +00001297 # test that tee objects are weak referencable
Guido van Rossum805365e2007-05-07 22:24:25 +00001298 a, b = tee(range(10))
Antoine Pitrou26f82ef2014-04-29 12:13:46 +02001299 p = weakref.proxy(a)
Raymond Hettingera9f60922004-10-17 16:40:14 +00001300 self.assertEqual(getattr(p, '__class__'), type(b))
1301 del a
1302 self.assertRaises(ReferenceError, getattr, p, '__class__')
1303
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001304 ans = list('abc')
1305 long_ans = list(range(10000))
1306
1307 # check copy
1308 a, b = tee('abc')
1309 self.assertEqual(list(copy.copy(a)), ans)
1310 self.assertEqual(list(copy.copy(b)), ans)
1311 a, b = tee(list(range(10000)))
1312 self.assertEqual(list(copy.copy(a)), long_ans)
1313 self.assertEqual(list(copy.copy(b)), long_ans)
1314
1315 # check partially consumed copy
1316 a, b = tee('abc')
1317 take(2, a)
1318 take(1, b)
1319 self.assertEqual(list(copy.copy(a)), ans[2:])
1320 self.assertEqual(list(copy.copy(b)), ans[1:])
1321 self.assertEqual(list(a), ans[2:])
1322 self.assertEqual(list(b), ans[1:])
1323 a, b = tee(range(10000))
1324 take(100, a)
1325 take(60, b)
1326 self.assertEqual(list(copy.copy(a)), long_ans[100:])
1327 self.assertEqual(list(copy.copy(b)), long_ans[60:])
1328 self.assertEqual(list(a), long_ans[100:])
1329 self.assertEqual(list(b), long_ans[60:])
1330
1331 # check deepcopy
1332 a, b = tee('abc')
1333 self.assertEqual(list(copy.deepcopy(a)), ans)
1334 self.assertEqual(list(copy.deepcopy(b)), ans)
1335 self.assertEqual(list(a), ans)
1336 self.assertEqual(list(b), ans)
1337 a, b = tee(range(10000))
1338 self.assertEqual(list(copy.deepcopy(a)), long_ans)
1339 self.assertEqual(list(copy.deepcopy(b)), long_ans)
1340 self.assertEqual(list(a), long_ans)
1341 self.assertEqual(list(b), long_ans)
1342
1343 # check partially consumed deepcopy
1344 a, b = tee('abc')
1345 take(2, a)
1346 take(1, b)
1347 self.assertEqual(list(copy.deepcopy(a)), ans[2:])
1348 self.assertEqual(list(copy.deepcopy(b)), ans[1:])
1349 self.assertEqual(list(a), ans[2:])
1350 self.assertEqual(list(b), ans[1:])
1351 a, b = tee(range(10000))
1352 take(100, a)
1353 take(60, b)
1354 self.assertEqual(list(copy.deepcopy(a)), long_ans[100:])
1355 self.assertEqual(list(copy.deepcopy(b)), long_ans[60:])
1356 self.assertEqual(list(a), long_ans[100:])
1357 self.assertEqual(list(b), long_ans[60:])
1358
1359 # check pickle
Serhiy Storchakabad12572014-12-15 14:03:42 +02001360 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1361 self.pickletest(proto, iter(tee('abc')))
1362 a, b = tee('abc')
1363 self.pickletest(proto, a, compare=ans)
1364 self.pickletest(proto, b, compare=ans)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001365
Serhiy Storchakaa3e91282013-01-25 13:19:31 +02001366 # Issue 13454: Crash when deleting backward iterator from tee()
1367 def test_tee_del_backward(self):
Serhiy Storchaka5bb893c2013-01-26 11:52:06 +02001368 forward, backward = tee(repeat(None, 20000000))
Serhiy Storchaka9db55002015-03-28 20:38:37 +02001369 try:
1370 any(forward) # exhaust the iterator
1371 del backward
1372 except:
1373 del forward, backward
1374 raise
Serhiy Storchakaa3e91282013-01-25 13:19:31 +02001375
Raymond Hettinger8fd3f872003-05-02 22:38:07 +00001376 def test_StopIteration(self):
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001377 self.assertRaises(StopIteration, next, zip())
Raymond Hettingerb5a42082003-08-08 05:10:41 +00001378
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001379 for f in (chain, cycle, zip, groupby):
Georg Brandla18af4e2007-04-21 15:47:16 +00001380 self.assertRaises(StopIteration, next, f([]))
1381 self.assertRaises(StopIteration, next, f(StopNow()))
Raymond Hettinger8fd3f872003-05-02 22:38:07 +00001382
Georg Brandla18af4e2007-04-21 15:47:16 +00001383 self.assertRaises(StopIteration, next, islice([], None))
1384 self.assertRaises(StopIteration, next, islice(StopNow(), None))
Raymond Hettinger8fd3f872003-05-02 22:38:07 +00001385
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001386 p, q = tee([])
Georg Brandla18af4e2007-04-21 15:47:16 +00001387 self.assertRaises(StopIteration, next, p)
1388 self.assertRaises(StopIteration, next, q)
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001389 p, q = tee(StopNow())
Georg Brandla18af4e2007-04-21 15:47:16 +00001390 self.assertRaises(StopIteration, next, p)
1391 self.assertRaises(StopIteration, next, q)
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001392
Georg Brandla18af4e2007-04-21 15:47:16 +00001393 self.assertRaises(StopIteration, next, repeat(None, 0))
Raymond Hettinger8fd3f872003-05-02 22:38:07 +00001394
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001395 for f in (filter, filterfalse, map, takewhile, dropwhile, starmap):
Georg Brandla18af4e2007-04-21 15:47:16 +00001396 self.assertRaises(StopIteration, next, f(lambda x:x, []))
1397 self.assertRaises(StopIteration, next, f(lambda x:x, StopNow()))
Raymond Hettinger8fd3f872003-05-02 22:38:07 +00001398
Christian Heimesdd15f6c2008-03-16 00:07:10 +00001399class TestExamples(unittest.TestCase):
1400
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001401 def test_accumulate(self):
Raymond Hettinger482ba772010-12-01 22:48:00 +00001402 self.assertEqual(list(accumulate([1,2,3,4,5])), [1, 3, 6, 10, 15])
1403
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001404 def test_accumulate_reducible(self):
1405 # check copy, deepcopy, pickle
1406 data = [1, 2, 3, 4, 5]
1407 accumulated = [1, 3, 6, 10, 15]
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001408
Serhiy Storchakabad12572014-12-15 14:03:42 +02001409 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1410 it = accumulate(data)
1411 self.assertEqual(list(pickle.loads(pickle.dumps(it, proto))), accumulated[:])
1412 self.assertEqual(next(it), 1)
1413 self.assertEqual(list(pickle.loads(pickle.dumps(it, proto))), accumulated[1:])
1414 it = accumulate(data)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001415 self.assertEqual(next(it), 1)
Kristján Valur Jónsson31668b82012-04-03 10:49:41 +00001416 self.assertEqual(list(copy.deepcopy(it)), accumulated[1:])
1417 self.assertEqual(list(copy.copy(it)), accumulated[1:])
1418
Serhiy Storchakad5516252016-03-06 14:00:45 +02001419 def test_accumulate_reducible_none(self):
1420 # Issue #25718: total is None
1421 it = accumulate([None, None, None], operator.is_)
1422 self.assertEqual(next(it), None)
1423 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
1424 it_copy = pickle.loads(pickle.dumps(it, proto))
1425 self.assertEqual(list(it_copy), [True, False])
1426 self.assertEqual(list(copy.deepcopy(it)), [True, False])
1427 self.assertEqual(list(copy.copy(it)), [True, False])
1428
Christian Heimesdd15f6c2008-03-16 00:07:10 +00001429 def test_chain(self):
1430 self.assertEqual(''.join(chain('ABC', 'DEF')), 'ABCDEF')
1431
1432 def test_chain_from_iterable(self):
1433 self.assertEqual(''.join(chain.from_iterable(['ABC', 'DEF'])), 'ABCDEF')
1434
1435 def test_combinations(self):
1436 self.assertEqual(list(combinations('ABCD', 2)),
1437 [('A','B'), ('A','C'), ('A','D'), ('B','C'), ('B','D'), ('C','D')])
1438 self.assertEqual(list(combinations(range(4), 3)),
1439 [(0,1,2), (0,1,3), (0,2,3), (1,2,3)])
1440
Raymond Hettingerd07d9392009-01-27 04:20:44 +00001441 def test_combinations_with_replacement(self):
1442 self.assertEqual(list(combinations_with_replacement('ABC', 2)),
1443 [('A','A'), ('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')])
1444
Raymond Hettinger6b3b0fc2009-01-26 02:56:58 +00001445 def test_compress(self):
1446 self.assertEqual(list(compress('ABCDEF', [1,0,1,0,1,1])), list('ACEF'))
1447
Christian Heimesdd15f6c2008-03-16 00:07:10 +00001448 def test_count(self):
1449 self.assertEqual(list(islice(count(10), 5)), [10, 11, 12, 13, 14])
1450
1451 def test_cycle(self):
1452 self.assertEqual(list(islice(cycle('ABCD'), 12)), list('ABCDABCDABCD'))
1453
1454 def test_dropwhile(self):
1455 self.assertEqual(list(dropwhile(lambda x: x<5, [1,4,6,4,1])), [6,4,1])
1456
1457 def test_groupby(self):
1458 self.assertEqual([k for k, g in groupby('AAAABBBCCDAABBB')],
1459 list('ABCDAB'))
1460 self.assertEqual([(list(g)) for k, g in groupby('AAAABBBCCD')],
1461 [list('AAAA'), list('BBB'), list('CC'), list('D')])
1462
1463 def test_filter(self):
1464 self.assertEqual(list(filter(lambda x: x%2, range(10))), [1,3,5,7,9])
1465
1466 def test_filterfalse(self):
1467 self.assertEqual(list(filterfalse(lambda x: x%2, range(10))), [0,2,4,6,8])
1468
1469 def test_map(self):
1470 self.assertEqual(list(map(pow, (2,3,10), (5,2,3))), [32, 9, 1000])
1471
1472 def test_islice(self):
1473 self.assertEqual(list(islice('ABCDEFG', 2)), list('AB'))
1474 self.assertEqual(list(islice('ABCDEFG', 2, 4)), list('CD'))
1475 self.assertEqual(list(islice('ABCDEFG', 2, None)), list('CDEFG'))
1476 self.assertEqual(list(islice('ABCDEFG', 0, None, 2)), list('ACEG'))
1477
1478 def test_zip(self):
1479 self.assertEqual(list(zip('ABCD', 'xy')), [('A', 'x'), ('B', 'y')])
1480
1481 def test_zip_longest(self):
1482 self.assertEqual(list(zip_longest('ABCD', 'xy', fillvalue='-')),
1483 [('A', 'x'), ('B', 'y'), ('C', '-'), ('D', '-')])
1484
1485 def test_permutations(self):
1486 self.assertEqual(list(permutations('ABCD', 2)),
1487 list(map(tuple, 'AB AC AD BA BC BD CA CB CD DA DB DC'.split())))
1488 self.assertEqual(list(permutations(range(3))),
1489 [(0,1,2), (0,2,1), (1,0,2), (1,2,0), (2,0,1), (2,1,0)])
1490
1491 def test_product(self):
1492 self.assertEqual(list(product('ABCD', 'xy')),
1493 list(map(tuple, 'Ax Ay Bx By Cx Cy Dx Dy'.split())))
1494 self.assertEqual(list(product(range(2), repeat=3)),
1495 [(0,0,0), (0,0,1), (0,1,0), (0,1,1),
1496 (1,0,0), (1,0,1), (1,1,0), (1,1,1)])
1497
1498 def test_repeat(self):
1499 self.assertEqual(list(repeat(10, 3)), [10, 10, 10])
1500
1501 def test_stapmap(self):
1502 self.assertEqual(list(starmap(pow, [(2,5), (3,2), (10,3)])),
1503 [32, 9, 1000])
1504
1505 def test_takewhile(self):
1506 self.assertEqual(list(takewhile(lambda x: x<5, [1,4,6,4,1])), [1,4])
1507
1508
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001509class TestGC(unittest.TestCase):
1510
1511 def makecycle(self, iterator, container):
1512 container.append(iterator)
Georg Brandla18af4e2007-04-21 15:47:16 +00001513 next(iterator)
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001514 del container, iterator
1515
Raymond Hettinger482ba772010-12-01 22:48:00 +00001516 def test_accumulate(self):
1517 a = []
1518 self.makecycle(accumulate([1,2,a,3]), a)
1519
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001520 def test_chain(self):
1521 a = []
1522 self.makecycle(chain(a), a)
1523
Christian Heimesdd15f6c2008-03-16 00:07:10 +00001524 def test_chain_from_iterable(self):
1525 a = []
1526 self.makecycle(chain.from_iterable([a]), a)
1527
1528 def test_combinations(self):
1529 a = []
1530 self.makecycle(combinations([1,2,a,3], 3), a)
1531
Raymond Hettingerd07d9392009-01-27 04:20:44 +00001532 def test_combinations_with_replacement(self):
1533 a = []
1534 self.makecycle(combinations_with_replacement([1,2,a,3], 3), a)
1535
Raymond Hettinger6b3b0fc2009-01-26 02:56:58 +00001536 def test_compress(self):
1537 a = []
1538 self.makecycle(compress('ABCDEF', [1,0,1,0,1,0]), a)
1539
Raymond Hettingerd6280f42009-02-16 20:50:56 +00001540 def test_count(self):
1541 a = []
1542 Int = type('Int', (int,), dict(x=a))
1543 self.makecycle(count(Int(0), Int(1)), a)
1544
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001545 def test_cycle(self):
1546 a = []
1547 self.makecycle(cycle([a]*2), a)
1548
Raymond Hettingerff5dc0e2004-09-29 11:40:50 +00001549 def test_dropwhile(self):
1550 a = []
1551 self.makecycle(dropwhile(bool, [0, a, a]), a)
1552
1553 def test_groupby(self):
1554 a = []
1555 self.makecycle(groupby([a]*2, lambda x:x), a)
1556
Christian Heimesdd15f6c2008-03-16 00:07:10 +00001557 def test_issue2246(self):
1558 # Issue 2246 -- the _grouper iterator was not included in GC
1559 n = 10
1560 keyfunc = lambda x: x
1561 for i, j in groupby(range(n), key=keyfunc):
1562 keyfunc.__dict__.setdefault('x',[]).append(j)
1563
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001564 def test_filter(self):
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001565 a = []
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001566 self.makecycle(filter(lambda x:True, [a]*2), a)
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001567
Raymond Hettingerb0002d22008-03-13 01:41:43 +00001568 def test_filterfalse(self):
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001569 a = []
Raymond Hettingerb0002d22008-03-13 01:41:43 +00001570 self.makecycle(filterfalse(lambda x:False, a), a)
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001571
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001572 def test_zip(self):
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001573 a = []
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001574 self.makecycle(zip([a]*2, [a]*3), a)
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001575
Christian Heimesdd15f6c2008-03-16 00:07:10 +00001576 def test_zip_longest(self):
1577 a = []
1578 self.makecycle(zip_longest([a]*2, [a]*3), a)
1579 b = [a, None]
1580 self.makecycle(zip_longest([a]*2, [a]*3, fillvalue=b), a)
1581
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001582 def test_map(self):
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001583 a = []
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001584 self.makecycle(map(lambda x:x, [a]*2), a)
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001585
1586 def test_islice(self):
1587 a = []
1588 self.makecycle(islice([a]*2, None), a)
1589
Christian Heimesdd15f6c2008-03-16 00:07:10 +00001590 def test_permutations(self):
1591 a = []
1592 self.makecycle(permutations([1,2,a,3], 3), a)
1593
1594 def test_product(self):
1595 a = []
1596 self.makecycle(product([1,2,a,3], repeat=3), a)
1597
Raymond Hettingerff5dc0e2004-09-29 11:40:50 +00001598 def test_repeat(self):
1599 a = []
1600 self.makecycle(repeat(a), a)
1601
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001602 def test_starmap(self):
1603 a = []
1604 self.makecycle(starmap(lambda *t: t, [(a,a)]*2), a)
1605
Raymond Hettingerff5dc0e2004-09-29 11:40:50 +00001606 def test_takewhile(self):
1607 a = []
1608 self.makecycle(takewhile(bool, [1, 0, a, a]), a)
1609
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001610def R(seqn):
1611 'Regular generator'
1612 for i in seqn:
1613 yield i
Raymond Hettinger8fd3f872003-05-02 22:38:07 +00001614
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001615class G:
1616 'Sequence using __getitem__'
1617 def __init__(self, seqn):
1618 self.seqn = seqn
1619 def __getitem__(self, i):
1620 return self.seqn[i]
1621
1622class I:
1623 'Sequence using iterator protocol'
1624 def __init__(self, seqn):
1625 self.seqn = seqn
1626 self.i = 0
1627 def __iter__(self):
1628 return self
Georg Brandla18af4e2007-04-21 15:47:16 +00001629 def __next__(self):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001630 if self.i >= len(self.seqn): raise StopIteration
1631 v = self.seqn[self.i]
1632 self.i += 1
1633 return v
1634
1635class Ig:
1636 'Sequence using iterator protocol defined with a generator'
1637 def __init__(self, seqn):
1638 self.seqn = seqn
1639 self.i = 0
1640 def __iter__(self):
1641 for val in self.seqn:
1642 yield val
1643
1644class X:
1645 'Missing __getitem__ and __iter__'
1646 def __init__(self, seqn):
1647 self.seqn = seqn
1648 self.i = 0
Georg Brandla18af4e2007-04-21 15:47:16 +00001649 def __next__(self):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001650 if self.i >= len(self.seqn): raise StopIteration
1651 v = self.seqn[self.i]
1652 self.i += 1
1653 return v
1654
1655class N:
Georg Brandla18af4e2007-04-21 15:47:16 +00001656 'Iterator missing __next__()'
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001657 def __init__(self, seqn):
1658 self.seqn = seqn
1659 self.i = 0
1660 def __iter__(self):
1661 return self
1662
1663class E:
1664 'Test propagation of exceptions'
1665 def __init__(self, seqn):
1666 self.seqn = seqn
1667 self.i = 0
1668 def __iter__(self):
1669 return self
Georg Brandla18af4e2007-04-21 15:47:16 +00001670 def __next__(self):
Raymond Hettingerffdb8bb2004-09-27 15:29:05 +00001671 3 // 0
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001672
1673class S:
1674 'Test immediate stop'
1675 def __init__(self, seqn):
1676 pass
1677 def __iter__(self):
1678 return self
Georg Brandla18af4e2007-04-21 15:47:16 +00001679 def __next__(self):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001680 raise StopIteration
1681
1682def L(seqn):
1683 'Test multiple tiers of iterators'
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001684 return chain(map(lambda x:x, R(Ig(G(seqn)))))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001685
1686
1687class TestVariousIteratorArgs(unittest.TestCase):
1688
Raymond Hettinger482ba772010-12-01 22:48:00 +00001689 def test_accumulate(self):
1690 s = [1,2,3,4,5]
1691 r = [1,3,6,10,15]
1692 n = len(s)
1693 for g in (G, I, Ig, L, R):
1694 self.assertEqual(list(accumulate(g(s))), r)
1695 self.assertEqual(list(accumulate(S(s))), [])
1696 self.assertRaises(TypeError, accumulate, X(s))
1697 self.assertRaises(TypeError, accumulate, N(s))
1698 self.assertRaises(ZeroDivisionError, list, accumulate(E(s)))
1699
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001700 def test_chain(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001701 for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001702 for g in (G, I, Ig, S, L, R):
1703 self.assertEqual(list(chain(g(s))), list(g(s)))
1704 self.assertEqual(list(chain(g(s), g(s))), list(g(s))+list(g(s)))
Christian Heimesf16baeb2008-02-29 14:57:44 +00001705 self.assertRaises(TypeError, list, chain(X(s)))
Mark Dickinson26a96fa2008-03-01 02:27:46 +00001706 self.assertRaises(TypeError, list, chain(N(s)))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001707 self.assertRaises(ZeroDivisionError, list, chain(E(s)))
1708
Raymond Hettinger6b3b0fc2009-01-26 02:56:58 +00001709 def test_compress(self):
1710 for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
1711 n = len(s)
1712 for g in (G, I, Ig, S, L, R):
1713 self.assertEqual(list(compress(g(s), repeat(1))), list(g(s)))
1714 self.assertRaises(TypeError, compress, X(s), repeat(1))
1715 self.assertRaises(TypeError, compress, N(s), repeat(1))
1716 self.assertRaises(ZeroDivisionError, list, compress(E(s), repeat(1)))
1717
Christian Heimesc3f30c42008-02-22 16:37:40 +00001718 def test_product(self):
1719 for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
1720 self.assertRaises(TypeError, product, X(s))
1721 self.assertRaises(TypeError, product, N(s))
1722 self.assertRaises(ZeroDivisionError, product, E(s))
1723
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001724 def test_cycle(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001725 for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001726 for g in (G, I, Ig, S, L, R):
1727 tgtlen = len(s) * 3
1728 expected = list(g(s))*3
1729 actual = list(islice(cycle(g(s)), tgtlen))
1730 self.assertEqual(actual, expected)
1731 self.assertRaises(TypeError, cycle, X(s))
Thomas Wouters8690c4e2006-04-15 09:07:20 +00001732 self.assertRaises(TypeError, cycle, N(s))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001733 self.assertRaises(ZeroDivisionError, list, cycle(E(s)))
1734
Raymond Hettingerd25c1c62003-12-06 16:23:06 +00001735 def test_groupby(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001736 for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
Raymond Hettingerd25c1c62003-12-06 16:23:06 +00001737 for g in (G, I, Ig, S, L, R):
1738 self.assertEqual([k for k, sb in groupby(g(s))], list(g(s)))
1739 self.assertRaises(TypeError, groupby, X(s))
Thomas Wouters8690c4e2006-04-15 09:07:20 +00001740 self.assertRaises(TypeError, groupby, N(s))
Raymond Hettingerd25c1c62003-12-06 16:23:06 +00001741 self.assertRaises(ZeroDivisionError, list, groupby(E(s)))
1742
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001743 def test_filter(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001744 for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001745 for g in (G, I, Ig, S, L, R):
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001746 self.assertEqual(list(filter(isEven, g(s))),
Guido van Rossumc1f779c2007-07-03 08:25:58 +00001747 [x for x in g(s) if isEven(x)])
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001748 self.assertRaises(TypeError, filter, isEven, X(s))
1749 self.assertRaises(TypeError, filter, isEven, N(s))
1750 self.assertRaises(ZeroDivisionError, list, filter(isEven, E(s)))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001751
Raymond Hettingerb0002d22008-03-13 01:41:43 +00001752 def test_filterfalse(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001753 for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001754 for g in (G, I, Ig, S, L, R):
Raymond Hettingerb0002d22008-03-13 01:41:43 +00001755 self.assertEqual(list(filterfalse(isEven, g(s))),
Guido van Rossumc1f779c2007-07-03 08:25:58 +00001756 [x for x in g(s) if isOdd(x)])
Raymond Hettingerb0002d22008-03-13 01:41:43 +00001757 self.assertRaises(TypeError, filterfalse, isEven, X(s))
1758 self.assertRaises(TypeError, filterfalse, isEven, N(s))
1759 self.assertRaises(ZeroDivisionError, list, filterfalse(isEven, E(s)))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001760
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001761 def test_zip(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001762 for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001763 for g in (G, I, Ig, S, L, R):
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001764 self.assertEqual(list(zip(g(s))), lzip(g(s)))
1765 self.assertEqual(list(zip(g(s), g(s))), lzip(g(s), g(s)))
1766 self.assertRaises(TypeError, zip, X(s))
1767 self.assertRaises(TypeError, zip, N(s))
1768 self.assertRaises(ZeroDivisionError, list, zip(E(s)))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001769
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001770 def test_ziplongest(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001771 for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
Thomas Wouterscf297e42007-02-23 15:07:44 +00001772 for g in (G, I, Ig, S, L, R):
Raymond Hettingerb0002d22008-03-13 01:41:43 +00001773 self.assertEqual(list(zip_longest(g(s))), list(zip(g(s))))
1774 self.assertEqual(list(zip_longest(g(s), g(s))), list(zip(g(s), g(s))))
1775 self.assertRaises(TypeError, zip_longest, X(s))
1776 self.assertRaises(TypeError, zip_longest, N(s))
1777 self.assertRaises(ZeroDivisionError, list, zip_longest(E(s)))
Thomas Wouterscf297e42007-02-23 15:07:44 +00001778
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001779 def test_map(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001780 for s in (range(10), range(0), range(100), (7,11), range(20,50,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001781 for g in (G, I, Ig, S, L, R):
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001782 self.assertEqual(list(map(onearg, g(s))),
Guido van Rossumc1f779c2007-07-03 08:25:58 +00001783 [onearg(x) for x in g(s)])
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001784 self.assertEqual(list(map(operator.pow, g(s), g(s))),
Guido van Rossumc1f779c2007-07-03 08:25:58 +00001785 [x**x for x in g(s)])
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001786 self.assertRaises(TypeError, map, onearg, X(s))
1787 self.assertRaises(TypeError, map, onearg, N(s))
1788 self.assertRaises(ZeroDivisionError, list, map(onearg, E(s)))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001789
1790 def test_islice(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001791 for s in ("12345", "", range(1000), ('do', 1.2), range(2000,2200,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001792 for g in (G, I, Ig, S, L, R):
1793 self.assertEqual(list(islice(g(s),1,None,2)), list(g(s))[1::2])
1794 self.assertRaises(TypeError, islice, X(s), 10)
Thomas Wouters8690c4e2006-04-15 09:07:20 +00001795 self.assertRaises(TypeError, islice, N(s), 10)
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001796 self.assertRaises(ZeroDivisionError, list, islice(E(s), 10))
1797
1798 def test_starmap(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001799 for s in (range(10), range(0), range(100), (7,11), range(20,50,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001800 for g in (G, I, Ig, S, L, R):
Guido van Rossum801f0d72006-08-24 19:48:10 +00001801 ss = lzip(s, s)
Guido van Rossumc1f779c2007-07-03 08:25:58 +00001802 self.assertEqual(list(starmap(operator.pow, g(ss))),
1803 [x**x for x in g(s)])
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001804 self.assertRaises(TypeError, starmap, operator.pow, X(ss))
Thomas Wouters8690c4e2006-04-15 09:07:20 +00001805 self.assertRaises(TypeError, starmap, operator.pow, N(ss))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001806 self.assertRaises(ZeroDivisionError, list, starmap(operator.pow, E(ss)))
1807
1808 def test_takewhile(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001809 for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001810 for g in (G, I, Ig, S, L, R):
1811 tgt = []
1812 for elem in g(s):
1813 if not isEven(elem): break
1814 tgt.append(elem)
1815 self.assertEqual(list(takewhile(isEven, g(s))), tgt)
1816 self.assertRaises(TypeError, takewhile, isEven, X(s))
Thomas Wouters8690c4e2006-04-15 09:07:20 +00001817 self.assertRaises(TypeError, takewhile, isEven, N(s))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001818 self.assertRaises(ZeroDivisionError, list, takewhile(isEven, E(s)))
1819
1820 def test_dropwhile(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001821 for s in (range(10), range(0), range(1000), (7,11), range(2000,2200,5)):
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001822 for g in (G, I, Ig, S, L, R):
1823 tgt = []
1824 for elem in g(s):
1825 if not tgt and isOdd(elem): continue
1826 tgt.append(elem)
1827 self.assertEqual(list(dropwhile(isOdd, g(s))), tgt)
1828 self.assertRaises(TypeError, dropwhile, isOdd, X(s))
Thomas Wouters8690c4e2006-04-15 09:07:20 +00001829 self.assertRaises(TypeError, dropwhile, isOdd, N(s))
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001830 self.assertRaises(ZeroDivisionError, list, dropwhile(isOdd, E(s)))
1831
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001832 def test_tee(self):
Guido van Rossum805365e2007-05-07 22:24:25 +00001833 for s in ("123", "", range(1000), ('do', 1.2), range(2000,2200,5)):
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001834 for g in (G, I, Ig, S, L, R):
1835 it1, it2 = tee(g(s))
1836 self.assertEqual(list(it1), list(g(s)))
1837 self.assertEqual(list(it2), list(g(s)))
1838 self.assertRaises(TypeError, tee, X(s))
Thomas Wouters8690c4e2006-04-15 09:07:20 +00001839 self.assertRaises(TypeError, tee, N(s))
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00001840 self.assertRaises(ZeroDivisionError, list, tee(E(s))[0])
1841
Raymond Hettinger5cab2e32004-02-10 09:25:40 +00001842class LengthTransparency(unittest.TestCase):
1843
1844 def test_repeat(self):
Armin Ronacheraa9a79d2012-10-06 14:03:24 +02001845 self.assertEqual(operator.length_hint(repeat(None, 50)), 50)
Raymond Hettinger97d35552014-06-24 21:36:58 -07001846 self.assertEqual(operator.length_hint(repeat(None, 0)), 0)
Armin Ronacheraa9a79d2012-10-06 14:03:24 +02001847 self.assertEqual(operator.length_hint(repeat(None), 12), 12)
Raymond Hettinger5cab2e32004-02-10 09:25:40 +00001848
Raymond Hettinger97d35552014-06-24 21:36:58 -07001849 def test_repeat_with_negative_times(self):
1850 self.assertEqual(operator.length_hint(repeat(None, -1)), 0)
1851 self.assertEqual(operator.length_hint(repeat(None, -2)), 0)
1852 self.assertEqual(operator.length_hint(repeat(None, times=-1)), 0)
1853 self.assertEqual(operator.length_hint(repeat(None, times=-2)), 0)
1854
Raymond Hettingera56f6b62003-08-29 23:09:58 +00001855class RegressionTests(unittest.TestCase):
1856
1857 def test_sf_793826(self):
1858 # Fix Armin Rigo's successful efforts to wreak havoc
1859
1860 def mutatingtuple(tuple1, f, tuple2):
1861 # this builds a tuple t which is a copy of tuple1,
1862 # then calls f(t), then mutates t to be equal to tuple2
1863 # (needs len(tuple1) == len(tuple2)).
1864 def g(value, first=[1]):
1865 if first:
1866 del first[:]
Georg Brandla18af4e2007-04-21 15:47:16 +00001867 f(next(z))
Raymond Hettingera56f6b62003-08-29 23:09:58 +00001868 return value
1869 items = list(tuple2)
1870 items[1:1] = list(tuple1)
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001871 gen = map(g, items)
1872 z = zip(*[gen]*len(tuple1))
Georg Brandla18af4e2007-04-21 15:47:16 +00001873 next(z)
Raymond Hettingera56f6b62003-08-29 23:09:58 +00001874
1875 def f(t):
1876 global T
1877 T = t
1878 first[:] = list(T)
1879
1880 first = []
1881 mutatingtuple((1,2,3), f, (4,5,6))
1882 second = list(T)
1883 self.assertEqual(first, second)
1884
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001885
Raymond Hettinger9d7c8702004-05-08 19:49:42 +00001886 def test_sf_950057(self):
1887 # Make sure that chain() and cycle() catch exceptions immediately
1888 # rather than when shifting between input sources
1889
1890 def gen1():
1891 hist.append(0)
1892 yield 1
1893 hist.append(1)
Tim Petersbeb7c0c2004-07-18 17:34:03 +00001894 raise AssertionError
Raymond Hettinger9d7c8702004-05-08 19:49:42 +00001895 hist.append(2)
1896
1897 def gen2(x):
1898 hist.append(3)
1899 yield 2
1900 hist.append(4)
Raymond Hettinger9d7c8702004-05-08 19:49:42 +00001901
1902 hist = []
1903 self.assertRaises(AssertionError, list, chain(gen1(), gen2(False)))
1904 self.assertEqual(hist, [0,1])
1905
1906 hist = []
1907 self.assertRaises(AssertionError, list, chain(gen1(), gen2(True)))
1908 self.assertEqual(hist, [0,1])
1909
1910 hist = []
1911 self.assertRaises(AssertionError, list, cycle(gen1()))
1912 self.assertEqual(hist, [0,1])
1913
Thomas Woutersb2137042007-02-01 18:02:27 +00001914class SubclassWithKwargsTest(unittest.TestCase):
1915 def test_keywords_in_subclass(self):
1916 # count is not subclassable...
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001917 for cls in (repeat, zip, filter, filterfalse, chain, map,
Raymond Hettinger6b3b0fc2009-01-26 02:56:58 +00001918 starmap, islice, takewhile, dropwhile, cycle, compress):
Thomas Woutersb2137042007-02-01 18:02:27 +00001919 class Subclass(cls):
1920 def __init__(self, newarg=None, *args):
1921 cls.__init__(self, *args)
1922 try:
1923 Subclass(newarg=1)
1924 except TypeError as err:
1925 # we expect type errors because of wrong argument count
Ezio Melottib58e0bd2010-01-23 15:40:09 +00001926 self.assertNotIn("does not take keyword arguments", err.args[0])
Thomas Woutersb2137042007-02-01 18:02:27 +00001927
Serhiy Storchaka2dae92a2013-12-09 17:45:57 +02001928@support.cpython_only
1929class SizeofTest(unittest.TestCase):
1930 def setUp(self):
1931 self.ssize_t = struct.calcsize('n')
1932
1933 check_sizeof = support.check_sizeof
1934
1935 def test_product_sizeof(self):
1936 basesize = support.calcobjsize('3Pi')
1937 check = self.check_sizeof
1938 check(product('ab', '12'), basesize + 2 * self.ssize_t)
1939 check(product(*(('abc',) * 10)), basesize + 10 * self.ssize_t)
1940
1941 def test_combinations_sizeof(self):
1942 basesize = support.calcobjsize('3Pni')
1943 check = self.check_sizeof
1944 check(combinations('abcd', 3), basesize + 3 * self.ssize_t)
1945 check(combinations(range(10), 4), basesize + 4 * self.ssize_t)
1946
1947 def test_combinations_with_replacement_sizeof(self):
1948 cwr = combinations_with_replacement
1949 basesize = support.calcobjsize('3Pni')
1950 check = self.check_sizeof
1951 check(cwr('abcd', 3), basesize + 3 * self.ssize_t)
1952 check(cwr(range(10), 4), basesize + 4 * self.ssize_t)
1953
1954 def test_permutations_sizeof(self):
1955 basesize = support.calcobjsize('4Pni')
1956 check = self.check_sizeof
1957 check(permutations('abcd'),
1958 basesize + 4 * self.ssize_t + 4 * self.ssize_t)
1959 check(permutations('abcd', 3),
1960 basesize + 4 * self.ssize_t + 3 * self.ssize_t)
1961 check(permutations('abcde', 3),
1962 basesize + 5 * self.ssize_t + 3 * self.ssize_t)
1963 check(permutations(range(10), 4),
1964 basesize + 10 * self.ssize_t + 4 * self.ssize_t)
1965
Thomas Woutersb2137042007-02-01 18:02:27 +00001966
Raymond Hettingerf0fa1c02003-05-29 07:18:57 +00001967libreftest = """ Doctest for examples in the library reference: libitertools.tex
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001968
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001969
1970>>> amounts = [120.15, 764.05, 823.14]
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001971>>> for checknum, amount in zip(count(1200), amounts):
Guido van Rossum7131f842007-02-09 20:13:25 +00001972... print('Check %d is for $%.2f' % (checknum, amount))
Guido van Rossumd8faa362007-04-27 19:54:29 +00001973...
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001974Check 1200 is for $120.15
1975Check 1201 is for $764.05
1976Check 1202 is for $823.14
1977
1978>>> import operator
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00001979>>> for cube in map(operator.pow, range(1,4), repeat(3)):
Guido van Rossum7131f842007-02-09 20:13:25 +00001980... print(cube)
Guido van Rossumd8faa362007-04-27 19:54:29 +00001981...
Raymond Hettinger96ef8112003-02-01 00:10:11 +000019821
19838
198427
1985
1986>>> reportlines = ['EuroPython', 'Roster', '', 'alex', '', 'laura', '', 'martin', '', 'walter', '', 'samuele']
Raymond Hettinger3567a872003-06-28 05:44:36 +00001987>>> for name in islice(reportlines, 3, None, 2):
Guido van Rossum7131f842007-02-09 20:13:25 +00001988... print(name.title())
Guido van Rossumd8faa362007-04-27 19:54:29 +00001989...
Raymond Hettinger96ef8112003-02-01 00:10:11 +00001990Alex
1991Laura
1992Martin
1993Walter
1994Samuele
1995
Raymond Hettingerd25c1c62003-12-06 16:23:06 +00001996>>> from operator import itemgetter
1997>>> d = dict(a=1, b=2, c=1, d=2, e=1, f=2, g=3)
Guido van Rossumcc2b0162007-02-11 06:12:03 +00001998>>> di = sorted(sorted(d.items()), key=itemgetter(1))
Raymond Hettingerd25c1c62003-12-06 16:23:06 +00001999>>> for k, g in groupby(di, itemgetter(1)):
Guido van Rossumc1f779c2007-07-03 08:25:58 +00002000... print(k, list(map(itemgetter(0), g)))
Guido van Rossumd8faa362007-04-27 19:54:29 +00002001...
Raymond Hettingerd25c1c62003-12-06 16:23:06 +000020021 ['a', 'c', 'e']
20032 ['b', 'd', 'f']
20043 ['g']
2005
Raymond Hettinger734fb572004-01-20 20:04:40 +00002006# Find runs of consecutive numbers using groupby. The key to the solution
2007# is differencing with a range so that consecutive numbers all appear in
2008# same group.
2009>>> data = [ 1, 4,5,6, 10, 15,16,17,18, 22, 25,26,27,28]
Guido van Rossum1bc535d2007-05-15 18:46:22 +00002010>>> for k, g in groupby(enumerate(data), lambda t:t[0]-t[1]):
Guido van Rossumc1f779c2007-07-03 08:25:58 +00002011... print(list(map(operator.itemgetter(1), g)))
Guido van Rossumd8faa362007-04-27 19:54:29 +00002012...
Raymond Hettinger734fb572004-01-20 20:04:40 +00002013[1]
2014[4, 5, 6]
2015[10]
2016[15, 16, 17, 18]
2017[22]
2018[25, 26, 27, 28]
2019
Georg Brandl3dbca812008-07-23 16:10:53 +00002020>>> def take(n, iterable):
2021... "Return first n items of the iterable as a list"
2022... return list(islice(iterable, n))
Raymond Hettingera098b332003-09-08 23:58:40 +00002023
Georg Brandl3dbca812008-07-23 16:10:53 +00002024>>> def enumerate(iterable, start=0):
2025... return zip(count(start), iterable)
Raymond Hettinger96ef8112003-02-01 00:10:11 +00002026
Georg Brandl3dbca812008-07-23 16:10:53 +00002027>>> def tabulate(function, start=0):
Raymond Hettinger96ef8112003-02-01 00:10:11 +00002028... "Return function(0), function(1), ..."
Georg Brandl3dbca812008-07-23 16:10:53 +00002029... return map(function, count(start))
Raymond Hettinger96ef8112003-02-01 00:10:11 +00002030
Raymond Hettingercdf8ba32009-02-19 04:45:07 +00002031>>> def nth(iterable, n, default=None):
2032... "Returns the nth item or a default value"
2033... return next(islice(iterable, n, None), default)
Raymond Hettinger60eca932003-02-09 06:40:58 +00002034
Raymond Hettingere525ee32016-03-06 18:11:38 -08002035>>> def all_equal(iterable):
2036... "Returns True if all the elements are equal to each other"
2037... g = groupby(iterable)
2038... return next(g, True) and not next(g, False)
2039
Georg Brandl3dbca812008-07-23 16:10:53 +00002040>>> def quantify(iterable, pred=bool):
2041... "Count how many times the predicate is true"
2042... return sum(map(pred, iterable))
Raymond Hettinger60eca932003-02-09 06:40:58 +00002043
Georg Brandl3dbca812008-07-23 16:10:53 +00002044>>> def padnone(iterable):
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002045... "Returns the sequence elements and then returns None indefinitely"
Georg Brandl3dbca812008-07-23 16:10:53 +00002046... return chain(iterable, repeat(None))
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002047
Georg Brandl3dbca812008-07-23 16:10:53 +00002048>>> def ncycles(iterable, n):
Ezio Melotti13925002011-03-16 11:05:33 +02002049... "Returns the sequence elements n times"
Georg Brandl3dbca812008-07-23 16:10:53 +00002050... return chain(*repeat(iterable, n))
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002051
2052>>> def dotproduct(vec1, vec2):
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00002053... return sum(map(operator.mul, vec1, vec2))
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002054
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00002055>>> def flatten(listOfLists):
Christian Heimesdd15f6c2008-03-16 00:07:10 +00002056... return list(chain.from_iterable(listOfLists))
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00002057
2058>>> def repeatfunc(func, times=None, *args):
2059... "Repeat calls to func with specified arguments."
2060... " Example: repeatfunc(random.random)"
2061... if times is None:
2062... return starmap(func, repeat(args))
2063... else:
2064... return starmap(func, repeat(args, times))
2065
Raymond Hettingerd591f662003-10-26 15:34:50 +00002066>>> def pairwise(iterable):
2067... "s -> (s0,s1), (s1,s2), (s2, s3), ..."
2068... a, b = tee(iterable)
Raymond Hettingerad983e72003-11-12 14:32:26 +00002069... try:
Georg Brandla18af4e2007-04-21 15:47:16 +00002070... next(b)
Raymond Hettingerad983e72003-11-12 14:32:26 +00002071... except StopIteration:
2072... pass
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00002073... return zip(a, b)
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002074
Christian Heimesdd15f6c2008-03-16 00:07:10 +00002075>>> def grouper(n, iterable, fillvalue=None):
Raymond Hettingerf5a2e472008-07-30 07:37:37 +00002076... "grouper(3, 'ABCDEFG', 'x') --> ABC DEF Gxx"
Christian Heimesdd15f6c2008-03-16 00:07:10 +00002077... args = [iter(iterable)] * n
Raymond Hettinger883d2762009-01-27 04:57:51 +00002078... return zip_longest(*args, fillvalue=fillvalue)
Christian Heimesdd15f6c2008-03-16 00:07:10 +00002079
2080>>> def roundrobin(*iterables):
Raymond Hettingerf5a2e472008-07-30 07:37:37 +00002081... "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
Christian Heimesdd15f6c2008-03-16 00:07:10 +00002082... # Recipe credited to George Sakkis
2083... pending = len(iterables)
2084... nexts = cycle(iter(it).__next__ for it in iterables)
2085... while pending:
2086... try:
2087... for next in nexts:
2088... yield next()
2089... except StopIteration:
2090... pending -= 1
2091... nexts = cycle(islice(nexts, pending))
2092
2093>>> def powerset(iterable):
Raymond Hettingerace67332009-01-26 02:23:50 +00002094... "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
2095... s = list(iterable)
2096... return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
Christian Heimesdd15f6c2008-03-16 00:07:10 +00002097
Raymond Hettingerad9d96b2009-01-02 21:39:07 +00002098>>> def unique_everseen(iterable, key=None):
2099... "List unique elements, preserving order. Remember all elements ever seen."
2100... # unique_everseen('AAAABBBCCDAABBB') --> A B C D
2101... # unique_everseen('ABBCcAD', str.lower) --> A B C D
2102... seen = set()
2103... seen_add = seen.add
2104... if key is None:
2105... for element in iterable:
2106... if element not in seen:
2107... seen_add(element)
2108... yield element
2109... else:
2110... for element in iterable:
2111... k = key(element)
2112... if k not in seen:
2113... seen_add(k)
2114... yield element
2115
2116>>> def unique_justseen(iterable, key=None):
2117... "List unique elements, preserving order. Remember only the element just seen."
2118... # unique_justseen('AAAABBBCCDAABBB') --> A B C D A B
2119... # unique_justseen('ABBCcAD', str.lower) --> A B C A D
2120... return map(next, map(itemgetter(1), groupby(iterable, key)))
2121
Raymond Hettinger31b26f62014-04-02 03:16:42 -07002122>>> def first_true(iterable, default=False, pred=None):
2123... '''Returns the first true value in the iterable.
2124...
2125... If no true value is found, returns *default*
2126...
2127... If *pred* is not None, returns the first item
2128... for which pred(item) is true.
2129...
2130... '''
2131... # first_true([a,b,c], x) --> a or b or c or x
2132... # first_true([a,b], x, f) --> a if f(a) else b if f(b) else x
2133... return next(filter(pred, iterable), default)
2134
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002135This is not part of the examples but it tests to make sure the definitions
2136perform as purported.
2137
Raymond Hettingera098b332003-09-08 23:58:40 +00002138>>> take(10, count())
2139[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2140
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002141>>> list(enumerate('abc'))
2142[(0, 'a'), (1, 'b'), (2, 'c')]
2143
2144>>> list(islice(tabulate(lambda x: 2*x), 4))
2145[0, 2, 4, 6]
2146
2147>>> nth('abcde', 3)
Raymond Hettingerd04fa312009-02-04 19:45:13 +00002148'd'
2149
2150>>> nth('abcde', 9) is None
2151True
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002152
Raymond Hettingere525ee32016-03-06 18:11:38 -08002153>>> [all_equal(s) for s in ('', 'A', 'AAAA', 'AAAB', 'AAABA')]
2154[True, True, True, False, False]
2155
Guido van Rossum805365e2007-05-07 22:24:25 +00002156>>> quantify(range(99), lambda x: x%2==0)
Raymond Hettingerb5a42082003-08-08 05:10:41 +0000215750
2158
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00002159>>> a = [[1, 2, 3], [4, 5, 6]]
2160>>> flatten(a)
2161[1, 2, 3, 4, 5, 6]
2162
2163>>> list(repeatfunc(pow, 5, 2, 3))
2164[8, 8, 8, 8, 8]
2165
2166>>> import random
Raymond Hettinger736c0ab2008-03-13 02:09:15 +00002167>>> take(5, map(int, repeatfunc(random.random)))
Raymond Hettinger6a5b0272003-10-24 08:45:23 +00002168[0, 0, 0, 0, 0]
2169
Raymond Hettingerd591f662003-10-26 15:34:50 +00002170>>> list(pairwise('abcd'))
2171[('a', 'b'), ('b', 'c'), ('c', 'd')]
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002172
Raymond Hettingerd591f662003-10-26 15:34:50 +00002173>>> list(pairwise([]))
2174[]
2175
2176>>> list(pairwise('a'))
Raymond Hettingerbefa37d2003-06-18 19:25:37 +00002177[]
2178
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002179>>> list(islice(padnone('abc'), 0, 6))
2180['a', 'b', 'c', None, None, None]
2181
2182>>> list(ncycles('abc', 3))
2183['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']
2184
2185>>> dotproduct([1,2,3], [4,5,6])
218632
2187
Christian Heimesdd15f6c2008-03-16 00:07:10 +00002188>>> list(grouper(3, 'abcdefg', 'x'))
2189[('a', 'b', 'c'), ('d', 'e', 'f'), ('g', 'x', 'x')]
2190
2191>>> list(roundrobin('abc', 'd', 'ef'))
2192['a', 'd', 'e', 'b', 'f', 'c']
2193
Raymond Hettingerace67332009-01-26 02:23:50 +00002194>>> list(powerset([1,2,3]))
2195[(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]
Christian Heimesdd15f6c2008-03-16 00:07:10 +00002196
Raymond Hettinger191e8502009-01-27 13:29:43 +00002197>>> all(len(list(powerset(range(n)))) == 2**n for n in range(18))
2198True
2199
2200>>> list(powerset('abcde')) == sorted(sorted(set(powerset('abcde'))), key=len)
2201True
2202
Raymond Hettingerad9d96b2009-01-02 21:39:07 +00002203>>> list(unique_everseen('AAAABBBCCDAABBB'))
2204['A', 'B', 'C', 'D']
2205
2206>>> list(unique_everseen('ABBCcAD', str.lower))
2207['A', 'B', 'C', 'D']
2208
2209>>> list(unique_justseen('AAAABBBCCDAABBB'))
2210['A', 'B', 'C', 'D', 'A', 'B']
2211
2212>>> list(unique_justseen('ABBCcAD', str.lower))
2213['A', 'B', 'C', 'A', 'D']
2214
Raymond Hettinger31b26f62014-04-02 03:16:42 -07002215>>> first_true('ABC0DEF1', '9', str.isdigit)
2216'0'
2217
Raymond Hettinger96ef8112003-02-01 00:10:11 +00002218"""
2219
2220__test__ = {'libreftest' : libreftest}
2221
2222def test_main(verbose=None):
Raymond Hettingera56f6b62003-08-29 23:09:58 +00002223 test_classes = (TestBasicOps, TestVariousIteratorArgs, TestGC,
Thomas Woutersb2137042007-02-01 18:02:27 +00002224 RegressionTests, LengthTransparency,
Serhiy Storchaka2dae92a2013-12-09 17:45:57 +02002225 SubclassWithKwargsTest, TestExamples,
2226 SizeofTest)
Benjamin Petersonee8712c2008-05-20 21:35:26 +00002227 support.run_unittest(*test_classes)
Raymond Hettinger96ef8112003-02-01 00:10:11 +00002228
2229 # verify reference counting
Raymond Hettinger96ef8112003-02-01 00:10:11 +00002230 if verbose and hasattr(sys, "gettotalrefcount"):
Raymond Hettinger02420702003-06-29 20:36:23 +00002231 import gc
Raymond Hettinger8fd3f872003-05-02 22:38:07 +00002232 counts = [None] * 5
Guido van Rossum805365e2007-05-07 22:24:25 +00002233 for i in range(len(counts)):
Benjamin Petersonee8712c2008-05-20 21:35:26 +00002234 support.run_unittest(*test_classes)
Raymond Hettinger02420702003-06-29 20:36:23 +00002235 gc.collect()
Raymond Hettinger8fd3f872003-05-02 22:38:07 +00002236 counts[i] = sys.gettotalrefcount()
Guido van Rossumbe19ed72007-02-09 05:37:30 +00002237 print(counts)
Raymond Hettinger96ef8112003-02-01 00:10:11 +00002238
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002239 # doctest the examples in the library reference
Benjamin Petersonee8712c2008-05-20 21:35:26 +00002240 support.run_doctest(sys.modules[__name__], verbose)
Raymond Hettinger14ef54c2003-05-02 19:04:37 +00002241
Raymond Hettinger96ef8112003-02-01 00:10:11 +00002242if __name__ == "__main__":
2243 test_main(verbose=True)