summaryrefslogtreecommitdiff
path: root/lib/python2.7/test/test_iter.py
diff options
context:
space:
mode:
Diffstat (limited to 'lib/python2.7/test/test_iter.py')
-rw-r--r--lib/python2.7/test/test_iter.py932
1 files changed, 932 insertions, 0 deletions
diff --git a/lib/python2.7/test/test_iter.py b/lib/python2.7/test/test_iter.py
new file mode 100644
index 0000000..8dc39d2
--- /dev/null
+++ b/lib/python2.7/test/test_iter.py
@@ -0,0 +1,932 @@
+# Test iterators.
+
+import unittest
+from test.test_support import run_unittest, TESTFN, unlink, have_unicode, \
+ check_py3k_warnings, cpython_only
+
+# Test result of triple loop (too big to inline)
+TRIPLETS = [(0, 0, 0), (0, 0, 1), (0, 0, 2),
+ (0, 1, 0), (0, 1, 1), (0, 1, 2),
+ (0, 2, 0), (0, 2, 1), (0, 2, 2),
+
+ (1, 0, 0), (1, 0, 1), (1, 0, 2),
+ (1, 1, 0), (1, 1, 1), (1, 1, 2),
+ (1, 2, 0), (1, 2, 1), (1, 2, 2),
+
+ (2, 0, 0), (2, 0, 1), (2, 0, 2),
+ (2, 1, 0), (2, 1, 1), (2, 1, 2),
+ (2, 2, 0), (2, 2, 1), (2, 2, 2)]
+
+# Helper classes
+
+class BasicIterClass:
+ def __init__(self, n):
+ self.n = n
+ self.i = 0
+ def next(self):
+ res = self.i
+ if res >= self.n:
+ raise StopIteration
+ self.i = res + 1
+ return res
+
+class IteratingSequenceClass:
+ def __init__(self, n):
+ self.n = n
+ def __iter__(self):
+ return BasicIterClass(self.n)
+
+class SequenceClass:
+ def __init__(self, n):
+ self.n = n
+ def __getitem__(self, i):
+ if 0 <= i < self.n:
+ return i
+ else:
+ raise IndexError
+
+# Main test suite
+
+class TestCase(unittest.TestCase):
+
+ # Helper to check that an iterator returns a given sequence
+ def check_iterator(self, it, seq):
+ res = []
+ while 1:
+ try:
+ val = it.next()
+ except StopIteration:
+ break
+ res.append(val)
+ self.assertEqual(res, seq)
+
+ # Helper to check that a for loop generates a given sequence
+ def check_for_loop(self, expr, seq):
+ res = []
+ for val in expr:
+ res.append(val)
+ self.assertEqual(res, seq)
+
+ # Test basic use of iter() function
+ def test_iter_basic(self):
+ self.check_iterator(iter(range(10)), range(10))
+
+ # Test that iter(iter(x)) is the same as iter(x)
+ def test_iter_idempotency(self):
+ seq = range(10)
+ it = iter(seq)
+ it2 = iter(it)
+ self.assertTrue(it is it2)
+
+ # Test that for loops over iterators work
+ def test_iter_for_loop(self):
+ self.check_for_loop(iter(range(10)), range(10))
+
+ # Test several independent iterators over the same list
+ def test_iter_independence(self):
+ seq = range(3)
+ res = []
+ for i in iter(seq):
+ for j in iter(seq):
+ for k in iter(seq):
+ res.append((i, j, k))
+ self.assertEqual(res, TRIPLETS)
+
+ # Test triple list comprehension using iterators
+ def test_nested_comprehensions_iter(self):
+ seq = range(3)
+ res = [(i, j, k)
+ for i in iter(seq) for j in iter(seq) for k in iter(seq)]
+ self.assertEqual(res, TRIPLETS)
+
+ # Test triple list comprehension without iterators
+ def test_nested_comprehensions_for(self):
+ seq = range(3)
+ res = [(i, j, k) for i in seq for j in seq for k in seq]
+ self.assertEqual(res, TRIPLETS)
+
+ # Test a class with __iter__ in a for loop
+ def test_iter_class_for(self):
+ self.check_for_loop(IteratingSequenceClass(10), range(10))
+
+ # Test a class with __iter__ with explicit iter()
+ def test_iter_class_iter(self):
+ self.check_iterator(iter(IteratingSequenceClass(10)), range(10))
+
+ # Test for loop on a sequence class without __iter__
+ def test_seq_class_for(self):
+ self.check_for_loop(SequenceClass(10), range(10))
+
+ # Test iter() on a sequence class without __iter__
+ def test_seq_class_iter(self):
+ self.check_iterator(iter(SequenceClass(10)), range(10))
+
+ # Test a new_style class with __iter__ but no next() method
+ def test_new_style_iter_class(self):
+ class IterClass(object):
+ def __iter__(self):
+ return self
+ self.assertRaises(TypeError, iter, IterClass())
+
+ # Test two-argument iter() with callable instance
+ def test_iter_callable(self):
+ class C:
+ def __init__(self):
+ self.i = 0
+ def __call__(self):
+ i = self.i
+ self.i = i + 1
+ if i > 100:
+ raise IndexError # Emergency stop
+ return i
+ self.check_iterator(iter(C(), 10), range(10))
+
+ # Test two-argument iter() with function
+ def test_iter_function(self):
+ def spam(state=[0]):
+ i = state[0]
+ state[0] = i+1
+ return i
+ self.check_iterator(iter(spam, 10), range(10))
+
+ # Test two-argument iter() with function that raises StopIteration
+ def test_iter_function_stop(self):
+ def spam(state=[0]):
+ i = state[0]
+ if i == 10:
+ raise StopIteration
+ state[0] = i+1
+ return i
+ self.check_iterator(iter(spam, 20), range(10))
+
+ # Test exception propagation through function iterator
+ def test_exception_function(self):
+ def spam(state=[0]):
+ i = state[0]
+ state[0] = i+1
+ if i == 10:
+ raise RuntimeError
+ return i
+ res = []
+ try:
+ for x in iter(spam, 20):
+ res.append(x)
+ except RuntimeError:
+ self.assertEqual(res, range(10))
+ else:
+ self.fail("should have raised RuntimeError")
+
+ # Test exception propagation through sequence iterator
+ def test_exception_sequence(self):
+ class MySequenceClass(SequenceClass):
+ def __getitem__(self, i):
+ if i == 10:
+ raise RuntimeError
+ return SequenceClass.__getitem__(self, i)
+ res = []
+ try:
+ for x in MySequenceClass(20):
+ res.append(x)
+ except RuntimeError:
+ self.assertEqual(res, range(10))
+ else:
+ self.fail("should have raised RuntimeError")
+
+ # Test for StopIteration from __getitem__
+ def test_stop_sequence(self):
+ class MySequenceClass(SequenceClass):
+ def __getitem__(self, i):
+ if i == 10:
+ raise StopIteration
+ return SequenceClass.__getitem__(self, i)
+ self.check_for_loop(MySequenceClass(20), range(10))
+
+ # Test a big range
+ def test_iter_big_range(self):
+ self.check_for_loop(iter(range(10000)), range(10000))
+
+ # Test an empty list
+ def test_iter_empty(self):
+ self.check_for_loop(iter([]), [])
+
+ # Test a tuple
+ def test_iter_tuple(self):
+ self.check_for_loop(iter((0,1,2,3,4,5,6,7,8,9)), range(10))
+
+ # Test an xrange
+ def test_iter_xrange(self):
+ self.check_for_loop(iter(xrange(10)), range(10))
+
+ # Test a string
+ def test_iter_string(self):
+ self.check_for_loop(iter("abcde"), ["a", "b", "c", "d", "e"])
+
+ # Test a Unicode string
+ if have_unicode:
+ def test_iter_unicode(self):
+ self.check_for_loop(iter(unicode("abcde")),
+ [unicode("a"), unicode("b"), unicode("c"),
+ unicode("d"), unicode("e")])
+
+ # Test a directory
+ def test_iter_dict(self):
+ dict = {}
+ for i in range(10):
+ dict[i] = None
+ self.check_for_loop(dict, dict.keys())
+
+ # Test a file
+ def test_iter_file(self):
+ f = open(TESTFN, "w")
+ try:
+ for i in range(5):
+ f.write("%d\n" % i)
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ self.check_for_loop(f, ["0\n", "1\n", "2\n", "3\n", "4\n"])
+ self.check_for_loop(f, [])
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ # Test list()'s use of iterators.
+ def test_builtin_list(self):
+ self.assertEqual(list(SequenceClass(5)), range(5))
+ self.assertEqual(list(SequenceClass(0)), [])
+ self.assertEqual(list(()), [])
+ self.assertEqual(list(range(10, -1, -1)), range(10, -1, -1))
+
+ d = {"one": 1, "two": 2, "three": 3}
+ self.assertEqual(list(d), d.keys())
+
+ self.assertRaises(TypeError, list, list)
+ self.assertRaises(TypeError, list, 42)
+
+ f = open(TESTFN, "w")
+ try:
+ for i in range(5):
+ f.write("%d\n" % i)
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ self.assertEqual(list(f), ["0\n", "1\n", "2\n", "3\n", "4\n"])
+ f.seek(0, 0)
+ self.assertEqual(list(f),
+ ["0\n", "1\n", "2\n", "3\n", "4\n"])
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ # Test tuples()'s use of iterators.
+ def test_builtin_tuple(self):
+ self.assertEqual(tuple(SequenceClass(5)), (0, 1, 2, 3, 4))
+ self.assertEqual(tuple(SequenceClass(0)), ())
+ self.assertEqual(tuple([]), ())
+ self.assertEqual(tuple(()), ())
+ self.assertEqual(tuple("abc"), ("a", "b", "c"))
+
+ d = {"one": 1, "two": 2, "three": 3}
+ self.assertEqual(tuple(d), tuple(d.keys()))
+
+ self.assertRaises(TypeError, tuple, list)
+ self.assertRaises(TypeError, tuple, 42)
+
+ f = open(TESTFN, "w")
+ try:
+ for i in range(5):
+ f.write("%d\n" % i)
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ self.assertEqual(tuple(f), ("0\n", "1\n", "2\n", "3\n", "4\n"))
+ f.seek(0, 0)
+ self.assertEqual(tuple(f),
+ ("0\n", "1\n", "2\n", "3\n", "4\n"))
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ # Test filter()'s use of iterators.
+ def test_builtin_filter(self):
+ self.assertEqual(filter(None, SequenceClass(5)), range(1, 5))
+ self.assertEqual(filter(None, SequenceClass(0)), [])
+ self.assertEqual(filter(None, ()), ())
+ self.assertEqual(filter(None, "abc"), "abc")
+
+ d = {"one": 1, "two": 2, "three": 3}
+ self.assertEqual(filter(None, d), d.keys())
+
+ self.assertRaises(TypeError, filter, None, list)
+ self.assertRaises(TypeError, filter, None, 42)
+
+ class Boolean:
+ def __init__(self, truth):
+ self.truth = truth
+ def __nonzero__(self):
+ return self.truth
+ bTrue = Boolean(1)
+ bFalse = Boolean(0)
+
+ class Seq:
+ def __init__(self, *args):
+ self.vals = args
+ def __iter__(self):
+ class SeqIter:
+ def __init__(self, vals):
+ self.vals = vals
+ self.i = 0
+ def __iter__(self):
+ return self
+ def next(self):
+ i = self.i
+ self.i = i + 1
+ if i < len(self.vals):
+ return self.vals[i]
+ else:
+ raise StopIteration
+ return SeqIter(self.vals)
+
+ seq = Seq(*([bTrue, bFalse] * 25))
+ self.assertEqual(filter(lambda x: not x, seq), [bFalse]*25)
+ self.assertEqual(filter(lambda x: not x, iter(seq)), [bFalse]*25)
+
+ # Test max() and min()'s use of iterators.
+ def test_builtin_max_min(self):
+ self.assertEqual(max(SequenceClass(5)), 4)
+ self.assertEqual(min(SequenceClass(5)), 0)
+ self.assertEqual(max(8, -1), 8)
+ self.assertEqual(min(8, -1), -1)
+
+ d = {"one": 1, "two": 2, "three": 3}
+ self.assertEqual(max(d), "two")
+ self.assertEqual(min(d), "one")
+ self.assertEqual(max(d.itervalues()), 3)
+ self.assertEqual(min(iter(d.itervalues())), 1)
+
+ f = open(TESTFN, "w")
+ try:
+ f.write("medium line\n")
+ f.write("xtra large line\n")
+ f.write("itty-bitty line\n")
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ self.assertEqual(min(f), "itty-bitty line\n")
+ f.seek(0, 0)
+ self.assertEqual(max(f), "xtra large line\n")
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ # Test map()'s use of iterators.
+ def test_builtin_map(self):
+ self.assertEqual(map(lambda x: x+1, SequenceClass(5)), range(1, 6))
+
+ d = {"one": 1, "two": 2, "three": 3}
+ self.assertEqual(map(lambda k, d=d: (k, d[k]), d), d.items())
+ dkeys = d.keys()
+ expected = [(i < len(d) and dkeys[i] or None,
+ i,
+ i < len(d) and dkeys[i] or None)
+ for i in range(5)]
+
+ # Deprecated map(None, ...)
+ with check_py3k_warnings():
+ self.assertEqual(map(None, SequenceClass(5)), range(5))
+ self.assertEqual(map(None, d), d.keys())
+ self.assertEqual(map(None, d,
+ SequenceClass(5),
+ iter(d.iterkeys())),
+ expected)
+
+ f = open(TESTFN, "w")
+ try:
+ for i in range(10):
+ f.write("xy" * i + "\n") # line i has len 2*i+1
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ self.assertEqual(map(len, f), range(1, 21, 2))
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ # Test zip()'s use of iterators.
+ def test_builtin_zip(self):
+ self.assertEqual(zip(), [])
+ self.assertEqual(zip(*[]), [])
+ self.assertEqual(zip(*[(1, 2), 'ab']), [(1, 'a'), (2, 'b')])
+
+ self.assertRaises(TypeError, zip, None)
+ self.assertRaises(TypeError, zip, range(10), 42)
+ self.assertRaises(TypeError, zip, range(10), zip)
+
+ self.assertEqual(zip(IteratingSequenceClass(3)),
+ [(0,), (1,), (2,)])
+ self.assertEqual(zip(SequenceClass(3)),
+ [(0,), (1,), (2,)])
+
+ d = {"one": 1, "two": 2, "three": 3}
+ self.assertEqual(d.items(), zip(d, d.itervalues()))
+
+ # Generate all ints starting at constructor arg.
+ class IntsFrom:
+ def __init__(self, start):
+ self.i = start
+
+ def __iter__(self):
+ return self
+
+ def next(self):
+ i = self.i
+ self.i = i+1
+ return i
+
+ f = open(TESTFN, "w")
+ try:
+ f.write("a\n" "bbb\n" "cc\n")
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ self.assertEqual(zip(IntsFrom(0), f, IntsFrom(-100)),
+ [(0, "a\n", -100),
+ (1, "bbb\n", -99),
+ (2, "cc\n", -98)])
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ self.assertEqual(zip(xrange(5)), [(i,) for i in range(5)])
+
+ # Classes that lie about their lengths.
+ class NoGuessLen5:
+ def __getitem__(self, i):
+ if i >= 5:
+ raise IndexError
+ return i
+
+ class Guess3Len5(NoGuessLen5):
+ def __len__(self):
+ return 3
+
+ class Guess30Len5(NoGuessLen5):
+ def __len__(self):
+ return 30
+
+ self.assertEqual(len(Guess3Len5()), 3)
+ self.assertEqual(len(Guess30Len5()), 30)
+ self.assertEqual(zip(NoGuessLen5()), zip(range(5)))
+ self.assertEqual(zip(Guess3Len5()), zip(range(5)))
+ self.assertEqual(zip(Guess30Len5()), zip(range(5)))
+
+ expected = [(i, i) for i in range(5)]
+ for x in NoGuessLen5(), Guess3Len5(), Guess30Len5():
+ for y in NoGuessLen5(), Guess3Len5(), Guess30Len5():
+ self.assertEqual(zip(x, y), expected)
+
+ # Test reduces()'s use of iterators.
+ def test_deprecated_builtin_reduce(self):
+ with check_py3k_warnings():
+ self._test_builtin_reduce()
+
+ def _test_builtin_reduce(self):
+ from operator import add
+ self.assertEqual(reduce(add, SequenceClass(5)), 10)
+ self.assertEqual(reduce(add, SequenceClass(5), 42), 52)
+ self.assertRaises(TypeError, reduce, add, SequenceClass(0))
+ self.assertEqual(reduce(add, SequenceClass(0), 42), 42)
+ self.assertEqual(reduce(add, SequenceClass(1)), 0)
+ self.assertEqual(reduce(add, SequenceClass(1), 42), 42)
+
+ d = {"one": 1, "two": 2, "three": 3}
+ self.assertEqual(reduce(add, d), "".join(d.keys()))
+
+ # This test case will be removed if we don't have Unicode
+ def test_unicode_join_endcase(self):
+
+ # This class inserts a Unicode object into its argument's natural
+ # iteration, in the 3rd position.
+ class OhPhooey:
+ def __init__(self, seq):
+ self.it = iter(seq)
+ self.i = 0
+
+ def __iter__(self):
+ return self
+
+ def next(self):
+ i = self.i
+ self.i = i+1
+ if i == 2:
+ return unicode("fooled you!")
+ return self.it.next()
+
+ f = open(TESTFN, "w")
+ try:
+ f.write("a\n" + "b\n" + "c\n")
+ finally:
+ f.close()
+
+ f = open(TESTFN, "r")
+ # Nasty: string.join(s) can't know whether unicode.join() is needed
+ # until it's seen all of s's elements. But in this case, f's
+ # iterator cannot be restarted. So what we're testing here is
+ # whether string.join() can manage to remember everything it's seen
+ # and pass that on to unicode.join().
+ try:
+ got = " - ".join(OhPhooey(f))
+ self.assertEqual(got, unicode("a\n - b\n - fooled you! - c\n"))
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+ if not have_unicode:
+ def test_unicode_join_endcase(self): pass
+
+ # Test iterators with 'x in y' and 'x not in y'.
+ def test_in_and_not_in(self):
+ for sc5 in IteratingSequenceClass(5), SequenceClass(5):
+ for i in range(5):
+ self.assertIn(i, sc5)
+ for i in "abc", -1, 5, 42.42, (3, 4), [], {1: 1}, 3-12j, sc5:
+ self.assertNotIn(i, sc5)
+
+ self.assertRaises(TypeError, lambda: 3 in 12)
+ self.assertRaises(TypeError, lambda: 3 not in map)
+
+ d = {"one": 1, "two": 2, "three": 3, 1j: 2j}
+ for k in d:
+ self.assertIn(k, d)
+ self.assertNotIn(k, d.itervalues())
+ for v in d.values():
+ self.assertIn(v, d.itervalues())
+ self.assertNotIn(v, d)
+ for k, v in d.iteritems():
+ self.assertIn((k, v), d.iteritems())
+ self.assertNotIn((v, k), d.iteritems())
+
+ f = open(TESTFN, "w")
+ try:
+ f.write("a\n" "b\n" "c\n")
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ for chunk in "abc":
+ f.seek(0, 0)
+ self.assertNotIn(chunk, f)
+ f.seek(0, 0)
+ self.assertIn((chunk + "\n"), f)
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ # Test iterators with operator.countOf (PySequence_Count).
+ def test_countOf(self):
+ from operator import countOf
+ self.assertEqual(countOf([1,2,2,3,2,5], 2), 3)
+ self.assertEqual(countOf((1,2,2,3,2,5), 2), 3)
+ self.assertEqual(countOf("122325", "2"), 3)
+ self.assertEqual(countOf("122325", "6"), 0)
+
+ self.assertRaises(TypeError, countOf, 42, 1)
+ self.assertRaises(TypeError, countOf, countOf, countOf)
+
+ d = {"one": 3, "two": 3, "three": 3, 1j: 2j}
+ for k in d:
+ self.assertEqual(countOf(d, k), 1)
+ self.assertEqual(countOf(d.itervalues(), 3), 3)
+ self.assertEqual(countOf(d.itervalues(), 2j), 1)
+ self.assertEqual(countOf(d.itervalues(), 1j), 0)
+
+ f = open(TESTFN, "w")
+ try:
+ f.write("a\n" "b\n" "c\n" "b\n")
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ for letter, count in ("a", 1), ("b", 2), ("c", 1), ("d", 0):
+ f.seek(0, 0)
+ self.assertEqual(countOf(f, letter + "\n"), count)
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ # Test iterators with operator.indexOf (PySequence_Index).
+ def test_indexOf(self):
+ from operator import indexOf
+ self.assertEqual(indexOf([1,2,2,3,2,5], 1), 0)
+ self.assertEqual(indexOf((1,2,2,3,2,5), 2), 1)
+ self.assertEqual(indexOf((1,2,2,3,2,5), 3), 3)
+ self.assertEqual(indexOf((1,2,2,3,2,5), 5), 5)
+ self.assertRaises(ValueError, indexOf, (1,2,2,3,2,5), 0)
+ self.assertRaises(ValueError, indexOf, (1,2,2,3,2,5), 6)
+
+ self.assertEqual(indexOf("122325", "2"), 1)
+ self.assertEqual(indexOf("122325", "5"), 5)
+ self.assertRaises(ValueError, indexOf, "122325", "6")
+
+ self.assertRaises(TypeError, indexOf, 42, 1)
+ self.assertRaises(TypeError, indexOf, indexOf, indexOf)
+
+ f = open(TESTFN, "w")
+ try:
+ f.write("a\n" "b\n" "c\n" "d\n" "e\n")
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ fiter = iter(f)
+ self.assertEqual(indexOf(fiter, "b\n"), 1)
+ self.assertEqual(indexOf(fiter, "d\n"), 1)
+ self.assertEqual(indexOf(fiter, "e\n"), 0)
+ self.assertRaises(ValueError, indexOf, fiter, "a\n")
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ iclass = IteratingSequenceClass(3)
+ for i in range(3):
+ self.assertEqual(indexOf(iclass, i), i)
+ self.assertRaises(ValueError, indexOf, iclass, -1)
+
+ # Test iterators with file.writelines().
+ def test_writelines(self):
+ f = file(TESTFN, "w")
+
+ try:
+ self.assertRaises(TypeError, f.writelines, None)
+ self.assertRaises(TypeError, f.writelines, 42)
+
+ f.writelines(["1\n", "2\n"])
+ f.writelines(("3\n", "4\n"))
+ f.writelines({'5\n': None})
+ f.writelines({})
+
+ # Try a big chunk too.
+ class Iterator:
+ def __init__(self, start, finish):
+ self.start = start
+ self.finish = finish
+ self.i = self.start
+
+ def next(self):
+ if self.i >= self.finish:
+ raise StopIteration
+ result = str(self.i) + '\n'
+ self.i += 1
+ return result
+
+ def __iter__(self):
+ return self
+
+ class Whatever:
+ def __init__(self, start, finish):
+ self.start = start
+ self.finish = finish
+
+ def __iter__(self):
+ return Iterator(self.start, self.finish)
+
+ f.writelines(Whatever(6, 6+2000))
+ f.close()
+
+ f = file(TESTFN)
+ expected = [str(i) + "\n" for i in range(1, 2006)]
+ self.assertEqual(list(f), expected)
+
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+
+ # Test iterators on RHS of unpacking assignments.
+ def test_unpack_iter(self):
+ a, b = 1, 2
+ self.assertEqual((a, b), (1, 2))
+
+ a, b, c = IteratingSequenceClass(3)
+ self.assertEqual((a, b, c), (0, 1, 2))
+
+ try: # too many values
+ a, b = IteratingSequenceClass(3)
+ except ValueError:
+ pass
+ else:
+ self.fail("should have raised ValueError")
+
+ try: # not enough values
+ a, b, c = IteratingSequenceClass(2)
+ except ValueError:
+ pass
+ else:
+ self.fail("should have raised ValueError")
+
+ try: # not iterable
+ a, b, c = len
+ except TypeError:
+ pass
+ else:
+ self.fail("should have raised TypeError")
+
+ a, b, c = {1: 42, 2: 42, 3: 42}.itervalues()
+ self.assertEqual((a, b, c), (42, 42, 42))
+
+ f = open(TESTFN, "w")
+ lines = ("a\n", "bb\n", "ccc\n")
+ try:
+ for line in lines:
+ f.write(line)
+ finally:
+ f.close()
+ f = open(TESTFN, "r")
+ try:
+ a, b, c = f
+ self.assertEqual((a, b, c), lines)
+ finally:
+ f.close()
+ try:
+ unlink(TESTFN)
+ except OSError:
+ pass
+
+ (a, b), (c,) = IteratingSequenceClass(2), {42: 24}
+ self.assertEqual((a, b, c), (0, 1, 42))
+
+
+ @cpython_only
+ def test_ref_counting_behavior(self):
+ class C(object):
+ count = 0
+ def __new__(cls):
+ cls.count += 1
+ return object.__new__(cls)
+ def __del__(self):
+ cls = self.__class__
+ assert cls.count > 0
+ cls.count -= 1
+ x = C()
+ self.assertEqual(C.count, 1)
+ del x
+ self.assertEqual(C.count, 0)
+ l = [C(), C(), C()]
+ self.assertEqual(C.count, 3)
+ try:
+ a, b = iter(l)
+ except ValueError:
+ pass
+ del l
+ self.assertEqual(C.count, 0)
+
+
+ # Make sure StopIteration is a "sink state".
+ # This tests various things that weren't sink states in Python 2.2.1,
+ # plus various things that always were fine.
+
+ def test_sinkstate_list(self):
+ # This used to fail
+ a = range(5)
+ b = iter(a)
+ self.assertEqual(list(b), range(5))
+ a.extend(range(5, 10))
+ self.assertEqual(list(b), [])
+
+ def test_sinkstate_tuple(self):
+ a = (0, 1, 2, 3, 4)
+ b = iter(a)
+ self.assertEqual(list(b), range(5))
+ self.assertEqual(list(b), [])
+
+ def test_sinkstate_string(self):
+ a = "abcde"
+ b = iter(a)
+ self.assertEqual(list(b), ['a', 'b', 'c', 'd', 'e'])
+ self.assertEqual(list(b), [])
+
+ def test_sinkstate_sequence(self):
+ # This used to fail
+ a = SequenceClass(5)
+ b = iter(a)
+ self.assertEqual(list(b), range(5))
+ a.n = 10
+ self.assertEqual(list(b), [])
+
+ def test_sinkstate_callable(self):
+ # This used to fail
+ def spam(state=[0]):
+ i = state[0]
+ state[0] = i+1
+ if i == 10:
+ raise AssertionError, "shouldn't have gotten this far"
+ return i
+ b = iter(spam, 5)
+ self.assertEqual(list(b), range(5))
+ self.assertEqual(list(b), [])
+
+ def test_sinkstate_dict(self):
+ # XXX For a more thorough test, see towards the end of:
+ # http://mail.python.org/pipermail/python-dev/2002-July/026512.html
+ a = {1:1, 2:2, 0:0, 4:4, 3:3}
+ for b in iter(a), a.iterkeys(), a.iteritems(), a.itervalues():
+ b = iter(a)
+ self.assertEqual(len(list(b)), 5)
+ self.assertEqual(list(b), [])
+
+ def test_sinkstate_yield(self):
+ def gen():
+ for i in range(5):
+ yield i
+ b = gen()
+ self.assertEqual(list(b), range(5))
+ self.assertEqual(list(b), [])
+
+ def test_sinkstate_range(self):
+ a = xrange(5)
+ b = iter(a)
+ self.assertEqual(list(b), range(5))
+ self.assertEqual(list(b), [])
+
+ def test_sinkstate_enumerate(self):
+ a = range(5)
+ e = enumerate(a)
+ b = iter(e)
+ self.assertEqual(list(b), zip(range(5), range(5)))
+ self.assertEqual(list(b), [])
+
+ def test_3720(self):
+ # Avoid a crash, when an iterator deletes its next() method.
+ class BadIterator(object):
+ def __iter__(self):
+ return self
+ def next(self):
+ del BadIterator.next
+ return 1
+
+ try:
+ for i in BadIterator() :
+ pass
+ except TypeError:
+ pass
+
+ def test_extending_list_with_iterator_does_not_segfault(self):
+ # The code to extend a list with an iterator has a fair
+ # amount of nontrivial logic in terms of guessing how
+ # much memory to allocate in advance, "stealing" refs,
+ # and then shrinking at the end. This is a basic smoke
+ # test for that scenario.
+ def gen():
+ for i in range(500):
+ yield i
+ lst = [0] * 500
+ for i in range(240):
+ lst.pop(0)
+ lst.extend(gen())
+ self.assertEqual(len(lst), 760)
+
+
+def test_main():
+ run_unittest(TestCase)
+
+
+if __name__ == "__main__":
+ test_main()
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-06 20:18:39 +0000