blob: d1fd60eec53f1dda182130dae9276bdcff1a284a [file] [log] [blame]
Raymond Hettingerd1ef8542008-01-11 00:23:13 +00001import unittest, doctest
Raymond Hettingerc37e5e02007-03-01 06:16:43 +00002from test import test_support
Raymond Hettinger01a09572007-10-23 20:37:41 +00003from collections import namedtuple
Raymond Hettingere98839a2008-06-09 01:28:30 +00004import pickle, cPickle, copy
Raymond Hettinger4f1e1632009-05-27 02:17:26 +00005import keyword
6import re
Guido van Rossum64c06e32007-11-22 00:55:51 +00007from collections import Hashable, Iterable, Iterator
8from collections import Sized, Container, Callable
9from collections import Set, MutableSet
10from collections import Mapping, MutableMapping
11from collections import Sequence, MutableSequence
12
Raymond Hettingere98839a2008-06-09 01:28:30 +000013TestNT = namedtuple('TestNT', 'x y z') # type used for pickle tests
Raymond Hettingerc37e5e02007-03-01 06:16:43 +000014
15class TestNamedTuple(unittest.TestCase):
16
17 def test_factory(self):
Raymond Hettinger01a09572007-10-23 20:37:41 +000018 Point = namedtuple('Point', 'x y')
Raymond Hettingerc37e5e02007-03-01 06:16:43 +000019 self.assertEqual(Point.__name__, 'Point')
20 self.assertEqual(Point.__doc__, 'Point(x, y)')
21 self.assertEqual(Point.__slots__, ())
22 self.assertEqual(Point.__module__, __name__)
23 self.assertEqual(Point.__getitem__, tuple.__getitem__)
Raymond Hettingere0734e72008-01-04 03:22:53 +000024 self.assertEqual(Point._fields, ('x', 'y'))
Raymond Hettingerabfd8df2007-10-16 21:28:32 +000025
Raymond Hettinger01a09572007-10-23 20:37:41 +000026 self.assertRaises(ValueError, namedtuple, 'abc%', 'efg ghi') # type has non-alpha char
27 self.assertRaises(ValueError, namedtuple, 'class', 'efg ghi') # type has keyword
28 self.assertRaises(ValueError, namedtuple, '9abc', 'efg ghi') # type starts with digit
Raymond Hettingerabfd8df2007-10-16 21:28:32 +000029
Raymond Hettinger01a09572007-10-23 20:37:41 +000030 self.assertRaises(ValueError, namedtuple, 'abc', 'efg g%hi') # field with non-alpha char
31 self.assertRaises(ValueError, namedtuple, 'abc', 'abc class') # field has keyword
32 self.assertRaises(ValueError, namedtuple, 'abc', '8efg 9ghi') # field starts with digit
Raymond Hettinger42da8742007-12-14 02:49:47 +000033 self.assertRaises(ValueError, namedtuple, 'abc', '_efg ghi') # field with leading underscore
Raymond Hettinger01a09572007-10-23 20:37:41 +000034 self.assertRaises(ValueError, namedtuple, 'abc', 'efg efg ghi') # duplicate field
Raymond Hettingerabfd8df2007-10-16 21:28:32 +000035
Raymond Hettinger01a09572007-10-23 20:37:41 +000036 namedtuple('Point0', 'x1 y2') # Verify that numbers are allowed in names
Raymond Hettinger42da8742007-12-14 02:49:47 +000037 namedtuple('_', 'a b c') # Test leading underscores in a typename
Raymond Hettingerc37e5e02007-03-01 06:16:43 +000038
Raymond Hettinger6ee7bc02008-09-25 23:31:52 +000039 nt = namedtuple('nt', u'the quick brown fox') # check unicode input
40 self.assert_("u'" not in repr(nt._fields))
41 nt = namedtuple('nt', (u'the', u'quick')) # check unicode input
42 self.assert_("u'" not in repr(nt._fields))
43
Raymond Hettinger02740f72008-01-05 01:35:43 +000044 self.assertRaises(TypeError, Point._make, [11]) # catch too few args
45 self.assertRaises(TypeError, Point._make, [11, 22, 33]) # catch too many args
46
Raymond Hettingerc37e5e02007-03-01 06:16:43 +000047 def test_instance(self):
Raymond Hettinger01a09572007-10-23 20:37:41 +000048 Point = namedtuple('Point', 'x y')
Raymond Hettingerc37e5e02007-03-01 06:16:43 +000049 p = Point(11, 22)
50 self.assertEqual(p, Point(x=11, y=22))
51 self.assertEqual(p, Point(11, y=22))
52 self.assertEqual(p, Point(y=22, x=11))
53 self.assertEqual(p, Point(*(11, 22)))
54 self.assertEqual(p, Point(**dict(x=11, y=22)))
55 self.assertRaises(TypeError, Point, 1) # too few args
56 self.assertRaises(TypeError, Point, 1, 2, 3) # too many args
57 self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)', locals()) # wrong keyword argument
58 self.assertRaises(TypeError, eval, 'Point(x=1)', locals()) # missing keyword argument
59 self.assertEqual(repr(p), 'Point(x=11, y=22)')
60 self.assert_('__dict__' not in dir(p)) # verify instance has no dict
61 self.assert_('__weakref__' not in dir(p))
Raymond Hettinger02740f72008-01-05 01:35:43 +000062 self.assertEqual(p, Point._make([11, 22])) # test _make classmethod
Raymond Hettinger42da8742007-12-14 02:49:47 +000063 self.assertEqual(p._fields, ('x', 'y')) # test _fields attribute
64 self.assertEqual(p._replace(x=1), (1, 22)) # test _replace method
65 self.assertEqual(p._asdict(), dict(x=11, y=22)) # test _asdict method
Raymond Hettingerd36a60e2007-09-17 00:55:00 +000066
Raymond Hettinger1b50fd72008-01-05 02:17:24 +000067 try:
68 p._replace(x=1, error=2)
69 except ValueError:
70 pass
71 else:
72 self._fail('Did not detect an incorrect fieldname')
73
Raymond Hettingerd36a60e2007-09-17 00:55:00 +000074 # verify that field string can have commas
Raymond Hettinger01a09572007-10-23 20:37:41 +000075 Point = namedtuple('Point', 'x, y')
Raymond Hettingerd36a60e2007-09-17 00:55:00 +000076 p = Point(x=11, y=22)
77 self.assertEqual(repr(p), 'Point(x=11, y=22)')
Raymond Hettingerc37e5e02007-03-01 06:16:43 +000078
Raymond Hettinger2115bbc2007-10-08 09:14:28 +000079 # verify that fieldspec can be a non-string sequence
Raymond Hettinger01a09572007-10-23 20:37:41 +000080 Point = namedtuple('Point', ('x', 'y'))
Raymond Hettinger2115bbc2007-10-08 09:14:28 +000081 p = Point(x=11, y=22)
82 self.assertEqual(repr(p), 'Point(x=11, y=22)')
83
Raymond Hettingerc37e5e02007-03-01 06:16:43 +000084 def test_tupleness(self):
Raymond Hettinger01a09572007-10-23 20:37:41 +000085 Point = namedtuple('Point', 'x y')
Raymond Hettingerc37e5e02007-03-01 06:16:43 +000086 p = Point(11, 22)
87
88 self.assert_(isinstance(p, tuple))
89 self.assertEqual(p, (11, 22)) # matches a real tuple
90 self.assertEqual(tuple(p), (11, 22)) # coercable to a real tuple
91 self.assertEqual(list(p), [11, 22]) # coercable to a list
92 self.assertEqual(max(p), 22) # iterable
93 self.assertEqual(max(*p), 22) # star-able
94 x, y = p
95 self.assertEqual(p, (x, y)) # unpacks like a tuple
96 self.assertEqual((p[0], p[1]), (11, 22)) # indexable like a tuple
97 self.assertRaises(IndexError, p.__getitem__, 3)
98
99 self.assertEqual(p.x, x)
100 self.assertEqual(p.y, y)
101 self.assertRaises(AttributeError, eval, 'p.z', locals())
102
Raymond Hettinger2b03d452007-09-18 03:33:19 +0000103 def test_odd_sizes(self):
Raymond Hettinger01a09572007-10-23 20:37:41 +0000104 Zero = namedtuple('Zero', '')
Raymond Hettinger2b03d452007-09-18 03:33:19 +0000105 self.assertEqual(Zero(), ())
Raymond Hettinger02740f72008-01-05 01:35:43 +0000106 self.assertEqual(Zero._make([]), ())
Raymond Hettinger88880b22007-12-18 00:13:45 +0000107 self.assertEqual(repr(Zero()), 'Zero()')
108 self.assertEqual(Zero()._asdict(), {})
109 self.assertEqual(Zero()._fields, ())
110
Raymond Hettinger01a09572007-10-23 20:37:41 +0000111 Dot = namedtuple('Dot', 'd')
Raymond Hettinger2b03d452007-09-18 03:33:19 +0000112 self.assertEqual(Dot(1), (1,))
Raymond Hettinger02740f72008-01-05 01:35:43 +0000113 self.assertEqual(Dot._make([1]), (1,))
Raymond Hettinger88880b22007-12-18 00:13:45 +0000114 self.assertEqual(Dot(1).d, 1)
115 self.assertEqual(repr(Dot(1)), 'Dot(d=1)')
116 self.assertEqual(Dot(1)._asdict(), {'d':1})
117 self.assertEqual(Dot(1)._replace(d=999), (999,))
118 self.assertEqual(Dot(1)._fields, ('d',))
Raymond Hettinger2b03d452007-09-18 03:33:19 +0000119
Raymond Hettingere98839a2008-06-09 01:28:30 +0000120 n = 5000
Raymond Hettinger88880b22007-12-18 00:13:45 +0000121 import string, random
Georg Brandl0bb02992008-05-18 10:39:26 +0000122 names = list(set(''.join([random.choice(string.ascii_letters)
123 for j in range(10)]) for i in range(n)))
124 n = len(names)
Raymond Hettinger88880b22007-12-18 00:13:45 +0000125 Big = namedtuple('Big', names)
126 b = Big(*range(n))
127 self.assertEqual(b, tuple(range(n)))
Raymond Hettinger02740f72008-01-05 01:35:43 +0000128 self.assertEqual(Big._make(range(n)), tuple(range(n)))
Raymond Hettinger88880b22007-12-18 00:13:45 +0000129 for pos, name in enumerate(names):
130 self.assertEqual(getattr(b, name), pos)
131 repr(b) # make sure repr() doesn't blow-up
132 d = b._asdict()
133 d_expected = dict(zip(names, range(n)))
134 self.assertEqual(d, d_expected)
135 b2 = b._replace(**dict([(names[1], 999),(names[-5], 42)]))
136 b2_expected = range(n)
137 b2_expected[1] = 999
138 b2_expected[-5] = 42
139 self.assertEqual(b2, tuple(b2_expected))
140 self.assertEqual(b._fields, tuple(names))
Guido van Rossum64c06e32007-11-22 00:55:51 +0000141
Raymond Hettingere98839a2008-06-09 01:28:30 +0000142 def test_pickle(self):
143 p = TestNT(x=10, y=20, z=30)
144 for module in pickle, cPickle:
145 loads = getattr(module, 'loads')
146 dumps = getattr(module, 'dumps')
147 for protocol in -1, 0, 1, 2:
148 q = loads(dumps(p, protocol))
149 self.assertEqual(p, q)
150 self.assertEqual(p._fields, q._fields)
151
152 def test_copy(self):
153 p = TestNT(x=10, y=20, z=30)
154 for copier in copy.copy, copy.deepcopy:
155 q = copier(p)
156 self.assertEqual(p, q)
157 self.assertEqual(p._fields, q._fields)
158
Raymond Hettinger4f1e1632009-05-27 02:17:26 +0000159 def test_name_conflicts(self):
160 # Some names like "self", "cls", "tuple", "itemgetter", and "property"
161 # failed when used as field names. Test to make sure these now work.
162 T = namedtuple('T', 'itemgetter property self cls tuple')
163 t = T(1, 2, 3, 4, 5)
164 self.assertEqual(t, (1,2,3,4,5))
165 newt = t._replace(itemgetter=10, property=20, self=30, cls=40, tuple=50)
166 self.assertEqual(newt, (10,20,30,40,50))
167
168 # Broader test of all interesting names in a template
169 with test_support.captured_stdout() as template:
170 T = namedtuple('T', 'x', verbose=True)
171 words = set(re.findall('[A-Za-z]+', template.getvalue()))
172 words -= set(keyword.kwlist)
173 T = namedtuple('T', words)
174 # test __new__
175 values = tuple(range(len(words)))
176 t = T(*values)
177 self.assertEqual(t, values)
178 t = T(**dict(zip(T._fields, values)))
179 self.assertEqual(t, values)
180 # test _make
181 t = T._make(values)
182 self.assertEqual(t, values)
183 # exercise __repr__
184 repr(t)
185 # test _asdict
186 self.assertEqual(t._asdict(), dict(zip(T._fields, values)))
187 # test _replace
188 t = T._make(values)
189 newvalues = tuple(v*10 for v in values)
190 newt = t._replace(**dict(zip(T._fields, newvalues)))
191 self.assertEqual(newt, newvalues)
192 # test _fields
193 self.assertEqual(T._fields, tuple(words))
194 # test __getnewargs__
195 self.assertEqual(t.__getnewargs__(), values)
196
Raymond Hettingerc9794482009-01-28 23:14:58 +0000197class ABCTestCase(unittest.TestCase):
198
199 def validate_abstract_methods(self, abc, *names):
200 methodstubs = dict.fromkeys(names, lambda s, *args: 0)
201
202 # everything should work will all required methods are present
203 C = type('C', (abc,), methodstubs)
204 C()
205
206 # instantiation should fail if a required method is missing
207 for name in names:
208 stubs = methodstubs.copy()
209 del stubs[name]
210 C = type('C', (abc,), stubs)
211 self.assertRaises(TypeError, C, name)
212
Florent Xiclunad474f3a2010-03-23 12:37:29 +0000213 def validate_isinstance(self, abc, name):
214 stub = lambda s, *args: 0
215
216 # new-style class
217 C = type('C', (object,), {name: stub})
218 self.assertTrue(isinstance(C(), abc))
219 self.assertTrue(issubclass(C, abc))
220 # old-style class
221 class C: pass
222 setattr(C, name, stub)
223 self.assertTrue(isinstance(C(), abc))
224 self.assertTrue(issubclass(C, abc))
225
226 # new-style class
227 C = type('C', (object,), {'__hash__': None})
228 self.assertFalse(isinstance(C(), abc))
229 self.assertFalse(issubclass(C, abc))
230 # old-style class
231 class C: pass
232 self.assertFalse(isinstance(C(), abc))
233 self.assertFalse(issubclass(C, abc))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000234
235class TestOneTrickPonyABCs(ABCTestCase):
Guido van Rossum64c06e32007-11-22 00:55:51 +0000236
237 def test_Hashable(self):
238 # Check some non-hashables
239 non_samples = [list(), set(), dict()]
240 for x in non_samples:
241 self.failIf(isinstance(x, Hashable), repr(x))
242 self.failIf(issubclass(type(x), Hashable), repr(type(x)))
243 # Check some hashables
244 samples = [None,
245 int(), float(), complex(),
246 str(),
247 tuple(), frozenset(),
248 int, list, object, type,
249 ]
250 for x in samples:
251 self.failUnless(isinstance(x, Hashable), repr(x))
252 self.failUnless(issubclass(type(x), Hashable), repr(type(x)))
253 self.assertRaises(TypeError, Hashable)
254 # Check direct subclassing
255 class H(Hashable):
256 def __hash__(self):
257 return super(H, self).__hash__()
Nick Coghlan48361f52008-08-11 15:45:58 +0000258 __eq__ = Hashable.__eq__ # Silence Py3k warning
Guido van Rossum64c06e32007-11-22 00:55:51 +0000259 self.assertEqual(hash(H()), 0)
260 self.failIf(issubclass(int, H))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000261 self.validate_abstract_methods(Hashable, '__hash__')
Florent Xiclunad474f3a2010-03-23 12:37:29 +0000262 self.validate_isinstance(Hashable, '__hash__')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000263
264 def test_Iterable(self):
265 # Check some non-iterables
266 non_samples = [None, 42, 3.14, 1j]
267 for x in non_samples:
268 self.failIf(isinstance(x, Iterable), repr(x))
269 self.failIf(issubclass(type(x), Iterable), repr(type(x)))
270 # Check some iterables
271 samples = [str(),
272 tuple(), list(), set(), frozenset(), dict(),
273 dict().keys(), dict().items(), dict().values(),
274 (lambda: (yield))(),
275 (x for x in []),
276 ]
277 for x in samples:
278 self.failUnless(isinstance(x, Iterable), repr(x))
279 self.failUnless(issubclass(type(x), Iterable), repr(type(x)))
280 # Check direct subclassing
281 class I(Iterable):
282 def __iter__(self):
283 return super(I, self).__iter__()
284 self.assertEqual(list(I()), [])
285 self.failIf(issubclass(str, I))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000286 self.validate_abstract_methods(Iterable, '__iter__')
Florent Xiclunad474f3a2010-03-23 12:37:29 +0000287 self.validate_isinstance(Iterable, '__iter__')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000288
289 def test_Iterator(self):
290 non_samples = [None, 42, 3.14, 1j, "".encode('ascii'), "", (), [],
291 {}, set()]
292 for x in non_samples:
293 self.failIf(isinstance(x, Iterator), repr(x))
294 self.failIf(issubclass(type(x), Iterator), repr(type(x)))
295 samples = [iter(str()),
296 iter(tuple()), iter(list()), iter(dict()),
297 iter(set()), iter(frozenset()),
298 iter(dict().keys()), iter(dict().items()),
299 iter(dict().values()),
300 (lambda: (yield))(),
301 (x for x in []),
302 ]
303 for x in samples:
304 self.failUnless(isinstance(x, Iterator), repr(x))
305 self.failUnless(issubclass(type(x), Iterator), repr(type(x)))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000306 self.validate_abstract_methods(Iterator, 'next')
Florent Xiclunad474f3a2010-03-23 12:37:29 +0000307 self.validate_isinstance(Iterator, 'next')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000308
309 def test_Sized(self):
310 non_samples = [None, 42, 3.14, 1j,
311 (lambda: (yield))(),
312 (x for x in []),
313 ]
314 for x in non_samples:
315 self.failIf(isinstance(x, Sized), repr(x))
316 self.failIf(issubclass(type(x), Sized), repr(type(x)))
317 samples = [str(),
318 tuple(), list(), set(), frozenset(), dict(),
319 dict().keys(), dict().items(), dict().values(),
320 ]
321 for x in samples:
322 self.failUnless(isinstance(x, Sized), repr(x))
323 self.failUnless(issubclass(type(x), Sized), repr(type(x)))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000324 self.validate_abstract_methods(Sized, '__len__')
Florent Xiclunad474f3a2010-03-23 12:37:29 +0000325 self.validate_isinstance(Sized, '__len__')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000326
327 def test_Container(self):
328 non_samples = [None, 42, 3.14, 1j,
329 (lambda: (yield))(),
330 (x for x in []),
331 ]
332 for x in non_samples:
333 self.failIf(isinstance(x, Container), repr(x))
334 self.failIf(issubclass(type(x), Container), repr(type(x)))
335 samples = [str(),
336 tuple(), list(), set(), frozenset(), dict(),
337 dict().keys(), dict().items(),
338 ]
339 for x in samples:
340 self.failUnless(isinstance(x, Container), repr(x))
341 self.failUnless(issubclass(type(x), Container), repr(type(x)))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000342 self.validate_abstract_methods(Container, '__contains__')
Florent Xiclunad474f3a2010-03-23 12:37:29 +0000343 self.validate_isinstance(Container, '__contains__')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000344
345 def test_Callable(self):
346 non_samples = [None, 42, 3.14, 1j,
347 "", "".encode('ascii'), (), [], {}, set(),
348 (lambda: (yield))(),
349 (x for x in []),
350 ]
351 for x in non_samples:
352 self.failIf(isinstance(x, Callable), repr(x))
353 self.failIf(issubclass(type(x), Callable), repr(type(x)))
354 samples = [lambda: None,
355 type, int, object,
356 len,
357 list.append, [].append,
358 ]
359 for x in samples:
360 self.failUnless(isinstance(x, Callable), repr(x))
361 self.failUnless(issubclass(type(x), Callable), repr(type(x)))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000362 self.validate_abstract_methods(Callable, '__call__')
Florent Xiclunad474f3a2010-03-23 12:37:29 +0000363 self.validate_isinstance(Callable, '__call__')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000364
365 def test_direct_subclassing(self):
366 for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
367 class C(B):
368 pass
369 self.failUnless(issubclass(C, B))
370 self.failIf(issubclass(int, C))
371
372 def test_registration(self):
373 for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
374 class C:
375 __metaclass__ = type
376 __hash__ = None # Make sure it isn't hashable by default
377 self.failIf(issubclass(C, B), B.__name__)
378 B.register(C)
379 self.failUnless(issubclass(C, B))
380
Raymond Hettinger38f57a12009-04-01 18:55:57 +0000381class WithSet(MutableSet):
382
383 def __init__(self, it=()):
384 self.data = set(it)
385
386 def __len__(self):
387 return len(self.data)
388
389 def __iter__(self):
390 return iter(self.data)
391
392 def __contains__(self, item):
393 return item in self.data
394
395 def add(self, item):
396 self.data.add(item)
397
398 def discard(self, item):
399 self.data.discard(item)
Guido van Rossum64c06e32007-11-22 00:55:51 +0000400
Raymond Hettingerc9794482009-01-28 23:14:58 +0000401class TestCollectionABCs(ABCTestCase):
Guido van Rossum64c06e32007-11-22 00:55:51 +0000402
403 # XXX For now, we only test some virtual inheritance properties.
404 # We should also test the proper behavior of the collection ABCs
405 # as real base classes or mix-in classes.
406
407 def test_Set(self):
408 for sample in [set, frozenset]:
409 self.failUnless(isinstance(sample(), Set))
410 self.failUnless(issubclass(sample, Set))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000411 self.validate_abstract_methods(Set, '__contains__', '__iter__', '__len__')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000412
Raymond Hettinger4c52f522008-06-23 03:29:28 +0000413 def test_hash_Set(self):
414 class OneTwoThreeSet(Set):
415 def __init__(self):
416 self.contents = [1, 2, 3]
417 def __contains__(self, x):
418 return x in self.contents
419 def __len__(self):
420 return len(self.contents)
421 def __iter__(self):
422 return iter(self.contents)
423 def __hash__(self):
424 return self._hash()
425 a, b = OneTwoThreeSet(), OneTwoThreeSet()
426 self.failUnless(hash(a) == hash(b))
427
Guido van Rossum64c06e32007-11-22 00:55:51 +0000428 def test_MutableSet(self):
429 self.failUnless(isinstance(set(), MutableSet))
430 self.failUnless(issubclass(set, MutableSet))
431 self.failIf(isinstance(frozenset(), MutableSet))
432 self.failIf(issubclass(frozenset, MutableSet))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000433 self.validate_abstract_methods(MutableSet, '__contains__', '__iter__', '__len__',
434 'add', 'discard')
435
Raymond Hettinger38f57a12009-04-01 18:55:57 +0000436 def test_issue_5647(self):
437 # MutableSet.__iand__ mutated the set during iteration
438 s = WithSet('abcd')
439 s &= WithSet('cdef') # This used to fail
440 self.assertEqual(set(s), set('cd'))
441
Raymond Hettingerc9794482009-01-28 23:14:58 +0000442 def test_issue_4920(self):
443 # MutableSet.pop() method did not work
444 class MySet(collections.MutableSet):
445 __slots__=['__s']
446 def __init__(self,items=None):
447 if items is None:
448 items=[]
449 self.__s=set(items)
450 def __contains__(self,v):
451 return v in self.__s
452 def __iter__(self):
453 return iter(self.__s)
454 def __len__(self):
455 return len(self.__s)
456 def add(self,v):
457 result=v not in self.__s
458 self.__s.add(v)
459 return result
460 def discard(self,v):
461 result=v in self.__s
462 self.__s.discard(v)
463 return result
464 def __repr__(self):
465 return "MySet(%s)" % repr(list(self))
466 s = MySet([5,43,2,1])
467 self.assertEqual(s.pop(), 1)
Guido van Rossum64c06e32007-11-22 00:55:51 +0000468
469 def test_Mapping(self):
470 for sample in [dict]:
471 self.failUnless(isinstance(sample(), Mapping))
472 self.failUnless(issubclass(sample, Mapping))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000473 self.validate_abstract_methods(Mapping, '__contains__', '__iter__', '__len__',
474 '__getitem__')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000475
476 def test_MutableMapping(self):
477 for sample in [dict]:
478 self.failUnless(isinstance(sample(), MutableMapping))
479 self.failUnless(issubclass(sample, MutableMapping))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000480 self.validate_abstract_methods(MutableMapping, '__contains__', '__iter__', '__len__',
481 '__getitem__', '__setitem__', '__delitem__')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000482
483 def test_Sequence(self):
484 for sample in [tuple, list, str]:
485 self.failUnless(isinstance(sample(), Sequence))
486 self.failUnless(issubclass(sample, Sequence))
487 self.failUnless(issubclass(basestring, Sequence))
Raymond Hettinger9293eb92009-02-24 12:25:32 +0000488 self.failUnless(isinstance(range(10), Sequence))
489 self.failUnless(issubclass(xrange, Sequence))
490 self.failUnless(issubclass(str, Sequence))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000491 self.validate_abstract_methods(Sequence, '__contains__', '__iter__', '__len__',
492 '__getitem__')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000493
494 def test_MutableSequence(self):
495 for sample in [tuple, str]:
496 self.failIf(isinstance(sample(), MutableSequence))
497 self.failIf(issubclass(sample, MutableSequence))
498 for sample in [list]:
499 self.failUnless(isinstance(sample(), MutableSequence))
500 self.failUnless(issubclass(sample, MutableSequence))
501 self.failIf(issubclass(basestring, MutableSequence))
Raymond Hettingerc9794482009-01-28 23:14:58 +0000502 self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__',
503 '__len__', '__getitem__', '__setitem__', '__delitem__', 'insert')
Guido van Rossum64c06e32007-11-22 00:55:51 +0000504
Florent Xiclunad474f3a2010-03-23 12:37:29 +0000505import collections
Guido van Rossum64c06e32007-11-22 00:55:51 +0000506
Raymond Hettingerc37e5e02007-03-01 06:16:43 +0000507def test_main(verbose=None):
Amaury Forgeot d'Arccb0f2ad2008-04-02 00:55:04 +0000508 NamedTupleDocs = doctest.DocTestSuite(module=collections)
Raymond Hettingerd1ef8542008-01-11 00:23:13 +0000509 test_classes = [TestNamedTuple, NamedTupleDocs, TestOneTrickPonyABCs, TestCollectionABCs]
Raymond Hettingerc37e5e02007-03-01 06:16:43 +0000510 test_support.run_unittest(*test_classes)
Amaury Forgeot d'Arccb0f2ad2008-04-02 00:55:04 +0000511 test_support.run_doctest(collections, verbose)
Raymond Hettingerc37e5e02007-03-01 06:16:43 +0000512
513if __name__ == "__main__":
514 test_main(verbose=True)