github.com/grumpyhome/grumpy@v0.3.1-0.20201208125205-7b775405bdf1/grumpy-runtime-src/third_party/stdlib/test/test_tuple.py (about) 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()