Lines Matching refs:list
23 return list(zip(*args))
62 return list(islice(seq, n))
95 l = list(islice(it, stop))
128 self.assertEqual(list(accumulate(range(10))), # one positional arg
130 self.assertEqual(list(accumulate(iterable=range(10))), # kw arg
134 list(accumulate(map(typ, range(10)))),
135 list(map(typ, [0, 1, 3, 6, 10, 15, 21, 28, 36, 45])))
136 self.assertEqual(list(accumulate('abc')), ['a', 'ab', 'abc']) # works with non-numeric
137 self.assertEqual(list(accumulate([])), []) # empty iterable
138 self.assertEqual(list(accumulate([7])), [7]) # iterable of length one
142 self.assertRaises(TypeError, list, accumulate([1, []])) # args that don't add
145 self.assertEqual(list(accumulate(s, min)),
147 self.assertEqual(list(accumulate(s, max)),
149 self.assertEqual(list(accumulate(s, operator.mul)),
152 list(accumulate(s, chr)) # unary-operation
156 self.assertEqual(list(accumulate([10, 5, 1], initial=None)), [10, 15, 16])
157 self.assertEqual(list(accumulate([10, 5, 1], initial=100)), [100, 110, 115, 116])
158 self.assertEqual(list(accumulate([], initial=100)), [100])
160 list(accumulate([10, 20], 100))
171 self.assertEqual(list(c('abc', 'def')), list('abcdef'))
172 self.assertEqual(list(c('abc')), list('abc'))
173 self.assertEqual(list(c('')), [])
174 self.assertEqual(take(4, c('abc', 'def')), list('abcd'))
175 self.assertRaises(TypeError, list,c(2, 3))
178 self.assertEqual(list(chain.from_iterable(['abc', 'def'])), list('abcdef'))
179 self.assertEqual(list(chain.from_iterable(['abc'])), list('abc'))
180 self.assertEqual(list(chain.from_iterable([''])), [])
181 self.assertEqual(take(4, chain.from_iterable(['abc', 'def'])), list('abcd'))
182 self.assertRaises(TypeError, list, chain.from_iterable([2, 3]))
187 self.assertEqual(list(oper(it)), list('abcdef'))
189 self.assertEqual(list(oper(it)), list('bcdef'))
191 self.assertEqual(list(oper(chain(''))), [])
192 self.assertEqual(take(4, oper(chain('abc', 'def'))), list('abcd'))
193 self.assertRaises(TypeError, list, oper(chain(2, 3)))
195 self.pickletest(proto, chain('abc', 'def'), compare=list('abcdef'))
205 self.assertEqual(list(it), ['a', 'b', 'c', 'd', 'e', 'f'])
208 self.assertEqual(list(it), ['ghi', 'a', 'b', 'c', 'd', 'e', 'f'])
217 self.assertEqual(list(op(combinations('abc', 32))), []) # r > n
219 self.assertEqual(list(op(combinations('ABCD', 2))),
223 self.assertEqual(list(op(testIntermediate)),
226 self.assertEqual(list(op(combinations(range(4), 3))),
230 self.assertEqual(list(op(testIntermediate)),
240 indices = list(range(r))
258 if sorted(indices) == list(indices):
272 result = list(combinations(values, r))
279 self.assertEqual(list(c), sorted(c)) # keep original ordering
281 self.assertEqual(list(c),
283 self.assertEqual(result, list(combinations1(values, r))) # matches first pure python version
284 self.assertEqual(result, list(combinations2(values, r))) # matches second pure python version
285 self.assertEqual(result, list(combinations3(values, r))) # matches second pure python version
299 self.assertNotEqual(len(set(map(id, list(combinations('abcde', 3))))), 1)
309 self.assertEqual(list(op(cwr('ABC', 2))),
313 self.assertEqual(list(op(testIntermediate)),
340 if sorted(indices) == list(indices):
351 result = list(cwr(values, r))
357 regular_combs = list(combinations(values, r)) # compare to combs without replacement
367 self.assertEqual(list(c), sorted(c)) # keep original ordering
371 self.assertEqual(result, list(cwr1(values, r))) # matches first pure python version
372 self.assertEqual(result, list(cwr2(values, r))) # matches second pure python version
387 self.assertNotEqual(len(set(map(id, list(cwr('abcde', 3))))), 1)
394 self.assertEqual(list(permutations('abc', 32)), []) # r > n
396 self.assertEqual(list(permutations(range(3), 2)),
406 indices = list(range(n))
407 cycles = list(range(n-r+1, n+1))[::-1]
435 result = list(permutations(values, r))
443 self.assertEqual(result, list(permutations1(values, r))) # matches first pure python version
444 self.assertEqual(result, list(permutations2(values, r))) # matches second pure python version
446 self.assertEqual(result, list(permutations(values, None))) # test r as None
447 self.assertEqual(result, list(permutations(values))) # test default r
460 self.assertNotEqual(len(set(map(id, list(permutations('abcde', 3))))), 1)
469 prod = list(product(s, repeat=r))
470 cwr = list(combinations_with_replacement(s, r))
471 perm = list(permutations(s, r))
472 comb = list(combinations(s, r))
487 self.assertEqual(cwr, [t for t in prod if sorted(t)==list(t)]) # cwr: prods which are sorted
489 self.assertEqual(comb, [t for t in perm if sorted(t)==list(t)]) # comb: perms that are sorted
491 self.assertEqual(comb, list(filter(set(cwr).__contains__, perm))) # comb: perm that is a cwr
492 self.assertEqual(comb, list(filter(set(perm).__contains__, cwr))) # comb: cwr that is a perm
496 self.assertEqual(list(compress(data='ABCDEF', selectors=[1,0,1,0,1,1])), list('ACEF'))
497 self.assertEqual(list(compress('ABCDEF', [1,0,1,0,1,1])), list('ACEF'))
498 self.assertEqual(list(compress('ABCDEF', [0,0,0,0,0,0])), list(''))
499 self.assertEqual(list(compress('ABCDEF', [1,1,1,1,1,1])), list('ABCDEF'))
500 self.assertEqual(list(compress('ABCDEF', [1,0,1])), list('AC'))
501 self.assertEqual(list(compress('ABC', [0,1,1,1,1,1])), list('BC'))
505 self.assertEqual(list(compress(data, selectors)), [1,3,5] * n)
521 self.assertEqual(list(op(compress(data=data, selectors=selectors))), list(result1))
522 self.assertEqual(list(op(compress(data, selectors))), list(result1))
526 self.assertEqual(list(op(testIntermediate)), list(result2))
538 list(range(maxsize-5, maxsize+5)))
540 list(range(-maxsize-5, -maxsize+5)))
590 list(range(10, 10+3*(maxsize+5), maxsize+5)))
633 self.assertEqual(take(10, cycle('abc')), list('abcabcabca'))
634 self.assertEqual(list(cycle('')), [])
637 self.assertEqual(list(islice(cycle(gen3()),10)), [0,1,2,0,1,2,0,1,2,0])
645 #self.assertEqual(take(10, copy.copy(c)), list('bcabcabcab'))
646 self.assertEqual(take(10, copy.deepcopy(c)), list('bcabcabcab'))
649 list('bcabcabcab'))
652 list('cabcabcabc'))
665 self.assertEqual(take(20, d), list('cdeabcdeabcdeabcdeab'))
673 self.assertEqual(take(20, d), list('cdeabcdeabcdeabcdeab'))
711 # a list of previously consumed values. There is no data
714 c.__setstate__((list('abc'), 0))
715 self.assertEqual(take(20, c), list('defgabcdefgabcdefgab'))
722 c.__setstate__((list('abcdefg'), 1))
723 self.assertEqual(take(20, c), list('defgabcdefgabcdefgab'))
727 cycle('defg').__setstate__([list('abcdefg'), 0])
729 # The first argument in the setstate tuple must be a list
737 cycle('defg').__setstate__((list('abcdefg'), 'x'))
744 self.assertEqual([], list(groupby([])))
745 self.assertEqual([], list(groupby([], key=id)))
746 self.assertRaises(TypeError, list, groupby('abc', []))
799 s = list(zip('AABBBAAAA', range(9)))
804 self.assertEqual(list(g1), [])
805 self.assertEqual(list(g2), [])
807 list(it) # exhaust the groupby iterator
808 self.assertEqual(list(g3), [])
815 self.assertEqual(list(pickle.loads(pickle.dumps(g, proto))), [])
823 r = [k for k, g in groupby(sorted(s)) if list(islice(g,1,2))]
826 r = [(len(list(g)), k) for k, g in groupby(sorted(s))]
829 r = sorted([(len(list(g)) , k) for k, g in groupby(sorted(s))], reverse=True)[:3]
839 def gulp(iterable, keyp=None, func=list):
873 self.assertEqual(list(filter(isEven, range(6))), [0,2,4])
874 self.assertEqual(list(filter(None, [0,1,0,2,0])), [1,2])
875 self.assertEqual(list(filter(bool, [0,1,0,2,0])), [1,2])
887 self.assertEqual(list(copy.copy(c)), ans)
889 self.assertEqual(list(copy.deepcopy(c)), ans)
892 self.assertEqual(list(pickle.loads(pickle.dumps(c, proto))), ans)
894 self.assertEqual(list(pickle.loads(pickle.dumps(c, proto))), ans[1:])
900 self.assertEqual(list(filterfalse(isEven, range(6))), [1,3,5])
901 self.assertEqual(list(filterfalse(None, [0,1,0,2,0])), [0,0,0])
902 self.assertEqual(list(filterfalse(bool, [0,1,0,2,0])), [0,0,0])
916 self.assertEqual(list(zip('abc', range(6))), lzip('abc', range(6)))
917 self.assertEqual(list(zip('abcdef', range(3))), lzip('abcdef', range(3)))
919 self.assertEqual(list(zip('abcdef')), lzip('abcdef'))
920 self.assertEqual(list(zip()), lzip())
923 self.assertEqual([tuple(list(pair)) for pair in zip('abc', 'def')],
930 ids = list(map(id, zip('abc', 'def')))
932 ids = list(map(id, list(zip('abc', 'def'))))
965 self.assertEqual(list(zip_longest(*args)), target)
966 self.assertEqual(list(zip_longest(*args, **{})), target)
968 self.assertEqual(list(zip_longest(*args, **dict(fillvalue='X'))), target)
970 self.assertEqual(take(3,zip_longest('abcdef', count())), list(zip('abcdef', range(3)))) # take 3 from infinite input
972 self.assertEqual(list(zip_longest()), list(zip()))
973 self.assertEqual(list(zip_longest([])), list(zip([])))
974 self.assertEqual(list(zip_longest('abcdef')), list(zip('abcdef')))
976 self.assertEqual(list(zip_longest('abc', 'defg', **{})),
977 list(zip(list('abc')+[None], 'defg'))) # empty keyword dict
992 self.assertEqual([tuple(list(pair)) for pair in zip_longest('abc', 'def')],
993 list(zip('abc', 'def')))
995 list(zip('abc', 'def')))
999 ids = list(map(id, zip_longest('abc', 'def')))
1001 ids = list(map(id, list(zip_longest('abc', 'def'))))
1064 self.assertEqual(list(pairwise('')), [])
1065 self.assertEqual(list(pairwise('a')), [])
1066 self.assertEqual(list(pairwise('ab')),
1068 self.assertEqual(list(pairwise('abcde')),
1070 self.assertEqual(list(pairwise(range(10_000))),
1071 list(zip(range(10_000), range(1, 10_000))))
1091 self.assertEqual(list(product(*args)), result)
1093 self.assertEqual(list(product(*(args*r))),
1094 list(product(*args, **dict(repeat=r))))
1095 self.assertEqual(len(list(product(*[range(7)]*6))), 7**6)
1099 pools = list(map(tuple, args)) * kwds.get('repeat', 1)
1122 pools = list(map(tuple, args)) * kwds.get('repeat', 1)
1134 self.assertEqual(len(list(product(*args))), expected_len)
1135 self.assertEqual(list(product(*args)), list(product1(*args)))
1136 self.assertEqual(list(product(*args)), list(product2(*args)))
1138 self.assertEqual(len(list(product(*args))), expected_len)
1148 self.assertNotEqual(len(set(map(id, list(product('abc', 'def'))))), 1)
1160 self.assertEqual(list(copy.copy(product(*args))), result)
1161 self.assertEqual(list(copy.deepcopy(product(*args))), result)
1170 # test that empty tuple in the list will result in an immediate StopIteration
1176 self.assertEqual(list(repeat(object='a', times=3)), ['a', 'a', 'a'])
1179 self.assertEqual(list(repeat('a', 3)), ['a', 'a', 'a'])
1181 self.assertEqual(list(repeat('a', 0)), [])
1182 self.assertEqual(list(repeat('a', -3)), [])
1190 list(r)
1196 self.assertEqual(take(2, copy.copy(c)), list('a' * 2))
1197 self.assertEqual(take(2, copy.deepcopy(c)), list('a' * 2))
1208 self.assertEqual(list(map(operator.pow, range(3), range(1,7))),
1210 self.assertEqual(list(map(tupleize, 'abc', range(5))),
1212 self.assertEqual(list(map(tupleize, 'abc', count())),
1216 self.assertEqual(list(map(operator.pow, [])), [])
1218 self.assertRaises(TypeError, list, map(None, range(3), range(3)))
1228 self.assertEqual(list(copy.copy(c)), ans)
1231 self.assertEqual(list(copy.deepcopy(c)), ans)
1238 self.assertEqual(list(starmap(operator.pow, zip(range(3), range(1,7)))),
1242 self.assertEqual(list(starmap(operator.pow, [])), [])
1243 self.assertEqual(list(starmap(operator.pow, [iter([4,5])])), [4**5])
1244 self.assertRaises(TypeError, list, starmap(operator.pow, [None]))
1255 self.assertEqual(list(copy.copy(c)), ans)
1258 self.assertEqual(list(copy.deepcopy(c)), ans)
1273 self.assertEqual(list(islice(range(100), *args)),
1274 list(range(*args)))
1281 self.assertEqual(list(islice(range(100), *args)),
1282 list(range(*tgtargs)))
1285 self.assertEqual(list(islice(range(10), None)), list(range(10)))
1286 self.assertEqual(list(islice(range(10), None, None)), list(range(10)))
1287 self.assertEqual(list(islice(range(10), None, None, None)), list(range(10)))
1288 self.assertEqual(list(islice(range(10), 2, None)), list(range(2, 10)))
1289 self.assertEqual(list(islice(range(10), 1, None, 2)), list(range(1, 10, 2)))
1293 self.assertEqual(list(islice(it, 3)), list(range(3)))
1294 self.assertEqual(list(it), list(range(3, 10)))
1297 self.assertEqual(list(islice(it, 3, 3)), [])
1298 self.assertEqual(list(it), list(range(3, 10)))
1313 self.assertEqual(len(list(islice(count(), 1, 10, maxsize))), 1)
1317 self.assertEqual(list(islice(c, 1, 3, 50)), [1])
1328 self.assertEqual(list(copy.copy(islice(range(100), *args))),
1329 list(range(*args)))
1330 self.assertEqual(list(copy.deepcopy(islice(range(100), *args))),
1331 list(range(*args)))
1341 list(it) # exhaust the iterator
1352 self.assertEqual(list(islice(range(100), IntLike(10))), list(range(10)))
1353 self.assertEqual(list(islice(range(100), IntLike(10), IntLike(50))),
1354 list(range(10, 50)))
1355 self.assertEqual(list(islice(range(100), IntLike(10), IntLike(50), IntLike(5))),
1356 list(range(10,50,5)))
1360 self.assertEqual(list(takewhile(underten, data)), [1, 3, 5])
1361 self.assertEqual(list(takewhile(underten, [])), [])
1368 self.assertEqual(list(t), [1, 1, 1])
1372 self.assertEqual(list(copy.copy(takewhile(underten, data))), [1, 3, 5])
1373 self.assertEqual(list(copy.deepcopy(takewhile(underten, data))),
1380 self.assertEqual(list(dropwhile(underten, data)), [20, 2, 4, 6, 8])
1381 self.assertEqual(list(dropwhile(underten, [])), [])
1389 self.assertEqual(list(copy.copy(dropwhile(underten, data))), [20, 2, 4, 6, 8])
1390 self.assertEqual(list(copy.deepcopy(dropwhile(underten, data))),
1399 self.assertEqual(list(a), [])
1400 self.assertEqual(list(b), [])
1406 self.assertEqual(list(a), list(range(n)))
1407 self.assertEqual(list(b), list(range(n)))
1413 self.assertEqual(list(b), list(range(n)))
1419 self.assertEqual(list(a), list(range(100, n)))
1429 self.assertEqual(lists[0], list(range(n)))
1430 self.assertEqual(lists[1], list(range(n)))
1441 self.assertEqual(list(c), list('def'))
1447 self.assertEqual(list(b), list(range(2000)))
1448 self.assertEqual([next(c), next(c)], list(range(2)))
1449 self.assertEqual(list(a), list(range(100,2000)))
1450 self.assertEqual(list(c), list(range(2,2000)))
1459 self.assertEqual([list(x) for x in result], [list('abc')]*n)
1472 self.assertTrue(list(t1) == list(t2) == list(t3) == list('abc'))
1482 ans = list('abc')
1483 long_ans = list(range(10000))
1487 self.assertEqual(list(copy.copy(a)), ans)
1488 self.assertEqual(list(copy.copy(b)), ans)
1489 a, b = tee(list(range(10000)))
1490 self.assertEqual(list(copy.copy(a)), long_ans)
1491 self.assertEqual(list(copy.copy(b)), long_ans)
1497 self.assertEqual(list(copy.copy(a)), ans[2:])
1498 self.assertEqual(list(copy.copy(b)), ans[1:])
1499 self.assertEqual(list(a), ans[2:])
1500 self.assertEqual(list(b), ans[1:])
1504 self.assertEqual(list(copy.copy(a)), long_ans[100:])
1505 self.assertEqual(list(copy.copy(b)), long_ans[60:])
1506 self.assertEqual(list(a), long_ans[100:])
1507 self.assertEqual(list(b), long_ans[60:])
1511 self.assertEqual(list(copy.deepcopy(a)), ans)
1512 self.assertEqual(list(copy.deepcopy(b)), ans)
1513 self.assertEqual(list(a), ans)
1514 self.assertEqual(list(b), ans)
1516 self.assertEqual(list(copy.deepcopy(a)), long_ans)
1517 self.assertEqual(list(copy.deepcopy(b)), long_ans)
1518 self.assertEqual(list(a), long_ans)
1519 self.assertEqual(list(b), long_ans)
1525 self.assertEqual(list(copy.deepcopy(a)), ans[2:])
1526 self.assertEqual(list(copy.deepcopy(b)), ans[1:])
1527 self.assertEqual(list(a), ans[2:])
1528 self.assertEqual(list(b), ans[1:])
1532 self.assertEqual(list(copy.deepcopy(a)), long_ans[100:])
1533 self.assertEqual(list(copy.deepcopy(b)), long_ans[60:])
1534 self.assertEqual(list(a), long_ans[100:])
1535 self.assertEqual(list(b), long_ans[60:])
1662 self.assertEqual(list(accumulate([1,2,3,4,5])), [1, 3, 6, 10, 15])
1671 self.assertEqual(list(pickle.loads(pickle.dumps(it, proto))), accumulated[:])
1673 self.assertEqual(list(pickle.loads(pickle.dumps(it, proto))), accumulated[1:])
1676 self.assertEqual(list(copy.deepcopy(it)), accumulated[1:])
1677 self.assertEqual(list(copy.copy(it)), accumulated[1:])
1685 self.assertEqual(list(it_copy), [True, False])
1686 self.assertEqual(list(copy.deepcopy(it)), [True, False])
1687 self.assertEqual(list(copy.copy(it)), [True, False])
1696 self.assertEqual(list(combinations('ABCD', 2)),
1698 self.assertEqual(list(combinations(range(4), 3)),
1702 self.assertEqual(list(combinations_with_replacement('ABC', 2)),
1706 self.assertEqual(list(compress('ABCDEF', [1,0,1,0,1,1])), list('ACEF'))
1709 self.assertEqual(list(islice(count(10), 5)), [10, 11, 12, 13, 14])
1712 self.assertEqual(list(islice(cycle('ABCD'), 12)), list('ABCDABCDABCD'))
1715 self.assertEqual(list(dropwhile(lambda x: x<5, [1,4,6,4,1])), [6,4,1])
1719 list('ABCDAB'))
1720 self.assertEqual([(list(g)) for k, g in groupby('AAAABBBCCD')],
1721 [list('AAAA'), list('BBB'), list('CC'), list('D')])
1724 self.assertEqual(list(filter(lambda x: x%2, range(10))), [1,3,5,7,9])
1727 self.assertEqual(list(filterfalse(lambda x: x%2, range(10))), [0,2,4,6,8])
1730 self.assertEqual(list(map(pow, (2,3,10), (5,2,3))), [32, 9, 1000])
1733 self.assertEqual(list(islice('ABCDEFG', 2)), list('AB'))
1734 self.assertEqual(list(islice('ABCDEFG', 2, 4)), list('CD'))
1735 self.assertEqual(list(islice('ABCDEFG', 2, None)), list('CDEFG'))
1736 self.assertEqual(list(islice('ABCDEFG', 0, None, 2)), list('ACEG'))
1739 self.assertEqual(list(zip('ABCD', 'xy')), [('A', 'x'), ('B', 'y')])
1742 self.assertEqual(list(zip_longest('ABCD', 'xy', fillvalue='-')),
1746 self.assertEqual(list(permutations('ABCD', 2)),
1747 list(map(tuple, 'AB AC AD BA BC BD CA CB CD DA DB DC'.split())))
1748 self.assertEqual(list(permutations(range(3))),
1752 self.assertEqual(list(product('ABCD', 'xy')),
1753 list(map(tuple, 'Ax Ay Bx By Cx Cy Dx Dy'.split())))
1754 self.assertEqual(list(product(range(2), repeat=3)),
1759 self.assertEqual(list(repeat(10, 3)), [10, 10, 10])
1762 self.assertEqual(list(starmap(pow, [(2,5), (3,2), (10,3)])),
1766 self.assertEqual(list(takewhile(lambda x: x<5, [1,4,6,4,1])), [1,4])
1794 self.assertEqual(list(self.islice('ABCDEFG', 2)), list('AB'))
1795 self.assertEqual(list(self.islice('ABCDEFG', 2, 4)), list('CD'))
1796 self.assertEqual(list(self.islice('ABCDEFG', 2, None)), list('CDEFG'))
1797 self.assertEqual(list(self.islice('ABCDEFG', 0, None, 2)), list('ACEG'))
1800 self.assertEqual(list(self.islice(it, 3)), list(range(3)))
1801 self.assertEqual(list(it), list(range(3, 10)))
1803 self.assertEqual(list(self.islice(it, 3, 3)), [])
1804 self.assertEqual(list(it), list(range(3, 10)))
1807 self.assertEqual(list(self.islice(c, 1, 3, 50)), [1])
2000 self.assertEqual(list(accumulate(g(s))), r)
2001 self.assertEqual(list(accumulate(S(s))), [])
2004 self.assertRaises(ZeroDivisionError, list, accumulate(E(s)))
2009 self.assertEqual(list(chain(g(s))), list(g(s)))
2010 self.assertEqual(list(chain(g(s), g(s))), list(g(s))+list(g(s)))
2011 self.assertRaises(TypeError, list, chain(X(s)))
2012 self.assertRaises(TypeError, list, chain(N(s)))
2013 self.assertRaises(ZeroDivisionError, list, chain(E(s)))
2019 self.assertEqual(list(compress(g(s), repeat(1))), list(g(s)))
2022 self.assertRaises(ZeroDivisionError, list, compress(E(s), repeat(1)))
2034 expected = list(g(s))*3
2035 actual = list(islice(cycle(g(s)), tgtlen))
2039 self.assertRaises(ZeroDivisionError, list, cycle(E(s)))
2044 self.assertEqual([k for k, sb in groupby(g(s))], list(g(s)))
2047 self.assertRaises(ZeroDivisionError, list, groupby(E(s)))
2052 self.assertEqual(list(filter(isEven, g(s))),
2056 self.assertRaises(ZeroDivisionError, list, filter(isEven, E(s)))
2061 self.assertEqual(list(filterfalse(isEven, g(s))),
2065 self.assertRaises(ZeroDivisionError, list, filterfalse(isEven, E(s)))
2070 self.assertEqual(list(zip(g(s))), lzip(g(s)))
2071 self.assertEqual(list(zip(g(s), g(s))), lzip(g(s), g(s)))
2074 self.assertRaises(ZeroDivisionError, list, zip(E(s)))
2079 self.assertEqual(list(zip_longest(g(s))), list(zip(g(s))))
2080 self.assertEqual(list(zip_longest(g(s), g(s))), list(zip(g(s), g(s))))
2083 self.assertRaises(ZeroDivisionError, list, zip_longest(E(s)))
2088 self.assertEqual(list(map(onearg, g(s))),
2090 self.assertEqual(list(map(operator.pow, g(s), g(s))),
2094 self.assertRaises(ZeroDivisionError, list, map(onearg, E(s)))
2099 self.assertEqual(list(islice(g(s),1,None,2)), list(g(s))[1::2])
2102 self.assertRaises(ZeroDivisionError, list, islice(E(s), 10))
2107 seq = list(g(s))
2108 expected = list(zip(seq, seq[1:]))
2109 actual = list(pairwise(g(s)))
2113 self.assertRaises(ZeroDivisionError, list, pairwise(E(s)))
2119 self.assertEqual(list(starmap(operator.pow, g(ss))),
2123 self.assertRaises(ZeroDivisionError, list, starmap(operator.pow, E(ss)))
2132 self.assertEqual(list(takewhile(isEven, g(s))), tgt)
2135 self.assertRaises(ZeroDivisionError, list, takewhile(isEven, E(s)))
2144 self.assertEqual(list(dropwhile(isOdd, g(s))), tgt)
2147 self.assertRaises(ZeroDivisionError, list, dropwhile(isOdd, E(s)))
2153 self.assertEqual(list(it1), list(g(s)))
2154 self.assertEqual(list(it2), list(g(s)))
2157 self.assertRaises(ZeroDivisionError, list, tee(E(s))[0])
2186 items = list(tuple2)
2187 items[1:1] = list(tuple1)
2195 first[:] = list(T)
2199 second = list(T)
2220 self.assertRaises(AssertionError, list, chain(gen1(), gen2(False)))
2224 self.assertRaises(AssertionError, list, chain(gen1(), gen2(True)))
2228 self.assertRaises(AssertionError, list, cycle(gen1()))
2243 list(b)
2246 list(b) # shouldn't crash
2287 self.assertEqual(list(islice(u, 0, 3)), result)
2303 self.assertEqual(list(islice(u, 0, 3)), result)
2315 self.assertEqual(list(islice(u, 0, 3)), result)