• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1from test import test_support, seq_tests
2
3import gc
4
5class 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
157def test_main():
158    test_support.run_unittest(TupleTest)
159
160if __name__=="__main__":
161    test_main()
162