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."""
20
import cPickle as pickle
33
from breezy.sixish import (
37
from breezy.tests import (
42
def load_tests(loader, standard_tests, pattern):
43
"""Parameterize tests for all versions of groupcompress."""
44
global compiled_static_tuple_feature
45
suite, compiled_static_tuple_feature = tests.permute_tests_for_extension(
46
standard_tests, loader, 'breezy._static_tuple_py',
47
'breezy._static_tuple_c')
51
class TestStaticTuple(tests.TestCase):
53
def assertRefcount(self, count, obj):
54
"""Assert that the refcount for obj is what we expect.
56
Note that this automatically adjusts for the fact that calling
57
assertRefcount actually creates a new pointer, as does calling
58
sys.getrefcount. So pass the expected value *before* the call.
60
# I don't understand why it is getrefcount()-3 here, but it seems to be
61
# correct. If I check in the calling function, with:
62
# self.assertEqual(count, sys.getrefcount(obj)-1)
63
# Then it works fine. Something about passing it to assertRefcount is
64
# actually double-incrementing (and decrementing) the refcount
65
self.assertEqual(count, sys.getrefcount(obj) - 3)
67
def test_create(self):
68
k = self.module.StaticTuple('foo')
69
k = self.module.StaticTuple('foo', 'bar')
71
def test_create_bad_args(self):
72
args_256 = ['a'] * 256
74
self.assertRaises(TypeError, self.module.StaticTuple, *args_256)
75
args_300 = ['a'] * 300
76
self.assertRaises(TypeError, self.module.StaticTuple, *args_300)
78
self.assertRaises(TypeError, self.module.StaticTuple, object())
80
def test_concat(self):
81
st1 = self.module.StaticTuple('foo')
82
st2 = self.module.StaticTuple('bar')
83
st3 = self.module.StaticTuple('foo', 'bar')
85
self.assertEqual(st3, st4)
86
self.assertIsInstance(st4, self.module.StaticTuple)
88
def test_concat_with_tuple(self):
89
st1 = self.module.StaticTuple('foo')
91
st3 = self.module.StaticTuple('foo', 'bar')
92
st4 = self.module.StaticTuple('bar', 'foo')
95
self.assertEqual(st3, st5)
96
self.assertIsInstance(st5, self.module.StaticTuple)
97
self.assertEqual(st4, st6)
98
if self.module is _static_tuple_py:
99
# _static_tuple_py has StaticTuple(tuple), so tuple thinks it
100
# already knows how to concatenate, as such we can't "inject" our
101
# own concatenation...
102
self.assertIsInstance(st6, tuple)
104
self.assertIsInstance(st6, self.module.StaticTuple)
106
def test_concat_with_bad_tuple(self):
107
st1 = self.module.StaticTuple('foo')
109
# Using st1.__add__ doesn't give the same results as doing the '+' form
110
self.assertRaises(TypeError, lambda: st1 + t2)
112
def test_concat_with_non_tuple(self):
113
st1 = self.module.StaticTuple('foo')
114
self.assertRaises(TypeError, lambda: st1 + 10)
116
def test_as_tuple(self):
117
k = self.module.StaticTuple('foo')
119
self.assertEqual(('foo',), t)
120
self.assertIsInstance(t, tuple)
121
self.assertFalse(isinstance(t, self.module.StaticTuple))
122
k = self.module.StaticTuple('foo', 'bar')
124
self.assertEqual(('foo', 'bar'), t)
125
k2 = self.module.StaticTuple(1, k)
127
self.assertIsInstance(t, tuple)
128
# For pickling to work, we need to keep the sub-items as StaticTuple so
129
# that it knows that they also need to be converted.
130
self.assertIsInstance(t[1], self.module.StaticTuple)
131
self.assertEqual((1, ('foo', 'bar')), t)
133
def test_as_tuples(self):
134
k1 = self.module.StaticTuple('foo', 'bar')
135
t = static_tuple.as_tuples(k1)
136
self.assertIsInstance(t, tuple)
137
self.assertEqual(('foo', 'bar'), t)
138
k2 = self.module.StaticTuple(1, k1)
139
t = static_tuple.as_tuples(k2)
140
self.assertIsInstance(t, tuple)
141
self.assertIsInstance(t[1], tuple)
142
self.assertEqual((1, ('foo', 'bar')), t)
144
t = static_tuple.as_tuples(mixed)
145
self.assertIsInstance(t, tuple)
146
self.assertIsInstance(t[1], tuple)
147
self.assertEqual((1, ('foo', 'bar')), t)
150
k = self.module.StaticTuple()
151
self.assertEqual(0, len(k))
152
k = self.module.StaticTuple('foo')
153
self.assertEqual(1, len(k))
154
k = self.module.StaticTuple('foo', 'bar')
155
self.assertEqual(2, len(k))
156
k = self.module.StaticTuple('foo', 'bar', 'b', 'b', 'b', 'b', 'b')
157
self.assertEqual(7, len(k))
159
k = self.module.StaticTuple(*args)
160
self.assertEqual(255, len(k))
162
def test_hold_other_static_tuples(self):
163
k = self.module.StaticTuple('foo', 'bar')
164
k2 = self.module.StaticTuple(k, k)
165
self.assertEqual(2, len(k2))
166
self.assertIs(k, k2[0])
167
self.assertIs(k, k2[1])
169
def test_getitem(self):
170
k = self.module.StaticTuple('foo', 'bar', 'b', 'b', 'b', 'b', 'z')
171
self.assertEqual('foo', k[0])
172
self.assertEqual('foo', k[0])
173
self.assertEqual('foo', k[0])
174
self.assertEqual('z', k[6])
175
self.assertEqual('z', k[-1])
176
self.assertRaises(IndexError, k.__getitem__, 7)
177
self.assertRaises(IndexError, k.__getitem__, 256 + 7)
178
self.assertRaises(IndexError, k.__getitem__, 12024)
179
# Python's [] resolver handles the negative arguments, so we can't
180
# really test StaticTuple_item() with negative values.
181
self.assertRaises(TypeError, k.__getitem__, 'not-an-int')
182
self.assertRaises(TypeError, k.__getitem__, '5')
184
def test_refcount(self):
186
num_refs = sys.getrefcount(f) - 1 # sys.getrefcount() adds one
187
k = self.module.StaticTuple(f)
188
self.assertRefcount(num_refs + 1, f)
190
self.assertRefcount(num_refs + 2, f)
192
self.assertRefcount(num_refs + 2, f)
194
self.assertRefcount(num_refs + 3, f)
196
self.assertRefcount(num_refs + 1, f)
198
self.assertRefcount(num_refs, f)
200
def test__repr__(self):
201
k = self.module.StaticTuple('foo', 'bar', 'baz', 'bing')
202
self.assertEqual("StaticTuple('foo', 'bar', 'baz', 'bing')", repr(k))
204
def assertCompareEqual(self, k1, k2):
205
self.assertTrue(k1 == k2)
206
self.assertTrue(k1 <= k2)
207
self.assertTrue(k1 >= k2)
208
self.assertFalse(k1 != k2)
209
self.assertFalse(k1 < k2)
210
self.assertFalse(k1 > k2)
212
def test_holds_None(self):
213
k1 = self.module.StaticTuple(None)
214
# You cannot subclass None anyway
216
def test_holds_int(self):
217
k1 = self.module.StaticTuple(1)
221
# But not a subclass, because subint could introduce refcycles
222
self.assertRaises(TypeError, self.module.StaticTuple, subint(2))
224
def test_holds_long(self):
226
self.skipTest("No long type on Python 3")
227
k1 = self.module.StaticTuple(2**65)
232
self.assertRaises(TypeError, self.module.StaticTuple, sublong(1))
234
def test_holds_float(self):
235
k1 = self.module.StaticTuple(1.2)
237
class subfloat(float):
239
self.assertRaises(TypeError, self.module.StaticTuple, subfloat(1.5))
241
def test_holds_bytes(self):
242
k1 = self.module.StaticTuple(b'astring')
246
self.assertRaises(TypeError, self.module.StaticTuple, substr(b'a'))
248
def test_holds_unicode(self):
249
k1 = self.module.StaticTuple(u'\xb5')
251
class subunicode(text_type):
253
self.assertRaises(TypeError, self.module.StaticTuple,
256
def test_hold_bool(self):
257
k1 = self.module.StaticTuple(True)
258
k2 = self.module.StaticTuple(False)
259
# Cannot subclass bool
261
def test_compare_same_obj(self):
262
k1 = self.module.StaticTuple('foo', 'bar')
263
self.assertCompareEqual(k1, k1)
264
k2 = self.module.StaticTuple(k1, k1)
265
self.assertCompareEqual(k2, k2)
266
k3 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
268
self.assertCompareEqual(k3, k3)
270
def test_compare_equivalent_obj(self):
271
k1 = self.module.StaticTuple('foo', 'bar')
272
k2 = self.module.StaticTuple('foo', 'bar')
273
self.assertCompareEqual(k1, k2)
274
k3 = self.module.StaticTuple(k1, k2)
275
k4 = self.module.StaticTuple(k2, k1)
276
self.assertCompareEqual(k1, k2)
277
k5 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
279
k6 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
281
self.assertCompareEqual(k5, k6)
282
k7 = self.module.StaticTuple(None)
283
k8 = self.module.StaticTuple(None)
284
self.assertCompareEqual(k7, k8)
286
def test_compare_similar_obj(self):
287
k1 = self.module.StaticTuple('foo' + ' bar', 'bar' + ' baz')
288
k2 = self.module.StaticTuple('fo' + 'o bar', 'ba' + 'r baz')
289
self.assertCompareEqual(k1, k2)
290
k3 = self.module.StaticTuple('foo ' + 'bar', 'bar ' + 'baz')
291
k4 = self.module.StaticTuple('f' + 'oo bar', 'b' + 'ar baz')
292
k5 = self.module.StaticTuple(k1, k2)
293
k6 = self.module.StaticTuple(k3, k4)
294
self.assertCompareEqual(k5, k6)
296
def check_strict_compare(self, k1, k2, mismatched_types):
297
"""True if on Python 3 and stricter comparison semantics are used."""
298
if PY3 and mismatched_types:
299
for op in ("ge", "gt", "le", "lt"):
300
self.assertRaises(TypeError, getattr(operator, op), k1, k2)
304
def assertCompareDifferent(self, k_small, k_big, mismatched_types=False):
305
self.assertFalse(k_small == k_big)
306
self.assertTrue(k_small != k_big)
307
if not self.check_strict_compare(k_small, k_big, mismatched_types):
308
self.assertFalse(k_small >= k_big)
309
self.assertFalse(k_small > k_big)
310
self.assertTrue(k_small <= k_big)
311
self.assertTrue(k_small < k_big)
313
def assertCompareNoRelation(self, k1, k2, mismatched_types=False):
314
"""Run the comparison operators, make sure they do something.
316
However, we don't actually care what comes first or second. This is
317
stuff like cross-class comparisons. We don't want to segfault/raise an
318
exception, but we don't care about the sort order.
320
self.assertFalse(k1 == k2)
321
self.assertTrue(k1 != k2)
322
if not self.check_strict_compare(k1, k2, mismatched_types):
323
# Do the comparison, but we don't care about the result
329
def test_compare_vs_none(self):
330
k1 = self.module.StaticTuple('baz', 'bing')
331
self.assertCompareDifferent(None, k1, mismatched_types=True)
333
def test_compare_cross_class(self):
334
k1 = self.module.StaticTuple('baz', 'bing')
335
self.assertCompareNoRelation(10, k1, mismatched_types=True)
336
self.assertCompareNoRelation('baz', k1, mismatched_types=True)
338
def test_compare_all_different_same_width(self):
339
k1 = self.module.StaticTuple('baz', 'bing')
340
k2 = self.module.StaticTuple('foo', 'bar')
341
self.assertCompareDifferent(k1, k2)
342
k3 = self.module.StaticTuple(k1, k2)
343
k4 = self.module.StaticTuple(k2, k1)
344
self.assertCompareDifferent(k3, k4)
345
k5 = self.module.StaticTuple(1)
346
k6 = self.module.StaticTuple(2)
347
self.assertCompareDifferent(k5, k6)
348
k7 = self.module.StaticTuple(1.2)
349
k8 = self.module.StaticTuple(2.4)
350
self.assertCompareDifferent(k7, k8)
351
k9 = self.module.StaticTuple(u's\xb5')
352
k10 = self.module.StaticTuple(u's\xe5')
353
self.assertCompareDifferent(k9, k10)
355
def test_compare_some_different(self):
356
k1 = self.module.StaticTuple('foo', 'bar')
357
k2 = self.module.StaticTuple('foo', 'zzz')
358
self.assertCompareDifferent(k1, k2)
359
k3 = self.module.StaticTuple(k1, k1)
360
k4 = self.module.StaticTuple(k1, k2)
361
self.assertCompareDifferent(k3, k4)
362
k5 = self.module.StaticTuple('foo', None)
363
self.assertCompareDifferent(k5, k1, mismatched_types=True)
364
self.assertCompareDifferent(k5, k2, mismatched_types=True)
366
def test_compare_diff_width(self):
367
k1 = self.module.StaticTuple('foo')
368
k2 = self.module.StaticTuple('foo', 'bar')
369
self.assertCompareDifferent(k1, k2)
370
k3 = self.module.StaticTuple(k1)
371
k4 = self.module.StaticTuple(k1, k2)
372
self.assertCompareDifferent(k3, k4)
374
def test_compare_different_types(self):
375
k1 = self.module.StaticTuple('foo', 'bar')
376
k2 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
378
self.assertCompareNoRelation(k1, k2, mismatched_types=True)
379
k3 = self.module.StaticTuple('foo')
380
self.assertCompareDifferent(k3, k1)
381
k4 = self.module.StaticTuple(None)
382
self.assertCompareDifferent(k4, k1, mismatched_types=True)
383
k5 = self.module.StaticTuple(1)
384
self.assertCompareNoRelation(k1, k5, mismatched_types=True)
386
def test_compare_to_tuples(self):
387
k1 = self.module.StaticTuple('foo')
388
self.assertCompareEqual(k1, ('foo',))
389
self.assertCompareEqual(('foo',), k1)
390
self.assertCompareDifferent(k1, ('foo', 'bar'))
391
self.assertCompareDifferent(k1, ('foo', 10))
393
k2 = self.module.StaticTuple('foo', 'bar')
394
self.assertCompareEqual(k2, ('foo', 'bar'))
395
self.assertCompareEqual(('foo', 'bar'), k2)
396
self.assertCompareDifferent(k2, ('foo', 'zzz'))
397
self.assertCompareDifferent(('foo',), k2)
398
self.assertCompareDifferent(('foo', 'aaa'), k2)
399
self.assertCompareDifferent(('baz', 'bing'), k2)
400
self.assertCompareDifferent(('foo', 10), k2, mismatched_types=True)
402
k3 = self.module.StaticTuple(k1, k2)
403
self.assertCompareEqual(k3, (('foo',), ('foo', 'bar')))
404
self.assertCompareEqual((('foo',), ('foo', 'bar')), k3)
405
self.assertCompareEqual(k3, (k1, ('foo', 'bar')))
406
self.assertCompareEqual((k1, ('foo', 'bar')), k3)
408
def test_compare_mixed_depths(self):
409
stuple = self.module.StaticTuple
410
k1 = stuple(stuple('a',), stuple('b',))
411
k2 = stuple(stuple(stuple('c',), stuple('d',)),
413
# This requires comparing a StaticTuple to a 'string', and then
414
# interpreting that value in the next higher StaticTuple. This used to
415
# generate a PyErr_BadIternalCall. We now fall back to *something*.
416
self.assertCompareNoRelation(k1, k2, mismatched_types=True)
419
k = self.module.StaticTuple('foo')
420
self.assertEqual(hash(k), hash(('foo',)))
421
k = self.module.StaticTuple('foo', 'bar', 'baz', 'bing')
422
as_tuple = ('foo', 'bar', 'baz', 'bing')
423
self.assertEqual(hash(k), hash(as_tuple))
425
# Because k == , it replaces the slot, rather than having both
426
# present in the dict.
427
self.assertEqual('foo', x[as_tuple])
429
self.assertEqual({as_tuple: 'bar'}, x)
431
k2 = self.module.StaticTuple(k)
432
as_tuple2 = (('foo', 'bar', 'baz', 'bing'),)
433
self.assertEqual(hash(k2), hash(as_tuple2))
435
k3 = self.module.StaticTuple('foo', 1, None, u'\xb5', 1.2, 2**65, True,
437
as_tuple3 = ('foo', 1, None, u'\xb5', 1.2, 2**65, True, k)
438
self.assertEqual(hash(as_tuple3), hash(k3))
440
def test_slice(self):
441
k = self.module.StaticTuple('foo', 'bar', 'baz', 'bing')
442
self.assertEqual(('foo', 'bar'), k[:2])
443
self.assertEqual(('baz',), k[2:-1])
444
self.assertEqual(('foo', 'baz',), k[::2])
445
self.assertRaises(TypeError, k.__getitem__, 'not_slice')
447
def test_referents(self):
448
# We implement tp_traverse so that things like 'meliae' can measure the
449
# amount of referenced memory. Unfortunately gc.get_referents() first
450
# checks the IS_GC flag before it traverses anything. We could write a
451
# helper func, but that won't work for the generic implementation...
452
self.requireFeature(features.meliae)
453
from meliae import scanner
454
strs = ['foo', 'bar', 'baz', 'bing']
455
k = self.module.StaticTuple(*strs)
456
if self.module is _static_tuple_py:
457
refs = strs + [self.module.StaticTuple]
460
self.assertEqual(sorted(refs), sorted(scanner.get_referents(k)))
462
def test_nested_referents(self):
463
self.requireFeature(features.meliae)
464
from meliae import scanner
465
strs = ['foo', 'bar', 'baz', 'bing']
466
k1 = self.module.StaticTuple(*strs[:2])
467
k2 = self.module.StaticTuple(*strs[2:])
468
k3 = self.module.StaticTuple(k1, k2)
470
if self.module is _static_tuple_py:
471
refs.append(self.module.StaticTuple)
472
self.assertEqual(sorted(refs),
473
sorted(scanner.get_referents(k3)))
475
def test_empty_is_singleton(self):
476
key = self.module.StaticTuple()
477
self.assertIs(key, self.module._empty_tuple)
479
def test_intern(self):
480
unique_str1 = 'unique str ' + osutils.rand_chars(20)
481
unique_str2 = 'unique str ' + osutils.rand_chars(20)
482
key = self.module.StaticTuple(unique_str1, unique_str2)
483
self.assertFalse(key in self.module._interned_tuples)
484
key2 = self.module.StaticTuple(unique_str1, unique_str2)
485
self.assertEqual(key, key2)
486
self.assertIsNot(key, key2)
488
self.assertIs(key, key3)
489
self.assertTrue(key in self.module._interned_tuples)
490
self.assertEqual(key, self.module._interned_tuples[key])
492
self.assertIs(key, key2)
494
def test__c_intern_handles_refcount(self):
495
if self.module is _static_tuple_py:
496
return # Not applicable
497
unique_str1 = 'unique str ' + osutils.rand_chars(20)
498
unique_str2 = 'unique str ' + osutils.rand_chars(20)
499
key = self.module.StaticTuple(unique_str1, unique_str2)
500
self.assertRefcount(1, key)
501
self.assertFalse(key in self.module._interned_tuples)
502
self.assertFalse(key._is_interned())
503
key2 = self.module.StaticTuple(unique_str1, unique_str2)
504
self.assertRefcount(1, key)
505
self.assertRefcount(1, key2)
506
self.assertEqual(key, key2)
507
self.assertIsNot(key, key2)
510
self.assertIs(key, key3)
511
self.assertTrue(key in self.module._interned_tuples)
512
self.assertEqual(key, self.module._interned_tuples[key])
513
# key and key3, but we 'hide' the one in _interned_tuples
514
self.assertRefcount(2, key)
516
self.assertRefcount(1, key)
517
self.assertTrue(key._is_interned())
518
self.assertRefcount(1, key2)
520
# key3 now points to key as well, and *not* to key2
521
self.assertRefcount(2, key)
522
self.assertRefcount(1, key2)
523
self.assertIs(key, key3)
524
self.assertIsNot(key3, key2)
527
self.assertRefcount(1, key)
529
def test__c_keys_are_not_immortal(self):
530
if self.module is _static_tuple_py:
531
return # Not applicable
532
unique_str1 = 'unique str ' + osutils.rand_chars(20)
533
unique_str2 = 'unique str ' + osutils.rand_chars(20)
534
key = self.module.StaticTuple(unique_str1, unique_str2)
535
self.assertFalse(key in self.module._interned_tuples)
536
self.assertRefcount(1, key)
538
self.assertRefcount(1, key)
539
self.assertTrue(key in self.module._interned_tuples)
540
self.assertTrue(key._is_interned())
542
# Create a new entry, which would point to the same location
543
key = self.module.StaticTuple(unique_str1, unique_str2)
544
self.assertRefcount(1, key)
545
# This old entry in _interned_tuples should be gone
546
self.assertFalse(key in self.module._interned_tuples)
547
self.assertFalse(key._is_interned())
549
def test__c_has_C_API(self):
550
if self.module is _static_tuple_py:
552
self.assertIsNot(None, self.module._C_API)
554
def test_from_sequence_tuple(self):
555
st = self.module.StaticTuple.from_sequence(('foo', 'bar'))
556
self.assertIsInstance(st, self.module.StaticTuple)
557
self.assertEqual(('foo', 'bar'), st)
559
def test_from_sequence_str(self):
560
st = self.module.StaticTuple.from_sequence('foo')
561
self.assertIsInstance(st, self.module.StaticTuple)
562
self.assertEqual(('f', 'o', 'o'), st)
564
def test_from_sequence_list(self):
565
st = self.module.StaticTuple.from_sequence(['foo', 'bar'])
566
self.assertIsInstance(st, self.module.StaticTuple)
567
self.assertEqual(('foo', 'bar'), st)
569
def test_from_sequence_static_tuple(self):
570
st = self.module.StaticTuple('foo', 'bar')
571
st2 = self.module.StaticTuple.from_sequence(st)
572
# If the source is a StaticTuple already, we return the exact object
573
self.assertIs(st, st2)
575
def test_from_sequence_not_sequence(self):
576
self.assertRaises(TypeError,
577
self.module.StaticTuple.from_sequence, object())
578
self.assertRaises(TypeError,
579
self.module.StaticTuple.from_sequence, 10)
581
def test_from_sequence_incorrect_args(self):
582
self.assertRaises(TypeError,
583
self.module.StaticTuple.from_sequence, object(), 'a')
584
self.assertRaises(TypeError,
585
self.module.StaticTuple.from_sequence, foo='a')
587
def test_from_sequence_iterable(self):
588
st = self.module.StaticTuple.from_sequence(iter(['foo', 'bar']))
589
self.assertIsInstance(st, self.module.StaticTuple)
590
self.assertEqual(('foo', 'bar'), st)
592
def test_from_sequence_generator(self):
593
def generate_tuple():
596
st = self.module.StaticTuple.from_sequence(generate_tuple())
597
self.assertIsInstance(st, self.module.StaticTuple)
598
self.assertEqual(('foo', 'bar'), st)
600
def test_pickle(self):
601
st = self.module.StaticTuple('foo', 'bar')
602
pickled = pickle.dumps(st)
603
unpickled = pickle.loads(pickled)
604
self.assertEqual(unpickled, st)
606
def test_pickle_empty(self):
607
st = self.module.StaticTuple()
608
pickled = pickle.dumps(st)
609
unpickled = pickle.loads(pickled)
610
self.assertIs(st, unpickled)
612
def test_pickle_nested(self):
613
st = self.module.StaticTuple('foo', self.module.StaticTuple('bar'))
614
pickled = pickle.dumps(st)
615
unpickled = pickle.loads(pickled)
616
self.assertEqual(unpickled, st)
618
def test_static_tuple_thunk(self):
619
# Make sure the right implementation is available from
620
# breezy.static_tuple.StaticTuple.
621
if self.module is _static_tuple_py:
622
if compiled_static_tuple_feature.available():
623
# We will be using the C version
625
self.assertIs(static_tuple.StaticTuple,
626
self.module.StaticTuple)
629
class TestEnsureStaticTuple(tests.TestCase):
631
def test_is_static_tuple(self):
632
st = static_tuple.StaticTuple('foo')
633
st2 = static_tuple.expect_static_tuple(st)
634
self.assertIs(st, st2)
636
def test_is_tuple(self):
638
st = static_tuple.expect_static_tuple(t)
639
self.assertIsInstance(st, static_tuple.StaticTuple)
640
self.assertEqual(t, st)
642
def test_flagged_is_static_tuple(self):
643
debug.debug_flags.add('static_tuple')
644
st = static_tuple.StaticTuple('foo')
645
st2 = static_tuple.expect_static_tuple(st)
646
self.assertIs(st, st2)
648
def test_flagged_is_tuple(self):
649
debug.debug_flags.add('static_tuple')
651
self.assertRaises(TypeError, static_tuple.expect_static_tuple, t)
added
removed
breezy/tests/test__static_tuple.py
