1 from test import test_support, seq_tests 2 3 import gc 4 5 class TupleTest(seq_tests.CommonTest): 6 type2test = tuple 7 8 def test_constructors(self): 9 super(TupleTest, self).test_constructors() 10 # calling built-in types without argument must return empty 11 self.assertEqual(tuple(), ()) 12 t0_3 = (0, 1, 2, 3) 13 t0_3_bis = tuple(t0_3) 14 self.assertTrue(t0_3 is t0_3_bis) 15 self.assertEqual(tuple([]), ()) 16 self.assertEqual(tuple([0, 1, 2, 3]), (0, 1, 2, 3)) 17 self.assertEqual(tuple(''), ()) 18 self.assertEqual(tuple('spam'), ('s', 'p', 'a', 'm')) 19 20 def test_truth(self): 21 super(TupleTest, self).test_truth() 22 self.assertTrue(not ()) 23 self.assertTrue((42, )) 24 25 def test_len(self): 26 super(TupleTest, self).test_len() 27 self.assertEqual(len(()), 0) 28 self.assertEqual(len((0,)), 1) 29 self.assertEqual(len((0, 1, 2)), 3) 30 31 def test_iadd(self): 32 super(TupleTest, self).test_iadd() 33 u = (0, 1) 34 u2 = u 35 u += (2, 3) 36 self.assertTrue(u is not u2) 37 38 def test_imul(self): 39 super(TupleTest, self).test_imul() 40 u = (0, 1) 41 u2 = u 42 u *= 3 43 self.assertTrue(u is not u2) 44 45 def test_tupleresizebug(self): 46 # Check that a specific bug in _PyTuple_Resize() is squashed. 47 def f(): 48 for i in range(1000): 49 yield i 50 self.assertEqual(list(tuple(f())), range(1000)) 51 52 def test_hash(self): 53 # See SF bug 942952: Weakness in tuple hash 54 # The hash should: 55 # be non-commutative 56 # should spread-out closely spaced values 57 # should not exhibit cancellation in tuples like (x,(x,y)) 58 # should be distinct from element hashes: hash(x)!=hash((x,)) 59 # This test exercises those cases. 60 # For a pure random hash and N=50, the expected number of occupied 61 # buckets when tossing 252,600 balls into 2**32 buckets 62 # is 252,592.6, or about 7.4 expected collisions. The 63 # standard deviation is 2.73. On a box with 64-bit hash 64 # codes, no collisions are expected. Here we accept no 65 # more than 15 collisions. Any worse and the hash function 66 # is sorely suspect. 67 68 N=50 69 base = range(N) 70 xp = [(i, j) for i in base for j in base] 71 inps = base + [(i, j) for i in base for j in xp] + \ 72 [(i, j) for i in xp for j in base] + xp + zip(base) 73 collisions = len(inps) - len(set(map(hash, inps))) 74 self.assertTrue(collisions <= 15) 75 76 def test_repr(self): 77 l0 = tuple() 78 l2 = (0, 1, 2) 79 a0 = self.type2test(l0) 80 a2 = self.type2test(l2) 81 82 self.assertEqual(str(a0), repr(l0)) 83 self.assertEqual(str(a2), repr(l2)) 84 self.assertEqual(repr(a0), "()") 85 self.assertEqual(repr(a2), "(0, 1, 2)") 86 87 def _not_tracked(self, t): 88 # Nested tuples can take several collections to untrack 89 gc.collect() 90 gc.collect() 91 self.assertFalse(gc.is_tracked(t), t) 92 93 def _tracked(self, t): 94 self.assertTrue(gc.is_tracked(t), t) 95 gc.collect() 96 gc.collect() 97 self.assertTrue(gc.is_tracked(t), t) 98 99 @test_support.cpython_only 100 def test_track_literals(self): 101 # Test GC-optimization of tuple literals 102 x, y, z = 1.5, "a", [] 103 104 self._not_tracked(()) 105 self._not_tracked((1,)) 106 self._not_tracked((1, 2)) 107 self._not_tracked((1, 2, "a")) 108 self._not_tracked((1, 2, (None, True, False, ()), int)) 109 self._not_tracked((object(),)) 110 self._not_tracked(((1, x), y, (2, 3))) 111 112 # Tuples with mutable elements are always tracked, even if those 113 # elements are not tracked right now. 114 self._tracked(([],)) 115 self._tracked(([1],)) 116 self._tracked(({},)) 117 self._tracked((set(),)) 118 self._tracked((x, y, z)) 119 120 def check_track_dynamic(self, tp, always_track): 121 x, y, z = 1.5, "a", [] 122 123 check = self._tracked if always_track else self._not_tracked 124 check(tp()) 125 check(tp([])) 126 check(tp(set())) 127 check(tp([1, x, y])) 128 check(tp(obj for obj in [1, x, y])) 129 check(tp(set([1, x, y]))) 130 check(tp(tuple([obj]) for obj in [1, x, y])) 131 check(tuple(tp([obj]) for obj in [1, x, y])) 132 133 self._tracked(tp([z])) 134 self._tracked(tp([[x, y]])) 135 self._tracked(tp([{x: y}])) 136 self._tracked(tp(obj for obj in [x, y, z])) 137 self._tracked(tp(tuple([obj]) for obj in [x, y, z])) 138 self._tracked(tuple(tp([obj]) for obj in [x, y, z])) 139 140 @test_support.cpython_only 141 def test_track_dynamic(self): 142 # Test GC-optimization of dynamically constructed tuples. 143 self.check_track_dynamic(tuple, False) 144 145 @test_support.cpython_only 146 def test_track_subtypes(self): 147 # Tuple subtypes must always be tracked 148 class MyTuple(tuple): 149 pass 150 self.check_track_dynamic(MyTuple, True) 151 152 @test_support.cpython_only 153 def test_bug7466(self): 154 # Trying to untrack an unfinished tuple could crash Python 155 self._not_tracked(tuple(gc.collect() for i in range(101))) 156 157 def test_main(): 158 test_support.run_unittest(TupleTest) 159 160 if __name__=="__main__": 161 test_main() 162
