Changeset 391 for python/trunk/Lib/test/test_tuple.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_tuple.py (modified) (7 diffs)

python/trunk/Lib/test/test_tuple.py

@@ -1 +1 @@
 from test import test_support, seq_tests
+
+import gc
 
 class TupleTest(seq_tests.CommonTest):
@@ -5 +7 @@
 
     def test_constructors(self):
-        super(TupleTest, self).test_len()
+        super(TupleTest, self).test_constructors()
         # calling built-in types without argument must return empty
         self.assertEqual(tuple(), ())
         t0_3 = (0, 1, 2, 3)
         t0_3_bis = tuple(t0_3)
-        self.assert_(t0_3 is t0_3_bis)
+        self.assertTrue(t0_3 is t0_3_bis)
         self.assertEqual(tuple([]), ())
         self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3))
@@ -18 +20 @@
     def test_truth(self):
         super(TupleTest, self).test_truth()
-        self.assert_(not ())
-        self.assert_((42, ))
+        self.assertTrue(not ())
+        self.assertTrue((42, ))
 
     def test_len(self):
@@ -32 +34 @@
         u2 = u
         u += (2, 3)
-        self.assert_(u is not u2)
+        self.assertTrue(u is not u2)
 
     def test_imul(self):
@@ -39 +41 @@
         u2 = u
         u *= 3
-        self.assert_(u is not u2)
+        self.assertTrue(u is not u2)
 
     def test_tupleresizebug(self):
@@ -70 +72 @@
                      [(i, j) for i in xp for j in base] + xp + zip(base)
         collisions = len(inps) - len(set(map(hash, inps)))
-        self.assert_(collisions <= 15)
+        self.assertTrue(collisions <= 15)
 
     def test_repr(self):
@@ -83 +85 @@
         self.assertEqual(repr(a2), "(0, 1, 2)")
 
+    def _not_tracked(self, t):
+        # Nested tuples can take several collections to untrack
+        gc.collect()
+        gc.collect()
+        self.assertFalse(gc.is_tracked(t), t)
+
+    def _tracked(self, t):
+        self.assertTrue(gc.is_tracked(t), t)
+        gc.collect()
+        gc.collect()
+        self.assertTrue(gc.is_tracked(t), t)
+
+    @test_support.cpython_only
+    def test_track_literals(self):
+        # Test GC-optimization of tuple literals
+        x, y, z = 1.5, "a", []
+
+        self._not_tracked(())
+        self._not_tracked((1,))
+        self._not_tracked((1, 2))
+        self._not_tracked((1, 2, "a"))
+        self._not_tracked((1, 2, (None, True, False, ()), int))
+        self._not_tracked((object(),))
+        self._not_tracked(((1, x), y, (2, 3)))
+
+        # Tuples with mutable elements are always tracked, even if those
+        # elements are not tracked right now.
+        self._tracked(([],))
+        self._tracked(([1],))
+        self._tracked(({},))
+        self._tracked((set(),))
+        self._tracked((x, y, z))
+
+    def check_track_dynamic(self, tp, always_track):
+        x, y, z = 1.5, "a", []
+
+        check = self._tracked if always_track else self._not_tracked
+        check(tp())
+        check(tp([]))
+        check(tp(set()))
+        check(tp([1, x, y]))
+        check(tp(obj for obj in [1, x, y]))
+        check(tp(set([1, x, y])))
+        check(tp(tuple([obj]) for obj in [1, x, y]))
+        check(tuple(tp([obj]) for obj in [1, x, y]))
+
+        self._tracked(tp([z]))
+        self._tracked(tp([[x, y]]))
+        self._tracked(tp([{x: y}]))
+        self._tracked(tp(obj for obj in [x, y, z]))
+        self._tracked(tp(tuple([obj]) for obj in [x, y, z]))
+        self._tracked(tuple(tp([obj]) for obj in [x, y, z]))
+
+    @test_support.cpython_only
+    def test_track_dynamic(self):
+        # Test GC-optimization of dynamically constructed tuples.
+        self.check_track_dynamic(tuple, False)
+
+    @test_support.cpython_only
+    def test_track_subtypes(self):
+        # Tuple subtypes must always be tracked
+        class MyTuple(tuple):
+            pass
+        self.check_track_dynamic(MyTuple, True)
+
+    @test_support.cpython_only
+    def test_bug7466(self):
+        # Trying to untrack an unfinished tuple could crash Python
+        self._not_tracked(tuple(gc.collect() for i in range(101)))
+
 def test_main():
     test_support.run_unittest(TupleTest)