cpython: afaad8dc8edf (original) (raw)
--- a/Lib/test/test_collections.py +++ b/Lib/test/test_collections.py @@ -1,19 +1,24 @@ +import collections +import copy +import doctest +import keyword +import operator +import pickle +import cPickle +from random import choice, randrange +import re +import string +import sys +from test import test_support +import unittest -import unittest, doctest, operator -import inspect -from test import test_support from collections import namedtuple, Counter, OrderedDict -from test import mapping_tests -import pickle, cPickle, copy -from random import randrange, shuffle -import keyword -import re -import sys from collections import Hashable, Iterable, Iterator from collections import Sized, Container, Callable from collections import Set, MutableSet from collections import Mapping, MutableMapping from collections import Sequence, MutableSequence +
Silence deprecation warning
sets = test_support.import_module('sets', deprecated=True) @@ -178,8 +183,7 @@ class TestNamedTuple(unittest.TestCase): self.assertEqual(Dot(1)._fields, ('d',)) n = 5000
import string, random[](#l1.41)names = list(set(''.join([random.choice(string.ascii_letters)[](#l1.42)
names = list(set(''.join([choice(string.ascii_letters)[](#l1.43) for j in range(10)]) for i in range(n)))[](#l1.44) n = len(names)[](#l1.45) Big = namedtuple('Big', names)[](#l1.46)
@@ -556,7 +560,7 @@ class TestCollectionABCs(ABCTestCase): def test_issue_4920(self): # MutableSet.pop() method did not work
class MySet(collections.MutableSet):[](#l1.51)
class MySet(MutableSet):[](#l1.52) __slots__=['__s'][](#l1.53) def __init__(self,items=None):[](#l1.54) if items is None:[](#l1.55)
@@ -802,7 +806,7 @@ class TestCollectionABCs(ABCTestCase): self.assertTrue(issubclass(sample, Mapping)) self.validate_abstract_methods(Mapping, 'contains', 'iter', 'len', 'getitem')
class MyMapping(collections.Mapping):[](#l1.60)
class MyMapping(Mapping):[](#l1.61) def __len__(self):[](#l1.62) return 0[](#l1.63) def __getitem__(self, i):[](#l1.64)
@@ -1038,290 +1042,11 @@ class TestCounter(unittest.TestCase): self.assertRaises(TypeError, Counter().subtract, {}, {}) self.assertRaises(TypeError, Counter.subtract) -class TestOrderedDict(unittest.TestCase): -
- def test_init(self):
with self.assertRaises(TypeError):[](#l1.72)OrderedDict([('a', 1), ('b', 2)], None) # too many args[](#l1.73)pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)][](#l1.74)self.assertEqual(sorted(OrderedDict(dict(pairs)).items()), pairs) # dict input[](#l1.75)self.assertEqual(sorted(OrderedDict(**dict(pairs)).items()), pairs) # kwds input[](#l1.76)self.assertEqual(list(OrderedDict(pairs).items()), pairs) # pairs input[](#l1.77)self.assertEqual(list(OrderedDict([('a', 1), ('b', 2), ('c', 9), ('d', 4)],[](#l1.78)c=3, e=5).items()), pairs) # mixed input[](#l1.79)
# make sure no positional args conflict with possible kwdargs[](#l1.81)self.assertEqual(list(OrderedDict(self=42).items()), [('self', 42)])[](#l1.82)self.assertEqual(list(OrderedDict(other=42).items()), [('other', 42)])[](#l1.83)self.assertRaises(TypeError, OrderedDict, 42)[](#l1.84)self.assertRaises(TypeError, OrderedDict, (), ())[](#l1.85)self.assertRaises(TypeError, OrderedDict.__init__)[](#l1.86)
# Make sure that direct calls to __init__ do not clear previous contents[](#l1.88)d = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 44), ('e', 55)])[](#l1.89)d.__init__([('e', 5), ('f', 6)], g=7, d=4)[](#l1.90)self.assertEqual(list(d.items()),[](#l1.91)[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])[](#l1.92)
- def test_update(self):
with self.assertRaises(TypeError):[](#l1.95)OrderedDict().update([('a', 1), ('b', 2)], None) # too many args[](#l1.96)pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)][](#l1.97)od = OrderedDict()[](#l1.98)od.update(dict(pairs))[](#l1.99)self.assertEqual(sorted(od.items()), pairs) # dict input[](#l1.100)od = OrderedDict()[](#l1.101)od.update(**dict(pairs))[](#l1.102)self.assertEqual(sorted(od.items()), pairs) # kwds input[](#l1.103)od = OrderedDict()[](#l1.104)od.update(pairs)[](#l1.105)self.assertEqual(list(od.items()), pairs) # pairs input[](#l1.106)od = OrderedDict()[](#l1.107)od.update([('a', 1), ('b', 2), ('c', 9), ('d', 4)], c=3, e=5)[](#l1.108)self.assertEqual(list(od.items()), pairs) # mixed input[](#l1.109)
# Issue 9137: Named argument called 'other' or 'self'[](#l1.111)# shouldn't be treated specially.[](#l1.112)od = OrderedDict()[](#l1.113)od.update(self=23)[](#l1.114)self.assertEqual(list(od.items()), [('self', 23)])[](#l1.115)od = OrderedDict()[](#l1.116)od.update(other={})[](#l1.117)self.assertEqual(list(od.items()), [('other', {})])[](#l1.118)od = OrderedDict()[](#l1.119)od.update(red=5, blue=6, other=7, self=8)[](#l1.120)self.assertEqual(sorted(list(od.items())),[](#l1.121)[('blue', 6), ('other', 7), ('red', 5), ('self', 8)])[](#l1.122)
# Make sure that direct calls to update do not clear previous contents[](#l1.124)# add that updates items are not moved to the end[](#l1.125)d = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 44), ('e', 55)])[](#l1.126)d.update([('e', 5), ('f', 6)], g=7, d=4)[](#l1.127)self.assertEqual(list(d.items()),[](#l1.128)[('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])[](#l1.129)
self.assertRaises(TypeError, OrderedDict().update, 42)[](#l1.131)self.assertRaises(TypeError, OrderedDict().update, (), ())[](#l1.132)self.assertRaises(TypeError, OrderedDict.update)[](#l1.133)
- def test_abc(self):
self.assertIsInstance(OrderedDict(), MutableMapping)[](#l1.136)self.assertTrue(issubclass(OrderedDict, MutableMapping))[](#l1.137)
- def test_clear(self):
pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.140)shuffle(pairs)[](#l1.141)od = OrderedDict(pairs)[](#l1.142)self.assertEqual(len(od), len(pairs))[](#l1.143)od.clear()[](#l1.144)self.assertEqual(len(od), 0)[](#l1.145)
- def test_delitem(self):
pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.148)od = OrderedDict(pairs)[](#l1.149)del od['a'][](#l1.150)self.assertNotIn('a', od)[](#l1.151)with self.assertRaises(KeyError):[](#l1.152)del od['a'][](#l1.153)self.assertEqual(list(od.items()), pairs[:2] + pairs[3:])[](#l1.154)
- def test_setitem(self):
od = OrderedDict([('d', 1), ('b', 2), ('c', 3), ('a', 4), ('e', 5)])[](#l1.157)od['c'] = 10 # existing element[](#l1.158)od['f'] = 20 # new element[](#l1.159)self.assertEqual(list(od.items()),[](#l1.160)[('d', 1), ('b', 2), ('c', 10), ('a', 4), ('e', 5), ('f', 20)])[](#l1.161)
- def test_iterators(self):
pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.164)shuffle(pairs)[](#l1.165)od = OrderedDict(pairs)[](#l1.166)self.assertEqual(list(od), [t[0] for t in pairs])[](#l1.167)self.assertEqual(od.keys()[:], [t[0] for t in pairs])[](#l1.168)self.assertEqual(od.values()[:], [t[1] for t in pairs])[](#l1.169)self.assertEqual(od.items()[:], pairs)[](#l1.170)self.assertEqual(list(od.iterkeys()), [t[0] for t in pairs])[](#l1.171)self.assertEqual(list(od.itervalues()), [t[1] for t in pairs])[](#l1.172)self.assertEqual(list(od.iteritems()), pairs)[](#l1.173)self.assertEqual(list(reversed(od)),[](#l1.174)[t[0] for t in reversed(pairs)])[](#l1.175)
- def test_popitem(self):
pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.178)shuffle(pairs)[](#l1.179)od = OrderedDict(pairs)[](#l1.180)while pairs:[](#l1.181)self.assertEqual(od.popitem(), pairs.pop())[](#l1.182)with self.assertRaises(KeyError):[](#l1.183)od.popitem()[](#l1.184)self.assertEqual(len(od), 0)[](#l1.185)
- def test_pop(self):
pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.188)shuffle(pairs)[](#l1.189)od = OrderedDict(pairs)[](#l1.190)shuffle(pairs)[](#l1.191)while pairs:[](#l1.192)k, v = pairs.pop()[](#l1.193)self.assertEqual(od.pop(k), v)[](#l1.194)with self.assertRaises(KeyError):[](#l1.195)od.pop('xyz')[](#l1.196)self.assertEqual(len(od), 0)[](#l1.197)self.assertEqual(od.pop(k, 12345), 12345)[](#l1.198)
# make sure pop still works when __missing__ is defined[](#l1.200)class Missing(OrderedDict):[](#l1.201)def __missing__(self, key):[](#l1.202)return 0[](#l1.203)m = Missing(a=1)[](#l1.204)self.assertEqual(m.pop('b', 5), 5)[](#l1.205)self.assertEqual(m.pop('a', 6), 1)[](#l1.206)self.assertEqual(m.pop('a', 6), 6)[](#l1.207)with self.assertRaises(KeyError):[](#l1.208)m.pop('a')[](#l1.209)
- def test_equality(self):
pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.212)shuffle(pairs)[](#l1.213)od1 = OrderedDict(pairs)[](#l1.214)od2 = OrderedDict(pairs)[](#l1.215)self.assertEqual(od1, od2) # same order implies equality[](#l1.216)pairs = pairs[2:] + pairs[:2][](#l1.217)od2 = OrderedDict(pairs)[](#l1.218)self.assertNotEqual(od1, od2) # different order implies inequality[](#l1.219)# comparison to regular dict is not order sensitive[](#l1.220)self.assertEqual(od1, dict(od2))[](#l1.221)self.assertEqual(dict(od2), od1)[](#l1.222)# different length implied inequality[](#l1.223)self.assertNotEqual(od1, OrderedDict(pairs[:-1]))[](#l1.224)
- def test_copying(self):
# Check that ordered dicts are copyable, deepcopyable, picklable,[](#l1.227)# and have a repr/eval round-trip[](#l1.228)pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.229)od = OrderedDict(pairs)[](#l1.230)update_test = OrderedDict()[](#l1.231)update_test.update(od)[](#l1.232)for i, dup in enumerate([[](#l1.233)od.copy(),[](#l1.234)copy.copy(od),[](#l1.235)copy.deepcopy(od),[](#l1.236)pickle.loads(pickle.dumps(od, 0)),[](#l1.237)pickle.loads(pickle.dumps(od, 1)),[](#l1.238)pickle.loads(pickle.dumps(od, 2)),[](#l1.239)pickle.loads(pickle.dumps(od, -1)),[](#l1.240)eval(repr(od)),[](#l1.241)update_test,[](#l1.242)OrderedDict(od),[](#l1.243)]):[](#l1.244)self.assertTrue(dup is not od)[](#l1.245)self.assertEqual(dup, od)[](#l1.246)self.assertEqual(list(dup.items()), list(od.items()))[](#l1.247)self.assertEqual(len(dup), len(od))[](#l1.248)self.assertEqual(type(dup), type(od))[](#l1.249)
- def test_yaml_linkage(self):
# Verify that __reduce__ is setup in a way that supports PyYAML's dump() feature.[](#l1.252)# In yaml, lists are native but tuples are not.[](#l1.253)pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.254)od = OrderedDict(pairs)[](#l1.255)# yaml.dump(od) -->[](#l1.256)# '!!python/object/apply:__main__.OrderedDict\n- - [a, 1]\n - [b, 2]\n'[](#l1.257)self.assertTrue(all(type(pair)==list for pair in od.__reduce__()[1]))[](#l1.258)
- def test_reduce_not_too_fat(self):
# do not save instance dictionary if not needed[](#l1.261)pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.262)od = OrderedDict(pairs)[](#l1.263)self.assertEqual(len(od.__reduce__()), 2)[](#l1.264)od.x = 10[](#l1.265)self.assertEqual(len(od.__reduce__()), 3)[](#l1.266)
- def test_repr(self):
od = OrderedDict([('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)])[](#l1.269)self.assertEqual(repr(od),[](#l1.270)"OrderedDict([('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)])")[](#l1.271)self.assertEqual(eval(repr(od)), od)[](#l1.272)self.assertEqual(repr(OrderedDict()), "OrderedDict()")[](#l1.273)
- def test_repr_recursive(self):
# See issue #9826[](#l1.276)od = OrderedDict.fromkeys('abc')[](#l1.277)od['x'] = od[](#l1.278)self.assertEqual(repr(od),[](#l1.279)"OrderedDict([('a', None), ('b', None), ('c', None), ('x', ...)])")[](#l1.280)
- def test_setdefault(self):
pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)][](#l1.283)shuffle(pairs)[](#l1.284)od = OrderedDict(pairs)[](#l1.285)pair_order = list(od.items())[](#l1.286)self.assertEqual(od.setdefault('a', 10), 3)[](#l1.287)# make sure order didn't change[](#l1.288)self.assertEqual(list(od.items()), pair_order)[](#l1.289)self.assertEqual(od.setdefault('x', 10), 10)[](#l1.290)# make sure 'x' is added to the end[](#l1.291)self.assertEqual(list(od.items())[-1], ('x', 10))[](#l1.292)
# make sure setdefault still works when __missing__ is defined[](#l1.294)class Missing(OrderedDict):[](#l1.295)def __missing__(self, key):[](#l1.296)return 0[](#l1.297)self.assertEqual(Missing().setdefault(5, 9), 9)[](#l1.298)
- def test_reinsert(self):
# Given insert a, insert b, delete a, re-insert a,[](#l1.301)# verify that a is now later than b.[](#l1.302)od = OrderedDict()[](#l1.303)od['a'] = 1[](#l1.304)od['b'] = 2[](#l1.305)del od['a'][](#l1.306)od['a'] = 1[](#l1.307)self.assertEqual(list(od.items()), [('b', 2), ('a', 1)])[](#l1.308)
- def test_views(self):
s = 'the quick brown fox jumped over a lazy dog yesterday before dawn'.split()[](#l1.311)od = OrderedDict.fromkeys(s)[](#l1.312)self.assertEqual(list(od.viewkeys()), s)[](#l1.313)self.assertEqual(list(od.viewvalues()), [None for k in s])[](#l1.314)self.assertEqual(list(od.viewitems()), [(k, None) for k in s])[](#l1.315)
# See http://bugs.python.org/issue24286[](#l1.317)self.assertEqual(od.viewkeys(), dict(od).viewkeys())[](#l1.318)self.assertEqual(od.viewitems(), dict(od).viewitems())[](#l1.319)
- def test_override_update(self):
# Verify that subclasses can override update() without breaking __init__()[](#l1.322)class MyOD(OrderedDict):[](#l1.323)def update(self, *args, **kwds):[](#l1.324)raise Exception()[](#l1.325)items = [('a', 1), ('c', 3), ('b', 2)][](#l1.326)self.assertEqual(list(MyOD(items).items()), items)[](#l1.327)
- -class GeneralMappingTests(mapping_tests.BasicTestMappingProtocol):
- def test_popitem(self):
d = self._empty_mapping()[](#l1.333)self.assertRaises(KeyError, d.popitem)[](#l1.334)
- -class MyOrderedDict(OrderedDict):
- -class SubclassMappingTests(mapping_tests.BasicTestMappingProtocol):
- def test_popitem(self):
d = self._empty_mapping()[](#l1.343)self.assertRaises(KeyError, d.popitem)[](#l1.344)
- -import collections def test_main(verbose=None): NamedTupleDocs = doctest.DocTestSuite(module=collections) test_classes = [TestNamedTuple, NamedTupleDocs, TestOneTrickPonyABCs,
TestCollectionABCs, TestCounter,[](#l1.351)TestOrderedDict, GeneralMappingTests, SubclassMappingTests][](#l1.352)
test_support.run_unittest(*test_classes) test_support.run_doctest(collections, verbose)TestCollectionABCs, TestCounter][](#l1.353)
copy from Lib/test/test_collections.py copy to Lib/test/test_ordered_dict.py --- a/Lib/test/test_collections.py +++ b/Lib/test/test_ordered_dict.py @@ -1,1042 +1,11 @@ - -import unittest, doctest, operator -import inspect -from test import test_support -from collections import namedtuple, Counter, OrderedDict -from test import mapping_tests -import pickle, cPickle, copy -from random import randrange, shuffle -import keyword -import re -import sys -from collections import Hashable, Iterable, Iterator -from collections import Sized, Container, Callable -from collections import Set, MutableSet -from collections import Mapping, MutableMapping -from collections import Sequence, MutableSequence -# Silence deprecation warning -sets = test_support.import_module('sets', deprecated=True) - -TestNT = namedtuple('TestNT', 'x y z') # type used for pickle tests - -py273_named_tuple_pickle = '''[](#l2.27) -ccopy_reg -reconstructor -p0 -(ctest.test_collections -TestNT -p1 -c__builtin_ -tuple -p2 -(I10 -I20 -I30 -tp3 -tp4 -Rp5 -ccollections -OrderedDict -p6 -((lp7 -(lp8 -S'x' -p9 -aI10 -aa(lp10 -S'y' -p11 -aI20 -aa(lp12 -S'z' -p13 -aI30 -aatp14 -Rp15 -b. -''' - -class TestNamedTuple(unittest.TestCase): -
- def test_factory(self):
Point = namedtuple('Point', 'x y')[](#l2.67)self.assertEqual(Point.__name__, 'Point')[](#l2.68)self.assertEqual(Point.__slots__, ())[](#l2.69)self.assertEqual(Point.__module__, __name__)[](#l2.70)self.assertEqual(Point.__getitem__, tuple.__getitem__)[](#l2.71)self.assertEqual(Point._fields, ('x', 'y'))[](#l2.72)
self.assertRaises(ValueError, namedtuple, 'abc%', 'efg ghi') # type has non-alpha char[](#l2.74)self.assertRaises(ValueError, namedtuple, 'class', 'efg ghi') # type has keyword[](#l2.75)self.assertRaises(ValueError, namedtuple, '9abc', 'efg ghi') # type starts with digit[](#l2.76)
self.assertRaises(ValueError, namedtuple, 'abc', 'efg g%hi') # field with non-alpha char[](#l2.78)self.assertRaises(ValueError, namedtuple, 'abc', 'abc class') # field has keyword[](#l2.79)self.assertRaises(ValueError, namedtuple, 'abc', '8efg 9ghi') # field starts with digit[](#l2.80)self.assertRaises(ValueError, namedtuple, 'abc', '_efg ghi') # field with leading underscore[](#l2.81)self.assertRaises(ValueError, namedtuple, 'abc', 'efg efg ghi') # duplicate field[](#l2.82)
namedtuple('Point0', 'x1 y2') # Verify that numbers are allowed in names[](#l2.84)namedtuple('_', 'a b c') # Test leading underscores in a typename[](#l2.85)
nt = namedtuple('nt', u'the quick brown fox') # check unicode input[](#l2.87)self.assertNotIn("u'", repr(nt._fields))[](#l2.88)nt = namedtuple('nt', (u'the', u'quick')) # check unicode input[](#l2.89)self.assertNotIn("u'", repr(nt._fields))[](#l2.90)
self.assertRaises(TypeError, Point._make, [11]) # catch too few args[](#l2.92)self.assertRaises(TypeError, Point._make, [11, 22, 33]) # catch too many args[](#l2.93)
- @unittest.skipIf(sys.flags.optimize >= 2,
"Docstrings are omitted with -O2 and above")[](#l2.96)- def test_factory_doc_attr(self):
Point = namedtuple('Point', 'x y')[](#l2.98)self.assertEqual(Point.__doc__, 'Point(x, y)')[](#l2.99)
- def test_name_fixer(self):
for spec, renamed in [[](#l2.102)[('efg', 'g%hi'), ('efg', '_1')], # field with non-alpha char[](#l2.103)[('abc', 'class'), ('abc', '_1')], # field has keyword[](#l2.104)[('8efg', '9ghi'), ('_0', '_1')], # field starts with digit[](#l2.105)[('abc', '_efg'), ('abc', '_1')], # field with leading underscore[](#l2.106)[('abc', 'efg', 'efg', 'ghi'), ('abc', 'efg', '_2', 'ghi')], # duplicate field[](#l2.107)[('abc', '', 'x'), ('abc', '_1', 'x')], # fieldname is a space[](#l2.108)]:[](#l2.109)self.assertEqual(namedtuple('NT', spec, rename=True)._fields, renamed)[](#l2.110)
- def test_instance(self):
Point = namedtuple('Point', 'x y')[](#l2.113)p = Point(11, 22)[](#l2.114)self.assertEqual(p, Point(x=11, y=22))[](#l2.115)self.assertEqual(p, Point(11, y=22))[](#l2.116)self.assertEqual(p, Point(y=22, x=11))[](#l2.117)self.assertEqual(p, Point(*(11, 22)))[](#l2.118)self.assertEqual(p, Point(**dict(x=11, y=22)))[](#l2.119)self.assertRaises(TypeError, Point, 1) # too few args[](#l2.120)self.assertRaises(TypeError, Point, 1, 2, 3) # too many args[](#l2.121)self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)', locals()) # wrong keyword argument[](#l2.122)self.assertRaises(TypeError, eval, 'Point(x=1)', locals()) # missing keyword argument[](#l2.123)self.assertEqual(repr(p), 'Point(x=11, y=22)')[](#l2.124)self.assertNotIn('__weakref__', dir(p))[](#l2.125)self.assertEqual(p, Point._make([11, 22])) # test _make classmethod[](#l2.126)self.assertEqual(p._fields, ('x', 'y')) # test _fields attribute[](#l2.127)self.assertEqual(p._replace(x=1), (1, 22)) # test _replace method[](#l2.128)self.assertEqual(p._asdict(), dict(x=11, y=22)) # test _asdict method[](#l2.129)self.assertEqual(vars(p), p._asdict()) # verify that vars() works[](#l2.130)
try:[](#l2.132)p._replace(x=1, error=2)[](#l2.133)except ValueError:[](#l2.134)pass[](#l2.135)else:[](#l2.136)self._fail('Did not detect an incorrect fieldname')[](#l2.137)
# verify that field string can have commas[](#l2.139)Point = namedtuple('Point', 'x, y')[](#l2.140)p = Point(x=11, y=22)[](#l2.141)self.assertEqual(repr(p), 'Point(x=11, y=22)')[](#l2.142)
# verify that fieldspec can be a non-string sequence[](#l2.144)Point = namedtuple('Point', ('x', 'y'))[](#l2.145)p = Point(x=11, y=22)[](#l2.146)self.assertEqual(repr(p), 'Point(x=11, y=22)')[](#l2.147)
- def test_tupleness(self):
Point = namedtuple('Point', 'x y')[](#l2.150)p = Point(11, 22)[](#l2.151)
self.assertIsInstance(p, tuple)[](#l2.153)self.assertEqual(p, (11, 22)) # matches a real tuple[](#l2.154)self.assertEqual(tuple(p), (11, 22)) # coercable to a real tuple[](#l2.155)self.assertEqual(list(p), [11, 22]) # coercable to a list[](#l2.156)self.assertEqual(max(p), 22) # iterable[](#l2.157)self.assertEqual(max(*p), 22) # star-able[](#l2.158)x, y = p[](#l2.159)self.assertEqual(p, (x, y)) # unpacks like a tuple[](#l2.160)self.assertEqual((p[0], p[1]), (11, 22)) # indexable like a tuple[](#l2.161)self.assertRaises(IndexError, p.__getitem__, 3)[](#l2.162)
self.assertEqual(p.x, x)[](#l2.164)self.assertEqual(p.y, y)[](#l2.165)self.assertRaises(AttributeError, eval, 'p.z', locals())[](#l2.166)
- def test_odd_sizes(self):
Zero = namedtuple('Zero', '')[](#l2.169)self.assertEqual(Zero(), ())[](#l2.170)self.assertEqual(Zero._make([]), ())[](#l2.171)self.assertEqual(repr(Zero()), 'Zero()')[](#l2.172)self.assertEqual(Zero()._asdict(), {})[](#l2.173)self.assertEqual(Zero()._fields, ())[](#l2.174)
Dot = namedtuple('Dot', 'd')[](#l2.176)self.assertEqual(Dot(1), (1,))[](#l2.177)self.assertEqual(Dot._make([1]), (1,))[](#l2.178)self.assertEqual(Dot(1).d, 1)[](#l2.179)self.assertEqual(repr(Dot(1)), 'Dot(d=1)')[](#l2.180)self.assertEqual(Dot(1)._asdict(), {'d':1})[](#l2.181)self.assertEqual(Dot(1)._replace(d=999), (999,))[](#l2.182)self.assertEqual(Dot(1)._fields, ('d',))[](#l2.183)
n = 5000[](#l2.185)import string, random[](#l2.186)names = list(set(''.join([random.choice(string.ascii_letters)[](#l2.187)for j in range(10)]) for i in range(n)))[](#l2.188)n = len(names)[](#l2.189)Big = namedtuple('Big', names)[](#l2.190)b = Big(*range(n))[](#l2.191)self.assertEqual(b, tuple(range(n)))[](#l2.192)self.assertEqual(Big._make(range(n)), tuple(range(n)))[](#l2.193)for pos, name in enumerate(names):[](#l2.194)self.assertEqual(getattr(b, name), pos)[](#l2.195)repr(b) # make sure repr() doesn't blow-up[](#l2.196)d = b._asdict()[](#l2.197)d_expected = dict(zip(names, range(n)))[](#l2.198)self.assertEqual(d, d_expected)[](#l2.199)b2 = b._replace(**dict([(names[1], 999),(names[-5], 42)]))[](#l2.200)b2_expected = range(n)[](#l2.201)b2_expected[1] = 999[](#l2.202)b2_expected[-5] = 42[](#l2.203)self.assertEqual(b2, tuple(b2_expected))[](#l2.204)self.assertEqual(b._fields, tuple(names))[](#l2.205)
- def test_pickle(self):
p = TestNT(x=10, y=20, z=30)[](#l2.208)for module in pickle, cPickle:[](#l2.209)loads = getattr(module, 'loads')[](#l2.210)dumps = getattr(module, 'dumps')[](#l2.211)for protocol in -1, 0, 1, 2:[](#l2.212)q = loads(dumps(p, protocol))[](#l2.213)self.assertEqual(p, q)[](#l2.214)self.assertEqual(p._fields, q._fields)[](#l2.215)
- def test_copy(self):
p = TestNT(x=10, y=20, z=30)[](#l2.218)for copier in copy.copy, copy.deepcopy:[](#l2.219)q = copier(p)[](#l2.220)self.assertEqual(p, q)[](#l2.221)self.assertEqual(p._fields, q._fields)[](#l2.222)
- def test_name_conflicts(self):
# Some names like "self", "cls", "tuple", "itemgetter", and "property"[](#l2.225)# failed when used as field names. Test to make sure these now work.[](#l2.226)T = namedtuple('T', 'itemgetter property self cls tuple')[](#l2.227)t = T(1, 2, 3, 4, 5)[](#l2.228)self.assertEqual(t, (1,2,3,4,5))[](#l2.229)newt = t._replace(itemgetter=10, property=20, self=30, cls=40, tuple=50)[](#l2.230)self.assertEqual(newt, (10,20,30,40,50))[](#l2.231)
# Broader test of all interesting names in a template[](#l2.233)with test_support.captured_stdout() as template:[](#l2.234)T = namedtuple('T', 'x', verbose=True)[](#l2.235)words = set(re.findall('[A-Za-z]+', template.getvalue()))[](#l2.236)words -= set(keyword.kwlist)[](#l2.237)T = namedtuple('T', words)[](#l2.238)# test __new__[](#l2.239)values = tuple(range(len(words)))[](#l2.240)t = T(*values)[](#l2.241)self.assertEqual(t, values)[](#l2.242)t = T(**dict(zip(T._fields, values)))[](#l2.243)self.assertEqual(t, values)[](#l2.244)# test _make[](#l2.245)t = T._make(values)[](#l2.246)self.assertEqual(t, values)[](#l2.247)# exercise __repr__[](#l2.248)repr(t)[](#l2.249)# test _asdict[](#l2.250)self.assertEqual(t._asdict(), dict(zip(T._fields, values)))[](#l2.251)# test _replace[](#l2.252)t = T._make(values)[](#l2.253)newvalues = tuple(v*10 for v in values)[](#l2.254)newt = t._replace(**dict(zip(T._fields, newvalues)))[](#l2.255)self.assertEqual(newt, newvalues)[](#l2.256)# test _fields[](#l2.257)self.assertEqual(T._fields, tuple(words))[](#l2.258)# test __getnewargs__[](#l2.259)self.assertEqual(t.__getnewargs__(), values)[](#l2.260)
- def test_pickling_bug_18015(self):
# http://bugs.python.org/issue18015[](#l2.263)pt = pickle.loads(py273_named_tuple_pickle)[](#l2.264)self.assertEqual(pt.x, 10)[](#l2.265)
- -class ABCTestCase(unittest.TestCase): -
- def validate_abstract_methods(self, abc, *names):
methodstubs = dict.fromkeys(names, lambda s, *args: 0)[](#l2.270)
# everything should work will all required methods are present[](#l2.272)C = type('C', (abc,), methodstubs)[](#l2.273)C()[](#l2.274)
# instantiation should fail if a required method is missing[](#l2.276)for name in names:[](#l2.277)stubs = methodstubs.copy()[](#l2.278)del stubs[name][](#l2.279)C = type('C', (abc,), stubs)[](#l2.280)self.assertRaises(TypeError, C, name)[](#l2.281)
# new-style class[](#l2.286)C = type('C', (object,), {name: stub})[](#l2.287)self.assertIsInstance(C(), abc)[](#l2.288)self.assertTrue(issubclass(C, abc))[](#l2.289)# old-style class[](#l2.290)class C: pass[](#l2.291)setattr(C, name, stub)[](#l2.292)self.assertIsInstance(C(), abc)[](#l2.293)self.assertTrue(issubclass(C, abc))[](#l2.294)
# new-style class[](#l2.296)C = type('C', (object,), {'__hash__': None})[](#l2.297)self.assertNotIsInstance(C(), abc)[](#l2.298)self.assertFalse(issubclass(C, abc))[](#l2.299)# old-style class[](#l2.300)class C: pass[](#l2.301)self.assertNotIsInstance(C(), abc)[](#l2.302)self.assertFalse(issubclass(C, abc))[](#l2.303)
- def validate_comparison(self, instance):
ops = ['lt', 'gt', 'le', 'ge', 'ne', 'or', 'and', 'xor', 'sub'][](#l2.306)operators = {}[](#l2.307)for op in ops:[](#l2.308)name = '__' + op + '__'[](#l2.309)operators[name] = getattr(operator, name)[](#l2.310)
class Other:[](#l2.312)def __init__(self):[](#l2.313)self.right_side = False[](#l2.314)def __eq__(self, other):[](#l2.315)self.right_side = True[](#l2.316)return True[](#l2.317)__lt__ = __eq__[](#l2.318)__gt__ = __eq__[](#l2.319)__le__ = __eq__[](#l2.320)__ge__ = __eq__[](#l2.321)__ne__ = __eq__[](#l2.322)__ror__ = __eq__[](#l2.323)__rand__ = __eq__[](#l2.324)__rxor__ = __eq__[](#l2.325)__rsub__ = __eq__[](#l2.326)
for name, op in operators.items():[](#l2.328)if not hasattr(instance, name):[](#l2.329)continue[](#l2.330)other = Other()[](#l2.331)op(instance, other)[](#l2.332)self.assertTrue(other.right_side,'Right side not called for %s.%s'[](#l2.333)% (type(instance), name))[](#l2.334)
- -class TestOneTrickPonyABCs(ABCTestCase): -
- def test_Hashable(self):
# Check some non-hashables[](#l2.339)non_samples = [list(), set(), dict()][](#l2.340)for x in non_samples:[](#l2.341)self.assertNotIsInstance(x, Hashable)[](#l2.342)self.assertFalse(issubclass(type(x), Hashable), repr(type(x)))[](#l2.343)# Check some hashables[](#l2.344)samples = [None,[](#l2.345)int(), float(), complex(),[](#l2.346)str(),[](#l2.347)tuple(), frozenset(),[](#l2.348)int, list, object, type,[](#l2.349)][](#l2.350)for x in samples:[](#l2.351)self.assertIsInstance(x, Hashable)[](#l2.352)self.assertTrue(issubclass(type(x), Hashable), repr(type(x)))[](#l2.353)self.assertRaises(TypeError, Hashable)[](#l2.354)# Check direct subclassing[](#l2.355)class H(Hashable):[](#l2.356)def __hash__(self):[](#l2.357)return super(H, self).__hash__()[](#l2.358)__eq__ = Hashable.__eq__ # Silence Py3k warning[](#l2.359)self.assertEqual(hash(H()), 0)[](#l2.360)self.assertFalse(issubclass(int, H))[](#l2.361)self.validate_abstract_methods(Hashable, '__hash__')[](#l2.362)self.validate_isinstance(Hashable, '__hash__')[](#l2.363)
- def test_Iterable(self):
# Check some non-iterables[](#l2.366)non_samples = [None, 42, 3.14, 1j][](#l2.367)for x in non_samples:[](#l2.368)self.assertNotIsInstance(x, Iterable)[](#l2.369)self.assertFalse(issubclass(type(x), Iterable), repr(type(x)))[](#l2.370)# Check some iterables[](#l2.371)samples = [str(),[](#l2.372)tuple(), list(), set(), frozenset(), dict(),[](#l2.373)dict().keys(), dict().items(), dict().values(),[](#l2.374)(lambda: (yield))(),[](#l2.375)(x for x in []),[](#l2.376)][](#l2.377)for x in samples:[](#l2.378)self.assertIsInstance(x, Iterable)[](#l2.379)self.assertTrue(issubclass(type(x), Iterable), repr(type(x)))[](#l2.380)# Check direct subclassing[](#l2.381)class I(Iterable):[](#l2.382)def __iter__(self):[](#l2.383)return super(I, self).__iter__()[](#l2.384)self.assertEqual(list(I()), [])[](#l2.385)self.assertFalse(issubclass(str, I))[](#l2.386)self.validate_abstract_methods(Iterable, '__iter__')[](#l2.387)self.validate_isinstance(Iterable, '__iter__')[](#l2.388)
- def test_Iterator(self):
non_samples = [None, 42, 3.14, 1j, "".encode('ascii'), "", (), [],[](#l2.391){}, set()][](#l2.392)for x in non_samples:[](#l2.393)self.assertNotIsInstance(x, Iterator)[](#l2.394)self.assertFalse(issubclass(type(x), Iterator), repr(type(x)))[](#l2.395)samples = [iter(str()),[](#l2.396)iter(tuple()), iter(list()), iter(dict()),[](#l2.397)iter(set()), iter(frozenset()),[](#l2.398)iter(dict().keys()), iter(dict().items()),[](#l2.399)iter(dict().values()),[](#l2.400)(lambda: (yield))(),[](#l2.401)(x for x in []),[](#l2.402)][](#l2.403)for x in samples:[](#l2.404)self.assertIsInstance(x, Iterator)[](#l2.405)self.assertTrue(issubclass(type(x), Iterator), repr(type(x)))[](#l2.406)self.validate_abstract_methods(Iterator, 'next', '__iter__')[](#l2.407)
# Issue 10565[](#l2.409)class NextOnly:[](#l2.410)def __next__(self):[](#l2.411)yield 1[](#l2.412)raise StopIteration[](#l2.413)self.assertNotIsInstance(NextOnly(), Iterator)[](#l2.414)class NextOnlyNew(object):[](#l2.415)def __next__(self):[](#l2.416)yield 1[](#l2.417)raise StopIteration[](#l2.418)self.assertNotIsInstance(NextOnlyNew(), Iterator)[](#l2.419)
- def test_Sized(self):
non_samples = [None, 42, 3.14, 1j,[](#l2.422)(lambda: (yield))(),[](#l2.423)(x for x in []),[](#l2.424)][](#l2.425)for x in non_samples:[](#l2.426)self.assertNotIsInstance(x, Sized)[](#l2.427)self.assertFalse(issubclass(type(x), Sized), repr(type(x)))[](#l2.428)samples = [str(),[](#l2.429)tuple(), list(), set(), frozenset(), dict(),[](#l2.430)dict().keys(), dict().items(), dict().values(),[](#l2.431)][](#l2.432)for x in samples:[](#l2.433)self.assertIsInstance(x, Sized)[](#l2.434)self.assertTrue(issubclass(type(x), Sized), repr(type(x)))[](#l2.435)self.validate_abstract_methods(Sized, '__len__')[](#l2.436)self.validate_isinstance(Sized, '__len__')[](#l2.437)
- def test_Container(self):
non_samples = [None, 42, 3.14, 1j,[](#l2.440)(lambda: (yield))(),[](#l2.441)(x for x in []),[](#l2.442)][](#l2.443)for x in non_samples:[](#l2.444)self.assertNotIsInstance(x, Container)[](#l2.445)self.assertFalse(issubclass(type(x), Container), repr(type(x)))[](#l2.446)samples = [str(),[](#l2.447)tuple(), list(), set(), frozenset(), dict(),[](#l2.448)dict().keys(), dict().items(),[](#l2.449)][](#l2.450)for x in samples:[](#l2.451)self.assertIsInstance(x, Container)[](#l2.452)self.assertTrue(issubclass(type(x), Container), repr(type(x)))[](#l2.453)self.validate_abstract_methods(Container, '__contains__')[](#l2.454)self.validate_isinstance(Container, '__contains__')[](#l2.455)
- def test_Callable(self):
non_samples = [None, 42, 3.14, 1j,[](#l2.458)"", "".encode('ascii'), (), [], {}, set(),[](#l2.459)(lambda: (yield))(),[](#l2.460)(x for x in []),[](#l2.461)][](#l2.462)for x in non_samples:[](#l2.463)self.assertNotIsInstance(x, Callable)[](#l2.464)self.assertFalse(issubclass(type(x), Callable), repr(type(x)))[](#l2.465)samples = [lambda: None,[](#l2.466)type, int, object,[](#l2.467)len,[](#l2.468)list.append, [].append,[](#l2.469)][](#l2.470)for x in samples:[](#l2.471)self.assertIsInstance(x, Callable)[](#l2.472)self.assertTrue(issubclass(type(x), Callable), repr(type(x)))[](#l2.473)self.validate_abstract_methods(Callable, '__call__')[](#l2.474)self.validate_isinstance(Callable, '__call__')[](#l2.475)
- def test_direct_subclassing(self):
for B in Hashable, Iterable, Iterator, Sized, Container, Callable:[](#l2.478)class C(B):[](#l2.479)pass[](#l2.480)self.assertTrue(issubclass(C, B))[](#l2.481)self.assertFalse(issubclass(int, C))[](#l2.482)
- def test_registration(self):
for B in Hashable, Iterable, Iterator, Sized, Container, Callable:[](#l2.485)class C:[](#l2.486)__metaclass__ = type[](#l2.487)__hash__ = None # Make sure it isn't hashable by default[](#l2.488)self.assertFalse(issubclass(C, B), B.__name__)[](#l2.489)B.register(C)[](#l2.490)self.assertTrue(issubclass(C, B))[](#l2.491)
- -class WithSet(MutableSet): -
- -class TestCollectionABCs(ABCTestCase): -
XXX For now, we only test some virtual inheritance properties.
We should also test the proper behavior of the collection ABCs
as real base classes or mix-in classes.
+import copy +import pickle +from random import shuffle +import unittest +from collections import OrderedDict +from collections import MutableMapping +from test import mapping_tests, test_support
- def test_Set(self):
for sample in [set, frozenset]:[](#l2.527)self.assertIsInstance(sample(), Set)[](#l2.528)self.assertTrue(issubclass(sample, Set))[](#l2.529)self.validate_abstract_methods(Set, '__contains__', '__iter__', '__len__')[](#l2.530)class MySet(Set):[](#l2.531)def __contains__(self, x):[](#l2.532)return False[](#l2.533)def __len__(self):[](#l2.534)return 0[](#l2.535)def __iter__(self):[](#l2.536)return iter([])[](#l2.537)self.validate_comparison(MySet())[](#l2.538)
- def test_hash_Set(self):
class OneTwoThreeSet(Set):[](#l2.541)def __init__(self):[](#l2.542)self.contents = [1, 2, 3][](#l2.543)def __contains__(self, x):[](#l2.544)return x in self.contents[](#l2.545)def __len__(self):[](#l2.546)return len(self.contents)[](#l2.547)def __iter__(self):[](#l2.548)return iter(self.contents)[](#l2.549)def __hash__(self):[](#l2.550)return self._hash()[](#l2.551)a, b = OneTwoThreeSet(), OneTwoThreeSet()[](#l2.552)self.assertTrue(hash(a) == hash(b))[](#l2.553)
- def test_MutableSet(self):
self.assertIsInstance(set(), MutableSet)[](#l2.556)self.assertTrue(issubclass(set, MutableSet))[](#l2.557)self.assertNotIsInstance(frozenset(), MutableSet)[](#l2.558)self.assertFalse(issubclass(frozenset, MutableSet))[](#l2.559)self.validate_abstract_methods(MutableSet, '__contains__', '__iter__', '__len__',[](#l2.560)'add', 'discard')[](#l2.561)
- def test_issue_5647(self):
# MutableSet.__iand__ mutated the set during iteration[](#l2.564)s = WithSet('abcd')[](#l2.565)s &= WithSet('cdef') # This used to fail[](#l2.566)self.assertEqual(set(s), set('cd'))[](#l2.567)
- def test_issue_4920(self):
# MutableSet.pop() method did not work[](#l2.570)class MySet(collections.MutableSet):[](#l2.571)__slots__=['__s'][](#l2.572)def __init__(self,items=None):[](#l2.573)if items is None:[](#l2.574)items=[][](#l2.575)self.__s=set(items)[](#l2.576)def __contains__(self,v):[](#l2.577)return v in self.__s[](#l2.578)def __iter__(self):[](#l2.579)return iter(self.__s)[](#l2.580)def __len__(self):[](#l2.581)return len(self.__s)[](#l2.582)def add(self,v):[](#l2.583)result=v not in self.__s[](#l2.584)self.__s.add(v)[](#l2.585)return result[](#l2.586)def discard(self,v):[](#l2.587)result=v in self.__s[](#l2.588)self.__s.discard(v)[](#l2.589)return result[](#l2.590)def __repr__(self):[](#l2.591)return "MySet(%s)" % repr(list(self))[](#l2.592)s = MySet([5,43,2,1])[](#l2.593)self.assertEqual(s.pop(), 1)[](#l2.594)
- def test_issue8750(self):
empty = WithSet()[](#l2.597)full = WithSet(range(10))[](#l2.598)s = WithSet(full)[](#l2.599)s -= s[](#l2.600)self.assertEqual(s, empty)[](#l2.601)s = WithSet(full)[](#l2.602)s ^= s[](#l2.603)self.assertEqual(s, empty)[](#l2.604)s = WithSet(full)[](#l2.605)s &= s[](#l2.606)self.assertEqual(s, full)[](#l2.607)s |= s[](#l2.608)self.assertEqual(s, full)[](#l2.609)
- def test_issue16373(self):
# Recursion error comparing comparable and noncomparable[](#l2.612)# Set instances[](#l2.613)class MyComparableSet(Set):[](#l2.614)def __contains__(self, x):[](#l2.615)return False[](#l2.616)def __len__(self):[](#l2.617)return 0[](#l2.618)def __iter__(self):[](#l2.619)return iter([])[](#l2.620)class MyNonComparableSet(Set):[](#l2.621)def __contains__(self, x):[](#l2.622)return False[](#l2.623)def __len__(self):[](#l2.624)return 0[](#l2.625)def __iter__(self):[](#l2.626)return iter([])[](#l2.627)def __le__(self, x):[](#l2.628)return NotImplemented[](#l2.629)def __lt__(self, x):[](#l2.630)return NotImplemented[](#l2.631)
cs = MyComparableSet()[](#l2.633)ncs = MyNonComparableSet()[](#l2.634)
# Run all the variants to make sure they don't mutually recurse[](#l2.636)ncs < cs[](#l2.637)ncs <= cs[](#l2.638)ncs > cs[](#l2.639)ncs >= cs[](#l2.640)cs < ncs[](#l2.641)cs <= ncs[](#l2.642)cs > ncs[](#l2.643)cs >= ncs[](#l2.644)
- def assertSameSet(self, s1, s2):
# coerce both to a real set then check equality[](#l2.647)self.assertEqual(set(s1), set(s2))[](#l2.648)
- def test_Set_interoperability_with_real_sets(self):
# Issue: 8743[](#l2.651)class ListSet(Set):[](#l2.652)def __init__(self, elements=()):[](#l2.653)self.data = [][](#l2.654)for elem in elements:[](#l2.655)if elem not in self.data:[](#l2.656)self.data.append(elem)[](#l2.657)def __contains__(self, elem):[](#l2.658)return elem in self.data[](#l2.659)def __iter__(self):[](#l2.660)return iter(self.data)[](#l2.661)def __len__(self):[](#l2.662)return len(self.data)[](#l2.663)def __repr__(self):[](#l2.664)return 'Set({!r})'.format(self.data)[](#l2.665)
r1 = set('abc')[](#l2.667)r2 = set('bcd')[](#l2.668)r3 = set('abcde')[](#l2.669)f1 = ListSet('abc')[](#l2.670)f2 = ListSet('bcd')[](#l2.671)f3 = ListSet('abcde')[](#l2.672)l1 = list('abccba')[](#l2.673)l2 = list('bcddcb')[](#l2.674)l3 = list('abcdeedcba')[](#l2.675)p1 = sets.Set('abc')[](#l2.676)p2 = sets.Set('bcd')[](#l2.677)p3 = sets.Set('abcde')[](#l2.678)
target = r1 & r2[](#l2.680)self.assertSameSet(f1 & f2, target)[](#l2.681)self.assertSameSet(f1 & r2, target)[](#l2.682)self.assertSameSet(r2 & f1, target)[](#l2.683)self.assertSameSet(f1 & p2, target)[](#l2.684)self.assertSameSet(p2 & f1, target)[](#l2.685)self.assertSameSet(f1 & l2, target)[](#l2.686)
target = r1 | r2[](#l2.688)self.assertSameSet(f1 | f2, target)[](#l2.689)self.assertSameSet(f1 | r2, target)[](#l2.690)self.assertSameSet(r2 | f1, target)[](#l2.691)self.assertSameSet(f1 | p2, target)[](#l2.692)self.assertSameSet(p2 | f1, target)[](#l2.693)self.assertSameSet(f1 | l2, target)[](#l2.694)
fwd_target = r1 - r2[](#l2.696)rev_target = r2 - r1[](#l2.697)self.assertSameSet(f1 - f2, fwd_target)[](#l2.698)self.assertSameSet(f2 - f1, rev_target)[](#l2.699)self.assertSameSet(f1 - r2, fwd_target)[](#l2.700)self.assertSameSet(f2 - r1, rev_target)[](#l2.701)self.assertSameSet(r1 - f2, fwd_target)[](#l2.702)self.assertSameSet(r2 - f1, rev_target)[](#l2.703)self.assertSameSet(f1 - p2, fwd_target)[](#l2.704)self.assertSameSet(f2 - p1, rev_target)[](#l2.705)self.assertSameSet(p1 - f2, fwd_target)[](#l2.706)self.assertSameSet(p2 - f1, rev_target)[](#l2.707)self.assertSameSet(f1 - l2, fwd_target)[](#l2.708)self.assertSameSet(f2 - l1, rev_target)[](#l2.709)
target = r1 ^ r2[](#l2.711)self.assertSameSet(f1 ^ f2, target)[](#l2.712)self.assertSameSet(f1 ^ r2, target)[](#l2.713)self.assertSameSet(r2 ^ f1, target)[](#l2.714)self.assertSameSet(f1 ^ p2, target)[](#l2.715)self.assertSameSet(p2 ^ f1, target)[](#l2.716)self.assertSameSet(f1 ^ l2, target)[](#l2.717)
# proper subset[](#l2.719)self.assertTrue(f1 < f3)[](#l2.720)self.assertFalse(f1 < f1)[](#l2.721)self.assertFalse(f1 < f2)[](#l2.722)self.assertTrue(r1 < f3)[](#l2.723)self.assertFalse(r1 < f1)[](#l2.724)self.assertFalse(r1 < f2)[](#l2.725)self.assertTrue(r1 < r3)[](#l2.726)self.assertFalse(r1 < r1)[](#l2.727)self.assertFalse(r1 < r2)[](#l2.728)
with test_support.check_py3k_warnings():[](#l2.730)# python 2 only, cross-type compares will succeed[](#l2.731)f1 < l3[](#l2.732)f1 < l1[](#l2.733)f1 < l2[](#l2.734)
# any subset[](#l2.736)self.assertTrue(f1 <= f3)[](#l2.737)self.assertTrue(f1 <= f1)[](#l2.738)self.assertFalse(f1 <= f2)[](#l2.739)self.assertTrue(r1 <= f3)[](#l2.740)self.assertTrue(r1 <= f1)[](#l2.741)self.assertFalse(r1 <= f2)[](#l2.742)self.assertTrue(r1 <= r3)[](#l2.743)self.assertTrue(r1 <= r1)[](#l2.744)self.assertFalse(r1 <= r2)[](#l2.745)
with test_support.check_py3k_warnings():[](#l2.747)# python 2 only, cross-type compares will succeed[](#l2.748)f1 <= l3[](#l2.749)f1 <= l1[](#l2.750)f1 <= l2[](#l2.751)
# proper superset[](#l2.753)self.assertTrue(f3 > f1)[](#l2.754)self.assertFalse(f1 > f1)[](#l2.755)self.assertFalse(f2 > f1)[](#l2.756)self.assertTrue(r3 > r1)[](#l2.757)self.assertFalse(f1 > r1)[](#l2.758)self.assertFalse(f2 > r1)[](#l2.759)self.assertTrue(r3 > r1)[](#l2.760)self.assertFalse(r1 > r1)[](#l2.761)self.assertFalse(r2 > r1)[](#l2.762)
with test_support.check_py3k_warnings():[](#l2.764)# python 2 only, cross-type compares will succeed[](#l2.765)f1 > l3[](#l2.766)f1 > l1[](#l2.767)f1 > l2[](#l2.768)
# any superset[](#l2.770)self.assertTrue(f3 >= f1)[](#l2.771)self.assertTrue(f1 >= f1)[](#l2.772)self.assertFalse(f2 >= f1)[](#l2.773)self.assertTrue(r3 >= r1)[](#l2.774)self.assertTrue(f1 >= r1)[](#l2.775)self.assertFalse(f2 >= r1)[](#l2.776)self.assertTrue(r3 >= r1)[](#l2.777)self.assertTrue(r1 >= r1)[](#l2.778)self.assertFalse(r2 >= r1)[](#l2.779)
with test_support.check_py3k_warnings():[](#l2.781)# python 2 only, cross-type compares will succeed[](#l2.782)f1 >= l3[](#l2.783)f1 >=l1[](#l2.784)f1 >= l2[](#l2.785)
# equality[](#l2.787)self.assertTrue(f1 == f1)[](#l2.788)self.assertTrue(r1 == f1)[](#l2.789)self.assertTrue(f1 == r1)[](#l2.790)self.assertFalse(f1 == f3)[](#l2.791)self.assertFalse(r1 == f3)[](#l2.792)self.assertFalse(f1 == r3)[](#l2.793)# python 2 only, cross-type compares will succeed[](#l2.794)f1 == l3[](#l2.795)f1 == l1[](#l2.796)f1 == l2[](#l2.797)
# inequality[](#l2.799)self.assertFalse(f1 != f1)[](#l2.800)self.assertFalse(r1 != f1)[](#l2.801)self.assertFalse(f1 != r1)[](#l2.802)self.assertTrue(f1 != f3)[](#l2.803)self.assertTrue(r1 != f3)[](#l2.804)self.assertTrue(f1 != r3)[](#l2.805)# python 2 only, cross-type compares will succeed[](#l2.806)f1 != l3[](#l2.807)f1 != l1[](#l2.808)f1 != l2[](#l2.809)
- def test_Mapping(self):
for sample in [dict]:[](#l2.812)self.assertIsInstance(sample(), Mapping)[](#l2.813)self.assertTrue(issubclass(sample, Mapping))[](#l2.814)self.validate_abstract_methods(Mapping, '__contains__', '__iter__', '__len__',[](#l2.815)'__getitem__')[](#l2.816)class MyMapping(collections.Mapping):[](#l2.817)def __len__(self):[](#l2.818)return 0[](#l2.819)def __getitem__(self, i):[](#l2.820)raise IndexError[](#l2.821)def __iter__(self):[](#l2.822)return iter(())[](#l2.823)self.validate_comparison(MyMapping())[](#l2.824)
- def test_MutableMapping(self):
for sample in [dict]:[](#l2.827)self.assertIsInstance(sample(), MutableMapping)[](#l2.828)self.assertTrue(issubclass(sample, MutableMapping))[](#l2.829)self.validate_abstract_methods(MutableMapping, '__contains__', '__iter__', '__len__',[](#l2.830)'__getitem__', '__setitem__', '__delitem__')[](#l2.831)
- def test_Sequence(self):
for sample in [tuple, list, str]:[](#l2.834)self.assertIsInstance(sample(), Sequence)[](#l2.835)self.assertTrue(issubclass(sample, Sequence))[](#l2.836)self.assertTrue(issubclass(basestring, Sequence))[](#l2.837)self.assertIsInstance(range(10), Sequence)[](#l2.838)self.assertTrue(issubclass(xrange, Sequence))[](#l2.839)self.assertTrue(issubclass(str, Sequence))[](#l2.840)self.validate_abstract_methods(Sequence, '__contains__', '__iter__', '__len__',[](#l2.841)'__getitem__')[](#l2.842)
- def test_MutableSequence(self):
for sample in [tuple, str]:[](#l2.845)self.assertNotIsInstance(sample(), MutableSequence)[](#l2.846)self.assertFalse(issubclass(sample, MutableSequence))[](#l2.847)for sample in [list]:[](#l2.848)self.assertIsInstance(sample(), MutableSequence)[](#l2.849)self.assertTrue(issubclass(sample, MutableSequence))[](#l2.850)self.assertFalse(issubclass(basestring, MutableSequence))[](#l2.851)self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__',[](#l2.852)'__len__', '__getitem__', '__setitem__', '__delitem__', 'insert')[](#l2.853)
- -class TestCounter(unittest.TestCase): -
- def test_basics(self):
c = Counter('abcaba')[](#l2.858)self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1}))[](#l2.859)self.assertEqual(c, Counter(a=3, b=2, c=1))[](#l2.860)self.assertIsInstance(c, dict)[](#l2.861)self.assertIsInstance(c, Mapping)[](#l2.862)self.assertTrue(issubclass(Counter, dict))[](#l2.863)self.assertTrue(issubclass(Counter, Mapping))[](#l2.864)self.assertEqual(len(c), 3)[](#l2.865)self.assertEqual(sum(c.values()), 6)[](#l2.866)self.assertEqual(sorted(c.values()), [1, 2, 3])[](#l2.867)self.assertEqual(sorted(c.keys()), ['a', 'b', 'c'])[](#l2.868)self.assertEqual(sorted(c), ['a', 'b', 'c'])[](#l2.869)self.assertEqual(sorted(c.items()),[](#l2.870)[('a', 3), ('b', 2), ('c', 1)])[](#l2.871)self.assertEqual(c['b'], 2)[](#l2.872)self.assertEqual(c['z'], 0)[](#l2.873)with test_support.check_py3k_warnings():[](#l2.874)self.assertEqual(c.has_key('c'), True)[](#l2.875)self.assertEqual(c.has_key('z'), False)[](#l2.876)self.assertEqual(c.__contains__('c'), True)[](#l2.877)self.assertEqual(c.__contains__('z'), False)[](#l2.878)self.assertEqual(c.get('b', 10), 2)[](#l2.879)self.assertEqual(c.get('z', 10), 10)[](#l2.880)self.assertEqual(c, dict(a=3, b=2, c=1))[](#l2.881)self.assertEqual(repr(c), "Counter({'a': 3, 'b': 2, 'c': 1})")[](#l2.882)self.assertEqual(c.most_common(), [('a', 3), ('b', 2), ('c', 1)])[](#l2.883)for i in range(5):[](#l2.884)self.assertEqual(c.most_common(i),[](#l2.885)[('a', 3), ('b', 2), ('c', 1)][:i])[](#l2.886)self.assertEqual(''.join(sorted(c.elements())), 'aaabbc')[](#l2.887)c['a'] += 1 # increment an existing value[](#l2.888)c['b'] -= 2 # sub existing value to zero[](#l2.889)del c['c'] # remove an entry[](#l2.890)del c['c'] # make sure that del doesn't raise KeyError[](#l2.891)c['d'] -= 2 # sub from a missing value[](#l2.892)c['e'] = -5 # directly assign a missing value[](#l2.893)c['f'] += 4 # add to a missing value[](#l2.894)self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))[](#l2.895)self.assertEqual(''.join(sorted(c.elements())), 'aaaaffff')[](#l2.896)self.assertEqual(c.pop('f'), 4)[](#l2.897)self.assertNotIn('f', c)[](#l2.898)for i in range(3):[](#l2.899)elem, cnt = c.popitem()[](#l2.900)self.assertNotIn(elem, c)[](#l2.901)c.clear()[](#l2.902)self.assertEqual(c, {})[](#l2.903)self.assertEqual(repr(c), 'Counter()')[](#l2.904)self.assertRaises(NotImplementedError, Counter.fromkeys, 'abc')[](#l2.905)self.assertRaises(TypeError, hash, c)[](#l2.906)c.update(dict(a=5, b=3))[](#l2.907)c.update(c=1)[](#l2.908)c.update(Counter('a' * 50 + 'b' * 30))[](#l2.909)c.update() # test case with no args[](#l2.910)c.__init__('a' * 500 + 'b' * 300)[](#l2.911)c.__init__('cdc')[](#l2.912)c.__init__()[](#l2.913)self.assertEqual(c, dict(a=555, b=333, c=3, d=1))[](#l2.914)self.assertEqual(c.setdefault('d', 5), 1)[](#l2.915)self.assertEqual(c['d'], 1)[](#l2.916)self.assertEqual(c.setdefault('e', 5), 5)[](#l2.917)self.assertEqual(c['e'], 5)[](#l2.918)
- def test_init(self):
self.assertEqual(list(Counter(self=42).items()), [('self', 42)])[](#l2.921)self.assertEqual(list(Counter(iterable=42).items()), [('iterable', 42)])[](#l2.922)self.assertEqual(list(Counter(iterable=None).items()), [('iterable', None)])[](#l2.923)self.assertRaises(TypeError, Counter, 42)[](#l2.924)self.assertRaises(TypeError, Counter, (), ())[](#l2.925)self.assertRaises(TypeError, Counter.__init__)[](#l2.926)
- def test_update(self):
c = Counter()[](#l2.929)c.update(self=42)[](#l2.930)self.assertEqual(list(c.items()), [('self', 42)])[](#l2.931)c = Counter()[](#l2.932)c.update(iterable=42)[](#l2.933)self.assertEqual(list(c.items()), [('iterable', 42)])[](#l2.934)c = Counter()[](#l2.935)c.update(iterable=None)[](#l2.936)self.assertEqual(list(c.items()), [('iterable', None)])[](#l2.937)self.assertRaises(TypeError, Counter().update, 42)[](#l2.938)self.assertRaises(TypeError, Counter().update, {}, {})[](#l2.939)self.assertRaises(TypeError, Counter.update)[](#l2.940)
- def test_copying(self):
# Check that counters are copyable, deepcopyable, picklable, and[](#l2.943)#have a repr/eval round-trip[](#l2.944)words = Counter('which witch had which witches wrist watch'.split())[](#l2.945)update_test = Counter()[](#l2.946)update_test.update(words)[](#l2.947)for i, dup in enumerate([[](#l2.948)words.copy(),[](#l2.949)copy.copy(words),[](#l2.950)copy.deepcopy(words),[](#l2.951)pickle.loads(pickle.dumps(words, 0)),[](#l2.952)pickle.loads(pickle.dumps(words, 1)),[](#l2.953)pickle.loads(pickle.dumps(words, 2)),[](#l2.954)pickle.loads(pickle.dumps(words, -1)),[](#l2.955)cPickle.loads(cPickle.dumps(words, 0)),[](#l2.956)cPickle.loads(cPickle.dumps(words, 1)),[](#l2.957)cPickle.loads(cPickle.dumps(words, 2)),[](#l2.958)cPickle.loads(cPickle.dumps(words, -1)),[](#l2.959)eval(repr(words)),[](#l2.960)update_test,[](#l2.961)Counter(words),[](#l2.962)]):[](#l2.963)msg = (i, dup, words)[](#l2.964)self.assertTrue(dup is not words)[](#l2.965)self.assertEqual(dup, words)[](#l2.966)self.assertEqual(len(dup), len(words))[](#l2.967)self.assertEqual(type(dup), type(words))[](#l2.968)
- def test_copy_subclass(self):
class MyCounter(Counter):[](#l2.971)pass[](#l2.972)c = MyCounter('slartibartfast')[](#l2.973)d = c.copy()[](#l2.974)self.assertEqual(d, c)[](#l2.975)self.assertEqual(len(d), len(c))[](#l2.976)self.assertEqual(type(d), type(c))[](#l2.977)
- def test_conversions(self):
# Convert to: set, list, dict[](#l2.980)s = 'she sells sea shells by the sea shore'[](#l2.981)self.assertEqual(sorted(Counter(s).elements()), sorted(s))[](#l2.982)self.assertEqual(sorted(Counter(s)), sorted(set(s)))[](#l2.983)self.assertEqual(dict(Counter(s)), dict(Counter(s).items()))[](#l2.984)self.assertEqual(set(Counter(s)), set(s))[](#l2.985)
- def test_invariant_for_the_in_operator(self):
c = Counter(a=10, b=-2, c=0)[](#l2.988)for elem in c:[](#l2.989)self.assertTrue(elem in c)[](#l2.990)self.assertIn(elem, c)[](#l2.991)
- def test_multiset_operations(self):
# Verify that adding a zero counter will strip zeros and negatives[](#l2.994)c = Counter(a=10, b=-2, c=0) + Counter()[](#l2.995)self.assertEqual(dict(c), dict(a=10))[](#l2.996)
elements = 'abcd'[](#l2.998)for i in range(1000):[](#l2.999)# test random pairs of multisets[](#l2.1000)p = Counter(dict((elem, randrange(-2,4)) for elem in elements))[](#l2.1001)p.update(e=1, f=-1, g=0)[](#l2.1002)q = Counter(dict((elem, randrange(-2,4)) for elem in elements))[](#l2.1003)q.update(h=1, i=-1, j=0)[](#l2.1004)for counterop, numberop in [[](#l2.1005)(Counter.__add__, lambda x, y: max(0, x+y)),[](#l2.1006)(Counter.__sub__, lambda x, y: max(0, x-y)),[](#l2.1007)(Counter.__or__, lambda x, y: max(0,x,y)),[](#l2.1008)(Counter.__and__, lambda x, y: max(0, min(x,y))),[](#l2.1009)]:[](#l2.1010)result = counterop(p, q)[](#l2.1011)for x in elements:[](#l2.1012)self.assertEqual(numberop(p[x], q[x]), result[x],[](#l2.1013)(counterop, x, p, q))[](#l2.1014)# verify that results exclude non-positive counts[](#l2.1015)self.assertTrue(x>0 for x in result.values())[](#l2.1016)
elements = 'abcdef'[](#l2.1018)for i in range(100):[](#l2.1019)# verify that random multisets with no repeats are exactly like sets[](#l2.1020)p = Counter(dict((elem, randrange(0, 2)) for elem in elements))[](#l2.1021)q = Counter(dict((elem, randrange(0, 2)) for elem in elements))[](#l2.1022)for counterop, setop in [[](#l2.1023)(Counter.__sub__, set.__sub__),[](#l2.1024)(Counter.__or__, set.__or__),[](#l2.1025)(Counter.__and__, set.__and__),[](#l2.1026)]:[](#l2.1027)counter_result = counterop(p, q)[](#l2.1028)set_result = setop(set(p.elements()), set(q.elements()))[](#l2.1029)self.assertEqual(counter_result, dict.fromkeys(set_result, 1))[](#l2.1030)
- def test_subtract(self):
c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)[](#l2.1033)c.subtract(a=1, b=2, c=-3, d=10, e=20, f=30, h=-50)[](#l2.1034)self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))[](#l2.1035)c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)[](#l2.1036)c.subtract(Counter(a=1, b=2, c=-3, d=10, e=20, f=30, h=-50))[](#l2.1037)self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))[](#l2.1038)c = Counter('aaabbcd')[](#l2.1039)c.subtract('aaaabbcce')[](#l2.1040)self.assertEqual(c, Counter(a=-1, b=0, c=-1, d=1, e=-1))[](#l2.1041)
c = Counter()[](#l2.1043)c.subtract(self=42)[](#l2.1044)self.assertEqual(list(c.items()), [('self', -42)])[](#l2.1045)c = Counter()[](#l2.1046)c.subtract(iterable=42)[](#l2.1047)self.assertEqual(list(c.items()), [('iterable', -42)])[](#l2.1048)self.assertRaises(TypeError, Counter().subtract, 42)[](#l2.1049)self.assertRaises(TypeError, Counter().subtract, {}, {})[](#l2.1050)self.assertRaises(TypeError, Counter.subtract)[](#l2.1051)
class TestOrderedDict(unittest.TestCase): @@ -1315,15 +284,10 @@ class SubclassMappingTests(mapping_tests d = self._empty_mapping() self.assertRaises(KeyError, d.popitem) -import collections def test_main(verbose=None):
- NamedTupleDocs = doctest.DocTestSuite(module=collections)
- test_classes = [TestNamedTuple, NamedTupleDocs, TestOneTrickPonyABCs,
TestCollectionABCs, TestCounter,[](#l2.1064)TestOrderedDict, GeneralMappingTests, SubclassMappingTests][](#l2.1065)
- test_classes = [TestOrderedDict, GeneralMappingTests, SubclassMappingTests] test_support.run_unittest(*test_classes)
if name == "main": test_main(verbose=True)