move sections
[python/dscho.git] / Lib / test / test_tuple.py
blob4d2137f6556ed202147507c9e1cd98ebcfa2ad8c
1 from test import test_support, seq_tests
3 import gc
5 class TupleTest(seq_tests.CommonTest):
6 type2test = tuple
8 def test_constructors(self):
9 super(TupleTest, self).test_len()
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'))
20 def test_truth(self):
21 super(TupleTest, self).test_truth()
22 self.assertTrue(not ())
23 self.assertTrue((42, ))
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)
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)
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)
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))
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.
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)
76 def test_repr(self):
77 l0 = tuple()
78 l2 = (0, 1, 2)
79 a0 = self.type2test(l0)
80 a2 = self.type2test(l2)
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)")
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)
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)
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", []
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)))
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))
120 def check_track_dynamic(self, tp, always_track):
121 x, y, z = 1.5, "a", []
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]))
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]))
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)
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)
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)))
157 def test_main():
158 test_support.run_unittest(TupleTest)
160 if __name__=="__main__":
161 test_main()