1
# Copyright (C) 2009, 2010, 2011 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Tests for the StaticTuple type."""
31
def load_tests(standard_tests, module, loader):
32
"""Parameterize tests for all versions of groupcompress."""
33
global compiled_static_tuple_feature
34
suite, compiled_static_tuple_feature = tests.permute_tests_for_extension(
35
standard_tests, loader, 'bzrlib._static_tuple_py',
36
'bzrlib._static_tuple_c')
40
class _Meliae(tests.Feature):
44
from meliae import scanner
49
def feature_name(self):
50
return "Meliae - python memory debugger"
55
class TestStaticTuple(tests.TestCase):
57
def assertRefcount(self, count, obj):
58
"""Assert that the refcount for obj is what we expect.
60
Note that this automatically adjusts for the fact that calling
61
assertRefcount actually creates a new pointer, as does calling
62
sys.getrefcount. So pass the expected value *before* the call.
64
# I don't understand why it is getrefcount()-3 here, but it seems to be
65
# correct. If I check in the calling function, with:
66
# self.assertEqual(count, sys.getrefcount(obj)-1)
67
# Then it works fine. Something about passing it to assertRefcount is
68
# actually double-incrementing (and decrementing) the refcount
69
self.assertEqual(count, sys.getrefcount(obj)-3)
71
def test_create(self):
72
k = self.module.StaticTuple('foo')
73
k = self.module.StaticTuple('foo', 'bar')
75
def test_create_bad_args(self):
78
self.assertRaises(TypeError, self.module.StaticTuple, *args_256)
80
self.assertRaises(TypeError, self.module.StaticTuple, *args_300)
82
self.assertRaises(TypeError, self.module.StaticTuple, object())
84
def test_concat(self):
85
st1 = self.module.StaticTuple('foo')
86
st2 = self.module.StaticTuple('bar')
87
st3 = self.module.StaticTuple('foo', 'bar')
89
self.assertEqual(st3, st4)
90
self.assertIsInstance(st4, self.module.StaticTuple)
92
def test_concat_with_tuple(self):
93
st1 = self.module.StaticTuple('foo')
95
st3 = self.module.StaticTuple('foo', 'bar')
96
st4 = self.module.StaticTuple('bar', 'foo')
99
self.assertEqual(st3, st5)
100
self.assertIsInstance(st5, self.module.StaticTuple)
101
self.assertEqual(st4, st6)
102
if self.module is _static_tuple_py:
103
# _static_tuple_py has StaticTuple(tuple), so tuple thinks it
104
# already knows how to concatenate, as such we can't "inject" our
105
# own concatenation...
106
self.assertIsInstance(st6, tuple)
108
self.assertIsInstance(st6, self.module.StaticTuple)
110
def test_concat_with_bad_tuple(self):
111
st1 = self.module.StaticTuple('foo')
113
# Using st1.__add__ doesn't give the same results as doing the '+' form
114
self.assertRaises(TypeError, lambda: st1 + t2)
116
def test_concat_with_non_tuple(self):
117
st1 = self.module.StaticTuple('foo')
118
self.assertRaises(TypeError, lambda: st1 + 10)
120
def test_as_tuple(self):
121
k = self.module.StaticTuple('foo')
123
self.assertEqual(('foo',), t)
124
self.assertIsInstance(t, tuple)
125
self.assertFalse(isinstance(t, self.module.StaticTuple))
126
k = self.module.StaticTuple('foo', 'bar')
128
self.assertEqual(('foo', 'bar'), t)
129
k2 = self.module.StaticTuple(1, k)
131
self.assertIsInstance(t, tuple)
132
# For pickling to work, we need to keep the sub-items as StaticTuple so
133
# that it knows that they also need to be converted.
134
self.assertIsInstance(t[1], self.module.StaticTuple)
135
self.assertEqual((1, ('foo', 'bar')), t)
137
def test_as_tuples(self):
138
k1 = self.module.StaticTuple('foo', 'bar')
139
t = static_tuple.as_tuples(k1)
140
self.assertIsInstance(t, tuple)
141
self.assertEqual(('foo', 'bar'), t)
142
k2 = self.module.StaticTuple(1, k1)
143
t = static_tuple.as_tuples(k2)
144
self.assertIsInstance(t, tuple)
145
self.assertIsInstance(t[1], tuple)
146
self.assertEqual((1, ('foo', 'bar')), t)
148
t = static_tuple.as_tuples(mixed)
149
self.assertIsInstance(t, tuple)
150
self.assertIsInstance(t[1], tuple)
151
self.assertEqual((1, ('foo', 'bar')), t)
154
k = self.module.StaticTuple()
155
self.assertEqual(0, len(k))
156
k = self.module.StaticTuple('foo')
157
self.assertEqual(1, len(k))
158
k = self.module.StaticTuple('foo', 'bar')
159
self.assertEqual(2, len(k))
160
k = self.module.StaticTuple('foo', 'bar', 'b', 'b', 'b', 'b', 'b')
161
self.assertEqual(7, len(k))
163
k = self.module.StaticTuple(*args)
164
self.assertEqual(255, len(k))
166
def test_hold_other_static_tuples(self):
167
k = self.module.StaticTuple('foo', 'bar')
168
k2 = self.module.StaticTuple(k, k)
169
self.assertEqual(2, len(k2))
170
self.assertIs(k, k2[0])
171
self.assertIs(k, k2[1])
173
def test_getitem(self):
174
k = self.module.StaticTuple('foo', 'bar', 'b', 'b', 'b', 'b', 'z')
175
self.assertEqual('foo', k[0])
176
self.assertEqual('foo', k[0])
177
self.assertEqual('foo', k[0])
178
self.assertEqual('z', k[6])
179
self.assertEqual('z', k[-1])
180
self.assertRaises(IndexError, k.__getitem__, 7)
181
self.assertRaises(IndexError, k.__getitem__, 256+7)
182
self.assertRaises(IndexError, k.__getitem__, 12024)
183
# Python's [] resolver handles the negative arguments, so we can't
184
# really test StaticTuple_item() with negative values.
185
self.assertRaises(TypeError, k.__getitem__, 'not-an-int')
186
self.assertRaises(TypeError, k.__getitem__, '5')
188
def test_refcount(self):
190
num_refs = sys.getrefcount(f) - 1 #sys.getrefcount() adds one
191
k = self.module.StaticTuple(f)
192
self.assertRefcount(num_refs + 1, f)
194
self.assertRefcount(num_refs + 2, f)
196
self.assertRefcount(num_refs + 2, f)
198
self.assertRefcount(num_refs + 3, f)
200
self.assertRefcount(num_refs + 1, f)
202
self.assertRefcount(num_refs, f)
204
def test__repr__(self):
205
k = self.module.StaticTuple('foo', 'bar', 'baz', 'bing')
206
self.assertEqual("StaticTuple('foo', 'bar', 'baz', 'bing')", repr(k))
208
def assertCompareEqual(self, k1, k2):
209
self.assertTrue(k1 == k2)
210
self.assertTrue(k1 <= k2)
211
self.assertTrue(k1 >= k2)
212
self.assertFalse(k1 != k2)
213
self.assertFalse(k1 < k2)
214
self.assertFalse(k1 > k2)
216
def test_holds_None(self):
217
k1 = self.module.StaticTuple(None)
218
# You cannot subclass None anyway
220
def test_holds_int(self):
221
k1 = self.module.StaticTuple(1)
224
# But not a subclass, because subint could introduce refcycles
225
self.assertRaises(TypeError, self.module.StaticTuple, subint(2))
227
def test_holds_long(self):
228
k1 = self.module.StaticTuple(2L**65)
232
self.assertRaises(TypeError, self.module.StaticTuple, sublong(1))
234
def test_holds_float(self):
235
k1 = self.module.StaticTuple(1.2)
236
class subfloat(float):
238
self.assertRaises(TypeError, self.module.StaticTuple, subfloat(1.5))
240
def test_holds_str(self):
241
k1 = self.module.StaticTuple('astring')
244
self.assertRaises(TypeError, self.module.StaticTuple, substr('a'))
246
def test_holds_unicode(self):
247
k1 = self.module.StaticTuple(u'\xb5')
248
class subunicode(unicode):
250
self.assertRaises(TypeError, self.module.StaticTuple,
253
def test_hold_bool(self):
254
k1 = self.module.StaticTuple(True)
255
k2 = self.module.StaticTuple(False)
256
# Cannot subclass bool
258
def test_compare_same_obj(self):
259
k1 = self.module.StaticTuple('foo', 'bar')
260
self.assertCompareEqual(k1, k1)
261
k2 = self.module.StaticTuple(k1, k1)
262
self.assertCompareEqual(k2, k2)
263
k3 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
265
self.assertCompareEqual(k3, k3)
267
def test_compare_equivalent_obj(self):
268
k1 = self.module.StaticTuple('foo', 'bar')
269
k2 = self.module.StaticTuple('foo', 'bar')
270
self.assertCompareEqual(k1, k2)
271
k3 = self.module.StaticTuple(k1, k2)
272
k4 = self.module.StaticTuple(k2, k1)
273
self.assertCompareEqual(k1, k2)
274
k5 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
276
k6 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
278
self.assertCompareEqual(k5, k6)
279
k7 = self.module.StaticTuple(None)
280
k8 = self.module.StaticTuple(None)
281
self.assertCompareEqual(k7, k8)
283
def test_compare_similar_obj(self):
284
k1 = self.module.StaticTuple('foo' + ' bar', 'bar' + ' baz')
285
k2 = self.module.StaticTuple('fo' + 'o bar', 'ba' + 'r baz')
286
self.assertCompareEqual(k1, k2)
287
k3 = self.module.StaticTuple('foo ' + 'bar', 'bar ' + 'baz')
288
k4 = self.module.StaticTuple('f' + 'oo bar', 'b' + 'ar baz')
289
k5 = self.module.StaticTuple(k1, k2)
290
k6 = self.module.StaticTuple(k3, k4)
291
self.assertCompareEqual(k5, k6)
293
def assertCompareDifferent(self, k_small, k_big):
294
self.assertFalse(k_small == k_big)
295
self.assertFalse(k_small >= k_big)
296
self.assertFalse(k_small > k_big)
297
self.assertTrue(k_small != k_big)
298
self.assertTrue(k_small <= k_big)
299
self.assertTrue(k_small < k_big)
301
def assertCompareNoRelation(self, k1, k2):
302
"""Run the comparison operators, make sure they do something.
304
However, we don't actually care what comes first or second. This is
305
stuff like cross-class comparisons. We don't want to segfault/raise an
306
exception, but we don't care about the sort order.
308
self.assertFalse(k1 == k2)
309
self.assertTrue(k1 != k2)
310
# Do the comparison, but we don't care about the result
316
def test_compare_vs_none(self):
317
k1 = self.module.StaticTuple('baz', 'bing')
318
self.assertCompareDifferent(None, k1)
320
def test_compare_cross_class(self):
321
k1 = self.module.StaticTuple('baz', 'bing')
322
self.assertCompareNoRelation(10, k1)
323
self.assertCompareNoRelation('baz', k1)
325
def test_compare_all_different_same_width(self):
326
k1 = self.module.StaticTuple('baz', 'bing')
327
k2 = self.module.StaticTuple('foo', 'bar')
328
self.assertCompareDifferent(k1, k2)
329
k3 = self.module.StaticTuple(k1, k2)
330
k4 = self.module.StaticTuple(k2, k1)
331
self.assertCompareDifferent(k3, k4)
332
k5 = self.module.StaticTuple(1)
333
k6 = self.module.StaticTuple(2)
334
self.assertCompareDifferent(k5, k6)
335
k7 = self.module.StaticTuple(1.2)
336
k8 = self.module.StaticTuple(2.4)
337
self.assertCompareDifferent(k7, k8)
338
k9 = self.module.StaticTuple(u's\xb5')
339
k10 = self.module.StaticTuple(u's\xe5')
340
self.assertCompareDifferent(k9, k10)
342
def test_compare_some_different(self):
343
k1 = self.module.StaticTuple('foo', 'bar')
344
k2 = self.module.StaticTuple('foo', 'zzz')
345
self.assertCompareDifferent(k1, k2)
346
k3 = self.module.StaticTuple(k1, k1)
347
k4 = self.module.StaticTuple(k1, k2)
348
self.assertCompareDifferent(k3, k4)
349
k5 = self.module.StaticTuple('foo', None)
350
self.assertCompareDifferent(k5, k1)
351
self.assertCompareDifferent(k5, k2)
353
def test_compare_diff_width(self):
354
k1 = self.module.StaticTuple('foo')
355
k2 = self.module.StaticTuple('foo', 'bar')
356
self.assertCompareDifferent(k1, k2)
357
k3 = self.module.StaticTuple(k1)
358
k4 = self.module.StaticTuple(k1, k2)
359
self.assertCompareDifferent(k3, k4)
361
def test_compare_different_types(self):
362
k1 = self.module.StaticTuple('foo', 'bar')
363
k2 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
365
self.assertCompareNoRelation(k1, k2)
366
k3 = self.module.StaticTuple('foo')
367
self.assertCompareDifferent(k3, k1)
368
k4 = self.module.StaticTuple(None)
369
self.assertCompareDifferent(k4, k1)
370
k5 = self.module.StaticTuple(1)
371
self.assertCompareNoRelation(k1, k5)
373
def test_compare_to_tuples(self):
374
k1 = self.module.StaticTuple('foo')
375
self.assertCompareEqual(k1, ('foo',))
376
self.assertCompareEqual(('foo',), k1)
377
self.assertCompareDifferent(k1, ('foo', 'bar'))
378
self.assertCompareDifferent(k1, ('foo', 10))
380
k2 = self.module.StaticTuple('foo', 'bar')
381
self.assertCompareEqual(k2, ('foo', 'bar'))
382
self.assertCompareEqual(('foo', 'bar'), k2)
383
self.assertCompareDifferent(k2, ('foo', 'zzz'))
384
self.assertCompareDifferent(('foo',), k2)
385
self.assertCompareDifferent(('foo', 'aaa'), k2)
386
self.assertCompareDifferent(('baz', 'bing'), k2)
387
self.assertCompareDifferent(('foo', 10), k2)
389
k3 = self.module.StaticTuple(k1, k2)
390
self.assertCompareEqual(k3, (('foo',), ('foo', 'bar')))
391
self.assertCompareEqual((('foo',), ('foo', 'bar')), k3)
392
self.assertCompareEqual(k3, (k1, ('foo', 'bar')))
393
self.assertCompareEqual((k1, ('foo', 'bar')), k3)
395
def test_compare_mixed_depths(self):
396
stuple = self.module.StaticTuple
397
k1 = stuple(stuple('a',), stuple('b',))
398
k2 = stuple(stuple(stuple('c',), stuple('d',)),
400
# This requires comparing a StaticTuple to a 'string', and then
401
# interpreting that value in the next higher StaticTuple. This used to
402
# generate a PyErr_BadIternalCall. We now fall back to *something*.
403
self.assertCompareNoRelation(k1, k2)
406
k = self.module.StaticTuple('foo')
407
self.assertEqual(hash(k), hash(('foo',)))
408
k = self.module.StaticTuple('foo', 'bar', 'baz', 'bing')
409
as_tuple = ('foo', 'bar', 'baz', 'bing')
410
self.assertEqual(hash(k), hash(as_tuple))
412
# Because k == , it replaces the slot, rather than having both
413
# present in the dict.
414
self.assertEqual('foo', x[as_tuple])
416
self.assertEqual({as_tuple: 'bar'}, x)
418
k2 = self.module.StaticTuple(k)
419
as_tuple2 = (('foo', 'bar', 'baz', 'bing'),)
420
self.assertEqual(hash(k2), hash(as_tuple2))
422
k3 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
424
as_tuple3 = ('foo', 1, None, u'\xb5', 1.2, 2**65, True, k)
425
self.assertEqual(hash(as_tuple3), hash(k3))
427
def test_slice(self):
428
k = self.module.StaticTuple('foo', 'bar', 'baz', 'bing')
429
self.assertEqual(('foo', 'bar'), k[:2])
430
self.assertEqual(('baz',), k[2:-1])
434
# C implementation raises a TypeError, we don't need the
435
# implementation yet, so allow this to pass
438
# Python implementation uses a regular Tuple, so make sure it gives
440
self.assertEqual(('foo', 'baz'), val)
442
def test_referents(self):
443
# We implement tp_traverse so that things like 'meliae' can measure the
444
# amount of referenced memory. Unfortunately gc.get_referents() first
445
# checks the IS_GC flag before it traverses anything. We could write a
446
# helper func, but that won't work for the generic implementation...
447
self.requireFeature(Meliae)
448
from meliae import scanner
449
strs = ['foo', 'bar', 'baz', 'bing']
450
k = self.module.StaticTuple(*strs)
451
if self.module is _static_tuple_py:
452
refs = strs + [self.module.StaticTuple]
455
self.assertEqual(sorted(refs), sorted(scanner.get_referents(k)))
457
def test_nested_referents(self):
458
self.requireFeature(Meliae)
459
from meliae import scanner
460
strs = ['foo', 'bar', 'baz', 'bing']
461
k1 = self.module.StaticTuple(*strs[:2])
462
k2 = self.module.StaticTuple(*strs[2:])
463
k3 = self.module.StaticTuple(k1, k2)
465
if self.module is _static_tuple_py:
466
refs.append(self.module.StaticTuple)
467
self.assertEqual(sorted(refs),
468
sorted(scanner.get_referents(k3)))
470
def test_empty_is_singleton(self):
471
key = self.module.StaticTuple()
472
self.assertIs(key, self.module._empty_tuple)
474
def test_intern(self):
475
unique_str1 = 'unique str ' + osutils.rand_chars(20)
476
unique_str2 = 'unique str ' + osutils.rand_chars(20)
477
key = self.module.StaticTuple(unique_str1, unique_str2)
478
self.assertFalse(key in self.module._interned_tuples)
479
key2 = self.module.StaticTuple(unique_str1, unique_str2)
480
self.assertEqual(key, key2)
481
self.assertIsNot(key, key2)
483
self.assertIs(key, key3)
484
self.assertTrue(key in self.module._interned_tuples)
485
self.assertEqual(key, self.module._interned_tuples[key])
487
self.assertIs(key, key2)
489
def test__c_intern_handles_refcount(self):
490
if self.module is _static_tuple_py:
491
return # Not applicable
492
unique_str1 = 'unique str ' + osutils.rand_chars(20)
493
unique_str2 = 'unique str ' + osutils.rand_chars(20)
494
key = self.module.StaticTuple(unique_str1, unique_str2)
495
self.assertRefcount(1, key)
496
self.assertFalse(key in self.module._interned_tuples)
497
self.assertFalse(key._is_interned())
498
key2 = self.module.StaticTuple(unique_str1, unique_str2)
499
self.assertRefcount(1, key)
500
self.assertRefcount(1, key2)
501
self.assertEqual(key, key2)
502
self.assertIsNot(key, key2)
505
self.assertIs(key, key3)
506
self.assertTrue(key in self.module._interned_tuples)
507
self.assertEqual(key, self.module._interned_tuples[key])
508
# key and key3, but we 'hide' the one in _interned_tuples
509
self.assertRefcount(2, key)
511
self.assertRefcount(1, key)
512
self.assertTrue(key._is_interned())
513
self.assertRefcount(1, key2)
515
# key3 now points to key as well, and *not* to key2
516
self.assertRefcount(2, key)
517
self.assertRefcount(1, key2)
518
self.assertIs(key, key3)
519
self.assertIsNot(key3, key2)
522
self.assertRefcount(1, key)
524
def test__c_keys_are_not_immortal(self):
525
if self.module is _static_tuple_py:
526
return # Not applicable
527
unique_str1 = 'unique str ' + osutils.rand_chars(20)
528
unique_str2 = 'unique str ' + osutils.rand_chars(20)
529
key = self.module.StaticTuple(unique_str1, unique_str2)
530
self.assertFalse(key in self.module._interned_tuples)
531
self.assertRefcount(1, key)
533
self.assertRefcount(1, key)
534
self.assertTrue(key in self.module._interned_tuples)
535
self.assertTrue(key._is_interned())
537
# Create a new entry, which would point to the same location
538
key = self.module.StaticTuple(unique_str1, unique_str2)
539
self.assertRefcount(1, key)
540
# This old entry in _interned_tuples should be gone
541
self.assertFalse(key in self.module._interned_tuples)
542
self.assertFalse(key._is_interned())
544
def test__c_has_C_API(self):
545
if self.module is _static_tuple_py:
547
self.assertIsNot(None, self.module._C_API)
549
def test_from_sequence_tuple(self):
550
st = self.module.StaticTuple.from_sequence(('foo', 'bar'))
551
self.assertIsInstance(st, self.module.StaticTuple)
552
self.assertEqual(('foo', 'bar'), st)
554
def test_from_sequence_str(self):
555
st = self.module.StaticTuple.from_sequence('foo')
556
self.assertIsInstance(st, self.module.StaticTuple)
557
self.assertEqual(('f', 'o', 'o'), st)
559
def test_from_sequence_list(self):
560
st = self.module.StaticTuple.from_sequence(['foo', 'bar'])
561
self.assertIsInstance(st, self.module.StaticTuple)
562
self.assertEqual(('foo', 'bar'), st)
564
def test_from_sequence_static_tuple(self):
565
st = self.module.StaticTuple('foo', 'bar')
566
st2 = self.module.StaticTuple.from_sequence(st)
567
# If the source is a StaticTuple already, we return the exact object
568
self.assertIs(st, st2)
570
def test_from_sequence_not_sequence(self):
571
self.assertRaises(TypeError,
572
self.module.StaticTuple.from_sequence, object())
573
self.assertRaises(TypeError,
574
self.module.StaticTuple.from_sequence, 10)
576
def test_from_sequence_incorrect_args(self):
577
self.assertRaises(TypeError,
578
self.module.StaticTuple.from_sequence, object(), 'a')
579
self.assertRaises(TypeError,
580
self.module.StaticTuple.from_sequence, foo='a')
582
def test_from_sequence_iterable(self):
583
st = self.module.StaticTuple.from_sequence(iter(['foo', 'bar']))
584
self.assertIsInstance(st, self.module.StaticTuple)
585
self.assertEqual(('foo', 'bar'), st)
587
def test_from_sequence_generator(self):
588
def generate_tuple():
591
st = self.module.StaticTuple.from_sequence(generate_tuple())
592
self.assertIsInstance(st, self.module.StaticTuple)
593
self.assertEqual(('foo', 'bar'), st)
595
def test_pickle(self):
596
st = self.module.StaticTuple('foo', 'bar')
597
pickled = cPickle.dumps(st)
598
unpickled = cPickle.loads(pickled)
599
self.assertEqual(unpickled, st)
601
def test_pickle_empty(self):
602
st = self.module.StaticTuple()
603
pickled = cPickle.dumps(st)
604
unpickled = cPickle.loads(pickled)
605
self.assertIs(st, unpickled)
607
def test_pickle_nested(self):
608
st = self.module.StaticTuple('foo', self.module.StaticTuple('bar'))
609
pickled = cPickle.dumps(st)
610
unpickled = cPickle.loads(pickled)
611
self.assertEqual(unpickled, st)
613
def test_static_tuple_thunk(self):
614
# Make sure the right implementation is available from
615
# bzrlib.static_tuple.StaticTuple.
616
if self.module is _static_tuple_py:
617
if compiled_static_tuple_feature.available():
618
# We will be using the C version
620
self.assertIs(static_tuple.StaticTuple,
621
self.module.StaticTuple)
624
class TestEnsureStaticTuple(tests.TestCase):
626
def test_is_static_tuple(self):
627
st = static_tuple.StaticTuple('foo')
628
st2 = static_tuple.expect_static_tuple(st)
629
self.assertIs(st, st2)
631
def test_is_tuple(self):
633
st = static_tuple.expect_static_tuple(t)
634
self.assertIsInstance(st, static_tuple.StaticTuple)
635
self.assertEqual(t, st)
637
def test_flagged_is_static_tuple(self):
638
debug.debug_flags.add('static_tuple')
639
st = static_tuple.StaticTuple('foo')
640
st2 = static_tuple.expect_static_tuple(st)
641
self.assertIs(st, st2)
643
def test_flagged_is_tuple(self):
644
debug.debug_flags.add('static_tuple')
646
self.assertRaises(TypeError, static_tuple.expect_static_tuple, t)
added
removed
bzrlib/tests/test__static_tuple.py
