Debian Codegraph @

Lib/test/test_collections.py

raw
1 """Unit tests for collections.py."""
2
3 import array
4 import collections
5 import copy
6 import doctest
7 import inspect
8 import operator
9 import pickle
10 from random import choice, randrange
11 from itertools import product, chain, combinations
12 import string
13 import sys
14 from test import support
15 import types
16 import unittest
17
18 from collections import namedtuple, Counter, OrderedDict, _count_elements
19 from collections import UserDict, UserString, UserList
20 from collections import ChainMap
21 from collections import deque
22 from collections.abc import Awaitable, Coroutine
23 from collections.abc import AsyncIterator, AsyncIterable, AsyncGenerator
24 from collections.abc import Hashable, Iterable, Iterator, Generator, Reversible
25 from collections.abc import Sized, Container, Callable, Collection
26 from collections.abc import Set, MutableSet
27 from collections.abc import Mapping, MutableMapping, KeysView, ItemsView, ValuesView
28 from collections.abc import Sequence, MutableSequence
29 from collections.abc import ByteString, Buffer
30
31
32 class TestUserObjects(unittest.TestCase):
33 def _superset_test(self, a, b):
34 self.assertGreaterEqual(
35 set(dir(a)),
36 set(dir(b)),
37 '{a} should have all the methods of {b}'.format(
38 a=a.__name__,
39 b=b.__name__,
40 ),
41 )
42
43 def _copy_test(self, obj):
44 # Test internal copy
45 obj_copy = obj.copy()
46 self.assertIsNot(obj.data, obj_copy.data)
47 self.assertEqual(obj.data, obj_copy.data)
48
49 # Test copy.copy
50 obj.test = [1234] # Make sure instance vars are also copied.
51 obj_copy = copy.copy(obj)
52 self.assertIsNot(obj.data, obj_copy.data)
53 self.assertEqual(obj.data, obj_copy.data)
54 self.assertIs(obj.test, obj_copy.test)
55
56 def test_str_protocol(self):
57 self._superset_test(UserString, str)
58
59 def test_list_protocol(self):
60 self._superset_test(UserList, list)
61
62 def test_dict_protocol(self):
63 self._superset_test(UserDict, dict)
64
65 def test_list_copy(self):
66 obj = UserList()
67 obj.append(123)
68 self._copy_test(obj)
69
70 def test_dict_copy(self):
71 obj = UserDict()
72 obj[123] = "abc"
73 self._copy_test(obj)
74
75 def test_dict_missing(self):
76 class A(UserDict):
77 def __missing__(self, key):
78 return 456
79 self.assertEqual(A()[123], 456)
80 # get() ignores __missing__ on dict
81 self.assertIs(A().get(123), None)
82
83
84 ################################################################################
85 ### ChainMap (helper class for configparser and the string module)
86 ################################################################################
87
88 class TestChainMap(unittest.TestCase):
89
90 def test_basics(self):
91 c = ChainMap()
92 c['a'] = 1
93 c['b'] = 2
94 d = c.new_child()
95 d['b'] = 20
96 d['c'] = 30
97 self.assertEqual(d.maps, [{'b':20, 'c':30}, {'a':1, 'b':2}]) # check internal state
98 self.assertEqual(d.items(), dict(a=1, b=20, c=30).items()) # check items/iter/getitem
99 self.assertEqual(len(d), 3) # check len
100 for key in 'abc': # check contains
101 self.assertIn(key, d)
102 for k, v in dict(a=1, b=20, c=30, z=100).items(): # check get
103 self.assertEqual(d.get(k, 100), v)
104
105 del d['b'] # unmask a value
106 self.assertEqual(d.maps, [{'c':30}, {'a':1, 'b':2}]) # check internal state
107 self.assertEqual(d.items(), dict(a=1, b=2, c=30).items()) # check items/iter/getitem
108 self.assertEqual(len(d), 3) # check len
109 for key in 'abc': # check contains
110 self.assertIn(key, d)
111 for k, v in dict(a=1, b=2, c=30, z=100).items(): # check get
112 self.assertEqual(d.get(k, 100), v)
113 self.assertIn(repr(d), [ # check repr
114 type(d).__name__ + "({'c': 30}, {'a': 1, 'b': 2})",
115 type(d).__name__ + "({'c': 30}, {'b': 2, 'a': 1})"
116 ])
117
118 for e in d.copy(), copy.copy(d): # check shallow copies
119 self.assertEqual(d, e)
120 self.assertEqual(d.maps, e.maps)
121 self.assertIsNot(d, e)
122 self.assertIsNot(d.maps[0], e.maps[0])
123 for m1, m2 in zip(d.maps[1:], e.maps[1:]):
124 self.assertIs(m1, m2)
125
126 # check deep copies
127 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
128 e = pickle.loads(pickle.dumps(d, proto))
129 self.assertEqual(d, e)
130 self.assertEqual(d.maps, e.maps)
131 self.assertIsNot(d, e)
132 for m1, m2 in zip(d.maps, e.maps):
133 self.assertIsNot(m1, m2, e)
134 for e in [copy.deepcopy(d),
135 eval(repr(d))
136 ]:
137 self.assertEqual(d, e)
138 self.assertEqual(d.maps, e.maps)
139 self.assertIsNot(d, e)
140 for m1, m2 in zip(d.maps, e.maps):
141 self.assertIsNot(m1, m2, e)
142
143 f = d.new_child()
144 f['b'] = 5
145 self.assertEqual(f.maps, [{'b': 5}, {'c':30}, {'a':1, 'b':2}])
146 self.assertEqual(f.parents.maps, [{'c':30}, {'a':1, 'b':2}]) # check parents
147 self.assertEqual(f['b'], 5) # find first in chain
148 self.assertEqual(f.parents['b'], 2) # look beyond maps[0]
149
150 def test_ordering(self):
151 # Combined order matches a series of dict updates from last to first.
152 # This test relies on the ordering of the underlying dicts.
153
154 baseline = {'music': 'bach', 'art': 'rembrandt'}
155 adjustments = {'art': 'van gogh', 'opera': 'carmen'}
156
157 cm = ChainMap(adjustments, baseline)
158
159 combined = baseline.copy()
160 combined.update(adjustments)
161
162 self.assertEqual(list(combined.items()), list(cm.items()))
163
164 def test_constructor(self):
165 self.assertEqual(ChainMap().maps, [{}]) # no-args --> one new dict
166 self.assertEqual(ChainMap({1:2}).maps, [{1:2}]) # 1 arg --> list
167
168 def test_bool(self):
169 self.assertFalse(ChainMap())
170 self.assertFalse(ChainMap({}, {}))
171 self.assertTrue(ChainMap({1:2}, {}))
172 self.assertTrue(ChainMap({}, {1:2}))
173
174 def test_missing(self):
175 class DefaultChainMap(ChainMap):
176 def __missing__(self, key):
177 return 999
178 d = DefaultChainMap(dict(a=1, b=2), dict(b=20, c=30))
179 for k, v in dict(a=1, b=2, c=30, d=999).items():
180 self.assertEqual(d[k], v) # check __getitem__ w/missing
181 for k, v in dict(a=1, b=2, c=30, d=77).items():
182 self.assertEqual(d.get(k, 77), v) # check get() w/ missing
183 for k, v in dict(a=True, b=True, c=True, d=False).items():
184 self.assertEqual(k in d, v) # check __contains__ w/missing
185 self.assertEqual(d.pop('a', 1001), 1, d)
186 self.assertEqual(d.pop('a', 1002), 1002) # check pop() w/missing
187 self.assertEqual(d.popitem(), ('b', 2)) # check popitem() w/missing
188 with self.assertRaises(KeyError):
189 d.popitem()
190
191 def test_order_preservation(self):
192 d = ChainMap(
193 OrderedDict(j=0, h=88888),
194 OrderedDict(),
195 OrderedDict(i=9999, d=4444, c=3333),
196 OrderedDict(f=666, b=222, g=777, c=333, h=888),
197 OrderedDict(),
198 OrderedDict(e=55, b=22),
199 OrderedDict(a=1, b=2, c=3, d=4, e=5),
200 OrderedDict(),
201 )
202 self.assertEqual(''.join(d), 'abcdefghij')
203 self.assertEqual(list(d.items()),
204 [('a', 1), ('b', 222), ('c', 3333), ('d', 4444),
205 ('e', 55), ('f', 666), ('g', 777), ('h', 88888),
206 ('i', 9999), ('j', 0)])
207
208 def test_iter_not_calling_getitem_on_maps(self):
209 class DictWithGetItem(UserDict):
210 def __init__(self, *args, **kwds):
211 self.called = False
212 UserDict.__init__(self, *args, **kwds)
213 def __getitem__(self, item):
214 self.called = True
215 UserDict.__getitem__(self, item)
216
217 d = DictWithGetItem(a=1)
218 c = ChainMap(d)
219 d.called = False
220
221 set(c) # iterate over chain map
222 self.assertFalse(d.called, '__getitem__ was called')
223
224 def test_dict_coercion(self):
225 d = ChainMap(dict(a=1, b=2), dict(b=20, c=30))
226 self.assertEqual(dict(d), dict(a=1, b=2, c=30))
227 self.assertEqual(dict(d.items()), dict(a=1, b=2, c=30))
228
229 def test_new_child(self):
230 'Tests for changes for issue #16613.'
231 c = ChainMap()
232 c['a'] = 1
233 c['b'] = 2
234 m = {'b':20, 'c': 30}
235 d = c.new_child(m)
236 self.assertEqual(d.maps, [{'b':20, 'c':30}, {'a':1, 'b':2}]) # check internal state
237 self.assertIs(m, d.maps[0])
238
239 # Use a different map than a dict
240 class lowerdict(dict):
241 def __getitem__(self, key):
242 if isinstance(key, str):
243 key = key.lower()
244 return dict.__getitem__(self, key)
245 def __contains__(self, key):
246 if isinstance(key, str):
247 key = key.lower()
248 return dict.__contains__(self, key)
249
250 c = ChainMap()
251 c['a'] = 1
252 c['b'] = 2
253 m = lowerdict(b=20, c=30)
254 d = c.new_child(m)
255 self.assertIs(m, d.maps[0])
256 for key in 'abc': # check contains
257 self.assertIn(key, d)
258 for k, v in dict(a=1, B=20, C=30, z=100).items(): # check get
259 self.assertEqual(d.get(k, 100), v)
260
261 c = ChainMap({'a': 1, 'b': 2})
262 d = c.new_child(b=20, c=30)
263 self.assertEqual(d.maps, [{'b': 20, 'c': 30}, {'a': 1, 'b': 2}])
264
265 def test_union_operators(self):
266 cm1 = ChainMap(dict(a=1, b=2), dict(c=3, d=4))
267 cm2 = ChainMap(dict(a=10, e=5), dict(b=20, d=4))
268 cm3 = cm1.copy()
269 d = dict(a=10, c=30)
270 pairs = [('c', 3), ('p',0)]
271
272 tmp = cm1 | cm2 # testing between chainmaps
273 self.assertEqual(tmp.maps, [cm1.maps[0] | dict(cm2), *cm1.maps[1:]])
274 cm1 |= cm2
275 self.assertEqual(tmp, cm1)
276
277 tmp = cm2 | d # testing between chainmap and mapping
278 self.assertEqual(tmp.maps, [cm2.maps[0] | d, *cm2.maps[1:]])
279 self.assertEqual((d | cm2).maps, [d | dict(cm2)])
280 cm2 |= d
281 self.assertEqual(tmp, cm2)
282
283 # testing behavior between chainmap and iterable key-value pairs
284 with self.assertRaises(TypeError):
285 cm3 | pairs
286 tmp = cm3.copy()
287 cm3 |= pairs
288 self.assertEqual(cm3.maps, [tmp.maps[0] | dict(pairs), *tmp.maps[1:]])
289
290 # testing proper return types for ChainMap and it's subclasses
291 class Subclass(ChainMap):
292 pass
293
294 class SubclassRor(ChainMap):
295 def __ror__(self, other):
296 return super().__ror__(other)
297
298 tmp = ChainMap() | ChainMap()
299 self.assertIs(type(tmp), ChainMap)
300 self.assertIs(type(tmp.maps[0]), dict)
301 tmp = ChainMap() | Subclass()
302 self.assertIs(type(tmp), ChainMap)
303 self.assertIs(type(tmp.maps[0]), dict)
304 tmp = Subclass() | ChainMap()
305 self.assertIs(type(tmp), Subclass)
306 self.assertIs(type(tmp.maps[0]), dict)
307 tmp = ChainMap() | SubclassRor()
308 self.assertIs(type(tmp), SubclassRor)
309 self.assertIs(type(tmp.maps[0]), dict)
310
311
312 ################################################################################
313 ### Named Tuples
314 ################################################################################
315
316 TestNT = namedtuple('TestNT', 'x y z') # type used for pickle tests
317
318 class TestNamedTuple(unittest.TestCase):
319
320 def test_factory(self):
321 Point = namedtuple('Point', 'x y')
322 self.assertEqual(Point.__name__, 'Point')
323 self.assertEqual(Point.__slots__, ())
324 self.assertEqual(Point.__module__, __name__)
325 self.assertEqual(Point.__getitem__, tuple.__getitem__)
326 self.assertEqual(Point._fields, ('x', 'y'))
327
328 self.assertRaises(ValueError, namedtuple, 'abc%', 'efg ghi') # type has non-alpha char
329 self.assertRaises(ValueError, namedtuple, 'class', 'efg ghi') # type has keyword
330 self.assertRaises(ValueError, namedtuple, '9abc', 'efg ghi') # type starts with digit
331
332 self.assertRaises(ValueError, namedtuple, 'abc', 'efg g%hi') # field with non-alpha char
333 self.assertRaises(ValueError, namedtuple, 'abc', 'abc class') # field has keyword
334 self.assertRaises(ValueError, namedtuple, 'abc', '8efg 9ghi') # field starts with digit
335 self.assertRaises(ValueError, namedtuple, 'abc', '_efg ghi') # field with leading underscore
336 self.assertRaises(ValueError, namedtuple, 'abc', 'efg efg ghi') # duplicate field
337
338 namedtuple('Point0', 'x1 y2') # Verify that numbers are allowed in names
339 namedtuple('_', 'a b c') # Test leading underscores in a typename
340
341 nt = namedtuple('nt', 'the quick brown fox') # check unicode input
342 self.assertNotIn("u'", repr(nt._fields))
343 nt = namedtuple('nt', ('the', 'quick')) # check unicode input
344 self.assertNotIn("u'", repr(nt._fields))
345
346 self.assertRaises(TypeError, Point._make, [11]) # catch too few args
347 self.assertRaises(TypeError, Point._make, [11, 22, 33]) # catch too many args
348
349 def test_defaults(self):
350 Point = namedtuple('Point', 'x y', defaults=(10, 20)) # 2 defaults
351 self.assertEqual(Point._field_defaults, {'x': 10, 'y': 20})
352 self.assertEqual(Point(1, 2), (1, 2))
353 self.assertEqual(Point(1), (1, 20))
354 self.assertEqual(Point(), (10, 20))
355
356 Point = namedtuple('Point', 'x y', defaults=(20,)) # 1 default
357 self.assertEqual(Point._field_defaults, {'y': 20})
358 self.assertEqual(Point(1, 2), (1, 2))
359 self.assertEqual(Point(1), (1, 20))
360
361 Point = namedtuple('Point', 'x y', defaults=()) # 0 defaults
362 self.assertEqual(Point._field_defaults, {})
363 self.assertEqual(Point(1, 2), (1, 2))
364 with self.assertRaises(TypeError):
365 Point(1)
366
367 with self.assertRaises(TypeError): # catch too few args
368 Point()
369 with self.assertRaises(TypeError): # catch too many args
370 Point(1, 2, 3)
371 with self.assertRaises(TypeError): # too many defaults
372 Point = namedtuple('Point', 'x y', defaults=(10, 20, 30))
373 with self.assertRaises(TypeError): # non-iterable defaults
374 Point = namedtuple('Point', 'x y', defaults=10)
375 with self.assertRaises(TypeError): # another non-iterable default
376 Point = namedtuple('Point', 'x y', defaults=False)
377
378 Point = namedtuple('Point', 'x y', defaults=None) # default is None
379 self.assertEqual(Point._field_defaults, {})
380 self.assertIsNone(Point.__new__.__defaults__, None)
381 self.assertEqual(Point(10, 20), (10, 20))
382 with self.assertRaises(TypeError): # catch too few args
383 Point(10)
384
385 Point = namedtuple('Point', 'x y', defaults=[10, 20]) # allow non-tuple iterable
386 self.assertEqual(Point._field_defaults, {'x': 10, 'y': 20})
387 self.assertEqual(Point.__new__.__defaults__, (10, 20))
388 self.assertEqual(Point(1, 2), (1, 2))
389 self.assertEqual(Point(1), (1, 20))
390 self.assertEqual(Point(), (10, 20))
391
392 Point = namedtuple('Point', 'x y', defaults=iter([10, 20])) # allow plain iterator
393 self.assertEqual(Point._field_defaults, {'x': 10, 'y': 20})
394 self.assertEqual(Point.__new__.__defaults__, (10, 20))
395 self.assertEqual(Point(1, 2), (1, 2))
396 self.assertEqual(Point(1), (1, 20))
397 self.assertEqual(Point(), (10, 20))
398
399 def test_readonly(self):
400 Point = namedtuple('Point', 'x y')
401 p = Point(11, 22)
402 with self.assertRaises(AttributeError):
403 p.x = 33
404 with self.assertRaises(AttributeError):
405 del p.x
406 with self.assertRaises(TypeError):
407 p[0] = 33
408 with self.assertRaises(TypeError):
409 del p[0]
410 self.assertEqual(p.x, 11)
411 self.assertEqual(p[0], 11)
412
413 @unittest.skipIf(sys.flags.optimize >= 2,
414 "Docstrings are omitted with -O2 and above")
415 def test_factory_doc_attr(self):
416 Point = namedtuple('Point', 'x y')
417 self.assertEqual(Point.__doc__, 'Point(x, y)')
418 Point.__doc__ = '2D point'
419 self.assertEqual(Point.__doc__, '2D point')
420
421 @unittest.skipIf(sys.flags.optimize >= 2,
422 "Docstrings are omitted with -O2 and above")
423 def test_field_doc(self):
424 Point = namedtuple('Point', 'x y')
425 self.assertEqual(Point.x.__doc__, 'Alias for field number 0')
426 self.assertEqual(Point.y.__doc__, 'Alias for field number 1')
427 Point.x.__doc__ = 'docstring for Point.x'
428 self.assertEqual(Point.x.__doc__, 'docstring for Point.x')
429 # namedtuple can mutate doc of descriptors independently
430 Vector = namedtuple('Vector', 'x y')
431 self.assertEqual(Vector.x.__doc__, 'Alias for field number 0')
432 Vector.x.__doc__ = 'docstring for Vector.x'
433 self.assertEqual(Vector.x.__doc__, 'docstring for Vector.x')
434
435 @support.cpython_only
436 @unittest.skipIf(sys.flags.optimize >= 2,
437 "Docstrings are omitted with -O2 and above")
438 def test_field_doc_reuse(self):
439 P = namedtuple('P', ['m', 'n'])
440 Q = namedtuple('Q', ['o', 'p'])
441 self.assertIs(P.m.__doc__, Q.o.__doc__)
442 self.assertIs(P.n.__doc__, Q.p.__doc__)
443
444 @support.cpython_only
445 def test_field_repr(self):
446 Point = namedtuple('Point', 'x y')
447 self.assertEqual(repr(Point.x), "_tuplegetter(0, 'Alias for field number 0')")
448 self.assertEqual(repr(Point.y), "_tuplegetter(1, 'Alias for field number 1')")
449
450 Point.x.__doc__ = 'The x-coordinate'
451 Point.y.__doc__ = 'The y-coordinate'
452
453 self.assertEqual(repr(Point.x), "_tuplegetter(0, 'The x-coordinate')")
454 self.assertEqual(repr(Point.y), "_tuplegetter(1, 'The y-coordinate')")
455
456 def test_name_fixer(self):
457 for spec, renamed in [
458 [('efg', 'g%hi'), ('efg', '_1')], # field with non-alpha char
459 [('abc', 'class'), ('abc', '_1')], # field has keyword
460 [('8efg', '9ghi'), ('_0', '_1')], # field starts with digit
461 [('abc', '_efg'), ('abc', '_1')], # field with leading underscore
462 [('abc', 'efg', 'efg', 'ghi'), ('abc', 'efg', '_2', 'ghi')], # duplicate field
463 [('abc', '', 'x'), ('abc', '_1', 'x')], # fieldname is a space
464 ]:
465 self.assertEqual(namedtuple('NT', spec, rename=True)._fields, renamed)
466
467 def test_module_parameter(self):
468 NT = namedtuple('NT', ['x', 'y'], module=collections)
469 self.assertEqual(NT.__module__, collections)
470
471 def test_instance(self):
472 Point = namedtuple('Point', 'x y')
473 p = Point(11, 22)
474 self.assertEqual(p, Point(x=11, y=22))
475 self.assertEqual(p, Point(11, y=22))
476 self.assertEqual(p, Point(y=22, x=11))
477 self.assertEqual(p, Point(*(11, 22)))
478 self.assertEqual(p, Point(**dict(x=11, y=22)))
479 self.assertRaises(TypeError, Point, 1) # too few args
480 self.assertRaises(TypeError, Point, 1, 2, 3) # too many args
481 with self.assertRaises(TypeError): # wrong keyword argument
482 Point(XXX=1, y=2)
483 with self.assertRaises(TypeError): # missing keyword argument
484 Point(x=1)
485 self.assertEqual(repr(p), 'Point(x=11, y=22)')
486 self.assertNotIn('__weakref__', dir(p))
487 self.assertEqual(p, Point._make([11, 22])) # test _make classmethod
488 self.assertEqual(p._fields, ('x', 'y')) # test _fields attribute
489 self.assertEqual(p._replace(x=1), (1, 22)) # test _replace method
490 self.assertEqual(p._asdict(), dict(x=11, y=22)) # test _asdict method
491
492 with self.assertRaises(TypeError):
493 p._replace(x=1, error=2)
494
495 # verify that field string can have commas
496 Point = namedtuple('Point', 'x, y')
497 p = Point(x=11, y=22)
498 self.assertEqual(repr(p), 'Point(x=11, y=22)')
499
500 # verify that fieldspec can be a non-string sequence
501 Point = namedtuple('Point', ('x', 'y'))
502 p = Point(x=11, y=22)
503 self.assertEqual(repr(p), 'Point(x=11, y=22)')
504
505 def test_tupleness(self):
506 Point = namedtuple('Point', 'x y')
507 p = Point(11, 22)
508
509 self.assertIsInstance(p, tuple)
510 self.assertEqual(p, (11, 22)) # matches a real tuple
511 self.assertEqual(tuple(p), (11, 22)) # coercible to a real tuple
512 self.assertEqual(list(p), [11, 22]) # coercible to a list
513 self.assertEqual(max(p), 22) # iterable
514 self.assertEqual(max(*p), 22) # star-able
515 x, y = p
516 self.assertEqual(p, (x, y)) # unpacks like a tuple
517 self.assertEqual((p[0], p[1]), (11, 22)) # indexable like a tuple
518 with self.assertRaises(IndexError):
519 p[3]
520 self.assertEqual(p[-1], 22)
521 self.assertEqual(hash(p), hash((11, 22)))
522
523 self.assertEqual(p.x, x)
524 self.assertEqual(p.y, y)
525 with self.assertRaises(AttributeError):
526 p.z
527
528 def test_odd_sizes(self):
529 Zero = namedtuple('Zero', '')
530 self.assertEqual(Zero(), ())
531 self.assertEqual(Zero._make([]), ())
532 self.assertEqual(repr(Zero()), 'Zero()')
533 self.assertEqual(Zero()._asdict(), {})
534 self.assertEqual(Zero()._fields, ())
535
536 Dot = namedtuple('Dot', 'd')
537 self.assertEqual(Dot(1), (1,))
538 self.assertEqual(Dot._make([1]), (1,))
539 self.assertEqual(Dot(1).d, 1)
540 self.assertEqual(repr(Dot(1)), 'Dot(d=1)')
541 self.assertEqual(Dot(1)._asdict(), {'d':1})
542 self.assertEqual(Dot(1)._replace(d=999), (999,))
543 self.assertEqual(Dot(1)._fields, ('d',))
544
545 @support.requires_resource('cpu')
546 def test_large_size(self):
547 n = support.exceeds_recursion_limit()
548 names = list(set(''.join([choice(string.ascii_letters)
549 for j in range(10)]) for i in range(n)))
550 n = len(names)
551 Big = namedtuple('Big', names)
552 b = Big(*range(n))
553 self.assertEqual(b, tuple(range(n)))
554 self.assertEqual(Big._make(range(n)), tuple(range(n)))
555 for pos, name in enumerate(names):
556 self.assertEqual(getattr(b, name), pos)
557 repr(b) # make sure repr() doesn't blow-up
558 d = b._asdict()
559 d_expected = dict(zip(names, range(n)))
560 self.assertEqual(d, d_expected)
561 b2 = b._replace(**dict([(names[1], 999),(names[-5], 42)]))
562 b2_expected = list(range(n))
563 b2_expected[1] = 999
564 b2_expected[-5] = 42
565 self.assertEqual(b2, tuple(b2_expected))
566 self.assertEqual(b._fields, tuple(names))
567
568 def test_pickle(self):
569 p = TestNT(x=10, y=20, z=30)
570 for module in (pickle,):
571 loads = getattr(module, 'loads')
572 dumps = getattr(module, 'dumps')
573 for protocol in range(-1, module.HIGHEST_PROTOCOL + 1):
574 q = loads(dumps(p, protocol))
575 self.assertEqual(p, q)
576 self.assertEqual(p._fields, q._fields)
577 self.assertNotIn(b'OrderedDict', dumps(p, protocol))
578
579 def test_copy(self):
580 p = TestNT(x=10, y=20, z=30)
581 for copier in copy.copy, copy.deepcopy:
582 q = copier(p)
583 self.assertEqual(p, q)
584 self.assertEqual(p._fields, q._fields)
585
586 def test_name_conflicts(self):
587 # Some names like "self", "cls", "tuple", "itemgetter", and "property"
588 # failed when used as field names. Test to make sure these now work.
589 T = namedtuple('T', 'itemgetter property self cls tuple')
590 t = T(1, 2, 3, 4, 5)
591 self.assertEqual(t, (1,2,3,4,5))
592 newt = t._replace(itemgetter=10, property=20, self=30, cls=40, tuple=50)
593 self.assertEqual(newt, (10,20,30,40,50))
594
595 # Broader test of all interesting names taken from the code, old
596 # template, and an example
597 words = {'Alias', 'At', 'AttributeError', 'Build', 'Bypass', 'Create',
598 'Encountered', 'Expected', 'Field', 'For', 'Got', 'Helper',
599 'IronPython', 'Jython', 'KeyError', 'Make', 'Modify', 'Note',
600 'OrderedDict', 'Point', 'Return', 'Returns', 'Type', 'TypeError',
601 'Used', 'Validate', 'ValueError', 'Variables', 'a', 'accessible', 'add',
602 'added', 'all', 'also', 'an', 'arg_list', 'args', 'arguments',
603 'automatically', 'be', 'build', 'builtins', 'but', 'by', 'cannot',
604 'class_namespace', 'classmethod', 'cls', 'collections', 'convert',
605 'copy', 'created', 'creation', 'd', 'debugging', 'defined', 'dict',
606 'dictionary', 'doc', 'docstring', 'docstrings', 'duplicate', 'effect',
607 'either', 'enumerate', 'environments', 'error', 'example', 'exec', 'f',
608 'f_globals', 'field', 'field_names', 'fields', 'formatted', 'frame',
609 'function', 'functions', 'generate', 'get', 'getter', 'got', 'greater',
610 'has', 'help', 'identifiers', 'index', 'indexable', 'instance',
611 'instantiate', 'interning', 'introspection', 'isidentifier',
612 'isinstance', 'itemgetter', 'iterable', 'join', 'keyword', 'keywords',
613 'kwds', 'len', 'like', 'list', 'map', 'maps', 'message', 'metadata',
614 'method', 'methods', 'module', 'module_name', 'must', 'name', 'named',
615 'namedtuple', 'namedtuple_', 'names', 'namespace', 'needs', 'new',
616 'nicely', 'num_fields', 'number', 'object', 'of', 'operator', 'option',
617 'p', 'particular', 'pickle', 'pickling', 'plain', 'pop', 'positional',
618 'property', 'r', 'regular', 'rename', 'replace', 'replacing', 'repr',
619 'repr_fmt', 'representation', 'result', 'reuse_itemgetter', 's', 'seen',
620 'self', 'sequence', 'set', 'side', 'specified', 'split', 'start',
621 'startswith', 'step', 'str', 'string', 'strings', 'subclass', 'sys',
622 'targets', 'than', 'the', 'their', 'this', 'to', 'tuple', 'tuple_new',
623 'type', 'typename', 'underscore', 'unexpected', 'unpack', 'up', 'use',
624 'used', 'user', 'valid', 'values', 'variable', 'verbose', 'where',
625 'which', 'work', 'x', 'y', 'z', 'zip'}
626 T = namedtuple('T', words)
627 # test __new__
628 values = tuple(range(len(words)))
629 t = T(*values)
630 self.assertEqual(t, values)
631 t = T(**dict(zip(T._fields, values)))
632 self.assertEqual(t, values)
633 # test _make
634 t = T._make(values)
635 self.assertEqual(t, values)
636 # exercise __repr__
637 repr(t)
638 # test _asdict
639 self.assertEqual(t._asdict(), dict(zip(T._fields, values)))
640 # test _replace
641 t = T._make(values)
642 newvalues = tuple(v*10 for v in values)
643 newt = t._replace(**dict(zip(T._fields, newvalues)))
644 self.assertEqual(newt, newvalues)
645 # test _fields
646 self.assertEqual(T._fields, tuple(words))
647 # test __getnewargs__
648 self.assertEqual(t.__getnewargs__(), values)
649
650 def test_repr(self):
651 A = namedtuple('A', 'x')
652 self.assertEqual(repr(A(1)), 'A(x=1)')
653 # repr should show the name of the subclass
654 class B(A):
655 pass
656 self.assertEqual(repr(B(1)), 'B(x=1)')
657
658 def test_keyword_only_arguments(self):
659 # See issue 25628
660 with self.assertRaises(TypeError):
661 NT = namedtuple('NT', ['x', 'y'], True)
662
663 NT = namedtuple('NT', ['abc', 'def'], rename=True)
664 self.assertEqual(NT._fields, ('abc', '_1'))
665 with self.assertRaises(TypeError):
666 NT = namedtuple('NT', ['abc', 'def'], False, True)
667
668 def test_namedtuple_subclass_issue_24931(self):
669 class Point(namedtuple('_Point', ['x', 'y'])):
670 pass
671
672 a = Point(3, 4)
673 self.assertEqual(a._asdict(), OrderedDict([('x', 3), ('y', 4)]))
674
675 a.w = 5
676 self.assertEqual(a.__dict__, {'w': 5})
677
678 @support.cpython_only
679 def test_field_descriptor(self):
680 Point = namedtuple('Point', 'x y')
681 p = Point(11, 22)
682 self.assertTrue(inspect.isdatadescriptor(Point.x))
683 self.assertEqual(Point.x.__get__(p), 11)
684 self.assertRaises(AttributeError, Point.x.__set__, p, 33)
685 self.assertRaises(AttributeError, Point.x.__delete__, p)
686
687 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
688 with self.subTest(proto=proto):
689 class NewPoint(tuple):
690 x = pickle.loads(pickle.dumps(Point.x, proto))
691 y = pickle.loads(pickle.dumps(Point.y, proto))
692
693 np = NewPoint([1, 2])
694
695 self.assertEqual(np.x, 1)
696 self.assertEqual(np.y, 2)
697
698 def test_new_builtins_issue_43102(self):
699 obj = namedtuple('C', ())
700 new_func = obj.__new__
701 self.assertEqual(new_func.__globals__['__builtins__'], {})
702 self.assertEqual(new_func.__builtins__, {})
703
704 def test_match_args(self):
705 Point = namedtuple('Point', 'x y')
706 self.assertEqual(Point.__match_args__, ('x', 'y'))
707
708 def test_non_generic_subscript(self):
709 # For backward compatibility, subscription works
710 # on arbitrary named tuple types.
711 Group = collections.namedtuple('Group', 'key group')
712 A = Group[int, list[int]]
713 self.assertEqual(A.__origin__, Group)
714 self.assertEqual(A.__parameters__, ())
715 self.assertEqual(A.__args__, (int, list[int]))
716 a = A(1, [2])
717 self.assertIs(type(a), Group)
718 self.assertEqual(a, (1, [2]))
719
720
721 ################################################################################
722 ### Abstract Base Classes
723 ################################################################################
724
725 class ABCTestCase(unittest.TestCase):
726
727 def validate_abstract_methods(self, abc, *names):
728 methodstubs = dict.fromkeys(names, lambda s, *args: 0)
729
730 # everything should work will all required methods are present
731 C = type('C', (abc,), methodstubs)
732 C()
733
734 # instantiation should fail if a required method is missing
735 for name in names:
736 stubs = methodstubs.copy()
737 del stubs[name]
738 C = type('C', (abc,), stubs)
739 self.assertRaises(TypeError, C)
740
741 def validate_isinstance(self, abc, name):
742 stub = lambda s, *args: 0
743
744 C = type('C', (object,), {'__hash__': None})
745 setattr(C, name, stub)
746 self.assertIsInstance(C(), abc)
747 self.assertIsSubclass(C, abc)
748
749 C = type('C', (object,), {'__hash__': None})
750 self.assertNotIsInstance(C(), abc)
751 self.assertNotIsSubclass(C, abc)
752
753 def validate_comparison(self, instance):
754 ops = ['lt', 'gt', 'le', 'ge', 'ne', 'or', 'and', 'xor', 'sub']
755 operators = {}
756 for op in ops:
757 name = '__' + op + '__'
758 operators[name] = getattr(operator, name)
759
760 class Other:
761 def __init__(self):
762 self.right_side = False
763 def __eq__(self, other):
764 self.right_side = True
765 return True
766 __lt__ = __eq__
767 __gt__ = __eq__
768 __le__ = __eq__
769 __ge__ = __eq__
770 __ne__ = __eq__
771 __ror__ = __eq__
772 __rand__ = __eq__
773 __rxor__ = __eq__
774 __rsub__ = __eq__
775
776 for name, op in operators.items():
777 if not hasattr(instance, name):
778 continue
779 other = Other()
780 op(instance, other)
781 self.assertTrue(other.right_side,'Right side not called for %s.%s'
782 % (type(instance), name))
783
784 def _test_gen():
785 yield
786
787 class TestOneTrickPonyABCs(ABCTestCase):
788
789 def test_Awaitable(self):
790 def gen():
791 yield
792
793 @types.coroutine
794 def coro():
795 yield
796
797 async def new_coro():
798 pass
799
800 class Bar:
801 def __await__(self):
802 yield
803
804 class MinimalCoro(Coroutine):
805 def send(self, value):
806 return value
807 def throw(self, typ, val=None, tb=None):
808 super().throw(typ, val, tb)
809 def __await__(self):
810 yield
811
812 self.validate_abstract_methods(Awaitable, '__await__')
813
814 non_samples = [None, int(), gen(), object()]
815 for x in non_samples:
816 self.assertNotIsInstance(x, Awaitable)
817 self.assertNotIsSubclass(type(x), Awaitable)
818
819 samples = [Bar(), MinimalCoro()]
820 for x in samples:
821 self.assertIsInstance(x, Awaitable)
822 self.assertIsSubclass(type(x), Awaitable)
823
824 c = coro()
825 # Iterable coroutines (generators with CO_ITERABLE_COROUTINE
826 # flag don't have '__await__' method, hence can't be instances
827 # of Awaitable. Use inspect.isawaitable to detect them.
828 self.assertNotIsInstance(c, Awaitable)
829
830 c = new_coro()
831 self.assertIsInstance(c, Awaitable)
832 c.close() # avoid RuntimeWarning that coro() was not awaited
833
834 class CoroLike: pass
835 Coroutine.register(CoroLike)
836 self.assertIsInstance(CoroLike(), Awaitable)
837 self.assertIsSubclass(CoroLike, Awaitable)
838 CoroLike = None
839 support.gc_collect() # Kill CoroLike to clean-up ABCMeta cache
840
841 def test_Coroutine(self):
842 def gen():
843 yield
844
845 @types.coroutine
846 def coro():
847 yield
848
849 async def new_coro():
850 pass
851
852 class Bar:
853 def __await__(self):
854 yield
855
856 class MinimalCoro(Coroutine):
857 def send(self, value):
858 return value
859 def throw(self, typ, val=None, tb=None):
860 super().throw(typ, val, tb)
861 def __await__(self):
862 yield
863
864 self.validate_abstract_methods(Coroutine, '__await__', 'send', 'throw')
865
866 non_samples = [None, int(), gen(), object(), Bar()]
867 for x in non_samples:
868 self.assertNotIsInstance(x, Coroutine)
869 self.assertNotIsSubclass(type(x), Coroutine)
870
871 samples = [MinimalCoro()]
872 for x in samples:
873 self.assertIsInstance(x, Awaitable)
874 self.assertIsSubclass(type(x), Awaitable)
875
876 c = coro()
877 # Iterable coroutines (generators with CO_ITERABLE_COROUTINE
878 # flag don't have '__await__' method, hence can't be instances
879 # of Coroutine. Use inspect.isawaitable to detect them.
880 self.assertNotIsInstance(c, Coroutine)
881
882 c = new_coro()
883 self.assertIsInstance(c, Coroutine)
884 c.close() # avoid RuntimeWarning that coro() was not awaited
885
886 class CoroLike:
887 def send(self, value):
888 pass
889 def throw(self, typ, val=None, tb=None):
890 pass
891 def close(self):
892 pass
893 def __await__(self):
894 pass
895 self.assertIsInstance(CoroLike(), Coroutine)
896 self.assertIsSubclass(CoroLike, Coroutine)
897
898 class CoroLike:
899 def send(self, value):
900 pass
901 def close(self):
902 pass
903 def __await__(self):
904 pass
905 self.assertNotIsInstance(CoroLike(), Coroutine)
906 self.assertNotIsSubclass(CoroLike, Coroutine)
907
908 def test_Hashable(self):
909 # Check some non-hashables
910 non_samples = [bytearray(), list(), set(), dict()]
911 for x in non_samples:
912 self.assertNotIsInstance(x, Hashable)
913 self.assertNotIsSubclass(type(x), Hashable)
914 # Check some hashables
915 samples = [None,
916 int(), float(), complex(),
917 str(),
918 tuple(), frozenset(),
919 int, list, object, type, bytes()
920 ]
921 for x in samples:
922 self.assertIsInstance(x, Hashable)
923 self.assertIsSubclass(type(x), Hashable)
924 self.assertRaises(TypeError, Hashable)
925 # Check direct subclassing
926 class H(Hashable):
927 def __hash__(self):
928 return super().__hash__()
929 self.assertEqual(hash(H()), 0)
930 self.assertNotIsSubclass(int, H)
931 self.validate_abstract_methods(Hashable, '__hash__')
932 self.validate_isinstance(Hashable, '__hash__')
933
934 def test_AsyncIterable(self):
935 class AI:
936 def __aiter__(self):
937 return self
938 self.assertIsInstance(AI(), AsyncIterable)
939 self.assertIsSubclass(AI, AsyncIterable)
940 # Check some non-iterables
941 non_samples = [None, object, []]
942 for x in non_samples:
943 self.assertNotIsInstance(x, AsyncIterable)
944 self.assertNotIsSubclass(type(x), AsyncIterable)
945 self.validate_abstract_methods(AsyncIterable, '__aiter__')
946 self.validate_isinstance(AsyncIterable, '__aiter__')
947
948 def test_AsyncIterator(self):
949 class AI:
950 def __aiter__(self):
951 return self
952 async def __anext__(self):
953 raise StopAsyncIteration
954 self.assertIsInstance(AI(), AsyncIterator)
955 self.assertIsSubclass(AI, AsyncIterator)
956 non_samples = [None, object, []]
957 # Check some non-iterables
958 for x in non_samples:
959 self.assertNotIsInstance(x, AsyncIterator)
960 self.assertNotIsSubclass(type(x), AsyncIterator)
961 # Similarly to regular iterators (see issue 10565)
962 class AnextOnly:
963 async def __anext__(self):
964 raise StopAsyncIteration
965 self.assertNotIsInstance(AnextOnly(), AsyncIterator)
966 self.validate_abstract_methods(AsyncIterator, '__anext__')
967
968 def test_Iterable(self):
969 # Check some non-iterables
970 non_samples = [None, 42, 3.14, 1j]
971 for x in non_samples:
972 self.assertNotIsInstance(x, Iterable)
973 self.assertNotIsSubclass(type(x), Iterable)
974 # Check some iterables
975 samples = [bytes(), str(),
976 tuple(), list(), set(), frozenset(), dict(),
977 dict().keys(), dict().items(), dict().values(),
978 _test_gen(),
979 (x for x in []),
980 ]
981 for x in samples:
982 self.assertIsInstance(x, Iterable)
983 self.assertIsSubclass(type(x), Iterable)
984 # Check direct subclassing
985 class I(Iterable):
986 def __iter__(self):
987 return super().__iter__()
988 self.assertEqual(list(I()), [])
989 self.assertNotIsSubclass(str, I)
990 self.validate_abstract_methods(Iterable, '__iter__')
991 self.validate_isinstance(Iterable, '__iter__')
992 # Check None blocking
993 class It:
994 def __iter__(self): return iter([])
995 class ItBlocked(It):
996 __iter__ = None
997 self.assertIsSubclass(It, Iterable)
998 self.assertIsInstance(It(), Iterable)
999 self.assertNotIsSubclass(ItBlocked, Iterable)
1000 self.assertNotIsInstance(ItBlocked(), Iterable)
1001
1002 def test_Reversible(self):
1003 # Check some non-reversibles
1004 non_samples = [None, 42, 3.14, 1j, set(), frozenset()]
1005 for x in non_samples:
1006 self.assertNotIsInstance(x, Reversible)
1007 self.assertNotIsSubclass(type(x), Reversible)
1008 # Check some non-reversible iterables
1009 non_reversibles = [_test_gen(), (x for x in []), iter([]), reversed([])]
1010 for x in non_reversibles:
1011 self.assertNotIsInstance(x, Reversible)
1012 self.assertNotIsSubclass(type(x), Reversible)
1013 # Check some reversible iterables
1014 samples = [bytes(), str(), tuple(), list(), OrderedDict(),
1015 OrderedDict().keys(), OrderedDict().items(),
1016 OrderedDict().values(), Counter(), Counter().keys(),
1017 Counter().items(), Counter().values(), dict(),
1018 dict().keys(), dict().items(), dict().values()]
1019 for x in samples:
1020 self.assertIsInstance(x, Reversible)
1021 self.assertIsSubclass(type(x), Reversible)
1022 # Check also Mapping, MutableMapping, and Sequence
1023 self.assertIsSubclass(Sequence, Reversible)
1024 self.assertNotIsSubclass(Mapping, Reversible)
1025 self.assertNotIsSubclass(MutableMapping, Reversible)
1026 # Check direct subclassing
1027 class R(Reversible):
1028 def __iter__(self):
1029 return iter(list())
1030 def __reversed__(self):
1031 return iter(list())
1032 self.assertEqual(list(reversed(R())), [])
1033 self.assertNotIsSubclass(float, R)
1034 self.validate_abstract_methods(Reversible, '__reversed__', '__iter__')
1035 # Check reversible non-iterable (which is not Reversible)
1036 class RevNoIter:
1037 def __reversed__(self): return reversed([])
1038 class RevPlusIter(RevNoIter):
1039 def __iter__(self): return iter([])
1040 self.assertNotIsSubclass(RevNoIter, Reversible)
1041 self.assertNotIsInstance(RevNoIter(), Reversible)
1042 self.assertIsSubclass(RevPlusIter, Reversible)
1043 self.assertIsInstance(RevPlusIter(), Reversible)
1044 # Check None blocking
1045 class Rev:
1046 def __iter__(self): return iter([])
1047 def __reversed__(self): return reversed([])
1048 class RevItBlocked(Rev):
1049 __iter__ = None
1050 class RevRevBlocked(Rev):
1051 __reversed__ = None
1052 self.assertIsSubclass(Rev, Reversible)
1053 self.assertIsInstance(Rev(), Reversible)
1054 self.assertNotIsSubclass(RevItBlocked, Reversible)
1055 self.assertNotIsInstance(RevItBlocked(), Reversible)
1056 self.assertNotIsSubclass(RevRevBlocked, Reversible)
1057 self.assertNotIsInstance(RevRevBlocked(), Reversible)
1058
1059 def test_Collection(self):
1060 # Check some non-collections
1061 non_collections = [None, 42, 3.14, 1j, lambda x: 2*x]
1062 for x in non_collections:
1063 self.assertNotIsInstance(x, Collection)
1064 self.assertNotIsSubclass(type(x), Collection)
1065 # Check some non-collection iterables
1066 non_col_iterables = [_test_gen(), iter(b''), iter(bytearray()),
1067 (x for x in [])]
1068 for x in non_col_iterables:
1069 self.assertNotIsInstance(x, Collection)
1070 self.assertNotIsSubclass(type(x), Collection)
1071 # Check some collections
1072 samples = [set(), frozenset(), dict(), bytes(), str(), tuple(),
1073 list(), dict().keys(), dict().items(), dict().values()]
1074 for x in samples:
1075 self.assertIsInstance(x, Collection)
1076 self.assertIsSubclass(type(x), Collection)
1077 # Check also Mapping, MutableMapping, etc.
1078 self.assertIsSubclass(Sequence, Collection)
1079 self.assertIsSubclass(Mapping, Collection)
1080 self.assertIsSubclass(MutableMapping, Collection)
1081 self.assertIsSubclass(Set, Collection)
1082 self.assertIsSubclass(MutableSet, Collection)
1083 self.assertIsSubclass(Sequence, Collection)
1084 # Check direct subclassing
1085 class Col(Collection):
1086 def __iter__(self):
1087 return iter(list())
1088 def __len__(self):
1089 return 0
1090 def __contains__(self, item):
1091 return False
1092 class DerCol(Col): pass
1093 self.assertEqual(list(iter(Col())), [])
1094 self.assertNotIsSubclass(list, Col)
1095 self.assertNotIsSubclass(set, Col)
1096 self.assertNotIsSubclass(float, Col)
1097 self.assertEqual(list(iter(DerCol())), [])
1098 self.assertNotIsSubclass(list, DerCol)
1099 self.assertNotIsSubclass(set, DerCol)
1100 self.assertNotIsSubclass(float, DerCol)
1101 self.validate_abstract_methods(Collection, '__len__', '__iter__',
1102 '__contains__')
1103 # Check sized container non-iterable (which is not Collection) etc.
1104 class ColNoIter:
1105 def __len__(self): return 0
1106 def __contains__(self, item): return False
1107 class ColNoSize:
1108 def __iter__(self): return iter([])
1109 def __contains__(self, item): return False
1110 class ColNoCont:
1111 def __iter__(self): return iter([])
1112 def __len__(self): return 0
1113 self.assertNotIsSubclass(ColNoIter, Collection)
1114 self.assertNotIsInstance(ColNoIter(), Collection)
1115 self.assertNotIsSubclass(ColNoSize, Collection)
1116 self.assertNotIsInstance(ColNoSize(), Collection)
1117 self.assertNotIsSubclass(ColNoCont, Collection)
1118 self.assertNotIsInstance(ColNoCont(), Collection)
1119 # Check None blocking
1120 class SizeBlock:
1121 def __iter__(self): return iter([])
1122 def __contains__(self): return False
1123 __len__ = None
1124 class IterBlock:
1125 def __len__(self): return 0
1126 def __contains__(self): return True
1127 __iter__ = None
1128 self.assertNotIsSubclass(SizeBlock, Collection)
1129 self.assertNotIsInstance(SizeBlock(), Collection)
1130 self.assertNotIsSubclass(IterBlock, Collection)
1131 self.assertNotIsInstance(IterBlock(), Collection)
1132 # Check None blocking in subclass
1133 class ColImpl:
1134 def __iter__(self):
1135 return iter(list())
1136 def __len__(self):
1137 return 0
1138 def __contains__(self, item):
1139 return False
1140 class NonCol(ColImpl):
1141 __contains__ = None
1142 self.assertNotIsSubclass(NonCol, Collection)
1143 self.assertNotIsInstance(NonCol(), Collection)
1144
1145
1146 def test_Iterator(self):
1147 non_samples = [None, 42, 3.14, 1j, b"", "", (), [], {}, set()]
1148 for x in non_samples:
1149 self.assertNotIsInstance(x, Iterator)
1150 self.assertNotIsSubclass(type(x), Iterator)
1151 samples = [iter(bytes()), iter(str()),
1152 iter(tuple()), iter(list()), iter(dict()),
1153 iter(set()), iter(frozenset()),
1154 iter(dict().keys()), iter(dict().items()),
1155 iter(dict().values()),
1156 _test_gen(),
1157 (x for x in []),
1158 ]
1159 for x in samples:
1160 self.assertIsInstance(x, Iterator)
1161 self.assertIsSubclass(type(x), Iterator)
1162 self.validate_abstract_methods(Iterator, '__next__')
1163
1164 # Issue 10565
1165 class NextOnly:
1166 def __next__(self):
1167 yield 1
1168 return
1169 self.assertNotIsInstance(NextOnly(), Iterator)
1170
1171 def test_Generator(self):
1172 class NonGen1:
1173 def __iter__(self): return self
1174 def __next__(self): return None
1175 def close(self): pass
1176 def throw(self, typ, val=None, tb=None): pass
1177
1178 class NonGen2:
1179 def __iter__(self): return self
1180 def __next__(self): return None
1181 def close(self): pass
1182 def send(self, value): return value
1183
1184 class NonGen3:
1185 def close(self): pass
1186 def send(self, value): return value
1187 def throw(self, typ, val=None, tb=None): pass
1188
1189 non_samples = [
1190 None, 42, 3.14, 1j, b"", "", (), [], {}, set(),
1191 iter(()), iter([]), NonGen1(), NonGen2(), NonGen3()]
1192 for x in non_samples:
1193 self.assertNotIsInstance(x, Generator)
1194 self.assertNotIsSubclass(type(x), Generator)
1195
1196 class Gen:
1197 def __iter__(self): return self
1198 def __next__(self): return None
1199 def close(self): pass
1200 def send(self, value): return value
1201 def throw(self, typ, val=None, tb=None): pass
1202
1203 class MinimalGen(Generator):
1204 def send(self, value):
1205 return value
1206 def throw(self, typ, val=None, tb=None):
1207 super().throw(typ, val, tb)
1208
1209 def gen():
1210 yield 1
1211
1212 samples = [gen(), (lambda: (yield))(), Gen(), MinimalGen()]
1213 for x in samples:
1214 self.assertIsInstance(x, Iterator)
1215 self.assertIsInstance(x, Generator)
1216 self.assertIsSubclass(type(x), Generator)
1217 self.validate_abstract_methods(Generator, 'send', 'throw')
1218
1219 # mixin tests
1220 mgen = MinimalGen()
1221 self.assertIs(mgen, iter(mgen))
1222 self.assertIs(mgen.send(None), next(mgen))
1223 self.assertEqual(2, mgen.send(2))
1224 self.assertIsNone(mgen.close())
1225 self.assertRaises(ValueError, mgen.throw, ValueError)
1226 self.assertRaisesRegex(ValueError, "^huhu$",
1227 mgen.throw, ValueError, ValueError("huhu"))
1228 self.assertRaises(StopIteration, mgen.throw, StopIteration())
1229
1230 class FailOnClose(Generator):
1231 def send(self, value): return value
1232 def throw(self, *args): raise ValueError
1233
1234 self.assertRaises(ValueError, FailOnClose().close)
1235
1236 class IgnoreGeneratorExit(Generator):
1237 def send(self, value): return value
1238 def throw(self, *args): pass
1239
1240 self.assertRaises(RuntimeError, IgnoreGeneratorExit().close)
1241
1242 def test_AsyncGenerator(self):
1243 class NonAGen1:
1244 def __aiter__(self): return self
1245 def __anext__(self): return None
1246 def aclose(self): pass
1247 def athrow(self, typ, val=None, tb=None): pass
1248
1249 class NonAGen2:
1250 def __aiter__(self): return self
1251 def __anext__(self): return None
1252 def aclose(self): pass
1253 def asend(self, value): return value
1254
1255 class NonAGen3:
1256 def aclose(self): pass
1257 def asend(self, value): return value
1258 def athrow(self, typ, val=None, tb=None): pass
1259
1260 non_samples = [
1261 None, 42, 3.14, 1j, b"", "", (), [], {}, set(),
1262 iter(()), iter([]), NonAGen1(), NonAGen2(), NonAGen3()]
1263 for x in non_samples:
1264 self.assertNotIsInstance(x, AsyncGenerator)
1265 self.assertNotIsSubclass(type(x), AsyncGenerator)
1266
1267 class Gen:
1268 def __aiter__(self): return self
1269 async def __anext__(self): return None
1270 async def aclose(self): pass
1271 async def asend(self, value): return value
1272 async def athrow(self, typ, val=None, tb=None): pass
1273
1274 class MinimalAGen(AsyncGenerator):
1275 async def asend(self, value):
1276 return value
1277 async def athrow(self, typ, val=None, tb=None):
1278 await super().athrow(typ, val, tb)
1279
1280 async def gen():
1281 yield 1
1282
1283 samples = [gen(), Gen(), MinimalAGen()]
1284 for x in samples:
1285 self.assertIsInstance(x, AsyncIterator)
1286 self.assertIsInstance(x, AsyncGenerator)
1287 self.assertIsSubclass(type(x), AsyncGenerator)
1288 self.validate_abstract_methods(AsyncGenerator, 'asend', 'athrow')
1289
1290 def run_async(coro):
1291 result = None
1292 while True:
1293 try:
1294 coro.send(None)
1295 except StopIteration as ex:
1296 result = ex.args[0] if ex.args else None
1297 break
1298 return result
1299
1300 # mixin tests
1301 mgen = MinimalAGen()
1302 self.assertIs(mgen, mgen.__aiter__())
1303 self.assertIs(run_async(mgen.asend(None)), run_async(mgen.__anext__()))
1304 self.assertEqual(2, run_async(mgen.asend(2)))
1305 self.assertIsNone(run_async(mgen.aclose()))
1306 with self.assertRaises(ValueError):
1307 run_async(mgen.athrow(ValueError))
1308
1309 class FailOnClose(AsyncGenerator):
1310 async def asend(self, value): return value
1311 async def athrow(self, *args): raise ValueError
1312
1313 with self.assertRaises(ValueError):
1314 run_async(FailOnClose().aclose())
1315
1316 class IgnoreGeneratorExit(AsyncGenerator):
1317 async def asend(self, value): return value
1318 async def athrow(self, *args): pass
1319
1320 with self.assertRaises(RuntimeError):
1321 run_async(IgnoreGeneratorExit().aclose())
1322
1323 def test_Sized(self):
1324 non_samples = [None, 42, 3.14, 1j,
1325 _test_gen(),
1326 (x for x in []),
1327 ]
1328 for x in non_samples:
1329 self.assertNotIsInstance(x, Sized)
1330 self.assertNotIsSubclass(type(x), Sized)
1331 samples = [bytes(), str(),
1332 tuple(), list(), set(), frozenset(), dict(),
1333 dict().keys(), dict().items(), dict().values(),
1334 ]
1335 for x in samples:
1336 self.assertIsInstance(x, Sized)
1337 self.assertIsSubclass(type(x), Sized)
1338 self.validate_abstract_methods(Sized, '__len__')
1339 self.validate_isinstance(Sized, '__len__')
1340
1341 def test_Container(self):
1342 non_samples = [None, 42, 3.14, 1j,
1343 _test_gen(),
1344 (x for x in []),
1345 ]
1346 for x in non_samples:
1347 self.assertNotIsInstance(x, Container)
1348 self.assertNotIsSubclass(type(x), Container)
1349 samples = [bytes(), str(),
1350 tuple(), list(), set(), frozenset(), dict(),
1351 dict().keys(), dict().items(),
1352 ]
1353 for x in samples:
1354 self.assertIsInstance(x, Container)
1355 self.assertIsSubclass(type(x), Container)
1356 self.validate_abstract_methods(Container, '__contains__')
1357 self.validate_isinstance(Container, '__contains__')
1358
1359 def test_Callable(self):
1360 non_samples = [None, 42, 3.14, 1j,
1361 "", b"", (), [], {}, set(),
1362 _test_gen(),
1363 (x for x in []),
1364 ]
1365 for x in non_samples:
1366 self.assertNotIsInstance(x, Callable)
1367 self.assertNotIsSubclass(type(x), Callable)
1368 samples = [lambda: None,
1369 type, int, object,
1370 len,
1371 list.append, [].append,
1372 ]
1373 for x in samples:
1374 self.assertIsInstance(x, Callable)
1375 self.assertIsSubclass(type(x), Callable)
1376 self.validate_abstract_methods(Callable, '__call__')
1377 self.validate_isinstance(Callable, '__call__')
1378
1379 def test_direct_subclassing(self):
1380 for B in Hashable, Iterable, Iterator, Reversible, Sized, Container, Callable:
1381 class C(B):
1382 pass
1383 self.assertIsSubclass(C, B)
1384 self.assertNotIsSubclass(int, C)
1385
1386 def test_registration(self):
1387 for B in Hashable, Iterable, Iterator, Reversible, Sized, Container, Callable:
1388 class C:
1389 __hash__ = None # Make sure it isn't hashable by default
1390 self.assertNotIsSubclass(C, B)
1391 B.register(C)
1392 self.assertIsSubclass(C, B)
1393
1394 class WithSet(MutableSet):
1395
1396 def __init__(self, it=()):
1397 self.data = set(it)
1398
1399 def __len__(self):
1400 return len(self.data)
1401
1402 def __iter__(self):
1403 return iter(self.data)
1404
1405 def __contains__(self, item):
1406 return item in self.data
1407
1408 def add(self, item):
1409 self.data.add(item)
1410
1411 def discard(self, item):
1412 self.data.discard(item)
1413
1414 class TestCollectionABCs(ABCTestCase):
1415
1416 # XXX For now, we only test some virtual inheritance properties.
1417 # We should also test the proper behavior of the collection ABCs
1418 # as real base classes or mix-in classes.
1419
1420 def test_Set(self):
1421 for sample in [set, frozenset]:
1422 self.assertIsInstance(sample(), Set)
1423 self.assertIsSubclass(sample, Set)
1424 self.validate_abstract_methods(Set, '__contains__', '__iter__', '__len__')
1425 class MySet(Set):
1426 def __contains__(self, x):
1427 return False
1428 def __len__(self):
1429 return 0
1430 def __iter__(self):
1431 return iter([])
1432 self.validate_comparison(MySet())
1433
1434 def test_hash_Set(self):
1435 class OneTwoThreeSet(Set):
1436 def __init__(self):
1437 self.contents = [1, 2, 3]
1438 def __contains__(self, x):
1439 return x in self.contents
1440 def __len__(self):
1441 return len(self.contents)
1442 def __iter__(self):
1443 return iter(self.contents)
1444 def __hash__(self):
1445 return self._hash()
1446 a, b = OneTwoThreeSet(), OneTwoThreeSet()
1447 self.assertTrue(hash(a) == hash(b))
1448
1449 def test_isdisjoint_Set(self):
1450 class MySet(Set):
1451 def __init__(self, itr):
1452 self.contents = itr
1453 def __contains__(self, x):
1454 return x in self.contents
1455 def __iter__(self):
1456 return iter(self.contents)
1457 def __len__(self):
1458 return len([x for x in self.contents])
1459 s1 = MySet((1, 2, 3))
1460 s2 = MySet((4, 5, 6))
1461 s3 = MySet((1, 5, 6))
1462 self.assertTrue(s1.isdisjoint(s2))
1463 self.assertFalse(s1.isdisjoint(s3))
1464
1465 def test_equality_Set(self):
1466 class MySet(Set):
1467 def __init__(self, itr):
1468 self.contents = itr
1469 def __contains__(self, x):
1470 return x in self.contents
1471 def __iter__(self):
1472 return iter(self.contents)
1473 def __len__(self):
1474 return len([x for x in self.contents])
1475 s1 = MySet((1,))
1476 s2 = MySet((1, 2))
1477 s3 = MySet((3, 4))
1478 s4 = MySet((3, 4))
1479 self.assertTrue(s2 > s1)
1480 self.assertTrue(s1 < s2)
1481 self.assertFalse(s2 <= s1)
1482 self.assertFalse(s2 <= s3)
1483 self.assertFalse(s1 >= s2)
1484 self.assertEqual(s3, s4)
1485 self.assertNotEqual(s2, s3)
1486
1487 def test_arithmetic_Set(self):
1488 class MySet(Set):
1489 def __init__(self, itr):
1490 self.contents = itr
1491 def __contains__(self, x):
1492 return x in self.contents
1493 def __iter__(self):
1494 return iter(self.contents)
1495 def __len__(self):
1496 return len([x for x in self.contents])
1497 s1 = MySet((1, 2, 3))
1498 s2 = MySet((3, 4, 5))
1499 s3 = s1 & s2
1500 self.assertEqual(s3, MySet((3,)))
1501
1502 def test_MutableSet(self):
1503 self.assertIsInstance(set(), MutableSet)
1504 self.assertIsSubclass(set, MutableSet)
1505 self.assertNotIsInstance(frozenset(), MutableSet)
1506 self.assertNotIsSubclass(frozenset, MutableSet)
1507 self.validate_abstract_methods(MutableSet, '__contains__', '__iter__', '__len__',
1508 'add', 'discard')
1509
1510 def test_issue_5647(self):
1511 # MutableSet.__iand__ mutated the set during iteration
1512 s = WithSet('abcd')
1513 s &= WithSet('cdef') # This used to fail
1514 self.assertEqual(set(s), set('cd'))
1515
1516 def test_issue_4920(self):
1517 # MutableSet.pop() method did not work
1518 class MySet(MutableSet):
1519 __slots__=['__s']
1520 def __init__(self,items=None):
1521 if items is None:
1522 items=[]
1523 self.__s=set(items)
1524 def __contains__(self,v):
1525 return v in self.__s
1526 def __iter__(self):
1527 return iter(self.__s)
1528 def __len__(self):
1529 return len(self.__s)
1530 def add(self,v):
1531 result=v not in self.__s
1532 self.__s.add(v)
1533 return result
1534 def discard(self,v):
1535 result=v in self.__s
1536 self.__s.discard(v)
1537 return result
1538 def __repr__(self):
1539 return "MySet(%s)" % repr(list(self))
1540 items = [5,43,2,1]
1541 s = MySet(items)
1542 r = s.pop()
1543 self.assertEqual(len(s), len(items) - 1)
1544 self.assertNotIn(r, s)
1545 self.assertIn(r, items)
1546
1547 def test_issue8750(self):
1548 empty = WithSet()
1549 full = WithSet(range(10))
1550 s = WithSet(full)
1551 s -= s
1552 self.assertEqual(s, empty)
1553 s = WithSet(full)
1554 s ^= s
1555 self.assertEqual(s, empty)
1556 s = WithSet(full)
1557 s &= s
1558 self.assertEqual(s, full)
1559 s |= s
1560 self.assertEqual(s, full)
1561
1562 def test_issue16373(self):
1563 # Recursion error comparing comparable and noncomparable
1564 # Set instances
1565 class MyComparableSet(Set):
1566 def __contains__(self, x):
1567 return False
1568 def __len__(self):
1569 return 0
1570 def __iter__(self):
1571 return iter([])
1572 class MyNonComparableSet(Set):
1573 def __contains__(self, x):
1574 return False
1575 def __len__(self):
1576 return 0
1577 def __iter__(self):
1578 return iter([])
1579 def __le__(self, x):
1580 return NotImplemented
1581 def __lt__(self, x):
1582 return NotImplemented
1583
1584 cs = MyComparableSet()
1585 ncs = MyNonComparableSet()
1586 self.assertFalse(ncs < cs)
1587 self.assertTrue(ncs <= cs)
1588 self.assertFalse(ncs > cs)
1589 self.assertTrue(ncs >= cs)
1590
1591 def test_issue26915(self):
1592 # Container membership test should check identity first
1593 class CustomSequence(Sequence):
1594 def __init__(self, seq):
1595 self._seq = seq
1596 def __getitem__(self, index):
1597 return self._seq[index]
1598 def __len__(self):
1599 return len(self._seq)
1600
1601 nan = float('nan')
1602 obj = support.NEVER_EQ
1603 seq = CustomSequence([nan, obj, nan])
1604 containers = [
1605 seq,
1606 ItemsView({1: nan, 2: obj}),
1607 KeysView({1: nan, 2: obj}),
1608 ValuesView({1: nan, 2: obj})
1609 ]
1610 for container in containers:
1611 for elem in container:
1612 self.assertIn(elem, container)
1613 self.assertEqual(seq.index(nan), 0)
1614 self.assertEqual(seq.index(obj), 1)
1615 self.assertEqual(seq.count(nan), 2)
1616 self.assertEqual(seq.count(obj), 1)
1617
1618 def assertSameSet(self, s1, s2):
1619 # coerce both to a real set then check equality
1620 self.assertSetEqual(set(s1), set(s2))
1621
1622 def test_Set_from_iterable(self):
1623 """Verify _from_iterable overridden to an instance method works."""
1624 class SetUsingInstanceFromIterable(MutableSet):
1625 def __init__(self, values, created_by):
1626 if not created_by:
1627 raise ValueError('created_by must be specified')
1628 self.created_by = created_by
1629 self._values = set(values)
1630
1631 def _from_iterable(self, values):
1632 return type(self)(values, 'from_iterable')
1633
1634 def __contains__(self, value):
1635 return value in self._values
1636
1637 def __iter__(self):
1638 yield from self._values
1639
1640 def __len__(self):
1641 return len(self._values)
1642
1643 def add(self, value):
1644 self._values.add(value)
1645
1646 def discard(self, value):
1647 self._values.discard(value)
1648
1649 impl = SetUsingInstanceFromIterable([1, 2, 3], 'test')
1650
1651 actual = impl - {1}
1652 self.assertIsInstance(actual, SetUsingInstanceFromIterable)
1653 self.assertEqual('from_iterable', actual.created_by)
1654 self.assertEqual({2, 3}, actual)
1655
1656 actual = impl | {4}
1657 self.assertIsInstance(actual, SetUsingInstanceFromIterable)
1658 self.assertEqual('from_iterable', actual.created_by)
1659 self.assertEqual({1, 2, 3, 4}, actual)
1660
1661 actual = impl & {2}
1662 self.assertIsInstance(actual, SetUsingInstanceFromIterable)
1663 self.assertEqual('from_iterable', actual.created_by)
1664 self.assertEqual({2}, actual)
1665
1666 actual = impl ^ {3, 4}
1667 self.assertIsInstance(actual, SetUsingInstanceFromIterable)
1668 self.assertEqual('from_iterable', actual.created_by)
1669 self.assertEqual({1, 2, 4}, actual)
1670
1671 # NOTE: ixor'ing with a list is important here: internally, __ixor__
1672 # only calls _from_iterable if the other value isn't already a Set.
1673 impl ^= [3, 4]
1674 self.assertIsInstance(impl, SetUsingInstanceFromIterable)
1675 self.assertEqual('test', impl.created_by)
1676 self.assertEqual({1, 2, 4}, impl)
1677
1678 def test_Set_interoperability_with_real_sets(self):
1679 # Issue: 8743
1680 class ListSet(Set):
1681 def __init__(self, elements=()):
1682 self.data = []
1683 for elem in elements:
1684 if elem not in self.data:
1685 self.data.append(elem)
1686 def __contains__(self, elem):
1687 return elem in self.data
1688 def __iter__(self):
1689 return iter(self.data)
1690 def __len__(self):
1691 return len(self.data)
1692 def __repr__(self):
1693 return 'Set({!r})'.format(self.data)
1694
1695 r1 = set('abc')
1696 r2 = set('bcd')
1697 r3 = set('abcde')
1698 f1 = ListSet('abc')
1699 f2 = ListSet('bcd')
1700 f3 = ListSet('abcde')
1701 l1 = list('abccba')
1702 l2 = list('bcddcb')
1703 l3 = list('abcdeedcba')
1704
1705 target = r1 & r2
1706 self.assertSameSet(f1 & f2, target)
1707 self.assertSameSet(f1 & r2, target)
1708 self.assertSameSet(r2 & f1, target)
1709 self.assertSameSet(f1 & l2, target)
1710
1711 target = r1 | r2
1712 self.assertSameSet(f1 | f2, target)
1713 self.assertSameSet(f1 | r2, target)
1714 self.assertSameSet(r2 | f1, target)
1715 self.assertSameSet(f1 | l2, target)
1716
1717 fwd_target = r1 - r2
1718 rev_target = r2 - r1
1719 self.assertSameSet(f1 - f2, fwd_target)
1720 self.assertSameSet(f2 - f1, rev_target)
1721 self.assertSameSet(f1 - r2, fwd_target)
1722 self.assertSameSet(f2 - r1, rev_target)
1723 self.assertSameSet(r1 - f2, fwd_target)
1724 self.assertSameSet(r2 - f1, rev_target)
1725 self.assertSameSet(f1 - l2, fwd_target)
1726 self.assertSameSet(f2 - l1, rev_target)
1727
1728 target = r1 ^ r2
1729 self.assertSameSet(f1 ^ f2, target)
1730 self.assertSameSet(f1 ^ r2, target)
1731 self.assertSameSet(r2 ^ f1, target)
1732 self.assertSameSet(f1 ^ l2, target)
1733
1734 # Don't change the following to use assertLess or other
1735 # "more specific" unittest assertions. The current
1736 # assertTrue/assertFalse style makes the pattern of test
1737 # case combinations clear and allows us to know for sure
1738 # the exact operator being invoked.
1739
1740 # proper subset
1741 self.assertTrue(f1 < f3)
1742 self.assertFalse(f1 < f1)
1743 self.assertFalse(f1 < f2)
1744 self.assertTrue(r1 < f3)
1745 self.assertFalse(r1 < f1)
1746 self.assertFalse(r1 < f2)
1747 self.assertTrue(r1 < r3)
1748 self.assertFalse(r1 < r1)
1749 self.assertFalse(r1 < r2)
1750 with self.assertRaises(TypeError):
1751 f1 < l3
1752 with self.assertRaises(TypeError):
1753 f1 < l1
1754 with self.assertRaises(TypeError):
1755 f1 < l2
1756
1757 # any subset
1758 self.assertTrue(f1 <= f3)
1759 self.assertTrue(f1 <= f1)
1760 self.assertFalse(f1 <= f2)
1761 self.assertTrue(r1 <= f3)
1762 self.assertTrue(r1 <= f1)
1763 self.assertFalse(r1 <= f2)
1764 self.assertTrue(r1 <= r3)
1765 self.assertTrue(r1 <= r1)
1766 self.assertFalse(r1 <= r2)
1767 with self.assertRaises(TypeError):
1768 f1 <= l3
1769 with self.assertRaises(TypeError):
1770 f1 <= l1
1771 with self.assertRaises(TypeError):
1772 f1 <= l2
1773
1774 # proper superset
1775 self.assertTrue(f3 > f1)
1776 self.assertFalse(f1 > f1)
1777 self.assertFalse(f2 > f1)
1778 self.assertTrue(r3 > r1)
1779 self.assertFalse(f1 > r1)
1780 self.assertFalse(f2 > r1)
1781 self.assertTrue(r3 > r1)
1782 self.assertFalse(r1 > r1)
1783 self.assertFalse(r2 > r1)
1784 with self.assertRaises(TypeError):
1785 f1 > l3
1786 with self.assertRaises(TypeError):
1787 f1 > l1
1788 with self.assertRaises(TypeError):
1789 f1 > l2
1790
1791 # any superset
1792 self.assertTrue(f3 >= f1)
1793 self.assertTrue(f1 >= f1)
1794 self.assertFalse(f2 >= f1)
1795 self.assertTrue(r3 >= r1)
1796 self.assertTrue(f1 >= r1)
1797 self.assertFalse(f2 >= r1)
1798 self.assertTrue(r3 >= r1)
1799 self.assertTrue(r1 >= r1)
1800 self.assertFalse(r2 >= r1)
1801 with self.assertRaises(TypeError):
1802 f1 >= l3
1803 with self.assertRaises(TypeError):
1804 f1 >=l1
1805 with self.assertRaises(TypeError):
1806 f1 >= l2
1807
1808 # equality
1809 self.assertTrue(f1 == f1)
1810 self.assertTrue(r1 == f1)
1811 self.assertTrue(f1 == r1)
1812 self.assertFalse(f1 == f3)
1813 self.assertFalse(r1 == f3)
1814 self.assertFalse(f1 == r3)
1815 self.assertFalse(f1 == l3)
1816 self.assertFalse(f1 == l1)
1817 self.assertFalse(f1 == l2)
1818
1819 # inequality
1820 self.assertFalse(f1 != f1)
1821 self.assertFalse(r1 != f1)
1822 self.assertFalse(f1 != r1)
1823 self.assertTrue(f1 != f3)
1824 self.assertTrue(r1 != f3)
1825 self.assertTrue(f1 != r3)
1826 self.assertTrue(f1 != l3)
1827 self.assertTrue(f1 != l1)
1828 self.assertTrue(f1 != l2)
1829
1830 def test_Set_hash_matches_frozenset(self):
1831 sets = [
1832 {}, {1}, {None}, {-1}, {0.0}, {"abc"}, {1, 2, 3},
1833 {10**100, 10**101}, {"a", "b", "ab", ""}, {False, True},
1834 {object(), object(), object()}, {float("nan")}, {frozenset()},
1835 {*range(1000)}, {*range(1000)} - {100, 200, 300},
1836 {*range(sys.maxsize - 10, sys.maxsize + 10)},
1837 ]
1838 for s in sets:
1839 fs = frozenset(s)
1840 self.assertEqual(hash(fs), Set._hash(fs), msg=s)
1841
1842 def test_Mapping(self):
1843 for sample in [dict]:
1844 self.assertIsInstance(sample(), Mapping)
1845 self.assertIsSubclass(sample, Mapping)
1846 self.validate_abstract_methods(Mapping, '__iter__', '__len__', '__getitem__')
1847 class MyMapping(Mapping):
1848 def __len__(self):
1849 return 0
1850 def __getitem__(self, i):
1851 raise IndexError
1852 def __iter__(self):
1853 return iter(())
1854 self.validate_comparison(MyMapping())
1855 self.assertRaises(TypeError, reversed, MyMapping())
1856
1857 def test_MutableMapping(self):
1858 for sample in [dict]:
1859 self.assertIsInstance(sample(), MutableMapping)
1860 self.assertIsSubclass(sample, MutableMapping)
1861 self.validate_abstract_methods(MutableMapping, '__iter__', '__len__',
1862 '__getitem__', '__setitem__', '__delitem__')
1863
1864 def test_MutableMapping_subclass(self):
1865 # Test issue 9214
1866 mymap = UserDict()
1867 mymap['red'] = 5
1868 self.assertIsInstance(mymap.keys(), Set)
1869 self.assertIsInstance(mymap.keys(), KeysView)
1870 self.assertIsInstance(mymap.values(), Collection)
1871 self.assertIsInstance(mymap.values(), ValuesView)
1872 self.assertIsInstance(mymap.items(), Set)
1873 self.assertIsInstance(mymap.items(), ItemsView)
1874
1875 mymap = UserDict()
1876 mymap['red'] = 5
1877 z = mymap.keys() | {'orange'}
1878 self.assertIsInstance(z, set)
1879 list(z)
1880 mymap['blue'] = 7 # Shouldn't affect 'z'
1881 self.assertEqual(sorted(z), ['orange', 'red'])
1882
1883 mymap = UserDict()
1884 mymap['red'] = 5
1885 z = mymap.items() | {('orange', 3)}
1886 self.assertIsInstance(z, set)
1887 list(z)
1888 mymap['blue'] = 7 # Shouldn't affect 'z'
1889 self.assertEqual(z, {('orange', 3), ('red', 5)})
1890
1891 def test_Sequence(self):
1892 for sample in [tuple, list, bytes, str]:
1893 self.assertIsInstance(sample(), Sequence)
1894 self.assertIsSubclass(sample, Sequence)
1895 self.assertIsInstance(range(10), Sequence)
1896 self.assertIsSubclass(range, Sequence)
1897 self.assertIsInstance(memoryview(b""), Sequence)
1898 self.assertIsSubclass(memoryview, Sequence)
1899 self.assertIsSubclass(str, Sequence)
1900 self.validate_abstract_methods(Sequence, '__len__', '__getitem__')
1901
1902 def test_Sequence_mixins(self):
1903 class SequenceSubclass(Sequence):
1904 def __init__(self, seq=()):
1905 self.seq = seq
1906
1907 def __getitem__(self, index):
1908 return self.seq[index]
1909
1910 def __len__(self):
1911 return len(self.seq)
1912
1913 # Compare Sequence.index() behavior to (list|str).index() behavior
1914 def assert_index_same(seq1, seq2, index_args):
1915 try:
1916 expected = seq1.index(*index_args)
1917 except ValueError:
1918 with self.assertRaises(ValueError):
1919 seq2.index(*index_args)
1920 else:
1921 actual = seq2.index(*index_args)
1922 self.assertEqual(
1923 actual, expected, '%r.index%s' % (seq1, index_args))
1924
1925 for ty in list, str:
1926 nativeseq = ty('abracadabra')
1927 indexes = [-10000, -9999] + list(range(-3, len(nativeseq) + 3))
1928 seqseq = SequenceSubclass(nativeseq)
1929 for letter in set(nativeseq) | {'z'}:
1930 assert_index_same(nativeseq, seqseq, (letter,))
1931 for start in range(-3, len(nativeseq) + 3):
1932 assert_index_same(nativeseq, seqseq, (letter, start))
1933 for stop in range(-3, len(nativeseq) + 3):
1934 assert_index_same(
1935 nativeseq, seqseq, (letter, start, stop))
1936
1937 def test_ByteString(self):
1938 for sample in [bytes, bytearray]:
1939 with self.assertWarns(DeprecationWarning):
1940 self.assertIsInstance(sample(), ByteString)
1941 self.assertTrue(issubclass(sample, ByteString))
1942 for sample in [str, list, tuple]:
1943 with self.assertWarns(DeprecationWarning):
1944 self.assertNotIsInstance(sample(), ByteString)
1945 self.assertFalse(issubclass(sample, ByteString))
1946 with self.assertWarns(DeprecationWarning):
1947 self.assertNotIsInstance(memoryview(b""), ByteString)
1948 self.assertFalse(issubclass(memoryview, ByteString))
1949 with self.assertWarns(DeprecationWarning):
1950 self.validate_abstract_methods(ByteString, '__getitem__', '__len__')
1951
1952 with self.assertWarns(DeprecationWarning):
1953 class X(ByteString): pass
1954
1955 with self.assertWarns(DeprecationWarning):
1956 # No metaclass conflict
1957 class Z(ByteString, Awaitable): pass
1958
1959 def test_Buffer(self):
1960 for sample in [bytes, bytearray, memoryview]:
1961 self.assertIsInstance(sample(b"x"), Buffer)
1962 self.assertIsSubclass(sample, Buffer)
1963 for sample in [str, list, tuple]:
1964 self.assertNotIsInstance(sample(), Buffer)
1965 self.assertNotIsSubclass(sample, Buffer)
1966 self.validate_abstract_methods(Buffer, '__buffer__')
1967
1968 def test_MutableSequence(self):
1969 for sample in [tuple, str, bytes]:
1970 self.assertNotIsInstance(sample(), MutableSequence)
1971 self.assertNotIsSubclass(sample, MutableSequence)
1972 for sample in [list, bytearray, deque]:
1973 self.assertIsInstance(sample(), MutableSequence)
1974 self.assertIsSubclass(sample, MutableSequence)
1975 self.assertIsSubclass(array.array, MutableSequence)
1976 self.assertNotIsSubclass(str, MutableSequence)
1977 self.validate_abstract_methods(MutableSequence, '__len__', '__getitem__',
1978 '__setitem__', '__delitem__', 'insert')
1979
1980 def test_MutableSequence_mixins(self):
1981 # Test the mixins of MutableSequence by creating a minimal concrete
1982 # class inherited from it.
1983 class MutableSequenceSubclass(MutableSequence):
1984 def __init__(self):
1985 self.lst = []
1986
1987 def __setitem__(self, index, value):
1988 self.lst[index] = value
1989
1990 def __getitem__(self, index):
1991 return self.lst[index]
1992
1993 def __len__(self):
1994 return len(self.lst)
1995
1996 def __delitem__(self, index):
1997 del self.lst[index]
1998
1999 def insert(self, index, value):
2000 self.lst.insert(index, value)
2001
2002 mss = MutableSequenceSubclass()
2003 mss.append(0)
2004 mss.extend((1, 2, 3, 4))
2005 self.assertEqual(len(mss), 5)
2006 self.assertEqual(mss[3], 3)
2007 mss.reverse()
2008 self.assertEqual(mss[3], 1)
2009 mss.pop()
2010 self.assertEqual(len(mss), 4)
2011 mss.remove(3)
2012 self.assertEqual(len(mss), 3)
2013 mss += (10, 20, 30)
2014 self.assertEqual(len(mss), 6)
2015 self.assertEqual(mss[-1], 30)
2016 mss.clear()
2017 self.assertEqual(len(mss), 0)
2018
2019 # issue 34427
2020 # extending self should not cause infinite loop
2021 items = 'ABCD'
2022 mss2 = MutableSequenceSubclass()
2023 mss2.extend(items + items)
2024 mss.clear()
2025 mss.extend(items)
2026 mss.extend(mss)
2027 self.assertEqual(len(mss), len(mss2))
2028 self.assertEqual(list(mss), list(mss2))
2029
2030 def test_illegal_patma_flags(self):
2031 with self.assertRaises(TypeError):
2032 class Both(Collection):
2033 __abc_tpflags__ = (Sequence.__flags__ | Mapping.__flags__)
2034
2035
2036
2037 ################################################################################
2038 ### Counter
2039 ################################################################################
2040
2041 class CounterSubclassWithSetItem(Counter):
2042 # Test a counter subclass that overrides __setitem__
2043 def __init__(self, *args, **kwds):
2044 self.called = False
2045 Counter.__init__(self, *args, **kwds)
2046 def __setitem__(self, key, value):
2047 self.called = True
2048 Counter.__setitem__(self, key, value)
2049
2050 class CounterSubclassWithGet(Counter):
2051 # Test a counter subclass that overrides get()
2052 def __init__(self, *args, **kwds):
2053 self.called = False
2054 Counter.__init__(self, *args, **kwds)
2055 def get(self, key, default):
2056 self.called = True
2057 return Counter.get(self, key, default)
2058
2059 class TestCounter(unittest.TestCase):
2060
2061 def test_basics(self):
2062 c = Counter('abcaba')
2063 self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1}))
2064 self.assertEqual(c, Counter(a=3, b=2, c=1))
2065 self.assertIsInstance(c, dict)
2066 self.assertIsInstance(c, Mapping)
2067 self.assertIsSubclass(Counter, dict)
2068 self.assertIsSubclass(Counter, Mapping)
2069 self.assertEqual(len(c), 3)
2070 self.assertEqual(sum(c.values()), 6)
2071 self.assertEqual(list(c.values()), [3, 2, 1])
2072 self.assertEqual(list(c.keys()), ['a', 'b', 'c'])
2073 self.assertEqual(list(c), ['a', 'b', 'c'])
2074 self.assertEqual(list(c.items()),
2075 [('a', 3), ('b', 2), ('c', 1)])
2076 self.assertEqual(c['b'], 2)
2077 self.assertEqual(c['z'], 0)
2078 self.assertEqual(c.__contains__('c'), True)
2079 self.assertEqual(c.__contains__('z'), False)
2080 self.assertEqual(c.get('b', 10), 2)
2081 self.assertEqual(c.get('z', 10), 10)
2082 self.assertEqual(c, dict(a=3, b=2, c=1))
2083 self.assertEqual(repr(c), "Counter({'a': 3, 'b': 2, 'c': 1})")
2084 self.assertEqual(c.most_common(), [('a', 3), ('b', 2), ('c', 1)])
2085 for i in range(5):
2086 self.assertEqual(c.most_common(i),
2087 [('a', 3), ('b', 2), ('c', 1)][:i])
2088 self.assertEqual(''.join(c.elements()), 'aaabbc')
2089 c['a'] += 1 # increment an existing value
2090 c['b'] -= 2 # sub existing value to zero
2091 del c['c'] # remove an entry
2092 del c['c'] # make sure that del doesn't raise KeyError
2093 c['d'] -= 2 # sub from a missing value
2094 c['e'] = -5 # directly assign a missing value
2095 c['f'] += 4 # add to a missing value
2096 self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))
2097 self.assertEqual(''.join(c.elements()), 'aaaaffff')
2098 self.assertEqual(c.pop('f'), 4)
2099 self.assertNotIn('f', c)
2100 for i in range(3):
2101 elem, cnt = c.popitem()
2102 self.assertNotIn(elem, c)
2103 c.clear()
2104 self.assertEqual(c, {})
2105 self.assertEqual(repr(c), 'Counter()')
2106 self.assertRaises(NotImplementedError, Counter.fromkeys, 'abc')
2107 self.assertRaises(TypeError, hash, c)
2108 c.update(dict(a=5, b=3))
2109 c.update(c=1)
2110 c.update(Counter('a' * 50 + 'b' * 30))
2111 c.update() # test case with no args
2112 c.__init__('a' * 500 + 'b' * 300)
2113 c.__init__('cdc')
2114 c.__init__()
2115 self.assertEqual(c, dict(a=555, b=333, c=3, d=1))
2116 self.assertEqual(c.setdefault('d', 5), 1)
2117 self.assertEqual(c['d'], 1)
2118 self.assertEqual(c.setdefault('e', 5), 5)
2119 self.assertEqual(c['e'], 5)
2120
2121 def test_update_reentrant_add_clears_counter(self):
2122 c = Counter()
2123 key = object()
2124
2125 class Evil(int):
2126 def __add__(self, other):
2127 c.clear()
2128 return NotImplemented
2129
2130 c[key] = Evil()
2131 c.update([key])
2132 self.assertEqual(c[key], 1)
2133
2134 def test_init(self):
2135 self.assertEqual(list(Counter(self=42).items()), [('self', 42)])
2136 self.assertEqual(list(Counter(iterable=42).items()), [('iterable', 42)])
2137 self.assertEqual(list(Counter(iterable=None).items()), [('iterable', None)])
2138 self.assertRaises(TypeError, Counter, 42)
2139 self.assertRaises(TypeError, Counter, (), ())
2140 self.assertRaises(TypeError, Counter.__init__)
2141
2142 def test_total(self):
2143 c = Counter(a=10, b=5, c=0)
2144 self.assertEqual(c.total(), 15)
2145
2146 def test_order_preservation(self):
2147 # Input order dictates items() order
2148 self.assertEqual(list(Counter('abracadabra').items()),
2149 [('a', 5), ('b', 2), ('r', 2), ('c', 1), ('d', 1)])
2150 # letters with same count: ^----------^ ^---------^
2151
2152 # Verify retention of order even when all counts are equal
2153 self.assertEqual(list(Counter('xyzpdqqdpzyx').items()),
2154 [('x', 2), ('y', 2), ('z', 2), ('p', 2), ('d', 2), ('q', 2)])
2155
2156 # Input order dictates elements() order
2157 self.assertEqual(list(Counter('abracadabra simsalabim').elements()),
2158 ['a', 'a', 'a', 'a', 'a', 'a', 'a', 'b', 'b', 'b','r',
2159 'r', 'c', 'd', ' ', 's', 's', 'i', 'i', 'm', 'm', 'l'])
2160
2161 # Math operations order first by the order encountered in the left
2162 # operand and then by the order encountered in the right operand.
2163 ps = 'aaabbcdddeefggghhijjjkkl'
2164 qs = 'abbcccdeefffhkkllllmmnno'
2165 order = {letter: i for i, letter in enumerate(dict.fromkeys(ps + qs))}
2166 def correctly_ordered(seq):
2167 'Return true if the letters occur in the expected order'
2168 positions = [order[letter] for letter in seq]
2169 return positions == sorted(positions)
2170
2171 p, q = Counter(ps), Counter(qs)
2172 self.assertTrue(correctly_ordered(+p))
2173 self.assertTrue(correctly_ordered(-p))
2174 self.assertTrue(correctly_ordered(p + q))
2175 self.assertTrue(correctly_ordered(p - q))
2176 self.assertTrue(correctly_ordered(p | q))
2177 self.assertTrue(correctly_ordered(p & q))
2178
2179 p, q = Counter(ps), Counter(qs)
2180 p += q
2181 self.assertTrue(correctly_ordered(p))
2182
2183 p, q = Counter(ps), Counter(qs)
2184 p -= q
2185 self.assertTrue(correctly_ordered(p))
2186
2187 p, q = Counter(ps), Counter(qs)
2188 p |= q
2189 self.assertTrue(correctly_ordered(p))
2190
2191 p, q = Counter(ps), Counter(qs)
2192 p &= q
2193 self.assertTrue(correctly_ordered(p))
2194
2195 p, q = Counter(ps), Counter(qs)
2196 p.update(q)
2197 self.assertTrue(correctly_ordered(p))
2198
2199 p, q = Counter(ps), Counter(qs)
2200 p.subtract(q)
2201 self.assertTrue(correctly_ordered(p))
2202
2203 def test_update(self):
2204 c = Counter()
2205 c.update(self=42)
2206 self.assertEqual(list(c.items()), [('self', 42)])
2207 c = Counter()
2208 c.update(iterable=42)
2209 self.assertEqual(list(c.items()), [('iterable', 42)])
2210 c = Counter()
2211 c.update(iterable=None)
2212 self.assertEqual(list(c.items()), [('iterable', None)])
2213 self.assertRaises(TypeError, Counter().update, 42)
2214 self.assertRaises(TypeError, Counter().update, {}, {})
2215 self.assertRaises(TypeError, Counter.update)
2216
2217 def test_copying(self):
2218 # Check that counters are copyable, deepcopyable, picklable, and
2219 #have a repr/eval round-trip
2220 words = Counter('which witch had which witches wrist watch'.split())
2221 def check(dup):
2222 msg = "\ncopy: %s\nwords: %s" % (dup, words)
2223 self.assertIsNot(dup, words, msg)
2224 self.assertEqual(dup, words)
2225 check(words.copy())
2226 check(copy.copy(words))
2227 check(copy.deepcopy(words))
2228 for proto in range(pickle.HIGHEST_PROTOCOL + 1):
2229 with self.subTest(proto=proto):
2230 check(pickle.loads(pickle.dumps(words, proto)))
2231 check(eval(repr(words)))
2232 update_test = Counter()
2233 update_test.update(words)
2234 check(update_test)
2235 check(Counter(words))
2236
2237 def test_copy_subclass(self):
2238 class MyCounter(Counter):
2239 pass
2240 c = MyCounter('slartibartfast')
2241 d = c.copy()
2242 self.assertEqual(d, c)
2243 self.assertEqual(len(d), len(c))
2244 self.assertEqual(type(d), type(c))
2245
2246 def test_conversions(self):
2247 # Convert to: set, list, dict
2248 s = 'she sells sea shells by the sea shore'
2249 self.assertEqual(sorted(Counter(s).elements()), sorted(s))
2250 self.assertEqual(sorted(Counter(s)), sorted(set(s)))
2251 self.assertEqual(dict(Counter(s)), dict(Counter(s).items()))
2252 self.assertEqual(set(Counter(s)), set(s))
2253
2254 def test_invariant_for_the_in_operator(self):
2255 c = Counter(a=10, b=-2, c=0)
2256 for elem in c:
2257 self.assertTrue(elem in c)
2258 self.assertIn(elem, c)
2259
2260 def test_multiset_operations(self):
2261 # Verify that adding a zero counter will strip zeros and negatives
2262 c = Counter(a=10, b=-2, c=0) + Counter()
2263 self.assertEqual(dict(c), dict(a=10))
2264
2265 elements = 'abcd'
2266 for i in range(1000):
2267 # test random pairs of multisets
2268 p = Counter(dict((elem, randrange(-2,4)) for elem in elements))
2269 p.update(e=1, f=-1, g=0)
2270 q = Counter(dict((elem, randrange(-2,4)) for elem in elements))
2271 q.update(h=1, i=-1, j=0)
2272 for counterop, numberop in [
2273 (Counter.__add__, lambda x, y: max(0, x+y)),
2274 (Counter.__sub__, lambda x, y: max(0, x-y)),
2275 (Counter.__or__, lambda x, y: max(0,x,y)),
2276 (Counter.__and__, lambda x, y: max(0, min(x,y))),
2277 ]:
2278 result = counterop(p, q)
2279 for x in elements:
2280 self.assertEqual(numberop(p[x], q[x]), result[x],
2281 (counterop, x, p, q))
2282 # verify that results exclude non-positive counts
2283 self.assertTrue(x>0 for x in result.values())
2284
2285 elements = 'abcdef'
2286 for i in range(100):
2287 # verify that random multisets with no repeats are exactly like sets
2288 p = Counter(dict((elem, randrange(0, 2)) for elem in elements))
2289 q = Counter(dict((elem, randrange(0, 2)) for elem in elements))
2290 for counterop, setop in [
2291 (Counter.__sub__, set.__sub__),
2292 (Counter.__or__, set.__or__),
2293 (Counter.__and__, set.__and__),
2294 ]:
2295 counter_result = counterop(p, q)
2296 set_result = setop(set(p.elements()), set(q.elements()))
2297 self.assertEqual(counter_result, dict.fromkeys(set_result, 1))
2298
2299 def test_inplace_operations(self):
2300 elements = 'abcd'
2301 for i in range(1000):
2302 # test random pairs of multisets
2303 p = Counter(dict((elem, randrange(-2,4)) for elem in elements))
2304 p.update(e=1, f=-1, g=0)
2305 q = Counter(dict((elem, randrange(-2,4)) for elem in elements))
2306 q.update(h=1, i=-1, j=0)
2307 for inplace_op, regular_op in [
2308 (Counter.__iadd__, Counter.__add__),
2309 (Counter.__isub__, Counter.__sub__),
2310 (Counter.__ior__, Counter.__or__),
2311 (Counter.__iand__, Counter.__and__),
2312 ]:
2313 c = p.copy()
2314 c_id = id(c)
2315 regular_result = regular_op(c, q)
2316 inplace_result = inplace_op(c, q)
2317 self.assertEqual(inplace_result, regular_result)
2318 self.assertEqual(id(inplace_result), c_id)
2319
2320 def test_subtract(self):
2321 c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)
2322 c.subtract(a=1, b=2, c=-3, d=10, e=20, f=30, h=-50)
2323 self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))
2324 c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)
2325 c.subtract(Counter(a=1, b=2, c=-3, d=10, e=20, f=30, h=-50))
2326 self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))
2327 c = Counter('aaabbcd')
2328 c.subtract('aaaabbcce')
2329 self.assertEqual(c, Counter(a=-1, b=0, c=-1, d=1, e=-1))
2330
2331 c = Counter()
2332 c.subtract(self=42)
2333 self.assertEqual(list(c.items()), [('self', -42)])
2334 c = Counter()
2335 c.subtract(iterable=42)
2336 self.assertEqual(list(c.items()), [('iterable', -42)])
2337 self.assertRaises(TypeError, Counter().subtract, 42)
2338 self.assertRaises(TypeError, Counter().subtract, {}, {})
2339 self.assertRaises(TypeError, Counter.subtract)
2340
2341 def test_unary(self):
2342 c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)
2343 self.assertEqual(dict(+c), dict(c=5, d=10, e=15, g=40))
2344 self.assertEqual(dict(-c), dict(a=5))
2345
2346 def test_repr_nonsortable(self):
2347 c = Counter(a=2, b=None)
2348 r = repr(c)
2349 self.assertIn("'a': 2", r)
2350 self.assertIn("'b': None", r)
2351
2352 def test_helper_function(self):
2353 # two paths, one for real dicts and one for other mappings
2354 elems = list('abracadabra')
2355
2356 d = dict()
2357 _count_elements(d, elems)
2358 self.assertEqual(d, {'a': 5, 'r': 2, 'b': 2, 'c': 1, 'd': 1})
2359
2360 m = OrderedDict()
2361 _count_elements(m, elems)
2362 self.assertEqual(m,
2363 OrderedDict([('a', 5), ('b', 2), ('r', 2), ('c', 1), ('d', 1)]))
2364
2365 # test fidelity to the pure python version
2366 c = CounterSubclassWithSetItem('abracadabra')
2367 self.assertTrue(c.called)
2368 self.assertEqual(dict(c), {'a': 5, 'b': 2, 'c': 1, 'd': 1, 'r':2 })
2369 c = CounterSubclassWithGet('abracadabra')
2370 self.assertTrue(c.called)
2371 self.assertEqual(dict(c), {'a': 5, 'b': 2, 'c': 1, 'd': 1, 'r':2 })
2372
2373 def test_multiset_operations_equivalent_to_set_operations(self):
2374 # When the multiplicities are all zero or one, multiset operations
2375 # are guaranteed to be equivalent to the corresponding operations
2376 # for regular sets.
2377 s = list(product(('a', 'b', 'c'), range(2)))
2378 powerset = chain.from_iterable(combinations(s, r) for r in range(len(s)+1))
2379 counters = [Counter(dict(groups)) for groups in powerset]
2380 for cp, cq in product(counters, repeat=2):
2381 sp = set(cp.elements())
2382 sq = set(cq.elements())
2383 self.assertEqual(set(cp + cq), sp | sq)
2384 self.assertEqual(set(cp - cq), sp - sq)
2385 self.assertEqual(set(cp | cq), sp | sq)
2386 self.assertEqual(set(cp & cq), sp & sq)
2387 self.assertEqual(cp == cq, sp == sq)
2388 self.assertEqual(cp != cq, sp != sq)
2389 self.assertEqual(cp <= cq, sp <= sq)
2390 self.assertEqual(cp >= cq, sp >= sq)
2391 self.assertEqual(cp < cq, sp < sq)
2392 self.assertEqual(cp > cq, sp > sq)
2393
2394 def test_eq(self):
2395 self.assertEqual(Counter(a=3, b=2, c=0), Counter('ababa'))
2396 self.assertNotEqual(Counter(a=3, b=2), Counter('babab'))
2397
2398 def test_le(self):
2399 self.assertTrue(Counter(a=3, b=2, c=0) <= Counter('ababa'))
2400 self.assertFalse(Counter(a=3, b=2) <= Counter('babab'))
2401
2402 def test_lt(self):
2403 self.assertTrue(Counter(a=3, b=1, c=0) < Counter('ababa'))
2404 self.assertFalse(Counter(a=3, b=2, c=0) < Counter('ababa'))
2405
2406 def test_ge(self):
2407 self.assertTrue(Counter(a=2, b=1, c=0) >= Counter('aab'))
2408 self.assertFalse(Counter(a=3, b=2, c=0) >= Counter('aabd'))
2409
2410 def test_gt(self):
2411 self.assertTrue(Counter(a=3, b=2, c=0) > Counter('aab'))
2412 self.assertFalse(Counter(a=2, b=1, c=0) > Counter('aab'))
2413
2414
2415 def load_tests(loader, tests, pattern):
2416 tests.addTest(doctest.DocTestSuite(collections))
2417 return tests
2418
2419
2420 if __name__ == "__main__":
2421 unittest.main()