/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test__static_tuple.py

  • Committer: Andrew Bennetts
  • Date: 2009-10-15 02:19:43 UTC
  • mfrom: (4634.85.12 cleanup-hof)
  • mto: This revision was merged to the branch mainline in revision 4775.
  • Revision ID: andrew.bennetts@canonical.com-20091015021943-l8tuonz6q30tc4t6
Merge do_with_cleanups from cleanup-hof, and drop (or at least make private) everything else from that branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test__static_tuple.py
1
 
# Copyright (C) 2009, 2010 Canonical Ltd
 
1
# Copyright (C) 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
16
16
 
17
17
"""Tests for the StaticTuple type."""
18
18
 
19
 
import cPickle
20
19
import gc
21
20
import sys
22
21
 
23
22
from bzrlib import (
24
23
    _static_tuple_py,
25
 
    debug,
26
24
    errors,
27
25
    osutils,
28
 
    static_tuple,
29
26
    tests,
30
27
    )
31
28
 
32
29
 
33
30
def load_tests(standard_tests, module, loader):
34
31
    """Parameterize tests for all versions of groupcompress."""
35
 
    global compiled_static_tuple_feature
36
 
    suite, compiled_static_tuple_feature = tests.permute_tests_for_extension(
37
 
        standard_tests, loader, 'bzrlib._static_tuple_py',
38
 
        'bzrlib._static_tuple_c')
39
 
    return suite
 
32
    scenarios = [
 
33
        ('python', {'module': _static_tuple_py}),
 
34
    ]
 
35
    suite = loader.suiteClass()
 
36
    if CompiledStaticTuple.available():
 
37
        from bzrlib import _static_tuple_c
 
38
        scenarios.append(('C', {'module': _static_tuple_c}))
 
39
    else:
 
40
        # the compiled module isn't available, so we add a failing test
 
41
        class FailWithoutFeature(tests.TestCase):
 
42
            def test_fail(self):
 
43
                self.requireFeature(CompiledStaticTuple)
 
44
        suite.addTest(loader.loadTestsFromTestCase(FailWithoutFeature))
 
45
    result = tests.multiply_tests(standard_tests, scenarios, suite)
 
46
    return result
 
47
 
 
48
 
 
49
class _CompiledStaticTuple(tests.Feature):
 
50
 
 
51
    def _probe(self):
 
52
        try:
 
53
            import bzrlib._static_tuple_c
 
54
        except ImportError:
 
55
            return False
 
56
        return True
 
57
 
 
58
    def feature_name(self):
 
59
        return 'bzrlib._static_tuple_c'
 
60
 
 
61
CompiledStaticTuple = _CompiledStaticTuple()
40
62
 
41
63
 
42
64
class _Meliae(tests.Feature):
77
99
    def test_create_bad_args(self):
78
100
        args_256 = ['a']*256
79
101
        # too many args
80
 
        self.assertRaises(TypeError, self.module.StaticTuple, *args_256)
 
102
        self.assertRaises(ValueError, self.module.StaticTuple, *args_256)
81
103
        args_300 = ['a']*300
82
 
        self.assertRaises(TypeError, self.module.StaticTuple, *args_300)
 
104
        self.assertRaises(ValueError, self.module.StaticTuple, *args_300)
83
105
        # not a string
84
 
        self.assertRaises(TypeError, self.module.StaticTuple, object())
85
 
 
86
 
    def test_concat(self):
87
 
        st1 = self.module.StaticTuple('foo')
88
 
        st2 = self.module.StaticTuple('bar')
89
 
        st3 = self.module.StaticTuple('foo', 'bar')
90
 
        st4 = st1 + st2
91
 
        self.assertEqual(st3, st4)
92
 
        self.assertIsInstance(st4, self.module.StaticTuple)
93
 
 
94
 
    def test_concat_with_tuple(self):
95
 
        st1 = self.module.StaticTuple('foo')
