Lines Matching refs:self
30 def __init__(self, n):
31 self.n = n
32 self.i = 0
33 def __next__(self):
34 res = self.i
35 if res >= self.n:
37 self.i = res + 1
39 def __iter__(self):
40 return self
43 def __init__(self, n):
44 self.n = n
45 def __iter__(self):
46 return BasicIterClass(self.n)
49 def __init__(self, i):
50 self.i = i
51 def __next__(self):
52 return next(self.i)
53 def __iter__(self):
54 return self
57 def __init__(self, n):
58 self.n = n
59 def __getitem__(self, i):
60 if 0 <= i < self.n:
66 def __init__(self, s):
67 self.s = s
68 def __getitem__(self, i):
69 return self.s[i]
72 def __getitem__(self, i):
79 def __getitem__(self, i):
84 def __iter__(self):
88 def __init__(self):
89 self.i = 0
90 def __call__(self):
91 i = self.i
92 self.i = i + 1
98 def __len__(self):
100 def __getitem__(self, i):
108 def check_iterator(self, it, seq, pickle=True):
110 self.check_pickle(it, seq)
118 self.assertEqual(res, seq)
121 def check_for_loop(self, expr, seq, pickle=True):
123 self.check_pickle(iter(expr), seq)
127 self.assertEqual(res, seq)
130 def check_pickle(self, itorg, seq):
136 # self.assertEqual(type(itorg), type(it))
137 self.assertTrue(isinstance(it, collections.abc.Iterator))
138 self.assertEqual(list(it), seq)
147 self.assertEqual(list(it), seq[1:])
150 def test_iter_basic(self):
151 self.check_iterator(iter(range(10)), list(range(10)))
154 def test_iter_idempotency(self):
158 self.assertTrue(it is it2)
161 def test_iter_for_loop(self):
162 self.check_for_loop(iter(range(10)), list(range(10)))
165 def test_iter_independence(self):
172 self.assertEqual(res, TRIPLETS)
175 def test_nested_comprehensions_iter(self):
179 self.assertEqual(res, TRIPLETS)
182 def test_nested_comprehensions_for(self):
185 self.assertEqual(res, TRIPLETS)
188 def test_iter_class_for(self):
189 self.check_for_loop(IteratingSequenceClass(10), list(range(10)))
192 def test_iter_class_iter(self):
193 self.check_iterator(iter(IteratingSequenceClass(10)), list(range(10)))
196 def test_seq_class_for(self):
197 self.check_for_loop(SequenceClass(10), list(range(10)))
200 def test_seq_class_iter(self):
201 self.check_iterator(iter(SequenceClass(10)), list(range(10)))
203 def test_mutating_seq_class_iter_pickle(self):
211 self.assertIs(type(it), type(itorig))
212 self.assertEqual(list(it), list(range(7)))
219 self.assertIs(type(it), type(itorig))
220 self.assertEqual(list(it), list(range(1, 7)))
228 self.assertIs(type(it), type(itorig))
229 self.assertEqual(list(it), list(range(5, 7)))
232 self.assertRaises(StopIteration, next, itorig)
236 self.assertTrue(isinstance(it, collections.abc.Iterator))
237 self.assertEqual(list(it), [])
239 def test_mutating_seq_class_exhausted_iter(self):
246 self.assertEqual(list(exhit), [])
247 self.assertEqual(list(empit), [5, 6])
248 self.assertEqual(list(a), [0, 1, 2, 3, 4, 5, 6])
250 def test_reduce_mutating_builtins_iter(self):
263 def __init__(self, name, iterator):
264 self.name = name
265 self.iterator = iterator
266 def __hash__(self):
267 return hash(self.name)
268 def __eq__(self, other):
273 list(self.iterator)
274 return other == self.name
298 self.assertEqual(run_iter("xyz"), (orig["iter"], ("",)))
299 self.assertEqual(run_iter([1, 2, 3]), (orig["iter"], ([],)))
303 self.assertEqual(
309 self.assertEqual(run_iter(*case), (orig["iter"], ((),)))
323 def test_new_style_iter_class(self):
325 def __iter__(self):
326 return self
327 self.assertRaises(TypeError, iter, IterClass())
330 def test_iter_callable(self):
331 self.check_iterator(iter(CallableIterClass(), 10), list(range(10)), pickle=True)
334 def test_iter_function(self):
339 self.check_iterator(iter(spam, 10), list(range(10)), pickle=False)
342 def test_iter_function_stop(self):
349 self.check_iterator(iter(spam, 20), list(range(10)), pickle=False)
351 def test_iter_function_concealing_reentrant_exhaustion(self):
373 with self.assertRaises(StopIteration):
377 def test_exception_function(self):
389 self.assertEqual(res, list(range(10)))
391 self.fail("should have raised RuntimeError")
394 def test_exception_sequence(self):
396 def __getitem__(self, i):
399 return SequenceClass.__getitem__(self, i)
405 self.assertEqual(res, list(range(10)))
407 self.fail("should have raised RuntimeError")
410 def test_stop_sequence(self):
412 def __getitem__(self, i):
415 return SequenceClass.__getitem__(self, i)
416 self.check_for_loop(MySequenceClass(20), list(range(10)), pickle=False)
419 def test_iter_big_range(self):
420 self.check_for_loop(iter(range(10000)), list(range(10000)))
423 def test_iter_empty(self):
424 self.check_for_loop(iter([]), [])
427 def test_iter_tuple(self):
428 self.check_for_loop(iter((0,1,2,3,4,5,6,7,8,9)), list(range(10)))
431 def test_iter_range(self):
432 self.check_for_loop(iter(range(10)), list(range(10)))
435 def test_iter_string(self):
436 self.check_for_loop(iter("abcde"), ["a", "b", "c", "d", "e"])
439 def test_iter_dict(self):
443 self.check_for_loop(dict, list(dict.keys()))
446 def test_iter_file(self):
455 self.check_for_loop(f, ["0\n", "1\n", "2\n", "3\n", "4\n"], pickle=False)
456 self.check_for_loop(f, [], pickle=False)
465 def test_builtin_list(self):
466 self.assertEqual(list(SequenceClass(5)), list(range(5)))
467 self.assertEqual(list(SequenceClass(0)), [])
468 self.assertEqual(list(()), [])
471 self.assertEqual(list(d), list(d.keys()))
473 self.assertRaises(TypeError, list, list)
474 self.assertRaises(TypeError, list, 42)
484 self.assertEqual(list(f), ["0\n", "1\n", "2\n", "3\n", "4\n"])
486 self.assertEqual(list(f),
496 def test_builtin_tuple(self):
497 self.assertEqual(tuple(SequenceClass(5)), (0, 1, 2, 3, 4))
498 self.assertEqual(tuple(SequenceClass(0)), ())
499 self.assertEqual(tuple([]), ())
500 self.assertEqual(tuple(()), ())
501 self.assertEqual(tuple("abc"), ("a", "b", "c"))
504 self.assertEqual(tuple(d), tuple(d.keys()))
506 self.assertRaises(TypeError, tuple, list)
507 self.assertRaises(TypeError, tuple, 42)
517 self.assertEqual(tuple(f), ("0\n", "1\n", "2\n", "3\n", "4\n"))
519 self.assertEqual(tuple(f),
529 def test_builtin_filter(self):
530 self.assertEqual(list(filter(None, SequenceClass(5))),
532 self.assertEqual(list(filter(None, SequenceClass(0))), [])
533 self.assertEqual(list(filter(None, ())), [])
534 self.assertEqual(list(filter(None, "abc")), ["a", "b", "c"])
537 self.assertEqual(list(filter(None, d)), list(d.keys()))
539 self.assertRaises(TypeError, filter, None, list)
540 self.assertRaises(TypeError, filter, None, 42)
543 def __init__(self, truth):
544 self.truth = truth
545 def __bool__(self):
546 return self.truth
551 def __init__(self, *args):
552 self.vals = args
553 def __iter__(self):
555 def __init__(self, vals):
556 self.vals = vals
557 self.i = 0
558 def __iter__(self):
559 return self
560 def __next__(self):
561 i = self.i
562 self.i = i + 1
563 if i < len(self.vals):
564 return self.vals[i]
567 return SeqIter(self.vals)
570 self.assertEqual(list(filter(lambda x: not x, seq)), [bFalse]*25)
571 self.assertEqual(list(filter(lambda x: not x, iter(seq))), [bFalse]*25)
574 def test_builtin_max_min(self):
575 self.assertEqual(max(SequenceClass(5)), 4)
576 self.assertEqual(min(SequenceClass(5)), 0)
577 self.assertEqual(max(8, -1), 8)
578 self.assertEqual(min(8, -1), -1)
581 self.assertEqual(max(d), "two")
582 self.assertEqual(min(d), "one")
583 self.assertEqual(max(d.values()), 3)
584 self.assertEqual(min(iter(d.values())), 1)
595 self.assertEqual(min(f), "itty-bitty line\n")
597 self.assertEqual(max(f), "xtra large line\n")
606 def test_builtin_map(self):
607 self.assertEqual(list(map(lambda x: x+1, SequenceClass(5))),
611 self.assertEqual(list(map(lambda k, d=d: (k, d[k]), d)),
627 self.assertEqual(list(map(len, f)), list(range(1, 21, 2)))
636 def test_builtin_zip(self):
637 self.assertEqual(list(zip()), [])
638 self.assertEqual(list(zip(*[])), [])
639 self.assertEqual(list(zip(*[(1, 2), 'ab'])), [(1, 'a'), (2, 'b')])
641 self.assertRaises(TypeError, zip, None)
642 self.assertRaises(TypeError, zip, range(10), 42)
643 self.assertRaises(TypeError, zip, range(10), zip)
645 self.assertEqual(list(zip(IteratingSequenceClass(3))),
647 self.assertEqual(list(zip(SequenceClass(3))),
651 self.assertEqual(list(d.items()), list(zip(d, d.values())))
655 def __init__(self, start):
656 self.i = start
658 def __iter__(self):
659 return self
661 def __next__(self):
662 i = self.i
663 self.i = i+1
673 self.assertEqual(list(zip(IntsFrom(0), f, IntsFrom(-100))),
684 self.assertEqual(list(zip(range(5))), [(i,) for i in range(5)])
688 def __getitem__(self, i):
694 def __len__(self):
698 def __len__(self):
704 self.assertEqual(len(Guess3Len5()), 3)
705 self.assertEqual(len(Guess30Len5()), 30)
706 self.assertEqual(lzip(NoGuessLen5()), lzip(range(5)))
707 self.assertEqual(lzip(Guess3Len5()), lzip(range(5)))
708 self.assertEqual(lzip(Guess30Len5()), lzip(range(5)))
713 self.assertEqual(lzip(x, y), expected)
715 def test_unicode_join_endcase(self):
720 def __init__(self, seq):
721 self.it = iter(seq)
722 self.i = 0
724 def __iter__(self):
725 return self
727 def __next__(self):
728 i = self.i
729 self.i = i+1
732 return next(self.it)
748 self.assertEqual(got, "a\n - b\n - fooled you! - c\n")
757 def test_in_and_not_in(self):
760 self.assertIn(i, sc5)
762 self.assertNotIn(i, sc5)
764 self.assertIn(ALWAYS_EQ, IteratorProxyClass(iter([1])))
765 self.assertIn(ALWAYS_EQ, SequenceProxyClass([1]))
766 self.assertNotIn(ALWAYS_EQ, IteratorProxyClass(iter([NEVER_EQ])))
767 self.assertNotIn(ALWAYS_EQ, SequenceProxyClass([NEVER_EQ]))
768 self.assertIn(NEVER_EQ, IteratorProxyClass(iter([ALWAYS_EQ])))
769 self.assertIn(NEVER_EQ, SequenceProxyClass([ALWAYS_EQ]))
771 self.assertRaises(TypeError, lambda: 3 in 12)
772 self.assertRaises(TypeError, lambda: 3 not in map)
773 self.assertRaises(ZeroDivisionError, lambda: 3 in BadIterableClass())
777 self.assertIn(k, d)
778 self.assertNotIn(k, d.values())
780 self.assertIn(v, d.values())
781 self.assertNotIn(v, d)
783 self.assertIn((k, v), d.items())
784 self.assertNotIn((v, k), d.items())
795 self.assertNotIn(chunk, f)
797 self.assertIn((chunk + "\n"), f)
806 def test_countOf(self):
808 self.assertEqual(countOf([1,2,2,3,2,5], 2), 3)
809 self.assertEqual(countOf((1,2,2,3,2,5), 2), 3)
810 self.assertEqual(countOf("122325", "2"), 3)
811 self.assertEqual(countOf("122325", "6"), 0)
813 self.assertRaises(TypeError, countOf, 42, 1)
814 self.assertRaises(TypeError, countOf, countOf, countOf)
818 self.assertEqual(countOf(d, k), 1)
819 self.assertEqual(countOf(d.values(), 3), 3)
820 self.assertEqual(countOf(d.values(), 2j), 1)
821 self.assertEqual(countOf(d.values(), 1j), 0)
832 self.assertEqual(countOf(f, letter + "\n"), count)
841 def test_indexOf(self):
843 self.assertEqual(indexOf([1,2,2,3,2,5], 1), 0)
844 self.assertEqual(indexOf((1,2,2,3,2,5), 2), 1)
845 self.assertEqual(indexOf((1,2,2,3,2,5), 3), 3)
846 self.assertEqual(indexOf((1,2,2,3,2,5), 5), 5)
847 self.assertRaises(ValueError, indexOf, (1,2,2,3,2,5), 0)
848 self.assertRaises(ValueError, indexOf, (1,2,2,3,2,5), 6)
850 self.assertEqual(indexOf("122325", "2"), 1)
851 self.assertEqual(indexOf("122325", "5"), 5)
852 self.assertRaises(ValueError, indexOf, "122325", "6")
854 self.assertRaises(TypeError, indexOf, 42, 1)
855 self.assertRaises(TypeError, indexOf, indexOf, indexOf)
856 self.assertRaises(ZeroDivisionError, indexOf, BadIterableClass(), 1)
866 self.assertEqual(indexOf(fiter, "b\n"), 1)
867 self.assertEqual(indexOf(fiter, "d\n"), 1)
868 self.assertEqual(indexOf(fiter, "e\n"), 0)
869 self.assertRaises(ValueError, indexOf, fiter, "a\n")
879 self.assertEqual(indexOf(iclass, i), i)
880 self.assertRaises(ValueError, indexOf, iclass, -1)
883 def test_writelines(self):
887 self.assertRaises(TypeError, f.writelines, None)
888 self.assertRaises(TypeError, f.writelines, 42)
897 def __init__(self, start, finish):
898 self.start = start
899 self.finish = finish
900 self.i = self.start
902 def __next__(self):
903 if self.i >= self.finish:
905 result = str(self.i) + '\n'
906 self.i += 1
909 def __iter__(self):
910 return self
913 def __init__(self, start, finish):
914 self.start = start
915 self.finish = finish
917 def __iter__(self):
918 return Iterator(self.start, self.finish)
925 self.assertEqual(list(f), expected)
936 def test_unpack_iter(self):
938 self.assertEqual((a, b), (1, 2))
941 self.assertEqual((a, b, c), (0, 1, 2))
948 self.fail("should have raised ValueError")
955 self.fail("should have raised ValueError")
962 self.fail("should have raised TypeError")
965 self.assertEqual((a, b, c), (42, 42, 42))
977 self.assertEqual((a, b, c), lines)
986 self.assertEqual((a, b, c), (0, 1, 42))
990 def test_ref_counting_behavior(self):
996 def __del__(self):
997 cls = self.__class__
1001 self.assertEqual(C.count, 1)
1003 self.assertEqual(C.count, 0)
1005 self.assertEqual(C.count, 3)
1011 self.assertEqual(C.count, 0)
1018 def test_sinkstate_list(self):
1022 self.assertEqual(list(b), list(range(5)))
1024 self.assertEqual(list(b), [])
1026 def test_sinkstate_tuple(self):
1029 self.assertEqual(list(b), list(range(5)))
1030 self.assertEqual(list(b), [])
1032 def test_sinkstate_string(self):
1035 self.assertEqual(list(b), ['a', 'b', 'c', 'd', 'e'])
1036 self.assertEqual(list(b), [])
1038 def test_sinkstate_sequence(self):
1042 self.assertEqual(list(b), list(range(5)))
1044 self.assertEqual(list(b), [])
1046 def test_sinkstate_callable(self):
1055 self.assertEqual(list(b), list(range(5)))
1056 self.assertEqual(list(b), [])
1058 def test_sinkstate_dict(self):
1064 self.assertEqual(len(list(b)), 5)
1065 self.assertEqual(list(b), [])
1067 def test_sinkstate_yield(self):
1072 self.assertEqual(list(b), list(range(5)))
1073 self.assertEqual(list(b), [])
1075 def test_sinkstate_range(self):
1078 self.assertEqual(list(b), list(range(5)))
1079 self.assertEqual(list(b), [])
1081 def test_sinkstate_enumerate(self):
1085 self.assertEqual(list(b), list(zip(range(5), range(5))))
1086 self.assertEqual(list(b), [])
1088 def test_3720(self):
1091 def __iter__(self):
1092 return self
1093 def __next__(self):
1103 def test_extending_list_with_iterator_does_not_segfault(self):
1116 self.assertEqual(len(lst), 760)
1119 def test_iter_overflow(self):
1124 self.assertEqual(next(it), sys.maxsize - 2)
1125 self.assertEqual(next(it), sys.maxsize - 1)
1126 with self.assertRaises(OverflowError):
1129 with self.assertRaises(OverflowError):
1132 def test_iter_neg_setstate(self):
1135 self.assertEqual(next(it), 0)
1136 self.assertEqual(next(it), 1)
1138 def test_free_after_iterating(self):
1139 check_free_after_iterating(self, iter, SequenceClass, (0,))
1141 def test_error_iter(self):
1143 self.assertRaises(TypeError, iter, typ())
1144 self.assertRaises(ZeroDivisionError, iter, BadIterableClass())