Home | History | Annotate | Download | only in test 
      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