96
 
        t2 = ('bar',)
97
 
        st3 = self.module.StaticTuple('foo', 'bar')
98
 
        st4 = self.module.StaticTuple('bar', 'foo')
99
 
        st5 = st1 + t2
100
 
        st6 = t2 + st1
101
 
        self.assertEqual(st3, st5)
102
 
        self.assertIsInstance(st5, self.module.StaticTuple)
103
 
        self.assertEqual(st4, st6)
104
 
        if self.module is _static_tuple_py:
105
 
            # _static_tuple_py has StaticTuple(tuple), so tuple thinks it
106
 
            # already knows how to concatenate, as such we can't "inject" our
107
 
            # own concatenation...
108
 
            self.assertIsInstance(st6, tuple)
109
 
        else:
110
 
            self.assertIsInstance(st6, self.module.StaticTuple)
111
 
 
112
 
    def test_concat_with_bad_tuple(self):
113
 
        st1 = self.module.StaticTuple('foo')
114
 
        t2 = (object(),)
115
 
        # Using st1.__add__ doesn't give the same results as doing the '+' form
116
 
        self.assertRaises(TypeError, lambda: st1 + t2)
117
 
 
118
 
    def test_concat_with_non_tuple(self):
119
 
        st1 = self.module.StaticTuple('foo')
120
 
        self.assertRaises(TypeError, lambda: st1 + 10)
 
106
        self.assertRaises(TypeError, self.module.StaticTuple, 10)
121
107
        
122
108
    def test_as_tuple(self):
123
109
        k = self.module.StaticTuple('foo')
124
110
        t = k.as_tuple()
125
111
        self.assertEqual(('foo',), t)
126
 
        self.assertIsInstance(t, tuple)
127
 
        self.assertFalse(isinstance(t, self.module.StaticTuple))
128
112
        k = self.module.StaticTuple('foo', 'bar')
129
113
        t = k.as_tuple()
130
114
        self.assertEqual(('foo', 'bar'), t)
131
 
        k2 = self.module.StaticTuple(1, k)
132
 
        t = k2.as_tuple()
133
 
        self.assertIsInstance(t, tuple)
134
 
        # For pickling to work, we need to keep the sub-items as StaticTuple so
135
 
        # that it knows that they also need to be converted.
136
 
        self.assertIsInstance(t[1], self.module.StaticTuple)
137
 
        self.assertEqual((1, ('foo', 'bar')), t)
138
 
 
139
 
    def test_as_tuples(self):
140
 
        k1 = self.module.StaticTuple('foo', 'bar')
141
 
        t = static_tuple.as_tuples(k1)
142
 
        self.assertIsInstance(t, tuple)
143
 
        self.assertEqual(('foo', 'bar'), t)
144
 
        k2 = self.module.StaticTuple(1, k1)
145
 
        t = static_tuple.as_tuples(k2)
146
 
        self.assertIsInstance(t, tuple)
147
 
        self.assertIsInstance(t[1], tuple)
148
 
        self.assertEqual((1, ('foo', 'bar')), t)
149
 
        mixed = (1, k1)
150
 
        t = static_tuple.as_tuples(mixed)
151
 
        self.assertIsInstance(t, tuple)
152
 
        self.assertIsInstance(t[1], tuple)
153
 
        self.assertEqual((1, ('foo', 'bar')), t)
154
115
 
155
116
    def test_len(self):
156
117
        k = self.module.StaticTuple()
215
176
        self.assertFalse(k1 < k2)
216
177
        self.assertFalse(k1 > k2)
217
178
 
218
 
    def test_holds_None(self):
219
 
        k1 = self.module.StaticTuple(None)
220
 
        # You cannot subclass None anyway
221
 
 
222
 
    def test_holds_int(self):
223
 
        k1 = self.module.StaticTuple(1)
224
 
        class subint(int):
225
 
            pass
226
 
        # But not a subclass, because subint could introduce refcycles
