From 4710c53dcad1ebf3755f3efb9e80ac24bd72a9b2 Mon Sep 17 00:00:00 2001 From: darylm503 Date: Mon, 16 Apr 2012 22:12:42 +0000 Subject: AppPkg/Applications/Python: Add Python 2.7.2 sources since the release of Python 2.7.3 made them unavailable from the python.org web site. These files are a subset of the python-2.7.2.tgz distribution from python.org. Changed files from PyMod-2.7.2 have been copied into the corresponding directories of this tree, replacing the original files in the distribution. Signed-off-by: daryl.mcdaniel@intel.com git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@13197 6f19259b-4bc3-4df7-8a09-765794883524 --- .../Python/Python-2.7.2/Lib/test/test_iter.py | 917 +++++++++++++++++++++ 1 file changed, 917 insertions(+) create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_iter.py (limited to 'AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_iter.py') diff --git a/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_iter.py b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_iter.py new file mode 100644 index 0000000000..3c62e27678 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Lib/test/test_iter.py @@ -0,0 +1,917 @@ +# 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_main(): + run_unittest(TestCase) + + +if __name__ == "__main__": + test_main() -- cgit v1.2.3