| 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() |