227
 
        self.assertRaises(TypeError, self.module.StaticTuple, subint(2))
228
 
 
229
 
    def test_holds_long(self):
230
 
        k1 = self.module.StaticTuple(2L**65)
231
 
        class sublong(long):
232
 
            pass
233
 
        # But not a subclass
234
 
        self.assertRaises(TypeError, self.module.StaticTuple, sublong(1))
235
 
 
236
 
    def test_holds_float(self):
237
 
        k1 = self.module.StaticTuple(1.2)
238
 
        class subfloat(float):
239
 
            pass
240
 
        self.assertRaises(TypeError, self.module.StaticTuple, subfloat(1.5))
241
 
 
242
 
    def test_holds_str(self):
243
 
        k1 = self.module.StaticTuple('astring')
244
 
        class substr(str):
245
 
            pass
246
 
        self.assertRaises(TypeError, self.module.StaticTuple, substr('a'))
247
 
 
248
 
    def test_holds_unicode(self):
249
 
        k1 = self.module.StaticTuple(u'\xb5')
250
 
        class subunicode(unicode):
251
 
            pass
252
 
        self.assertRaises(TypeError, self.module.StaticTuple,
253
 
                          subunicode(u'\xb5'))
254
 
 
255
 
    def test_hold_bool(self):
256
 
        k1 = self.module.StaticTuple(True)
257
 
        k2 = self.module.StaticTuple(False)
258
 
        # Cannot subclass bool
259
 
 
260
179
    def test_compare_same_obj(self):
261
180
        k1 = self.module.StaticTuple('foo', 'bar')
262
181
        self.assertCompareEqual(k1, k1)
263
182
        k2 = self.module.StaticTuple(k1, k1)
264
183
        self.assertCompareEqual(k2, k2)
265
 
        k3 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
266
 
                                     k1)
267
 
        self.assertCompareEqual(k3, k3)
268
184
 
269
185
    def test_compare_equivalent_obj(self):
270
186
        k1 = self.module.StaticTuple('foo', 'bar')
273
189
        k3 = self.module.StaticTuple(k1, k2)
274
190
        k4 = self.module.StaticTuple(k2, k1)
275
191
        self.assertCompareEqual(k1, k2)
276
 
        k5 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
277
 
                                     k1)
278
 
        k6 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
279
 
                                     k1)
280
 
        self.assertCompareEqual(k5, k6)
281
 
        k7 = self.module.StaticTuple(None)
282
 
        k8 = self.module.StaticTuple(None)
283
 
        self.assertCompareEqual(k7, k8)
284
192
 
285
193
    def test_compare_similar_obj(self):
286
194
        k1 = self.module.StaticTuple('foo' + ' bar', 'bar' + ' baz')
331
239
        k3 = self.module.StaticTuple(k1, k2)
332
240
        k4 = self.module.StaticTuple(k2, k1)
333
241
        self.assertCompareDifferent(k3, k4)
334
 
        k5 = self.module.StaticTuple(1)
335
 
        k6 = self.module.StaticTuple(2)
336
 
        self.assertCompareDifferent(k5, k6)
337
 
        k7 = self.module.StaticTuple(1.2)
338
 
        k8 = self.module.StaticTuple(2.4)
339
 
        self.assertCompareDifferent(k7, k8)
340
 
        k9 = self.module.StaticTuple(u's\xb5')
341
 
        k10 = self.module.StaticTuple(u's\xe5')
342
 
        self.assertCompareDifferent(k9, k10)
343
242
 
344
243
    def test_compare_some_different(self):
345
244
        k1 = self.module.StaticTuple('foo', 'bar')
348
247
        k3 = self.module.StaticTuple(k1, k1)
349
248
        k4 = self.module.StaticTuple(k1, k2)
350
249
        self.assertCompareDifferent(k3, k4)
351
 
        k5 = self.module.StaticTuple('foo', None)
352
 
        self.assertCompareDifferent(k5, k1)
