Lines Matching refs:self

32     def _superset_test(self, a, b):
33 self.assertGreaterEqual(
42 def _copy_test(self, obj):
45 self.assertIsNot(obj.data, obj_copy.data)
46 self.assertEqual(obj.data, obj_copy.data)
51 self.assertIsNot(obj.data, obj_copy.data)
52 self.assertEqual(obj.data, obj_copy.data)
53 self.assertIs(obj.test, obj_copy.test)
55 def test_str_protocol(self):
56 self._superset_test(UserString, str)
58 def test_list_protocol(self):
59 self._superset_test(UserList, list)
61 def test_dict_protocol(self):
62 self._superset_test(UserDict, dict)
64 def test_list_copy(self):
67 self._copy_test(obj)
69 def test_dict_copy(self):
72 self._copy_test(obj)
81 def test_basics(self):
88 self.assertEqual(d.maps, [{'b':20, 'c':30}, {'a':1, 'b':2}]) # check internal state
89 self.assertEqual(d.items(), dict(a=1, b=20, c=30).items()) # check items/iter/getitem
90 self.assertEqual(len(d), 3) # check len
92 self.assertIn(key, d)
94 self.assertEqual(d.get(k, 100), v)
97 self.assertEqual(d.maps, [{'c':30}, {'a':1, 'b':2}]) # check internal state
98 self.assertEqual(d.items(), dict(a=1, b=2, c=30).items()) # check items/iter/getitem
99 self.assertEqual(len(d), 3) # check len
101 self.assertIn(key, d)
103 self.assertEqual(d.get(k, 100), v)
104 self.assertIn(repr(d), [ # check repr
110 self.assertEqual(d, e)
111 self.assertEqual(d.maps, e.maps)
112 self.assertIsNot(d, e)
113 self.assertIsNot(d.maps[0], e.maps[0])
115 self.assertIs(m1, m2)
120 self.assertEqual(d, e)
121 self.assertEqual(d.maps, e.maps)
122 self.assertIsNot(d, e)
124 self.assertIsNot(m1, m2, e)
128 self.assertEqual(d, e)
129 self.assertEqual(d.maps, e.maps)
130 self.assertIsNot(d, e)
132 self.assertIsNot(m1, m2, e)
136 self.assertEqual(f.maps, [{'b': 5}, {'c':30}, {'a':1, 'b':2}])
137 self.assertEqual(f.parents.maps, [{'c':30}, {'a':1, 'b':2}]) # check parents
138 self.assertEqual(f['b'], 5) # find first in chain
139 self.assertEqual(f.parents['b'], 2) # look beyond maps[0]
141 def test_ordering(self):
153 self.assertEqual(list(combined.items()), list(cm.items()))
155 def test_constructor(self):
156 self.assertEqual(ChainMap().maps, [{}]) # no-args --> one new dict
157 self.assertEqual(ChainMap({1:2}).maps, [{1:2}]) # 1 arg --> list
159 def test_bool(self):
160 self.assertFalse(ChainMap())
161 self.assertFalse(ChainMap({}, {}))
162 self.assertTrue(ChainMap({1:2}, {}))
163 self.assertTrue(ChainMap({}, {1:2}))
165 def test_missing(self):
167 def __missing__(self, key):
171 self.assertEqual(d[k], v) # check __getitem__ w/missing
173 self.assertEqual(d.get(k, 77), v) # check get() w/ missing
175 self.assertEqual(k in d, v) # check __contains__ w/missing
176 self.assertEqual(d.pop('a', 1001), 1, d)
177 self.assertEqual(d.pop('a', 1002), 1002) # check pop() w/missing
178 self.assertEqual(d.popitem(), ('b', 2)) # check popitem() w/missing
179 with self.assertRaises(KeyError):
182 def test_order_preservation(self):
193 self.assertEqual(''.join(d), 'abcdefghij')
194 self.assertEqual(list(d.items()),
199 def test_iter_not_calling_getitem_on_maps(self):
201 def __init__(self, *args, **kwds):
202 self.called = False
203 UserDict.__init__(self, *args, **kwds)
204 def __getitem__(self, item):
205 self.called = True
206 UserDict.__getitem__(self, item)
213 self.assertFalse(d.called, '__getitem__ was called')
215 def test_dict_coercion(self):
217 self.assertEqual(dict(d), dict(a=1, b=2, c=30))
218 self.assertEqual(dict(d.items()), dict(a=1, b=2, c=30))
220 def test_new_child(self):
227 self.assertEqual(d.maps, [{'b':20, 'c':30}, {'a':1, 'b':2}]) # check internal state
228 self.assertIs(m, d.maps[0])
232 def __getitem__(self, key):
235 return dict.__getitem__(self, key)
236 def __contains__(self, key):
239 return dict.__contains__(self, key)
246 self.assertIs(m, d.maps[0])
248 self.assertIn(key, d)
250 self.assertEqual(d.get(k, 100), v)
254 self.assertEqual(d.maps, [{'b': 20, 'c': 30}, {'a': 1, 'b': 2}])
256 def test_union_operators(self):
264 self.assertEqual(tmp.maps, [cm1.maps[0] | dict(cm2), *cm1.maps[1:]])
266 self.assertEqual(tmp, cm1)
269 self.assertEqual(tmp.maps, [cm2.maps[0] | d, *cm2.maps[1:]])
270 self.assertEqual((d | cm2).maps, [d | dict(cm2)])
272 self.assertEqual(tmp, cm2)
275 with self.assertRaises(TypeError):
279 self.assertEqual(cm3.maps, [tmp.maps[0] | dict(pairs), *tmp.maps[1:]])
286 def __ror__(self, other):
290 self.assertIs(type(tmp), ChainMap)
291 self.assertIs(type(tmp.maps[0]), dict)
293 self.assertIs(type(tmp), ChainMap)
294 self.assertIs(type(tmp.maps[0]), dict)
296 self.assertIs(type(tmp), Subclass)
297 self.assertIs(type(tmp.maps[0]), dict)
299 self.assertIs(type(tmp), SubclassRor)
300 self.assertIs(type(tmp.maps[0]), dict)
311 def test_factory(self):
313 self.assertEqual(Point.__name__, 'Point')
314 self.assertEqual(Point.__slots__, ())
315 self.assertEqual(Point.__module__, __name__)
316 self.assertEqual(Point.__getitem__, tuple.__getitem__)
317 self.assertEqual(Point._fields, ('x', 'y'))
319 self.assertRaises(ValueError, namedtuple, 'abc%', 'efg ghi') # type has non-alpha char
320 self.assertRaises(ValueError, namedtuple, 'class', 'efg ghi') # type has keyword
321 self.assertRaises(ValueError, namedtuple, '9abc', 'efg ghi') # type starts with digit
323 self.assertRaises(ValueError, namedtuple, 'abc', 'efg g%hi') # field with non-alpha char
324 self.assertRaises(ValueError, namedtuple, 'abc', 'abc class') # field has keyword
325 self.assertRaises(ValueError, namedtuple, 'abc', '8efg 9ghi') # field starts with digit
326 self.assertRaises(ValueError, namedtuple, 'abc', '_efg ghi') # field with leading underscore
327 self.assertRaises(ValueError, namedtuple, 'abc', 'efg efg ghi') # duplicate field
333 self.assertNotIn("u'", repr(nt._fields))
335 self.assertNotIn("u'", repr(nt._fields))
337 self.assertRaises(TypeError, Point._make, [11]) # catch too few args
338 self.assertRaises(TypeError, Point._make, [11, 22, 33]) # catch too many args
340 def test_defaults(self):
342 self.assertEqual(Point._field_defaults, {'x': 10, 'y': 20})
343 self.assertEqual(Point(1, 2), (1, 2))
344 self.assertEqual(Point(1), (1, 20))
345 self.assertEqual(Point(), (10, 20))
348 self.assertEqual(Point._field_defaults, {'y': 20})
349 self.assertEqual(Point(1, 2), (1, 2))
350 self.assertEqual(Point(1), (1, 20))
353 self.assertEqual(Point._field_defaults, {})
354 self.assertEqual(Point(1, 2), (1, 2))
355 with self.assertRaises(TypeError):
358 with self.assertRaises(TypeError): # catch too few args
360 with self.assertRaises(TypeError): # catch too many args
362 with self.assertRaises(TypeError): # too many defaults
364 with self.assertRaises(TypeError): # non-iterable defaults
366 with self.assertRaises(TypeError): # another non-iterable default
370 self.assertEqual(Point._field_defaults, {})
371 self.assertIsNone(Point.__new__.__defaults__, None)
372 self.assertEqual(Point(10, 20), (10, 20))
373 with self.assertRaises(TypeError): # catch too few args
377 self.assertEqual(Point._field_defaults, {'x': 10, 'y': 20})
378 self.assertEqual(Point.__new__.__defaults__, (10, 20))
379 self.assertEqual(Point(1, 2), (1, 2))
380 self.assertEqual(Point(1), (1, 20))
381 self.assertEqual(Point(), (10, 20))
384 self.assertEqual(Point._field_defaults, {'x': 10, 'y': 20})
385 self.assertEqual(Point.__new__.__defaults__, (10, 20))
386 self.assertEqual(Point(1, 2), (1, 2))
387 self.assertEqual(Point(1), (1, 20))
388 self.assertEqual(Point(), (10, 20))
390 def test_readonly(self):
393 with self.assertRaises(AttributeError):
395 with self.assertRaises(AttributeError):
397 with self.assertRaises(TypeError):
399 with self.assertRaises(TypeError):
401 self.assertEqual(p.x, 11)
402 self.assertEqual(p[0], 11)
406 def test_factory_doc_attr(self):
408 self.assertEqual(Point.__doc__, 'Point(x, y)')
410 self.assertEqual(Point.__doc__, '2D point')
414 def test_field_doc(self):
416 self.assertEqual(Point.x.__doc__, 'Alias for field number 0')
417 self.assertEqual(Point.y.__doc__, 'Alias for field number 1')
419 self.assertEqual(Point.x.__doc__, 'docstring for Point.x')
422 self.assertEqual(Vector.x.__doc__, 'Alias for field number 0')
424 self.assertEqual(Vector.x.__doc__, 'docstring for Vector.x')
429 def test_field_doc_reuse(self):
432 self.assertIs(P.m.__doc__, Q.o.__doc__)
433 self.assertIs(P.n.__doc__, Q.p.__doc__)
436 def test_field_repr(self):
438 self.assertEqual(repr(Point.x), "_tuplegetter(0, 'Alias for field number 0')")
439 self.assertEqual(repr(Point.y), "_tuplegetter(1, 'Alias for field number 1')")
444 self.assertEqual(repr(Point.x), "_tuplegetter(0, 'The x-coordinate')")
445 self.assertEqual(repr(Point.y), "_tuplegetter(1, 'The y-coordinate')")
447 def test_name_fixer(self):
456 self.assertEqual(namedtuple('NT', spec, rename=True)._fields, renamed)
458 def test_module_parameter(self):
460 self.assertEqual(NT.__module__, collections)
462 def test_instance(self):
465 self.assertEqual(p, Point(x=11, y=22))
466 self.assertEqual(p, Point(11, y=22))
467 self.assertEqual(p, Point(y=22, x=11))
468 self.assertEqual(p, Point(*(11, 22)))
469 self.assertEqual(p, Point(**dict(x=11, y=22)))
470 self.assertRaises(TypeError, Point, 1) # too few args
471 self.assertRaises(TypeError, Point, 1, 2, 3) # too many args
472 with self.assertRaises(TypeError): # wrong keyword argument
474 with self.assertRaises(TypeError): # missing keyword argument
476 self.assertEqual(repr(p), 'Point(x=11, y=22)')
477 self.assertNotIn('__weakref__', dir(p))
478 self.assertEqual(p, Point._make([11, 22])) # test _make classmethod
479 self.assertEqual(p._fields, ('x', 'y')) # test _fields attribute
480 self.assertEqual(p._replace(x=1), (1, 22)) # test _replace method
481 self.assertEqual(p._asdict(), dict(x=11, y=22)) # test _asdict method
488 self._fail('Did not detect an incorrect fieldname')
493 self.assertEqual(repr(p), 'Point(x=11, y=22)')
498 self.assertEqual(repr(p), 'Point(x=11, y=22)')
500 def test_tupleness(self):
504 self.assertIsInstance(p, tuple)
505 self.assertEqual(p, (11, 22)) # matches a real tuple
506 self.assertEqual(tuple(p), (11, 22)) # coercible to a real tuple
507 self.assertEqual(list(p), [11, 22]) # coercible to a list
508 self.assertEqual(max(p), 22) # iterable
509 self.assertEqual(max(*p), 22) # star-able
511 self.assertEqual(p, (x, y)) # unpacks like a tuple
512 self.assertEqual((p[0], p[1]), (11, 22)) # indexable like a tuple
513 with self.assertRaises(IndexError):
515 self.assertEqual(p[-1], 22)
516 self.assertEqual(hash(p), hash((11, 22)))
518 self.assertEqual(p.x, x)
519 self.assertEqual(p.y, y)
520 with self.assertRaises(AttributeError):
523 def test_odd_sizes(self):
525 self.assertEqual(Zero(), ())
526 self.assertEqual(Zero._make([]), ())
527 self.assertEqual(repr(Zero()), 'Zero()')
528 self.assertEqual(Zero()._asdict(), {})
529 self.assertEqual(Zero()._fields, ())
532 self.assertEqual(Dot(1), (1,))
533 self.assertEqual(Dot._make([1]), (1,))
534 self.assertEqual(Dot(1).d, 1)
535 self.assertEqual(repr(Dot(1)), 'Dot(d=1)')
536 self.assertEqual(Dot(1)._asdict(), {'d':1})
537 self.assertEqual(Dot(1)._replace(d=999), (999,))
538 self.assertEqual(Dot(1)._fields, ('d',))
546 self.assertEqual(b, tuple(range(n)))
547 self.assertEqual(Big._make(range(n)), tuple(range(n)))
549 self.assertEqual(getattr(b, name), pos)
553 self.assertEqual(d, d_expected)
558 self.assertEqual(b2, tuple(b2_expected))
559 self.assertEqual(b._fields, tuple(names))
561 def test_pickle(self):
568 self.assertEqual(p, q)
569 self.assertEqual(p._fields, q._fields)
570 self.assertNotIn(b'OrderedDict', dumps(p, protocol))
572 def test_copy(self):
576 self.assertEqual(p, q)
577 self.assertEqual(p._fields, q._fields)
579 def test_name_conflicts(self):
580 # Some names like "self", "cls", "tuple", "itemgetter", and "property"
582 T = namedtuple('T', 'itemgetter property self cls tuple')
584 self.assertEqual(t, (1,2,3,4,5))
585 newt = t._replace(itemgetter=10, property=20, self=30, cls=40, tuple=50)
586 self.assertEqual(newt, (10,20,30,40,50))
613 'self', 'sequence', 'set', 'side', 'specified', 'split', 'start',
623 self.assertEqual(t, values)
625 self.assertEqual(t, values)
628 self.assertEqual(t, values)
632 self.assertEqual(t._asdict(), dict(zip(T._fields, values)))
637 self.assertEqual(newt, newvalues)
639 self.assertEqual(T._fields, tuple(words))
641 self.assertEqual(t.__getnewargs__(), values)
643 def test_repr(self):
645 self.assertEqual(repr(A(1)), 'A(x=1)')
649 self.assertEqual(repr(B(1)), 'B(x=1)')
651 def test_keyword_only_arguments(self):
653 with self.assertRaises(TypeError):
657 self.assertEqual(NT._fields, ('abc', '_1'))
658 with self.assertRaises(TypeError):
661 def test_namedtuple_subclass_issue_24931(self):
666 self.assertEqual(a._asdict(), OrderedDict([('x', 3), ('y', 4)]))
669 self.assertEqual(a.__dict__, {'w': 5})
672 def test_field_descriptor(self):
675 self.assertTrue(inspect.isdatadescriptor(Point.x))
676 self.assertEqual(Point.x.__get__(p), 11)
677 self.assertRaises(AttributeError, Point.x.__set__, p, 33)
678 self.assertRaises(AttributeError, Point.x.__delete__, p)
681 with self.subTest(proto=proto):
688 self.assertEqual(np.x, 1)
689 self.assertEqual(np.y, 2)
691 def test_new_builtins_issue_43102(self):
694 self.assertEqual(new_func.__globals__['__builtins__'], {})
695 self.assertEqual(new_func.__builtins__, {})
697 def test_match_args(self):
699 self.assertEqual(Point.__match_args__, ('x', 'y'))
701 def test_non_generic_subscript(self):
706 self.assertEqual(A.__origin__, Group)
707 self.assertEqual(A.__parameters__, ())
708 self.assertEqual(A.__args__, (int, list[int]))
710 self.assertIs(type(a), Group)
711 self.assertEqual(a, (1, [2]))
720 def validate_abstract_methods(self, abc, *names):
732 self.assertRaises(TypeError, C, name)
734 def validate_isinstance(self, abc, name):
739 self.assertIsInstance(C(), abc)
740 self.assertTrue(issubclass(C, abc))
743 self.assertNotIsInstance(C(), abc)
744 self.assertFalse(issubclass(C, abc))
746 def validate_comparison(self, instance):
754 def __init__(self):
755 self.right_side = False
756 def __eq__(self, other):
757 self.right_side = True
774 self.assertTrue(other.right_side,'Right side not called for %s.%s'
782 def test_Awaitable(self):
794 def __await__(self):
798 def send(self, value):
800 def throw(self, typ, val=None, tb=None):
802 def __await__(self):
805 self.validate_abstract_methods(Awaitable, '__await__')
809 self.assertNotIsInstance(x, Awaitable)
810 self.assertFalse(issubclass(type(x), Awaitable), repr(type(x)))
814 self.assertIsInstance(x, Awaitable)
815 self.assertTrue(issubclass(type(x), Awaitable))
821 self.assertNotIsInstance(c, Awaitable)
824 self.assertIsInstance(c, Awaitable)
829 self.assertTrue(isinstance(CoroLike(), Awaitable))
830 self.assertTrue(issubclass(CoroLike, Awaitable))
834 def test_Coroutine(self):
846 def __await__(self):
850 def send(self, value):
852 def throw(self, typ, val=None, tb=None):
854 def __await__(self):
857 self.validate_abstract_methods(Coroutine, '__await__', 'send', 'throw')
861 self.assertNotIsInstance(x, Coroutine)
862 self.assertFalse(issubclass(type(x), Coroutine), repr(type(x)))
866 self.assertIsInstance(x, Awaitable)
867 self.assertTrue(issubclass(type(x), Awaitable))
873 self.assertNotIsInstance(c, Coroutine)
876 self.assertIsInstance(c, Coroutine)
880 def send(self, value):
882 def throw(self, typ, val=None, tb=None):
884 def close(self):
886 def __await__(self):
888 self.assertTrue(isinstance(CoroLike(), Coroutine))
889 self.assertTrue(issubclass(CoroLike, Coroutine))
892 def send(self, value):
894 def close(self):
896 def __await__(self):
898 self.assertFalse(isinstance(CoroLike(), Coroutine))
899 self.assertFalse(issubclass(CoroLike, Coroutine))
901 def test_Hashable(self):
905 self.assertNotIsInstance(x, Hashable)
906 self.assertFalse(issubclass(type(x), Hashable), repr(type(x)))
915 self.assertIsInstance(x, Hashable)
916 self.assertTrue(issubclass(type(x), Hashable), repr(type(x)))
917 self.assertRaises(TypeError, Hashable)
920 def __hash__(self):
922 self.assertEqual(hash(H()), 0)
923 self.assertFalse(issubclass(int, H))
924 self.validate_abstract_methods(Hashable, '__hash__')
925 self.validate_isinstance(Hashable, '__hash__')
927 def test_AsyncIterable(self):
929 def __aiter__(self):
930 return self
931 self.assertTrue(isinstance(AI(), AsyncIterable))
932 self.assertTrue(issubclass(AI, AsyncIterable))
936 self.assertNotIsInstance(x, AsyncIterable)
937 self.assertFalse(issubclass(type(x), AsyncIterable), repr(type(x)))
938 self.validate_abstract_methods(AsyncIterable, '__aiter__')
939 self.validate_isinstance(AsyncIterable, '__aiter__')
941 def test_AsyncIterator(self):
943 def __aiter__(self):
944 return self
945 async def __anext__(self):
947 self.assertTrue(isinstance(AI(), AsyncIterator))
948 self.assertTrue(issubclass(AI, AsyncIterator))
952 self.assertNotIsInstance(x, AsyncIterator)
953 self.assertFalse(issubclass(type(x), AsyncIterator), repr(type(x)))
956 async def __anext__(self):
958 self.assertNotIsInstance(AnextOnly(), AsyncIterator)
959 self.validate_abstract_methods(AsyncIterator, '__anext__', '__aiter__')
961 def test_Iterable(self):
965 self.assertNotIsInstance(x, Iterable)
966 self.assertFalse(issubclass(type(x), Iterable), repr(type(x)))
975 self.assertIsInstance(x, Iterable)
976 self.assertTrue(issubclass(type(x), Iterable), repr(type(x)))
979 def __iter__(self):
981 self.assertEqual(list(I()), [])
982 self.assertFalse(issubclass(str, I))
983 self.validate_abstract_methods(Iterable, '__iter__')
984 self.validate_isinstance(Iterable, '__iter__')
987 def __iter__(self): return iter([])
990 self.assertTrue(issubclass(It, Iterable))
991 self.assertTrue(isinstance(It(), Iterable))
992 self.assertFalse(issubclass(ItBlocked, Iterable))
993 self.assertFalse(isinstance(ItBlocked(), Iterable))
995 def test_Reversible(self):
999 self.assertNotIsInstance(x, Reversible)
1000 self.assertFalse(issubclass(type(x), Reversible), repr(type(x)))
1004 self.assertNotIsInstance(x, Reversible)
1005 self.assertFalse(issubclass(type(x), Reversible), repr(type(x)))
1013 self.assertIsInstance(x, Reversible)
1014 self.assertTrue(issubclass(type(x), Reversible), repr(type(x)))
1016 self.assertTrue(issubclass(Sequence, Reversible), repr(Sequence))
1017 self.assertFalse(issubclass(Mapping, Reversible), repr(Mapping))
1018 self.assertFalse(issubclass(MutableMapping, Reversible), repr(MutableMapping))
1021 def __iter__(self):
1023 def __reversed__(self):
1025 self.assertEqual(list(reversed(R())), [])
1026 self.assertFalse(issubclass(float, R))
1027 self.validate_abstract_methods(Reversible, '__reversed__', '__iter__')
1030 def __reversed__(self): return reversed([])
1032 def __iter__(self): return iter([])
1033 self.assertFalse(issubclass(RevNoIter, Reversible))
1034 self.assertFalse(isinstance(RevNoIter(), Reversible))
1035 self.assertTrue(issubclass(RevPlusIter, Reversible))
1036 self.assertTrue(isinstance(RevPlusIter(), Reversible))
1039 def __iter__(self): return iter([])
1040 def __reversed__(self): return reversed([])
1045 self.assertTrue(issubclass(Rev, Reversible))
1046 self.assertTrue(isinstance(Rev(), Reversible))
1047 self.assertFalse(issubclass(RevItBlocked, Reversible))
1048 self.assertFalse(isinstance(RevItBlocked(), Reversible))
1049 self.assertFalse(issubclass(RevRevBlocked, Reversible))
1050 self.assertFalse(isinstance(RevRevBlocked(), Reversible))
1052 def test_Collection(self):
1056 self.assertNotIsInstance(x, Collection)
1057 self.assertFalse(issubclass(type(x), Collection), repr(type(x)))
1062 self.assertNotIsInstance(x, Collection)
1063 self.assertFalse(issubclass(type(x), Collection), repr(type(x)))
1068 self.assertIsInstance(x, Collection)
1069 self.assertTrue(issubclass(type(x), Collection), repr(type(x)))
1071 self.assertTrue(issubclass(Sequence, Collection), repr(Sequence))
1072 self.assertTrue(issubclass(Mapping, Collection), repr(Mapping))
1073 self.assertTrue(issubclass(MutableMapping, Collection),
1075 self.assertTrue(issubclass(Set, Collection), repr(Set))
1076 self.assertTrue(issubclass(MutableSet, Collection), repr(MutableSet))
1077 self.assertTrue(issubclass(Sequence, Collection), repr(MutableSet))
1080 def __iter__(self):
1082 def __len__(self):
1084 def __contains__(self, item):
1087 self.assertEqual(list(iter(Col())), [])
1088 self.assertFalse(issubclass(list, Col))
1089 self.assertFalse(issubclass(set, Col))
1090 self.assertFalse(issubclass(float, Col))
1091 self.assertEqual(list(iter(DerCol())), [])
1092 self.assertFalse(issubclass(list, DerCol))
1093 self.assertFalse(issubclass(set, DerCol))
1094 self.assertFalse(issubclass(float, DerCol))
1095 self.validate_abstract_methods(Collection, '__len__', '__iter__',
1099 def __len__(self): return 0
1100 def __contains__(self, item): return False
1102 def __iter__(self): return iter([])
1103 def __contains__(self, item): return False
1105 def __iter__(self): return iter([])
1106 def __len__(self): return 0
1107 self.assertFalse(issubclass(ColNoIter, Collection))
1108 self.assertFalse(isinstance(ColNoIter(), Collection))
1109 self.assertFalse(issubclass(ColNoSize, Collection))
1110 self.assertFalse(isinstance(ColNoSize(), Collection))
1111 self.assertFalse(issubclass(ColNoCont, Collection))
1112 self.assertFalse(isinstance(ColNoCont(), Collection))
1115 def __iter__(self): return iter([])
1116 def __contains__(self): return False
1119 def __len__(self): return 0
1120 def __contains__(self): return True
1122 self.assertFalse(issubclass(SizeBlock, Collection))
1123 self.assertFalse(isinstance(SizeBlock(), Collection))
1124 self.assertFalse(issubclass(IterBlock, Collection))
1125 self.assertFalse(isinstance(IterBlock(), Collection))
1128 def __iter__(self):
1130 def __len__(self):
1132 def __contains__(self, item):
1136 self.assertFalse(issubclass(NonCol, Collection))
1137 self.assertFalse(isinstance(NonCol(), Collection))
1140 def test_Iterator(self):
1143 self.assertNotIsInstance(x, Iterator)
1144 self.assertFalse(issubclass(type(x), Iterator), repr(type(x)))
1154 self.assertIsInstance(x, Iterator)
1155 self.assertTrue(issubclass(type(x), Iterator), repr(type(x)))
1156 self.validate_abstract_methods(Iterator, '__next__', '__iter__')
1160 def __next__(self):
1163 self.assertNotIsInstance(NextOnly(), Iterator)
1165 def test_Generator(self):
1167 def __iter__(self): return self
1168 def __next__(self): return None
1169 def close(self): pass
1170 def throw(self, typ, val=None, tb=None): pass
1173 def __iter__(self): return self
1174 def __next__(self): return None
1175 def close(self): pass
1176 def send(self, value): return value
1179 def close(self): pass
1180 def send(self, value): return value
1181 def throw(self, typ, val=None, tb=None): pass
1187 self.assertNotIsInstance(x, Generator)
1188 self.assertFalse(issubclass(type(x), Generator), repr(type(x)))
1191 def __iter__(self): return self
1192 def __next__(self): return None
1193 def close(self): pass
1194 def send(self, value): return value
1195 def throw(self, typ, val=None, tb=None): pass
1198 def send(self, value):
1200 def throw(self, typ, val=None, tb=None):
1208 self.assertIsInstance(x, Iterator)
1209 self.assertIsInstance(x, Generator)
1210 self.assertTrue(issubclass(type(x), Generator), repr(type(x)))
1211 self.validate_abstract_methods(Generator, 'send', 'throw')
1215 self.assertIs(mgen, iter(mgen))
1216 self.assertIs(mgen.send(None), next(mgen))
1217 self.assertEqual(2, mgen.send(2))
1218 self.assertIsNone(mgen.close())
1219 self.assertRaises(ValueError, mgen.throw, ValueError)
1220 self.assertRaisesRegex(ValueError, "^huhu$",
1222 self.assertRaises(StopIteration, mgen.throw, StopIteration())
1225 def send(self, value): return value
1226 def throw(self, *args): raise ValueError
1228 self.assertRaises(ValueError, FailOnClose().close)
1231 def send(self, value): return value
1232 def throw(self, *args): pass
1234 self.assertRaises(RuntimeError, IgnoreGeneratorExit().close)
1236 def test_AsyncGenerator(self):
1238 def __aiter__(self): return self
1239 def __anext__(self): return None
1240 def aclose(self): pass
1241 def athrow(self, typ, val=None, tb=None): pass
1244 def __aiter__(self): return self
1245 def __anext__(self): return None
1246 def aclose(self): pass
1247 def asend(self, value): return value
1250 def aclose(self): pass
1251 def asend(self, value): return value
1252 def athrow(self, typ, val=None, tb=None): pass
1258 self.assertNotIsInstance(x, AsyncGenerator)
1259 self.assertFalse(issubclass(type(x), AsyncGenerator), repr(type(x)))
1262 def __aiter__(self): return self
1263 async def __anext__(self): return None
1264 async def aclose(self): pass
1265 async def asend(self, value): return value
1266 async def athrow(self, typ, val=None, tb=None): pass
1269 async def asend(self, value):
1271 async def athrow(self, typ, val=None, tb=None):
1279 self.assertIsInstance(x, AsyncIterator)
1280 self.assertIsInstance(x, AsyncGenerator)
1281 self.assertTrue(issubclass(type(x), AsyncGenerator), repr(type(x)))
1282 self.validate_abstract_methods(AsyncGenerator, 'asend', 'athrow')
1296 self.assertIs(mgen, mgen.__aiter__())
1297 self.assertIs(run_async(mgen.asend(None)), run_async(mgen.__anext__()))
1298 self.assertEqual(2, run_async(mgen.asend(2)))
1299 self.assertIsNone(run_async(mgen.aclose()))
1300 with self.assertRaises(ValueError):
1304 async def asend(self, value): return value
1305 async def athrow(self, *args): raise ValueError
1307 with self.assertRaises(ValueError):
1311 async def asend(self, value): return value
1312 async def athrow(self, *args): pass
1314 with self.assertRaises(RuntimeError):
1317 def test_Sized(self):
1323 self.assertNotIsInstance(x, Sized)
1324 self.assertFalse(issubclass(type(x), Sized), repr(type(x)))
1330 self.assertIsInstance(x, Sized)
1331 self.assertTrue(issubclass(type(x), Sized), repr(type(x)))
1332 self.validate_abstract_methods(Sized, '__len__')
1333 self.validate_isinstance(Sized, '__len__')
1335 def test_Container(self):
1341 self.assertNotIsInstance(x, Container)
1342 self.assertFalse(issubclass(type(x), Container), repr(type(x)))
1348 self.assertIsInstance(x, Container)
1349 self.assertTrue(issubclass(type(x), Container), repr(type(x)))
1350 self.validate_abstract_methods(Container, '__contains__')
1351 self.validate_isinstance(Container, '__contains__')
1353 def test_Callable(self):
1360 self.assertNotIsInstance(x, Callable)
1361 self.assertFalse(issubclass(type(x), Callable), repr(type(x)))
1368 self.assertIsInstance(x, Callable)
1369 self.assertTrue(issubclass(type(x), Callable), repr(type(x)))
1370 self.validate_abstract_methods(Callable, '__call__')
1371 self.validate_isinstance(Callable, '__call__')
1373 def test_direct_subclassing(self):
1377 self.assertTrue(issubclass(C, B))
1378 self.assertFalse(issubclass(int, C))
1380 def test_registration(self):
1384 self.assertFalse(issubclass(C, B), B.__name__)
1386 self.assertTrue(issubclass(C, B))
1390 def __init__(self, it=()):
1391 self.data = set(it)
1393 def __len__(self):
1394 return len(self.data)
1396 def __iter__(self):
1397 return iter(self.data)
1399 def __contains__(self, item):
1400 return item in self.data
1402 def add(self, item):
1403 self.data.add(item)
1405 def discard(self, item):
1406 self.data.discard(item)
1414 def test_Set(self):
1416 self.assertIsInstance(sample(), Set)
1417 self.assertTrue(issubclass(sample, Set))
1418 self.validate_abstract_methods(Set, '__contains__', '__iter__', '__len__')
1420 def __contains__(self, x):
1422 def __len__(self):
1424 def __iter__(self):
1426 self.validate_comparison(MySet())
1428 def test_hash_Set(self):
1430 def __init__(self):
1431 self.contents = [1, 2, 3]
1432 def __contains__(self, x):
1433 return x in self.contents
1434 def __len__(self):
1435 return len(self.contents)
1436 def __iter__(self):
1437 return iter(self.contents)
1438 def __hash__(self):
1439 return self._hash()
1441 self.assertTrue(hash(a) == hash(b))
1443 def test_isdisjoint_Set(self):
1445 def __init__(self, itr):
1446 self.contents = itr
1447 def __contains__(self, x):
1448 return x in self.contents
1449 def __iter__(self):
1450 return iter(self.contents)
1451 def __len__(self):
1452 return len([x for x in self.contents])
1456 self.assertTrue(s1.isdisjoint(s2))
1457 self.assertFalse(s1.isdisjoint(s3))
1459 def test_equality_Set(self):
1461 def __init__(self, itr):
1462 self.contents = itr
1463 def __contains__(self, x):
1464 return x in self.contents
1465 def __iter__(self):
1466 return iter(self.contents)
1467 def __len__(self):
1468 return len([x for x in self.contents])
1473 self.assertTrue(s2 > s1)
1474 self.assertTrue(s1 < s2)
1475 self.assertFalse(s2 <= s1)
1476 self.assertFalse(s2 <= s3)
1477 self.assertFalse(s1 >= s2)
1478 self.assertEqual(s3, s4)
1479 self.assertNotEqual(s2, s3)
1481 def test_arithmetic_Set(self):
1483 def __init__(self, itr):
1484 self.contents = itr
1485 def __contains__(self, x):
1486 return x in self.contents
1487 def __iter__(self):
1488 return iter(self.contents)
1489 def __len__(self):
1490 return len([x for x in self.contents])
1494 self.assertEqual(s3, MySet((3,)))
1496 def test_MutableSet(self):
1497 self.assertIsInstance(set(), MutableSet)
1498 self.assertTrue(issubclass(set, MutableSet))
1499 self.assertNotIsInstance(frozenset(), MutableSet)
1500 self.assertFalse(issubclass(frozenset, MutableSet))
1501 self.validate_abstract_methods(MutableSet, '__contains__', '__iter__', '__len__',
1504 def test_issue_5647(self):
1508 self.assertEqual(set(s), set('cd'))
1510 def test_issue_4920(self):
1514 def __init__(self,items=None):
1517 self.__s=set(items)
1518 def __contains__(self,v):
1519 return v in self.__s
1520 def __iter__(self):
1521 return iter(self.__s)
1522 def __len__(self):
1523 return len(self.__s)
1524 def add(self,v):
1525 result=v not in self.__s
1526 self.__s.add(v)
1528 def discard(self,v):
1529 result=v in self.__s
1530 self.__s.discard(v)
1532 def __repr__(self):
1533 return "MySet(%s)" % repr(list(self))
1537 self.assertEqual(len(s), len(items) - 1)
1538 self.assertNotIn(r, s)
1539 self.assertIn(r, items)
1541 def test_issue8750(self):
1546 self.assertEqual(s, empty)
1549 self.assertEqual(s, empty)
1552 self.assertEqual(s, full)
1554 self.assertEqual(s, full)
1556 def test_issue16373(self):
1560 def __contains__(self, x):
1562 def __len__(self):
1564 def __iter__(self):
1567 def __contains__(self, x):
1569 def __len__(self):
1571 def __iter__(self):
1573 def __le__(self, x):
1575 def __lt__(self, x):
1580 self.assertFalse(ncs < cs)
1581 self.assertTrue(ncs <= cs)
1582 self.assertFalse(ncs > cs)
1583 self.assertTrue(ncs >= cs)
1585 def test_issue26915(self):
1588 def __init__(self, seq):
1589 self._seq = seq
1590 def __getitem__(self, index):
1591 return self._seq[index]
1592 def __len__(self):
1593 return len(self._seq)
1606 self.assertIn(elem, container)
1607 self.assertEqual(seq.index(nan), 0)
1608 self.assertEqual(seq.index(obj), 1)
1609 self.assertEqual(seq.count(nan), 2)
1610 self.assertEqual(seq.count(obj), 1)
1612 def assertSameSet(self, s1, s2):
1614 self.assertSetEqual(set(s1), set(s2))
1616 def test_Set_from_iterable(self):
1619 def __init__(self, values, created_by):
1622 self.created_by = created_by
1623 self._values = set(values)
1625 def _from_iterable(self, values):
1626 return type(self)(values, 'from_iterable')
1628 def __contains__(self, value):
1629 return value in self._values
1631 def __iter__(self):
1632 yield from self._values
1634 def __len__(self):
1635 return len(self._values)
1637 def add(self, value):
1638 self._values.add(value)
1640 def discard(self, value):
1641 self._values.discard(value)
1646 self.assertIsInstance(actual, SetUsingInstanceFromIterable)
1647 self.assertEqual('from_iterable', actual.created_by)
1648 self.assertEqual({2, 3}, actual)
1651 self.assertIsInstance(actual, SetUsingInstanceFromIterable)
1652 self.assertEqual('from_iterable', actual.created_by)
1653 self.assertEqual({1, 2, 3, 4}, actual)
1656 self.assertIsInstance(actual, SetUsingInstanceFromIterable)
1657 self.assertEqual('from_iterable', actual.created_by)
1658 self.assertEqual({2}, actual)
1661 self.assertIsInstance(actual, SetUsingInstanceFromIterable)
1662 self.assertEqual('from_iterable', actual.created_by)
1663 self.assertEqual({1, 2, 4}, actual)
1668 self.assertIsInstance(impl, SetUsingInstanceFromIterable)
1669 self.assertEqual('test', impl.created_by)
1670 self.assertEqual({1, 2, 4}, impl)
1672 def test_Set_interoperability_with_real_sets(self):
1675 def __init__(self, elements=()):
1676 self.data = []
1678 if elem not in self.data:
1679 self.data.append(elem)
1680 def __contains__(self, elem):
1681 return elem in self.data
1682 def __iter__(self):
1683 return iter(self.data)
1684 def __len__(self):
1685 return len(self.data)
1686 def __repr__(self):
1687 return 'Set({!r})'.format(self.data)
1700 self.assertSameSet(f1 & f2, target)
1701 self.assertSameSet(f1 & r2, target)
1702 self.assertSameSet(r2 & f1, target)
1703 self.assertSameSet(f1 & l2, target)
1706 self.assertSameSet(f1 | f2, target)
1707 self.assertSameSet(f1 | r2, target)
1708 self.assertSameSet(r2 | f1, target)
1709 self.assertSameSet(f1 | l2, target)
1713 self.assertSameSet(f1 - f2, fwd_target)
1714 self.assertSameSet(f2 - f1, rev_target)
1715 self.assertSameSet(f1 - r2, fwd_target)
1716 self.assertSameSet(f2 - r1, rev_target)
1717 self.assertSameSet(r1 - f2, fwd_target)
1718 self.assertSameSet(r2 - f1, rev_target)
1719 self.assertSameSet(f1 - l2, fwd_target)
1720 self.assertSameSet(f2 - l1, rev_target)
1723 self.assertSameSet(f1 ^ f2, target)
1724 self.assertSameSet(f1 ^ r2, target)
1725 self.assertSameSet(r2 ^ f1, target)
1726 self.assertSameSet(f1 ^ l2, target)
1735 self.assertTrue(f1 < f3)
1736 self.assertFalse(f1 < f1)
1737 self.assertFalse(f1 < f2)
1738 self.assertTrue(r1 < f3)
1739 self.assertFalse(r1 < f1)
1740 self.assertFalse(r1 < f2)
1741 self.assertTrue(r1 < r3)
1742 self.assertFalse(r1 < r1)
1743 self.assertFalse(r1 < r2)
1744 with self.assertRaises(TypeError):
1746 with self.assertRaises(TypeError):
1748 with self.assertRaises(TypeError):
1752 self.assertTrue(f1 <= f3)
1753 self.assertTrue(f1 <= f1)
1754 self.assertFalse(f1 <= f2)
1755 self.assertTrue(r1 <= f3)
1756 self.assertTrue(r1 <= f1)
1757 self.assertFalse(r1 <= f2)
1758 self.assertTrue(r1 <= r3)
1759 self.assertTrue(r1 <= r1)
1760 self.assertFalse(r1 <= r2)
1761 with self.assertRaises(TypeError):
1763 with self.assertRaises(TypeError):
1765 with self.assertRaises(TypeError):
1769 self.assertTrue(f3 > f1)
1770 self.assertFalse(f1 > f1)
1771 self.assertFalse(f2 > f1)
1772 self.assertTrue(r3 > r1)
1773 self.assertFalse(f1 > r1)
1774 self.assertFalse(f2 > r1)
1775 self.assertTrue(r3 > r1)
1776 self.assertFalse(r1 > r1)
1777 self.assertFalse(r2 > r1)
1778 with self.assertRaises(TypeError):
1780 with self.assertRaises(TypeError):
1782 with self.assertRaises(TypeError):
1786 self.assertTrue(f3 >= f1)
1787 self.assertTrue(f1 >= f1)
1788 self.assertFalse(f2 >= f1)
1789 self.assertTrue(r3 >= r1)
1790 self.assertTrue(f1 >= r1)
1791 self.assertFalse(f2 >= r1)
1792 self.assertTrue(r3 >= r1)
1793 self.assertTrue(r1 >= r1)
1794 self.assertFalse(r2 >= r1)
1795 with self.assertRaises(TypeError):
1797 with self.assertRaises(TypeError):
1799 with self.assertRaises(TypeError):
1803 self.assertTrue(f1 == f1)
1804 self.assertTrue(r1 == f1)
1805 self.assertTrue(f1 == r1)
1806 self.assertFalse(f1 == f3)
1807 self.assertFalse(r1 == f3)
1808 self.assertFalse(f1 == r3)
1809 self.assertFalse(f1 == l3)
1810 self.assertFalse(f1 == l1)
1811 self.assertFalse(f1 == l2)
1814 self.assertFalse(f1 != f1)
1815 self.assertFalse(r1 != f1)
1816 self.assertFalse(f1 != r1)
1817 self.assertTrue(f1 != f3)
1818 self.assertTrue(r1 != f3)
1819 self.assertTrue(f1 != r3)
1820 self.assertTrue(f1 != l3)
1821 self.assertTrue(f1 != l1)
1822 self.assertTrue(f1 != l2)
1824 def test_Set_hash_matches_frozenset(self):
1834 self.assertEqual(hash(fs), Set._hash(fs), msg=s)
1836 def test_Mapping(self):
1838 self.assertIsInstance(sample(), Mapping)
1839 self.assertTrue(issubclass(sample, Mapping))
1840 self.validate_abstract_methods(Mapping, '__contains__', '__iter__', '__len__',
1843 def __len__(self):
1845 def __getitem__(self, i):
1847 def __iter__(self):
1849 self.validate_comparison(MyMapping())
1850 self.assertRaises(TypeError, reversed, MyMapping())
1852 def test_MutableMapping(self):
1854 self.assertIsInstance(sample(), MutableMapping)
1855 self.assertTrue(issubclass(sample, MutableMapping))
1856 self.validate_abstract_methods(MutableMapping, '__contains__', '__iter__', '__len__',
1859 def test_MutableMapping_subclass(self):
1863 self.assertIsInstance(mymap.keys(), Set)
1864 self.assertIsInstance(mymap.keys(), KeysView)
1865 self.assertIsInstance(mymap.values(), Collection)
1866 self.assertIsInstance(mymap.values(), ValuesView)
1867 self.assertIsInstance(mymap.items(), Set)
1868 self.assertIsInstance(mymap.items(), ItemsView)
1873 self.assertIsInstance(z, set)
1876 self.assertEqual(sorted(z), ['orange', 'red'])
1881 self.assertIsInstance(z, set)
1884 self.assertEqual(z, {('orange', 3), ('red', 5)})
1886 def test_Sequence(self):
1888 self.assertIsInstance(sample(), Sequence)
1889 self.assertTrue(issubclass(sample, Sequence))
1890 self.assertIsInstance(range(10), Sequence)
1891 self.assertTrue(issubclass(range, Sequence))
1892 self.assertIsInstance(memoryview(b""), Sequence)
1893 self.assertTrue(issubclass(memoryview, Sequence))
1894 self.assertTrue(issubclass(str, Sequence))
1895 self.validate_abstract_methods(Sequence, '__contains__', '__iter__', '__len__',
1898 def test_Sequence_mixins(self):
1900 def __init__(self, seq=()):
1901 self.seq = seq
1903 def __getitem__(self, index):
1904 return self.seq[index]
1906 def __len__(self):
1907 return len(self.seq)
1914 with self.assertRaises(ValueError):
1918 self.assertEqual(
1933 def test_ByteString(self):
1935 self.assertIsInstance(sample(), ByteString)
1936 self.assertTrue(issubclass(sample, ByteString))
1938 self.assertNotIsInstance(sample(), ByteString)
1939 self.assertFalse(issubclass(sample, ByteString))
1940 self.assertNotIsInstance(memoryview(b""), ByteString)
1941 self.assertFalse(issubclass(memoryview, ByteString))
1942 self.validate_abstract_methods(ByteString, '__getitem__', '__len__')
1944 def test_MutableSequence(self):
1946 self.assertNotIsInstance(sample(), MutableSequence)
1947 self.assertFalse(issubclass(sample, MutableSequence))
1949 self.assertIsInstance(sample(), MutableSequence)
1950 self.assertTrue(issubclass(sample, MutableSequence))
1951 self.assertFalse(issubclass(str, MutableSequence))
1952 self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__',
1955 def test_MutableSequence_mixins(self):
1959 def __init__(self):
1960 self.lst = []
1962 def __setitem__(self, index, value):
1963 self.lst[index] = value
1965 def __getitem__(self, index):
1966 return self.lst[index]
1968 def __len__(self):
1969 return len(self.lst)
1971 def __delitem__(self, index):
1972 del self.lst[index]
1974 def insert(self, index, value):
1975 self.lst.insert(index, value)
1980 self.assertEqual(len(mss), 5)
1981 self.assertEqual(mss[3], 3)
1983 self.assertEqual(mss[3], 1)
1985 self.assertEqual(len(mss), 4)
1987 self.assertEqual(len(mss), 3)
1989 self.assertEqual(len(mss), 6)
1990 self.assertEqual(mss[-1], 30)
1992 self.assertEqual(len(mss), 0)
1995 # extending self should not cause infinite loop
2002 self.assertEqual(len(mss), len(mss2))
2003 self.assertEqual(list(mss), list(mss2))
2005 def test_illegal_patma_flags(self):
2006 with self.assertRaises(TypeError):
2018 def __init__(self, *args, **kwds):
2019 self.called = False
2020 Counter.__init__(self, *args, **kwds)
2021 def __setitem__(self, key, value):
2022 self.called = True
2023 Counter.__setitem__(self, key, value)
2027 def __init__(self, *args, **kwds):
2028 self.called = False
2029 Counter.__init__(self, *args, **kwds)
2030 def get(self, key, default):
2031 self.called = True
2032 return Counter.get(self, key, default)
2036 def test_basics(self):
2038 self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1}))
2039 self.assertEqual(c, Counter(a=3, b=2, c=1))
2040 self.assertIsInstance(c, dict)
2041 self.assertIsInstance(c, Mapping)
2042 self.assertTrue(issubclass(Counter, dict))
2043 self.assertTrue(issubclass(Counter, Mapping))
2044 self.assertEqual(len(c), 3)
2045 self.assertEqual(sum(c.values()), 6)
2046 self.assertEqual(list(c.values()), [3, 2, 1])
2047 self.assertEqual(list(c.keys()), ['a', 'b', 'c'])
2048 self.assertEqual(list(c), ['a', 'b', 'c'])
2049 self.assertEqual(list(c.items()),
2051 self.assertEqual(c['b'], 2)
2052 self.assertEqual(c['z'], 0)
2053 self.assertEqual(c.__contains__('c'), True)
2054 self.assertEqual(c.__contains__('z'), False)
2055 self.assertEqual(c.get('b', 10), 2)
2056 self.assertEqual(c.get('z', 10), 10)
2057 self.assertEqual(c, dict(a=3, b=2, c=1))
2058 self.assertEqual(repr(c), "Counter({'a': 3, 'b': 2, 'c': 1})")
2059 self.assertEqual(c.most_common(), [('a', 3), ('b', 2), ('c', 1)])
2061 self.assertEqual(c.most_common(i),
2063 self.assertEqual(''.join(c.elements()), 'aaabbc')
2071 self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))
2072 self.assertEqual(''.join(c.elements()), 'aaaaffff')
2073 self.assertEqual(c.pop('f'), 4)
2074 self.assertNotIn('f', c)
2077 self.assertNotIn(elem, c)
2079 self.assertEqual(c, {})
2080 self.assertEqual(repr(c), 'Counter()')
2081 self.assertRaises(NotImplementedError, Counter.fromkeys, 'abc')
2082 self.assertRaises(TypeError, hash, c)
2090 self.assertEqual(c, dict(a=555, b=333, c=3, d=1))
2091 self.assertEqual(c.setdefault('d', 5), 1)
2092 self.assertEqual(c['d'], 1)
2093 self.assertEqual(c.setdefault('e', 5), 5)
2094 self.assertEqual(c['e'], 5)
2096 def test_init(self):
2097 self.assertEqual(list(Counter(self=42).items()), [('self', 42)])
2098 self.assertEqual(list(Counter(iterable=42).items()), [('iterable', 42)])
2099 self.assertEqual(list(Counter(iterable=None).items()), [('iterable', None)])
2100 self.assertRaises(TypeError, Counter, 42)
2101 self.assertRaises(TypeError, Counter, (), ())
2102 self.assertRaises(TypeError, Counter.__init__)
2104 def test_total(self):
2106 self.assertEqual(c.total(), 15)
2108 def test_order_preservation(self):
2110 self.assertEqual(list(Counter('abracadabra').items()),
2115 self.assertEqual(list(Counter('xyzpdqqdpzyx').items()),
2119 self.assertEqual(list(Counter('abracadabra simsalabim').elements()),
2134 self.assertTrue(correctly_ordered(+p))
2135 self.assertTrue(correctly_ordered(-p))
2136 self.assertTrue(correctly_ordered(p + q))
2137 self.assertTrue(correctly_ordered(p - q))
2138 self.assertTrue(correctly_ordered(p | q))
2139 self.assertTrue(correctly_ordered(p & q))
2143 self.assertTrue(correctly_ordered(p))
2147 self.assertTrue(correctly_ordered(p))
2151 self.assertTrue(correctly_ordered(p))
2155 self.assertTrue(correctly_ordered(p))
2159 self.assertTrue(correctly_ordered(p))
2163 self.assertTrue(correctly_ordered(p))
2165 def test_update(self):
2167 c.update(self=42)
2168 self.assertEqual(list(c.items()), [('self', 42)])
2171 self.assertEqual(list(c.items()), [('iterable', 42)])
2174 self.assertEqual(list(c.items()), [('iterable', None)])
2175 self.assertRaises(TypeError, Counter().update, 42)
2176 self.assertRaises(TypeError, Counter().update, {}, {})
2177 self.assertRaises(TypeError, Counter.update)
2179 def test_copying(self):
2185 self.assertIsNot(dup, words, msg)
2186 self.assertEqual(dup, words)
2191 with self.subTest(proto=proto):
2199 def test_copy_subclass(self):
2204 self.assertEqual(d, c)
2205 self.assertEqual(len(d), len(c))
2206 self.assertEqual(type(d), type(c))
2208 def test_conversions(self):
2211 self.assertEqual(sorted(Counter(s).elements()), sorted(s))
2212 self.assertEqual(sorted(Counter(s)), sorted(set(s)))
2213 self.assertEqual(dict(Counter(s)), dict(Counter(s).items()))
2214 self.assertEqual(set(Counter(s)), set(s))
2216 def test_invariant_for_the_in_operator(self):
2219 self.assertTrue(elem in c)
2220 self.assertIn(elem, c)
2222 def test_multiset_operations(self):
2225 self.assertEqual(dict(c), dict(a=10))
2242 self.assertEqual(numberop(p[x], q[x]), result[x],
2245 self.assertTrue(x>0 for x in result.values())
2259 self.assertEqual(counter_result, dict.fromkeys(set_result, 1))
2261 def test_inplace_operations(self):
2279 self.assertEqual(inplace_result, regular_result)
2280 self.assertEqual(id(inplace_result), c_id)
2282 def test_subtract(self):
2285 self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))
2288 self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))
2291 self.assertEqual(c, Counter(a=-1, b=0, c=-1, d=1, e=-1))
2294 c.subtract(self=42)
2295 self.assertEqual(list(c.items()), [('self', -42)])
2298 self.assertEqual(list(c.items()), [('iterable', -42)])
2299 self.assertRaises(TypeError, Counter().subtract, 42)
2300 self.assertRaises(TypeError, Counter().subtract, {}, {})
2301 self.assertRaises(TypeError, Counter.subtract)
2303 def test_unary(self):
2305 self.assertEqual(dict(+c), dict(c=5, d=10, e=15, g=40))
2306 self.assertEqual(dict(-c), dict(a=5))
2308 def test_repr_nonsortable(self):
2311 self.assertIn("'a': 2", r)
2312 self.assertIn("'b': None", r)
2314 def test_helper_function(self):
2320 self.assertEqual(d, {'a': 5, 'r': 2, 'b': 2, 'c': 1, 'd': 1})
2324 self.assertEqual(m,
2329 self.assertTrue(c.called)
2330 self.assertEqual(dict(c), {'a': 5, 'b': 2, 'c': 1, 'd': 1, 'r':2 })
2332 self.assertTrue(c.called)
2333 self.assertEqual(dict(c), {'a': 5, 'b': 2, 'c': 1, 'd': 1, 'r':2 })
2335 def test_multiset_operations_equivalent_to_set_operations(self):
2345 self.assertEqual(set(cp + cq), sp | sq)
2346 self.assertEqual(set(cp - cq), sp - sq)
2347 self.assertEqual(set(cp | cq), sp | sq)
2348 self.assertEqual(set(cp & cq), sp & sq)
2349 self.assertEqual(cp == cq, sp == sq)
2350 self.assertEqual(cp != cq, sp != sq)
2351 self.assertEqual(cp <= cq, sp <= sq)
2352 self.assertEqual(cp >= cq, sp >= sq)
2353 self.assertEqual(cp < cq, sp < sq)
2354 self.assertEqual(cp > cq, sp > sq)
2356 def test_eq(self):
2357 self.assertEqual(Counter(a=3, b=2, c=0), Counter('ababa'))
2358 self.assertNotEqual(Counter(a=3, b=2), Counter('babab'))
2360 def test_le(self):
2361 self.assertTrue(Counter(a=3, b=2, c=0) <= Counter('ababa'))
2362 self.assertFalse(Counter(a=3, b=2) <= Counter('babab'))
2364 def test_lt(self):
2365 self.assertTrue(Counter(a=3, b=1, c=0) < Counter('ababa'))
2366 self.assertFalse(Counter(a=3, b=2, c=0) < Counter('ababa'))
2368 def test_ge(self):
2369 self.assertTrue(Counter(a=2, b=1, c=0) >= Counter('aab'))
2370 self.assertFalse(Counter(a=3, b=2, c=0) >= Counter('aabd'))
2372 def test_gt(self):
2373 self.assertTrue(Counter(a=3, b=2, c=0) > Counter('aab'))
2374 self.assertFalse(Counter(a=2, b=1, c=0) > Counter('aab'))