Changeset 391 for python/trunk/Lib/test/test_iter.py

Timestamp:

Mar 19, 2014, 11:31:01 PM (11 years ago)

Author:

dmik

Message:

python: Merge vendor 2.7.6 to trunk.

Location:

python/trunk

Files:

• . (modified) (1 prop)
• Lib/test/test_iter.py (modified) (11 diffs)

python/trunk/Lib/test/test_iter.py

@@ -2 +2 @@
 
 import unittest
-from test.test_support import run_unittest, TESTFN, unlink, have_unicode
+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)
@@ -76 +77 @@
         it = iter(seq)
         it2 = iter(it)
-        self.assert_(it is it2)
+        self.assertTrue(it is it2)
 
     # Test that for loops over iterators work
@@ -120 +121 @@
     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
@@ -390 +398 @@
     # Test map()'s use of iterators.
     def test_builtin_map(self):
-        self.assertEqual(map(None, SequenceClass(5)), range(5))
         self.assertEqual(map(lambda x: x+1, SequenceClass(5)), range(1, 6))
 
         d = {"one": 1, "two": 2, "three": 3}
-        self.assertEqual(map(None, d), d.keys())
         self.assertEqual(map(lambda k, d=d: (k, d[k]), d), d.items())
         dkeys = d.keys()
@@ -401 +407 @@
                      i < len(d) and dkeys[i] or None)
                     for i in range(5)]
-        self.assertEqual(map(None, d,
-                                   SequenceClass(5),
-                                   iter(d.iterkeys())),
-                         expected)
+
+        # 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")
@@ -500 +511 @@
 
     # Test reduces()'s use of iterators.
-    def test_builtin_reduce(self):
+    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)
@@ -560 +575 @@
         for sc5 in IteratingSequenceClass(5), SequenceClass(5):
             for i in range(5):
-                self.assert_(i in sc5)
+                self.assertIn(i, sc5)
             for i in "abc", -1, 5, 42.42, (3, 4), [], {1: 1}, 3-12j, sc5:
-                self.assert_(i not in sc5)
+                self.assertNotIn(i, sc5)
 
         self.assertRaises(TypeError, lambda: 3 in 12)
@@ -569 +584 @@
         d = {"one": 1, "two": 2, "three": 3, 1j: 2j}
         for k in d:
-            self.assert_(k in d)
-            self.assert_(k not in d.itervalues())
+            self.assertIn(k, d)
+            self.assertNotIn(k, d.itervalues())
         for v in d.values():
-            self.assert_(v in d.itervalues())
-            self.assert_(v not in d)
+            self.assertIn(v, d.itervalues())
+            self.assertNotIn(v, d)
         for k, v in d.iteritems():
-            self.assert_((k, v) in d.iteritems())
-            self.assert_((v, k) not in d.iteritems())
+            self.assertIn((k, v), d.iteritems())
+            self.assertNotIn((v, k), d.iteritems())
 
         f = open(TESTFN, "w")
@@ -587 +602 @@
             for chunk in "abc":
                 f.seek(0, 0)
-                self.assert_(chunk not in f)
+                self.assertNotIn(chunk, f)
                 f.seek(0, 0)
-                self.assert_((chunk + "\n") in f)
+                self.assertIn((chunk + "\n"), f)
         finally:
             f.close()
@@ -779 +794 @@
         self.assertEqual((a, b, c), (0, 1, 42))
 
-        # Test reference count behavior
-
+
+    @cpython_only
+    def test_ref_counting_behavior(self):
         class C(object):
             count = 0
@@ -878 +894 @@
         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():