353
 
        self.assertCompareDifferent(k5, k2)
354
250
 
355
251
    def test_compare_diff_width(self):
356
252
        k1 = self.module.StaticTuple('foo')
360
256
        k4 = self.module.StaticTuple(k1, k2)
361
257
        self.assertCompareDifferent(k3, k4)
362
258
 
363
 
    def test_compare_different_types(self):
364
 
        k1 = self.module.StaticTuple('foo', 'bar')
365
 
        k2 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
366
 
                                     k1)
367
 
        self.assertCompareNoRelation(k1, k2)
368
 
        k3 = self.module.StaticTuple('foo')
369
 
        self.assertCompareDifferent(k3, k1)
370
 
        k4 = self.module.StaticTuple(None)
371
 
        self.assertCompareDifferent(k4, k1)
372
 
        k5 = self.module.StaticTuple(1)
373
 
        self.assertCompareNoRelation(k1, k5)
374
 
 
375
259
    def test_compare_to_tuples(self):
376
260
        k1 = self.module.StaticTuple('foo')
377
261
        self.assertCompareEqual(k1, ('foo',))
394
278
        self.assertCompareEqual(k3, (k1, ('foo', 'bar')))
395
279
        self.assertCompareEqual((k1, ('foo', 'bar')), k3)
396
280
 
397
 
    def test_compare_mixed_depths(self):
398
 
        stuple = self.module.StaticTuple
399
 
        k1 = stuple(stuple('a',), stuple('b',))
400
 
        k2 = stuple(stuple(stuple('c',), stuple('d',)),
401
 
                    stuple('b',))
402
 
        # This requires comparing a StaticTuple to a 'string', and then
403
 
        # interpreting that value in the next higher StaticTuple. This used to
404
 
        # generate a PyErr_BadIternalCall. We now fall back to *something*.
405
 
        self.assertCompareNoRelation(k1, k2)
406
 
 
407
281
    def test_hash(self):
408
282
        k = self.module.StaticTuple('foo')
409
283
        self.assertEqual(hash(k), hash(('foo',)))
421
295
        as_tuple2 = (('foo', 'bar', 'baz', 'bing'),)
422
296
        self.assertEqual(hash(k2), hash(as_tuple2))
423
297
 
424
 
        k3 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
425
 
                                     k)
426
 
        as_tuple3 = ('foo', 1, None, u'\xb5', 1.2, 2**65, True, k)
427
 
        self.assertEqual(hash(as_tuple3), hash(k3))
428
 
 
429
298
    def test_slice(self):
430
299
        k = self.module.StaticTuple('foo', 'bar', 'baz', 'bing')
431
300
        self.assertEqual(('foo', 'bar'), k[:2])
547
416
        if self.module is _static_tuple_py:
548
417
            return
549
418
        self.assertIsNot(None, self.module._C_API)
550
 
 
551
 
    def test_from_sequence_tuple(self):
552
 
        st = self.module.StaticTuple.from_sequence(('foo', 'bar'))
553
 
        self.assertIsInstance(st, self.module.StaticTuple)
554
 
        self.assertEqual(('foo', 'bar'), st)
555
 
 
556
 
    def test_from_sequence_str(self):
557
 
        st = self.module.StaticTuple.from_sequence('foo')
558
 
        self.assertIsInstance(st, self.module.StaticTuple)
559
 
        self.assertEqual(('f', 'o', 'o'), st)
560
 
 
561
 
    def test_from_sequence_list(self):
562
 
        st = self.module.StaticTuple.from_sequence(['foo', 'bar'])
563
 
        self.assertIsInstance(st, self.module.StaticTuple)
564
 
        self.assertEqual(('foo', 'bar'), st)
565
 
 
566
 
    def test_from_sequence_static_tuple(self):
567
 
        st = self.module.StaticTuple('foo', 'bar')
568
 
        st2 = self.module.StaticTuple.from_sequence(st)
569
 
        # If the source is a StaticTuple already, we return the exact object
570
 
        self.assertIs(st, st2)
571
 
 
572
 
    def test_from_sequence_not_sequence(self):
573
 
        self.assertRaises(TypeError,
574
 
                          self.module.StaticTuple.from_sequence, object())
575
 
        self.assertRaises(TypeError,
576
 
                          self.module.StaticTuple.from_sequence, 10)
577
 
 
578
 
    def test_from_sequence_incorrect_args(self):
579
 
        self.assertRaises(TypeError,
580
 
                          self.module.StaticTuple.from_sequence, object(), 'a')
581
 
        self.assertRaises(TypeError,
582
 
                          self.module.StaticTuple.from_sequence, foo='a')
583
 
 
584
 
    def test_from_sequence_iterable(self):
585
 
        st = self.module.StaticTuple.from_sequence(iter(['foo', 'bar']))
586
 
        self.assertIsInstance(st, self.module.StaticTuple)
587
 
        self.assertEqual(('foo', 'bar'), st)
588
 
 
589
 
    def test_from_sequence_generator(self):
590
 
        def generate_tuple():
591
 
            yield 'foo'
592
 
            yield 'bar'
593
 
        st = self.module.StaticTuple.from_sequence(generate_tuple())
594
 
        self.assertIsInstance(st, self.module.StaticTuple)
595
 
        self.assertEqual(('foo', 'bar'), st)
596
 
 
597
 
    def test_pickle(self):
598
 
        st = self.module.StaticTuple('foo', 'bar')
599
 
        pickled = cPickle.dumps(st)
600
 
        unpickled = cPickle.loads(pickled)
601
 
        self.assertEqual(unpickled, st)
602
 
 
603
 
    def test_pickle_empty(self):
604
 
        st = self.module.StaticTuple()
605
 
        pickled = cPickle.dumps(st)
606
 
        unpickled = cPickle.loads(pickled)
607
 
        self.assertIs(st, unpickled)
608
 
 
609
 
    def test_pickle_nested(self):
610
 
        st = self.module.StaticTuple('foo', self.module.StaticTuple('bar'))
611
 
        pickled = cPickle.dumps(st)
612
 
        unpickled = cPickle.loads(pickled)
613
 
        self.assertEqual(unpickled, st)
614
 
 
615
 
    def test_static_tuple_thunk(self):
616
 
        # Make sure the right implementation is available from
617
 
        # bzrlib.static_tuple.StaticTuple.
618
 
        if self.module is _static_tuple_py:
619
 
            if compiled_static_tuple_feature.available():
620
 
                # We will be using the C version
621
 
                return
622
 
        self.assertIs(static_tuple.StaticTuple,
623
 
                      self.module.StaticTuple)
624
 
 
625
 
 
626
 
class TestEnsureStaticTuple(tests.TestCase):
627
 
 
628
 
    def test_is_static_tuple(self):
629
 
        st = static_tuple.StaticTuple('foo')
630
 
        st2 = static_tuple.expect_static_tuple(st)
631
 
        self.assertIs(st, st2)
632
 
 
633
 
    def test_is_tuple(self):
634
 
        t = ('foo',)
635
 
        st = static_tuple.expect_static_tuple(t)
636
 
        self.assertIsInstance(st, static_tuple.StaticTuple)
637
 
        self.assertEqual(t, st)
638
 
 
639
 
    def test_flagged_is_static_tuple(self):
640
 
        debug.debug_flags.add('static_tuple')
641
 
        st = static_tuple.StaticTuple('foo')
642
 
        st2 = static_tuple.expect_static_tuple(st)
643
 
        self.assertIs(st, st2)
644
 
 
645
 
    def test_flagged_is_tuple(self):
646
 
        debug.debug_flags.add('static_tuple')
647
 
        t = ('foo',)
648
 
        self.assertRaises(TypeError, static_tuple.expect_static_tuple, t)