source: titan/mediathek/localhoster/lib/python2.7/test/test_collections.py @ 40661

Last change on this file since 40661 was 40661, checked in by obi, 7 years ago

reset

File size: 51.0 KB
Line 
1
2import unittest, doctest, operator
3import inspect
4from test import test_support
5from collections import namedtuple, Counter, OrderedDict
6from test import mapping_tests
7import pickle, cPickle, copy
8from random import randrange, shuffle
9import keyword
10import re
11import sys
12from collections import Hashable, Iterable, Iterator
13from collections import Sized, Container, Callable
14from collections import Set, MutableSet
15from collections import Mapping, MutableMapping
16from collections import Sequence, MutableSequence
17# Silence deprecation warning
18sets = test_support.import_module('sets', deprecated=True)
19
20TestNT = namedtuple('TestNT', 'x y z')    # type used for pickle tests
21
22py273_named_tuple_pickle = '''\
23ccopy_reg
24_reconstructor
25p0
26(ctest.test_collections
27TestNT
28p1
29c__builtin__
30tuple
31p2
32(I10
33I20
34I30
35tp3
36tp4
37Rp5
38ccollections
39OrderedDict
40p6
41((lp7
42(lp8
43S'x'
44p9
45aI10
46aa(lp10
47S'y'
48p11
49aI20
50aa(lp12
51S'z'
52p13
53aI30
54aatp14
55Rp15
56b.
57'''
58
59class TestNamedTuple(unittest.TestCase):
60
61    def test_factory(self):
62        Point = namedtuple('Point', 'x y')
63        self.assertEqual(Point.__name__, 'Point')
64        self.assertEqual(Point.__slots__, ())
65        self.assertEqual(Point.__module__, __name__)
66        self.assertEqual(Point.__getitem__, tuple.__getitem__)
67        self.assertEqual(Point._fields, ('x', 'y'))
68
69        self.assertRaises(ValueError, namedtuple, 'abc%', 'efg ghi')       # type has non-alpha char
70        self.assertRaises(ValueError, namedtuple, 'class', 'efg ghi')      # type has keyword
71        self.assertRaises(ValueError, namedtuple, '9abc', 'efg ghi')       # type starts with digit
72
73        self.assertRaises(ValueError, namedtuple, 'abc', 'efg g%hi')       # field with non-alpha char
74        self.assertRaises(ValueError, namedtuple, 'abc', 'abc class')      # field has keyword
75        self.assertRaises(ValueError, namedtuple, 'abc', '8efg 9ghi')      # field starts with digit
76        self.assertRaises(ValueError, namedtuple, 'abc', '_efg ghi')       # field with leading underscore
77        self.assertRaises(ValueError, namedtuple, 'abc', 'efg efg ghi')    # duplicate field
78
79        namedtuple('Point0', 'x1 y2')   # Verify that numbers are allowed in names
80        namedtuple('_', 'a b c')        # Test leading underscores in a typename
81
82        nt = namedtuple('nt', u'the quick brown fox')                       # check unicode input
83        self.assertNotIn("u'", repr(nt._fields))
84        nt = namedtuple('nt', (u'the', u'quick'))                           # check unicode input
85        self.assertNotIn("u'", repr(nt._fields))
86
87        self.assertRaises(TypeError, Point._make, [11])                     # catch too few args
88        self.assertRaises(TypeError, Point._make, [11, 22, 33])             # catch too many args
89
90    @unittest.skipIf(sys.flags.optimize >= 2,
91                     "Docstrings are omitted with -O2 and above")
92    def test_factory_doc_attr(self):
93        Point = namedtuple('Point', 'x y')
94        self.assertEqual(Point.__doc__, 'Point(x, y)')
95
96    def test_name_fixer(self):
97        for spec, renamed in [
98            [('efg', 'g%hi'),  ('efg', '_1')],                              # field with non-alpha char
99            [('abc', 'class'), ('abc', '_1')],                              # field has keyword
100            [('8efg', '9ghi'), ('_0', '_1')],                               # field starts with digit
101            [('abc', '_efg'), ('abc', '_1')],                               # field with leading underscore
102            [('abc', 'efg', 'efg', 'ghi'), ('abc', 'efg', '_2', 'ghi')],    # duplicate field
103            [('abc', '', 'x'), ('abc', '_1', 'x')],                         # fieldname is a space
104        ]:
105            self.assertEqual(namedtuple('NT', spec, rename=True)._fields, renamed)
106
107    def test_instance(self):
108        Point = namedtuple('Point', 'x y')
109        p = Point(11, 22)
110        self.assertEqual(p, Point(x=11, y=22))
111        self.assertEqual(p, Point(11, y=22))
112        self.assertEqual(p, Point(y=22, x=11))
113        self.assertEqual(p, Point(*(11, 22)))
114        self.assertEqual(p, Point(**dict(x=11, y=22)))
115        self.assertRaises(TypeError, Point, 1)                              # too few args
116        self.assertRaises(TypeError, Point, 1, 2, 3)                        # too many args
117        self.assertRaises(TypeError, eval, 'Point(XXX=1, y=2)', locals())   # wrong keyword argument
118        self.assertRaises(TypeError, eval, 'Point(x=1)', locals())          # missing keyword argument
119        self.assertEqual(repr(p), 'Point(x=11, y=22)')
120        self.assertNotIn('__weakref__', dir(p))
121        self.assertEqual(p, Point._make([11, 22]))                          # test _make classmethod
122        self.assertEqual(p._fields, ('x', 'y'))                             # test _fields attribute
123        self.assertEqual(p._replace(x=1), (1, 22))                          # test _replace method
124        self.assertEqual(p._asdict(), dict(x=11, y=22))                     # test _asdict method
125        self.assertEqual(vars(p), p._asdict())                              # verify that vars() works
126
127        try:
128            p._replace(x=1, error=2)
129        except ValueError:
130            pass
131        else:
132            self._fail('Did not detect an incorrect fieldname')
133
134        # verify that field string can have commas
135        Point = namedtuple('Point', 'x, y')
136        p = Point(x=11, y=22)
137        self.assertEqual(repr(p), 'Point(x=11, y=22)')
138
139        # verify that fieldspec can be a non-string sequence
140        Point = namedtuple('Point', ('x', 'y'))
141        p = Point(x=11, y=22)
142        self.assertEqual(repr(p), 'Point(x=11, y=22)')
143
144    def test_tupleness(self):
145        Point = namedtuple('Point', 'x y')
146        p = Point(11, 22)
147
148        self.assertIsInstance(p, tuple)
149        self.assertEqual(p, (11, 22))                                       # matches a real tuple
150        self.assertEqual(tuple(p), (11, 22))                                # coercable to a real tuple
151        self.assertEqual(list(p), [11, 22])                                 # coercable to a list
152        self.assertEqual(max(p), 22)                                        # iterable
153        self.assertEqual(max(*p), 22)                                       # star-able
154        x, y = p
155        self.assertEqual(p, (x, y))                                         # unpacks like a tuple
156        self.assertEqual((p[0], p[1]), (11, 22))                            # indexable like a tuple
157        self.assertRaises(IndexError, p.__getitem__, 3)
158
159        self.assertEqual(p.x, x)
160        self.assertEqual(p.y, y)
161        self.assertRaises(AttributeError, eval, 'p.z', locals())
162
163    def test_odd_sizes(self):
164        Zero = namedtuple('Zero', '')
165        self.assertEqual(Zero(), ())
166        self.assertEqual(Zero._make([]), ())
167        self.assertEqual(repr(Zero()), 'Zero()')
168        self.assertEqual(Zero()._asdict(), {})
169        self.assertEqual(Zero()._fields, ())
170
171        Dot = namedtuple('Dot', 'd')
172        self.assertEqual(Dot(1), (1,))
173        self.assertEqual(Dot._make([1]), (1,))
174        self.assertEqual(Dot(1).d, 1)
175        self.assertEqual(repr(Dot(1)), 'Dot(d=1)')
176        self.assertEqual(Dot(1)._asdict(), {'d':1})
177        self.assertEqual(Dot(1)._replace(d=999), (999,))
178        self.assertEqual(Dot(1)._fields, ('d',))
179
180        n = 5000
181        import string, random
182        names = list(set(''.join([random.choice(string.ascii_letters)
183                                  for j in range(10)]) for i in range(n)))
184        n = len(names)
185        Big = namedtuple('Big', names)
186        b = Big(*range(n))
187        self.assertEqual(b, tuple(range(n)))
188        self.assertEqual(Big._make(range(n)), tuple(range(n)))
189        for pos, name in enumerate(names):
190            self.assertEqual(getattr(b, name), pos)
191        repr(b)                                 # make sure repr() doesn't blow-up
192        d = b._asdict()
193        d_expected = dict(zip(names, range(n)))
194        self.assertEqual(d, d_expected)
195        b2 = b._replace(**dict([(names[1], 999),(names[-5], 42)]))
196        b2_expected = range(n)
197        b2_expected[1] = 999
198        b2_expected[-5] = 42
199        self.assertEqual(b2, tuple(b2_expected))
200        self.assertEqual(b._fields, tuple(names))
201
202    def test_pickle(self):
203        p = TestNT(x=10, y=20, z=30)
204        for module in pickle, cPickle:
205            loads = getattr(module, 'loads')
206            dumps = getattr(module, 'dumps')
207            for protocol in -1, 0, 1, 2:
208                q = loads(dumps(p, protocol))
209                self.assertEqual(p, q)
210                self.assertEqual(p._fields, q._fields)
211
212    def test_copy(self):
213        p = TestNT(x=10, y=20, z=30)
214        for copier in copy.copy, copy.deepcopy:
215            q = copier(p)
216            self.assertEqual(p, q)
217            self.assertEqual(p._fields, q._fields)
218
219    def test_name_conflicts(self):
220        # Some names like "self", "cls", "tuple", "itemgetter", and "property"
221        # failed when used as field names.  Test to make sure these now work.
222        T = namedtuple('T', 'itemgetter property self cls tuple')
223        t = T(1, 2, 3, 4, 5)
224        self.assertEqual(t, (1,2,3,4,5))
225        newt = t._replace(itemgetter=10, property=20, self=30, cls=40, tuple=50)
226        self.assertEqual(newt, (10,20,30,40,50))
227
228        # Broader test of all interesting names in a template
229        with test_support.captured_stdout() as template:
230            T = namedtuple('T', 'x', verbose=True)
231        words = set(re.findall('[A-Za-z]+', template.getvalue()))
232        words -= set(keyword.kwlist)
233        T = namedtuple('T', words)
234        # test __new__
235        values = tuple(range(len(words)))
236        t = T(*values)
237        self.assertEqual(t, values)
238        t = T(**dict(zip(T._fields, values)))
239        self.assertEqual(t, values)
240        # test _make
241        t = T._make(values)
242        self.assertEqual(t, values)
243        # exercise __repr__
244        repr(t)
245        # test _asdict
246        self.assertEqual(t._asdict(), dict(zip(T._fields, values)))
247        # test _replace
248        t = T._make(values)
249        newvalues = tuple(v*10 for v in values)
250        newt = t._replace(**dict(zip(T._fields, newvalues)))
251        self.assertEqual(newt, newvalues)
252        # test _fields
253        self.assertEqual(T._fields, tuple(words))
254        # test __getnewargs__
255        self.assertEqual(t.__getnewargs__(), values)
256
257    def test_pickling_bug_18015(self):
258        # http://bugs.python.org/issue18015
259        pt = pickle.loads(py273_named_tuple_pickle)
260        self.assertEqual(pt.x, 10)
261
262class ABCTestCase(unittest.TestCase):
263
264    def validate_abstract_methods(self, abc, *names):
265        methodstubs = dict.fromkeys(names, lambda s, *args: 0)
266
267        # everything should work will all required methods are present
268        C = type('C', (abc,), methodstubs)
269        C()
270
271        # instantiation should fail if a required method is missing
272        for name in names:
273            stubs = methodstubs.copy()
274            del stubs[name]
275            C = type('C', (abc,), stubs)
276            self.assertRaises(TypeError, C, name)
277
278    def validate_isinstance(self, abc, name):
279        stub = lambda s, *args: 0
280
281        # new-style class
282        C = type('C', (object,), {name: stub})
283        self.assertIsInstance(C(), abc)
284        self.assertTrue(issubclass(C, abc))
285        # old-style class
286        class C: pass
287        setattr(C, name, stub)
288        self.assertIsInstance(C(), abc)
289        self.assertTrue(issubclass(C, abc))
290
291        # new-style class
292        C = type('C', (object,), {'__hash__': None})
293        self.assertNotIsInstance(C(), abc)
294        self.assertFalse(issubclass(C, abc))
295        # old-style class
296        class C: pass
297        self.assertNotIsInstance(C(), abc)
298        self.assertFalse(issubclass(C, abc))
299
300    def validate_comparison(self, instance):
301        ops = ['lt', 'gt', 'le', 'ge', 'ne', 'or', 'and', 'xor', 'sub']
302        operators = {}
303        for op in ops:
304            name = '__' + op + '__'
305            operators[name] = getattr(operator, name)
306
307        class Other:
308            def __init__(self):
309                self.right_side = False
310            def __eq__(self, other):
311                self.right_side = True
312                return True
313            __lt__ = __eq__
314            __gt__ = __eq__
315            __le__ = __eq__
316            __ge__ = __eq__
317            __ne__ = __eq__
318            __ror__ = __eq__
319            __rand__ = __eq__
320            __rxor__ = __eq__
321            __rsub__ = __eq__
322
323        for name, op in operators.items():
324            if not hasattr(instance, name):
325                continue
326            other = Other()
327            op(instance, other)
328            self.assertTrue(other.right_side,'Right side not called for %s.%s'
329                            % (type(instance), name))
330
331class TestOneTrickPonyABCs(ABCTestCase):
332
333    def test_Hashable(self):
334        # Check some non-hashables
335        non_samples = [list(), set(), dict()]
336        for x in non_samples:
337            self.assertNotIsInstance(x, Hashable)
338            self.assertFalse(issubclass(type(x), Hashable), repr(type(x)))
339        # Check some hashables
340        samples = [None,
341                   int(), float(), complex(),
342                   str(),
343                   tuple(), frozenset(),
344                   int, list, object, type,
345                   ]
346        for x in samples:
347            self.assertIsInstance(x, Hashable)
348            self.assertTrue(issubclass(type(x), Hashable), repr(type(x)))
349        self.assertRaises(TypeError, Hashable)
350        # Check direct subclassing
351        class H(Hashable):
352            def __hash__(self):
353                return super(H, self).__hash__()
354            __eq__ = Hashable.__eq__ # Silence Py3k warning
355        self.assertEqual(hash(H()), 0)
356        self.assertFalse(issubclass(int, H))
357        self.validate_abstract_methods(Hashable, '__hash__')
358        self.validate_isinstance(Hashable, '__hash__')
359
360    def test_Iterable(self):
361        # Check some non-iterables
362        non_samples = [None, 42, 3.14, 1j]
363        for x in non_samples:
364            self.assertNotIsInstance(x, Iterable)
365            self.assertFalse(issubclass(type(x), Iterable), repr(type(x)))
366        # Check some iterables
367        samples = [str(),
368                   tuple(), list(), set(), frozenset(), dict(),
369                   dict().keys(), dict().items(), dict().values(),
370                   (lambda: (yield))(),
371                   (x for x in []),
372                   ]
373        for x in samples:
374            self.assertIsInstance(x, Iterable)
375            self.assertTrue(issubclass(type(x), Iterable), repr(type(x)))
376        # Check direct subclassing
377        class I(Iterable):
378            def __iter__(self):
379                return super(I, self).__iter__()
380        self.assertEqual(list(I()), [])
381        self.assertFalse(issubclass(str, I))
382        self.validate_abstract_methods(Iterable, '__iter__')
383        self.validate_isinstance(Iterable, '__iter__')
384
385    def test_Iterator(self):
386        non_samples = [None, 42, 3.14, 1j, "".encode('ascii'), "", (), [],
387            {}, set()]
388        for x in non_samples:
389            self.assertNotIsInstance(x, Iterator)
390            self.assertFalse(issubclass(type(x), Iterator), repr(type(x)))
391        samples = [iter(str()),
392                   iter(tuple()), iter(list()), iter(dict()),
393                   iter(set()), iter(frozenset()),
394                   iter(dict().keys()), iter(dict().items()),
395                   iter(dict().values()),
396                   (lambda: (yield))(),
397                   (x for x in []),
398                   ]
399        for x in samples:
400            self.assertIsInstance(x, Iterator)
401            self.assertTrue(issubclass(type(x), Iterator), repr(type(x)))
402        self.validate_abstract_methods(Iterator, 'next', '__iter__')
403
404        # Issue 10565
405        class NextOnly:
406            def __next__(self):
407                yield 1
408                raise StopIteration
409        self.assertNotIsInstance(NextOnly(), Iterator)
410        class NextOnlyNew(object):
411            def __next__(self):
412                yield 1
413                raise StopIteration
414        self.assertNotIsInstance(NextOnlyNew(), Iterator)
415
416    def test_Sized(self):
417        non_samples = [None, 42, 3.14, 1j,
418                       (lambda: (yield))(),
419                       (x for x in []),
420                       ]
421        for x in non_samples:
422            self.assertNotIsInstance(x, Sized)
423            self.assertFalse(issubclass(type(x), Sized), repr(type(x)))
424        samples = [str(),
425                   tuple(), list(), set(), frozenset(), dict(),
426                   dict().keys(), dict().items(), dict().values(),
427                   ]
428        for x in samples:
429            self.assertIsInstance(x, Sized)
430            self.assertTrue(issubclass(type(x), Sized), repr(type(x)))
431        self.validate_abstract_methods(Sized, '__len__')
432        self.validate_isinstance(Sized, '__len__')
433
434    def test_Container(self):
435        non_samples = [None, 42, 3.14, 1j,
436                       (lambda: (yield))(),
437                       (x for x in []),
438                       ]
439        for x in non_samples:
440            self.assertNotIsInstance(x, Container)
441            self.assertFalse(issubclass(type(x), Container), repr(type(x)))
442        samples = [str(),
443                   tuple(), list(), set(), frozenset(), dict(),
444                   dict().keys(), dict().items(),
445                   ]
446        for x in samples:
447            self.assertIsInstance(x, Container)
448            self.assertTrue(issubclass(type(x), Container), repr(type(x)))
449        self.validate_abstract_methods(Container, '__contains__')
450        self.validate_isinstance(Container, '__contains__')
451
452    def test_Callable(self):
453        non_samples = [None, 42, 3.14, 1j,
454                       "", "".encode('ascii'), (), [], {}, set(),
455                       (lambda: (yield))(),
456                       (x for x in []),
457                       ]
458        for x in non_samples:
459            self.assertNotIsInstance(x, Callable)
460            self.assertFalse(issubclass(type(x), Callable), repr(type(x)))
461        samples = [lambda: None,
462                   type, int, object,
463                   len,
464                   list.append, [].append,
465                   ]
466        for x in samples:
467            self.assertIsInstance(x, Callable)
468            self.assertTrue(issubclass(type(x), Callable), repr(type(x)))
469        self.validate_abstract_methods(Callable, '__call__')
470        self.validate_isinstance(Callable, '__call__')
471
472    def test_direct_subclassing(self):
473        for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
474            class C(B):
475                pass
476            self.assertTrue(issubclass(C, B))
477            self.assertFalse(issubclass(int, C))
478
479    def test_registration(self):
480        for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
481            class C:
482                __metaclass__ = type
483                __hash__ = None  # Make sure it isn't hashable by default
484            self.assertFalse(issubclass(C, B), B.__name__)
485            B.register(C)
486            self.assertTrue(issubclass(C, B))
487
488class WithSet(MutableSet):
489
490    def __init__(self, it=()):
491        self.data = set(it)
492
493    def __len__(self):
494        return len(self.data)
495
496    def __iter__(self):
497        return iter(self.data)
498
499    def __contains__(self, item):
500        return item in self.data
501
502    def add(self, item):
503        self.data.add(item)
504
505    def discard(self, item):
506        self.data.discard(item)
507
508class TestCollectionABCs(ABCTestCase):
509
510    # XXX For now, we only test some virtual inheritance properties.
511    # We should also test the proper behavior of the collection ABCs
512    # as real base classes or mix-in classes.
513
514    def test_Set(self):
515        for sample in [set, frozenset]:
516            self.assertIsInstance(sample(), Set)
517            self.assertTrue(issubclass(sample, Set))
518        self.validate_abstract_methods(Set, '__contains__', '__iter__', '__len__')
519        class MySet(Set):
520            def __contains__(self, x):
521                return False
522            def __len__(self):
523                return 0
524            def __iter__(self):
525                return iter([])
526        self.validate_comparison(MySet())
527
528    def test_hash_Set(self):
529        class OneTwoThreeSet(Set):
530            def __init__(self):
531                self.contents = [1, 2, 3]
532            def __contains__(self, x):
533                return x in self.contents
534            def __len__(self):
535                return len(self.contents)
536            def __iter__(self):
537                return iter(self.contents)
538            def __hash__(self):
539                return self._hash()
540        a, b = OneTwoThreeSet(), OneTwoThreeSet()
541        self.assertTrue(hash(a) == hash(b))
542
543    def test_MutableSet(self):
544        self.assertIsInstance(set(), MutableSet)
545        self.assertTrue(issubclass(set, MutableSet))
546        self.assertNotIsInstance(frozenset(), MutableSet)
547        self.assertFalse(issubclass(frozenset, MutableSet))
548        self.validate_abstract_methods(MutableSet, '__contains__', '__iter__', '__len__',
549            'add', 'discard')
550
551    def test_issue_5647(self):
552        # MutableSet.__iand__ mutated the set during iteration
553        s = WithSet('abcd')
554        s &= WithSet('cdef')            # This used to fail
555        self.assertEqual(set(s), set('cd'))
556
557    def test_issue_4920(self):
558        # MutableSet.pop() method did not work
559        class MySet(collections.MutableSet):
560            __slots__=['__s']
561            def __init__(self,items=None):
562                if items is None:
563                    items=[]
564                self.__s=set(items)
565            def __contains__(self,v):
566                return v in self.__s
567            def __iter__(self):
568                return iter(self.__s)
569            def __len__(self):
570                return len(self.__s)
571            def add(self,v):
572                result=v not in self.__s
573                self.__s.add(v)
574                return result
575            def discard(self,v):
576                result=v in self.__s
577                self.__s.discard(v)
578                return result
579            def __repr__(self):
580                return "MySet(%s)" % repr(list(self))
581        s = MySet([5,43,2,1])
582        self.assertEqual(s.pop(), 1)
583
584    def test_issue8750(self):
585        empty = WithSet()
586        full = WithSet(range(10))
587        s = WithSet(full)
588        s -= s
589        self.assertEqual(s, empty)
590        s = WithSet(full)
591        s ^= s
592        self.assertEqual(s, empty)
593        s = WithSet(full)
594        s &= s
595        self.assertEqual(s, full)
596        s |= s
597        self.assertEqual(s, full)
598
599    def test_issue16373(self):
600        # Recursion error comparing comparable and noncomparable
601        # Set instances
602        class MyComparableSet(Set):
603            def __contains__(self, x):
604                return False
605            def __len__(self):
606                return 0
607            def __iter__(self):
608                return iter([])
609        class MyNonComparableSet(Set):
610            def __contains__(self, x):
611                return False
612            def __len__(self):
613                return 0
614            def __iter__(self):
615                return iter([])
616            def __le__(self, x):
617                return NotImplemented
618            def __lt__(self, x):
619                return NotImplemented
620
621        cs = MyComparableSet()
622        ncs = MyNonComparableSet()
623
624        # Run all the variants to make sure they don't mutually recurse
625        ncs < cs
626        ncs <= cs
627        ncs > cs
628        ncs >= cs
629        cs < ncs
630        cs <= ncs
631        cs > ncs
632        cs >= ncs
633
634    def assertSameSet(self, s1, s2):
635        # coerce both to a real set then check equality
636        self.assertEqual(set(s1), set(s2))
637
638    def test_Set_interoperability_with_real_sets(self):
639        # Issue: 8743
640        class ListSet(Set):
641            def __init__(self, elements=()):
642                self.data = []
643                for elem in elements:
644                    if elem not in self.data:
645                        self.data.append(elem)
646            def __contains__(self, elem):
647                return elem in self.data
648            def __iter__(self):
649                return iter(self.data)
650            def __len__(self):
651                return len(self.data)
652            def __repr__(self):
653                return 'Set({!r})'.format(self.data)
654
655        r1 = set('abc')
656        r2 = set('bcd')
657        r3 = set('abcde')
658        f1 = ListSet('abc')
659        f2 = ListSet('bcd')
660        f3 = ListSet('abcde')
661        l1 = list('abccba')
662        l2 = list('bcddcb')
663        l3 = list('abcdeedcba')
664        p1 = sets.Set('abc')
665        p2 = sets.Set('bcd')
666        p3 = sets.Set('abcde')
667
668        target = r1 & r2
669        self.assertSameSet(f1 & f2, target)
670        self.assertSameSet(f1 & r2, target)
671        self.assertSameSet(r2 & f1, target)
672        self.assertSameSet(f1 & p2, target)
673        self.assertSameSet(p2 & f1, target)
674        self.assertSameSet(f1 & l2, target)
675
676        target = r1 | r2
677        self.assertSameSet(f1 | f2, target)
678        self.assertSameSet(f1 | r2, target)
679        self.assertSameSet(r2 | f1, target)
680        self.assertSameSet(f1 | p2, target)
681        self.assertSameSet(p2 | f1, target)
682        self.assertSameSet(f1 | l2, target)
683
684        fwd_target = r1 - r2
685        rev_target = r2 - r1
686        self.assertSameSet(f1 - f2, fwd_target)
687        self.assertSameSet(f2 - f1, rev_target)
688        self.assertSameSet(f1 - r2, fwd_target)
689        self.assertSameSet(f2 - r1, rev_target)
690        self.assertSameSet(r1 - f2, fwd_target)
691        self.assertSameSet(r2 - f1, rev_target)
692        self.assertSameSet(f1 - p2, fwd_target)
693        self.assertSameSet(f2 - p1, rev_target)
694        self.assertSameSet(p1 - f2, fwd_target)
695        self.assertSameSet(p2 - f1, rev_target)
696        self.assertSameSet(f1 - l2, fwd_target)
697        self.assertSameSet(f2 - l1, rev_target)
698
699        target = r1 ^ r2
700        self.assertSameSet(f1 ^ f2, target)
701        self.assertSameSet(f1 ^ r2, target)
702        self.assertSameSet(r2 ^ f1, target)
703        self.assertSameSet(f1 ^ p2, target)
704        self.assertSameSet(p2 ^ f1, target)
705        self.assertSameSet(f1 ^ l2, target)
706
707        # proper subset
708        self.assertTrue(f1 < f3)
709        self.assertFalse(f1 < f1)
710        self.assertFalse(f1 < f2)
711        self.assertTrue(r1 < f3)
712        self.assertFalse(r1 < f1)
713        self.assertFalse(r1 < f2)
714        self.assertTrue(r1 < r3)
715        self.assertFalse(r1 < r1)
716        self.assertFalse(r1 < r2)
717
718        with test_support.check_py3k_warnings():
719            # python 2 only, cross-type compares will succeed
720            f1 < l3
721            f1 < l1
722            f1 < l2
723
724        # any subset
725        self.assertTrue(f1 <= f3)
726        self.assertTrue(f1 <= f1)
727        self.assertFalse(f1 <= f2)
728        self.assertTrue(r1 <= f3)
729        self.assertTrue(r1 <= f1)
730        self.assertFalse(r1 <= f2)
731        self.assertTrue(r1 <= r3)
732        self.assertTrue(r1 <= r1)
733        self.assertFalse(r1 <= r2)
734
735        with test_support.check_py3k_warnings():
736            # python 2 only, cross-type compares will succeed
737            f1 <= l3
738            f1 <= l1
739            f1 <= l2
740
741        # proper superset
742        self.assertTrue(f3 > f1)
743        self.assertFalse(f1 > f1)
744        self.assertFalse(f2 > f1)
745        self.assertTrue(r3 > r1)
746        self.assertFalse(f1 > r1)
747        self.assertFalse(f2 > r1)
748        self.assertTrue(r3 > r1)
749        self.assertFalse(r1 > r1)
750        self.assertFalse(r2 > r1)
751
752        with test_support.check_py3k_warnings():
753            # python 2 only, cross-type compares will succeed
754            f1 > l3
755            f1 > l1
756            f1 > l2
757
758        # any superset
759        self.assertTrue(f3 >= f1)
760        self.assertTrue(f1 >= f1)
761        self.assertFalse(f2 >= f1)
762        self.assertTrue(r3 >= r1)
763        self.assertTrue(f1 >= r1)
764        self.assertFalse(f2 >= r1)
765        self.assertTrue(r3 >= r1)
766        self.assertTrue(r1 >= r1)
767        self.assertFalse(r2 >= r1)
768
769        with test_support.check_py3k_warnings():
770            # python 2 only, cross-type compares will succeed
771            f1 >= l3
772            f1 >=l1
773            f1 >= l2
774
775        # equality
776        self.assertTrue(f1 == f1)
777        self.assertTrue(r1 == f1)
778        self.assertTrue(f1 == r1)
779        self.assertFalse(f1 == f3)
780        self.assertFalse(r1 == f3)
781        self.assertFalse(f1 == r3)
782        # python 2 only, cross-type compares will succeed
783        f1 == l3
784        f1 == l1
785        f1 == l2
786
787        # inequality
788        self.assertFalse(f1 != f1)
789        self.assertFalse(r1 != f1)
790        self.assertFalse(f1 != r1)
791        self.assertTrue(f1 != f3)
792        self.assertTrue(r1 != f3)
793        self.assertTrue(f1 != r3)
794        # python 2 only, cross-type compares will succeed
795        f1 != l3
796        f1 != l1
797        f1 != l2
798
799    def test_Mapping(self):
800        for sample in [dict]:
801            self.assertIsInstance(sample(), Mapping)
802            self.assertTrue(issubclass(sample, Mapping))
803        self.validate_abstract_methods(Mapping, '__contains__', '__iter__', '__len__',
804            '__getitem__')
805        class MyMapping(collections.Mapping):
806            def __len__(self):
807                return 0
808            def __getitem__(self, i):
809                raise IndexError
810            def __iter__(self):
811                return iter(())
812        self.validate_comparison(MyMapping())
813
814    def test_MutableMapping(self):
815        for sample in [dict]:
816            self.assertIsInstance(sample(), MutableMapping)
817            self.assertTrue(issubclass(sample, MutableMapping))
818        self.validate_abstract_methods(MutableMapping, '__contains__', '__iter__', '__len__',
819            '__getitem__', '__setitem__', '__delitem__')
820
821    def test_Sequence(self):
822        for sample in [tuple, list, str]:
823            self.assertIsInstance(sample(), Sequence)
824            self.assertTrue(issubclass(sample, Sequence))
825        self.assertTrue(issubclass(basestring, Sequence))
826        self.assertIsInstance(range(10), Sequence)
827        self.assertTrue(issubclass(xrange, Sequence))
828        self.assertTrue(issubclass(str, Sequence))
829        self.validate_abstract_methods(Sequence, '__contains__', '__iter__', '__len__',
830            '__getitem__')
831
832    def test_MutableSequence(self):
833        for sample in [tuple, str]:
834            self.assertNotIsInstance(sample(), MutableSequence)
835            self.assertFalse(issubclass(sample, MutableSequence))
836        for sample in [list]:
837            self.assertIsInstance(sample(), MutableSequence)
838            self.assertTrue(issubclass(sample, MutableSequence))
839        self.assertFalse(issubclass(basestring, MutableSequence))
840        self.validate_abstract_methods(MutableSequence, '__contains__', '__iter__',
841            '__len__', '__getitem__', '__setitem__', '__delitem__', 'insert')
842
843class TestCounter(unittest.TestCase):
844
845    def test_basics(self):
846        c = Counter('abcaba')
847        self.assertEqual(c, Counter({'a':3 , 'b': 2, 'c': 1}))
848        self.assertEqual(c, Counter(a=3, b=2, c=1))
849        self.assertIsInstance(c, dict)
850        self.assertIsInstance(c, Mapping)
851        self.assertTrue(issubclass(Counter, dict))
852        self.assertTrue(issubclass(Counter, Mapping))
853        self.assertEqual(len(c), 3)
854        self.assertEqual(sum(c.values()), 6)
855        self.assertEqual(sorted(c.values()), [1, 2, 3])
856        self.assertEqual(sorted(c.keys()), ['a', 'b', 'c'])
857        self.assertEqual(sorted(c), ['a', 'b', 'c'])
858        self.assertEqual(sorted(c.items()),
859                         [('a', 3), ('b', 2), ('c', 1)])
860        self.assertEqual(c['b'], 2)
861        self.assertEqual(c['z'], 0)
862        with test_support.check_py3k_warnings():
863            self.assertEqual(c.has_key('c'), True)
864            self.assertEqual(c.has_key('z'), False)
865        self.assertEqual(c.__contains__('c'), True)
866        self.assertEqual(c.__contains__('z'), False)
867        self.assertEqual(c.get('b', 10), 2)
868        self.assertEqual(c.get('z', 10), 10)
869        self.assertEqual(c, dict(a=3, b=2, c=1))
870        self.assertEqual(repr(c), "Counter({'a': 3, 'b': 2, 'c': 1})")
871        self.assertEqual(c.most_common(), [('a', 3), ('b', 2), ('c', 1)])
872        for i in range(5):
873            self.assertEqual(c.most_common(i),
874                             [('a', 3), ('b', 2), ('c', 1)][:i])
875        self.assertEqual(''.join(sorted(c.elements())), 'aaabbc')
876        c['a'] += 1         # increment an existing value
877        c['b'] -= 2         # sub existing value to zero
878        del c['c']          # remove an entry
879        del c['c']          # make sure that del doesn't raise KeyError
880        c['d'] -= 2         # sub from a missing value
881        c['e'] = -5         # directly assign a missing value
882        c['f'] += 4         # add to a missing value
883        self.assertEqual(c, dict(a=4, b=0, d=-2, e=-5, f=4))
884        self.assertEqual(''.join(sorted(c.elements())), 'aaaaffff')
885        self.assertEqual(c.pop('f'), 4)
886        self.assertNotIn('f', c)
887        for i in range(3):
888            elem, cnt = c.popitem()
889            self.assertNotIn(elem, c)
890        c.clear()
891        self.assertEqual(c, {})
892        self.assertEqual(repr(c), 'Counter()')
893        self.assertRaises(NotImplementedError, Counter.fromkeys, 'abc')
894        self.assertRaises(TypeError, hash, c)
895        c.update(dict(a=5, b=3))
896        c.update(c=1)
897        c.update(Counter('a' * 50 + 'b' * 30))
898        c.update()          # test case with no args
899        c.__init__('a' * 500 + 'b' * 300)
900        c.__init__('cdc')
901        c.__init__()
902        self.assertEqual(c, dict(a=555, b=333, c=3, d=1))
903        self.assertEqual(c.setdefault('d', 5), 1)
904        self.assertEqual(c['d'], 1)
905        self.assertEqual(c.setdefault('e', 5), 5)
906        self.assertEqual(c['e'], 5)
907
908    def test_init(self):
909        self.assertEqual(list(Counter(self=42).items()), [('self', 42)])
910        self.assertEqual(list(Counter(iterable=42).items()), [('iterable', 42)])
911        self.assertEqual(list(Counter(iterable=None).items()), [('iterable', None)])
912        self.assertRaises(TypeError, Counter, 42)
913        self.assertRaises(TypeError, Counter, (), ())
914        self.assertRaises(TypeError, Counter.__init__)
915
916    def test_update(self):
917        c = Counter()
918        c.update(self=42)
919        self.assertEqual(list(c.items()), [('self', 42)])
920        c = Counter()
921        c.update(iterable=42)
922        self.assertEqual(list(c.items()), [('iterable', 42)])
923        c = Counter()
924        c.update(iterable=None)
925        self.assertEqual(list(c.items()), [('iterable', None)])
926        self.assertRaises(TypeError, Counter().update, 42)
927        self.assertRaises(TypeError, Counter().update, {}, {})
928        self.assertRaises(TypeError, Counter.update)
929
930    def test_copying(self):
931        # Check that counters are copyable, deepcopyable, picklable, and
932        #have a repr/eval round-trip
933        words = Counter('which witch had which witches wrist watch'.split())
934        update_test = Counter()
935        update_test.update(words)
936        for i, dup in enumerate([
937                    words.copy(),
938                    copy.copy(words),
939                    copy.deepcopy(words),
940                    pickle.loads(pickle.dumps(words, 0)),
941                    pickle.loads(pickle.dumps(words, 1)),
942                    pickle.loads(pickle.dumps(words, 2)),
943                    pickle.loads(pickle.dumps(words, -1)),
944                    cPickle.loads(cPickle.dumps(words, 0)),
945                    cPickle.loads(cPickle.dumps(words, 1)),
946                    cPickle.loads(cPickle.dumps(words, 2)),
947                    cPickle.loads(cPickle.dumps(words, -1)),
948                    eval(repr(words)),
949                    update_test,
950                    Counter(words),
951                    ]):
952            msg = (i, dup, words)
953            self.assertTrue(dup is not words)
954            self.assertEqual(dup, words)
955            self.assertEqual(len(dup), len(words))
956            self.assertEqual(type(dup), type(words))
957
958    def test_copy_subclass(self):
959        class MyCounter(Counter):
960            pass
961        c = MyCounter('slartibartfast')
962        d = c.copy()
963        self.assertEqual(d, c)
964        self.assertEqual(len(d), len(c))
965        self.assertEqual(type(d), type(c))
966
967    def test_conversions(self):
968        # Convert to: set, list, dict
969        s = 'she sells sea shells by the sea shore'
970        self.assertEqual(sorted(Counter(s).elements()), sorted(s))
971        self.assertEqual(sorted(Counter(s)), sorted(set(s)))
972        self.assertEqual(dict(Counter(s)), dict(Counter(s).items()))
973        self.assertEqual(set(Counter(s)), set(s))
974
975    def test_invariant_for_the_in_operator(self):
976        c = Counter(a=10, b=-2, c=0)
977        for elem in c:
978            self.assertTrue(elem in c)
979            self.assertIn(elem, c)
980
981    def test_multiset_operations(self):
982        # Verify that adding a zero counter will strip zeros and negatives
983        c = Counter(a=10, b=-2, c=0) + Counter()
984        self.assertEqual(dict(c), dict(a=10))
985
986        elements = 'abcd'
987        for i in range(1000):
988            # test random pairs of multisets
989            p = Counter(dict((elem, randrange(-2,4)) for elem in elements))
990            p.update(e=1, f=-1, g=0)
991            q = Counter(dict((elem, randrange(-2,4)) for elem in elements))
992            q.update(h=1, i=-1, j=0)
993            for counterop, numberop in [
994                (Counter.__add__, lambda x, y: max(0, x+y)),
995                (Counter.__sub__, lambda x, y: max(0, x-y)),
996                (Counter.__or__, lambda x, y: max(0,x,y)),
997                (Counter.__and__, lambda x, y: max(0, min(x,y))),
998            ]:
999                result = counterop(p, q)
1000                for x in elements:
1001                    self.assertEqual(numberop(p[x], q[x]), result[x],
1002                                     (counterop, x, p, q))
1003                # verify that results exclude non-positive counts
1004                self.assertTrue(x>0 for x in result.values())
1005
1006        elements = 'abcdef'
1007        for i in range(100):
1008            # verify that random multisets with no repeats are exactly like sets
1009            p = Counter(dict((elem, randrange(0, 2)) for elem in elements))
1010            q = Counter(dict((elem, randrange(0, 2)) for elem in elements))
1011            for counterop, setop in [
1012                (Counter.__sub__, set.__sub__),
1013                (Counter.__or__, set.__or__),
1014                (Counter.__and__, set.__and__),
1015            ]:
1016                counter_result = counterop(p, q)
1017                set_result = setop(set(p.elements()), set(q.elements()))
1018                self.assertEqual(counter_result, dict.fromkeys(set_result, 1))
1019
1020    def test_subtract(self):
1021        c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)
1022        c.subtract(a=1, b=2, c=-3, d=10, e=20, f=30, h=-50)
1023        self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))
1024        c = Counter(a=-5, b=0, c=5, d=10, e=15,g=40)
1025        c.subtract(Counter(a=1, b=2, c=-3, d=10, e=20, f=30, h=-50))
1026        self.assertEqual(c, Counter(a=-6, b=-2, c=8, d=0, e=-5, f=-30, g=40, h=50))
1027        c = Counter('aaabbcd')
1028        c.subtract('aaaabbcce')
1029        self.assertEqual(c, Counter(a=-1, b=0, c=-1, d=1, e=-1))
1030
1031        c = Counter()
1032        c.subtract(self=42)
1033        self.assertEqual(list(c.items()), [('self', -42)])
1034        c = Counter()
1035        c.subtract(iterable=42)
1036        self.assertEqual(list(c.items()), [('iterable', -42)])
1037        self.assertRaises(TypeError, Counter().subtract, 42)
1038        self.assertRaises(TypeError, Counter().subtract, {}, {})
1039        self.assertRaises(TypeError, Counter.subtract)
1040
1041class TestOrderedDict(unittest.TestCase):
1042
1043    def test_init(self):
1044        with self.assertRaises(TypeError):
1045            OrderedDict([('a', 1), ('b', 2)], None)                                 # too many args
1046        pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
1047        self.assertEqual(sorted(OrderedDict(dict(pairs)).items()), pairs)           # dict input
1048        self.assertEqual(sorted(OrderedDict(**dict(pairs)).items()), pairs)         # kwds input
1049        self.assertEqual(list(OrderedDict(pairs).items()), pairs)                   # pairs input
1050        self.assertEqual(list(OrderedDict([('a', 1), ('b', 2), ('c', 9), ('d', 4)],
1051                                          c=3, e=5).items()), pairs)                # mixed input
1052
1053        # make sure no positional args conflict with possible kwdargs
1054        self.assertEqual(list(OrderedDict(self=42).items()), [('self', 42)])
1055        self.assertEqual(list(OrderedDict(other=42).items()), [('other', 42)])
1056        self.assertRaises(TypeError, OrderedDict, 42)
1057        self.assertRaises(TypeError, OrderedDict, (), ())
1058        self.assertRaises(TypeError, OrderedDict.__init__)
1059
1060        # Make sure that direct calls to __init__ do not clear previous contents
1061        d = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 44), ('e', 55)])
1062        d.__init__([('e', 5), ('f', 6)], g=7, d=4)
1063        self.assertEqual(list(d.items()),
1064            [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])
1065
1066    def test_update(self):
1067        with self.assertRaises(TypeError):
1068            OrderedDict().update([('a', 1), ('b', 2)], None)                        # too many args
1069        pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
1070        od = OrderedDict()
1071        od.update(dict(pairs))
1072        self.assertEqual(sorted(od.items()), pairs)                                 # dict input
1073        od = OrderedDict()
1074        od.update(**dict(pairs))
1075        self.assertEqual(sorted(od.items()), pairs)                                 # kwds input
1076        od = OrderedDict()
1077        od.update(pairs)
1078        self.assertEqual(list(od.items()), pairs)                                   # pairs input
1079        od = OrderedDict()
1080        od.update([('a', 1), ('b', 2), ('c', 9), ('d', 4)], c=3, e=5)
1081        self.assertEqual(list(od.items()), pairs)                                   # mixed input
1082
1083        # Issue 9137: Named argument called 'other' or 'self'
1084        # shouldn't be treated specially.
1085        od = OrderedDict()
1086        od.update(self=23)
1087        self.assertEqual(list(od.items()), [('self', 23)])
1088        od = OrderedDict()
1089        od.update(other={})
1090        self.assertEqual(list(od.items()), [('other', {})])
1091        od = OrderedDict()
1092        od.update(red=5, blue=6, other=7, self=8)
1093        self.assertEqual(sorted(list(od.items())),
1094                         [('blue', 6), ('other', 7), ('red', 5), ('self', 8)])
1095
1096        # Make sure that direct calls to update do not clear previous contents
1097        # add that updates items are not moved to the end
1098        d = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 44), ('e', 55)])
1099        d.update([('e', 5), ('f', 6)], g=7, d=4)
1100        self.assertEqual(list(d.items()),
1101            [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])
1102
1103        self.assertRaises(TypeError, OrderedDict().update, 42)
1104        self.assertRaises(TypeError, OrderedDict().update, (), ())
1105        self.assertRaises(TypeError, OrderedDict.update)
1106
1107    def test_abc(self):
1108        self.assertIsInstance(OrderedDict(), MutableMapping)
1109        self.assertTrue(issubclass(OrderedDict, MutableMapping))
1110
1111    def test_clear(self):
1112        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1113        shuffle(pairs)
1114        od = OrderedDict(pairs)
1115        self.assertEqual(len(od), len(pairs))
1116        od.clear()
1117        self.assertEqual(len(od), 0)
1118
1119    def test_delitem(self):
1120        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1121        od = OrderedDict(pairs)
1122        del od['a']
1123        self.assertNotIn('a', od)
1124        with self.assertRaises(KeyError):
1125            del od['a']
1126        self.assertEqual(list(od.items()), pairs[:2] + pairs[3:])
1127
1128    def test_setitem(self):
1129        od = OrderedDict([('d', 1), ('b', 2), ('c', 3), ('a', 4), ('e', 5)])
1130        od['c'] = 10           # existing element
1131        od['f'] = 20           # new element
1132        self.assertEqual(list(od.items()),
1133                         [('d', 1), ('b', 2), ('c', 10), ('a', 4), ('e', 5), ('f', 20)])
1134
1135    def test_iterators(self):
1136        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1137        shuffle(pairs)
1138        od = OrderedDict(pairs)
1139        self.assertEqual(list(od), [t[0] for t in pairs])
1140        self.assertEqual(od.keys()[:], [t[0] for t in pairs])
1141        self.assertEqual(od.values()[:], [t[1] for t in pairs])
1142        self.assertEqual(od.items()[:], pairs)
1143        self.assertEqual(list(od.iterkeys()), [t[0] for t in pairs])
1144        self.assertEqual(list(od.itervalues()), [t[1] for t in pairs])
1145        self.assertEqual(list(od.iteritems()), pairs)
1146        self.assertEqual(list(reversed(od)),
1147                         [t[0] for t in reversed(pairs)])
1148
1149    def test_popitem(self):
1150        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1151        shuffle(pairs)
1152        od = OrderedDict(pairs)
1153        while pairs:
1154            self.assertEqual(od.popitem(), pairs.pop())
1155        with self.assertRaises(KeyError):
1156            od.popitem()
1157        self.assertEqual(len(od), 0)
1158
1159    def test_pop(self):
1160        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1161        shuffle(pairs)
1162        od = OrderedDict(pairs)
1163        shuffle(pairs)
1164        while pairs:
1165            k, v = pairs.pop()
1166            self.assertEqual(od.pop(k), v)
1167        with self.assertRaises(KeyError):
1168            od.pop('xyz')
1169        self.assertEqual(len(od), 0)
1170        self.assertEqual(od.pop(k, 12345), 12345)
1171
1172        # make sure pop still works when __missing__ is defined
1173        class Missing(OrderedDict):
1174            def __missing__(self, key):
1175                return 0
1176        m = Missing(a=1)
1177        self.assertEqual(m.pop('b', 5), 5)
1178        self.assertEqual(m.pop('a', 6), 1)
1179        self.assertEqual(m.pop('a', 6), 6)
1180        with self.assertRaises(KeyError):
1181            m.pop('a')
1182
1183    def test_equality(self):
1184        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1185        shuffle(pairs)
1186        od1 = OrderedDict(pairs)
1187        od2 = OrderedDict(pairs)
1188        self.assertEqual(od1, od2)          # same order implies equality
1189        pairs = pairs[2:] + pairs[:2]
1190        od2 = OrderedDict(pairs)
1191        self.assertNotEqual(od1, od2)       # different order implies inequality
1192        # comparison to regular dict is not order sensitive
1193        self.assertEqual(od1, dict(od2))
1194        self.assertEqual(dict(od2), od1)
1195        # different length implied inequality
1196        self.assertNotEqual(od1, OrderedDict(pairs[:-1]))
1197
1198    def test_copying(self):
1199        # Check that ordered dicts are copyable, deepcopyable, picklable,
1200        # and have a repr/eval round-trip
1201        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1202        od = OrderedDict(pairs)
1203        update_test = OrderedDict()
1204        update_test.update(od)
1205        for i, dup in enumerate([
1206                    od.copy(),
1207                    copy.copy(od),
1208                    copy.deepcopy(od),
1209                    pickle.loads(pickle.dumps(od, 0)),
1210                    pickle.loads(pickle.dumps(od, 1)),
1211                    pickle.loads(pickle.dumps(od, 2)),
1212                    pickle.loads(pickle.dumps(od, -1)),
1213                    eval(repr(od)),
1214                    update_test,
1215                    OrderedDict(od),
1216                    ]):
1217            self.assertTrue(dup is not od)
1218            self.assertEqual(dup, od)
1219            self.assertEqual(list(dup.items()), list(od.items()))
1220            self.assertEqual(len(dup), len(od))
1221            self.assertEqual(type(dup), type(od))
1222
1223    def test_yaml_linkage(self):
1224        # Verify that __reduce__ is setup in a way that supports PyYAML's dump() feature.
1225        # In yaml, lists are native but tuples are not.
1226        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1227        od = OrderedDict(pairs)
1228        # yaml.dump(od) -->
1229        # '!!python/object/apply:__main__.OrderedDict\n- - [a, 1]\n  - [b, 2]\n'
1230        self.assertTrue(all(type(pair)==list for pair in od.__reduce__()[1]))
1231
1232    def test_reduce_not_too_fat(self):
1233        # do not save instance dictionary if not needed
1234        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1235        od = OrderedDict(pairs)
1236        self.assertEqual(len(od.__reduce__()), 2)
1237        od.x = 10
1238        self.assertEqual(len(od.__reduce__()), 3)
1239
1240    def test_repr(self):
1241        od = OrderedDict([('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)])
1242        self.assertEqual(repr(od),
1243            "OrderedDict([('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)])")
1244        self.assertEqual(eval(repr(od)), od)
1245        self.assertEqual(repr(OrderedDict()), "OrderedDict()")
1246
1247    def test_repr_recursive(self):
1248        # See issue #9826
1249        od = OrderedDict.fromkeys('abc')
1250        od['x'] = od
1251        self.assertEqual(repr(od),
1252            "OrderedDict([('a', None), ('b', None), ('c', None), ('x', ...)])")
1253
1254    def test_setdefault(self):
1255        pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
1256        shuffle(pairs)
1257        od = OrderedDict(pairs)
1258        pair_order = list(od.items())
1259        self.assertEqual(od.setdefault('a', 10), 3)
1260        # make sure order didn't change
1261        self.assertEqual(list(od.items()), pair_order)
1262        self.assertEqual(od.setdefault('x', 10), 10)
1263        # make sure 'x' is added to the end
1264        self.assertEqual(list(od.items())[-1], ('x', 10))
1265
1266        # make sure setdefault still works when __missing__ is defined
1267        class Missing(OrderedDict):
1268            def __missing__(self, key):
1269                return 0
1270        self.assertEqual(Missing().setdefault(5, 9), 9)
1271
1272    def test_reinsert(self):
1273        # Given insert a, insert b, delete a, re-insert a,
1274        # verify that a is now later than b.
1275        od = OrderedDict()
1276        od['a'] = 1
1277        od['b'] = 2
1278        del od['a']
1279        od['a'] = 1
1280        self.assertEqual(list(od.items()), [('b', 2), ('a', 1)])
1281
1282    def test_views(self):
1283        s = 'the quick brown fox jumped over a lazy dog yesterday before dawn'.split()
1284        od = OrderedDict.fromkeys(s)
1285        self.assertEqual(list(od.viewkeys()),  s)
1286        self.assertEqual(list(od.viewvalues()),  [None for k in s])
1287        self.assertEqual(list(od.viewitems()),  [(k, None) for k in s])
1288
1289        # See http://bugs.python.org/issue24286
1290        self.assertEqual(od.viewkeys(), dict(od).viewkeys())
1291        self.assertEqual(od.viewitems(), dict(od).viewitems())
1292
1293    def test_override_update(self):
1294        # Verify that subclasses can override update() without breaking __init__()
1295        class MyOD(OrderedDict):
1296            def update(self, *args, **kwds):
1297                raise Exception()
1298        items = [('a', 1), ('c', 3), ('b', 2)]
1299        self.assertEqual(list(MyOD(items).items()), items)
1300
1301class GeneralMappingTests(mapping_tests.BasicTestMappingProtocol):
1302    type2test = OrderedDict
1303
1304    def test_popitem(self):
1305        d = self._empty_mapping()
1306        self.assertRaises(KeyError, d.popitem)
1307
1308class MyOrderedDict(OrderedDict):
1309    pass
1310
1311class SubclassMappingTests(mapping_tests.BasicTestMappingProtocol):
1312    type2test = MyOrderedDict
1313
1314    def test_popitem(self):
1315        d = self._empty_mapping()
1316        self.assertRaises(KeyError, d.popitem)
1317
1318import collections
1319
1320def test_main(verbose=None):
1321    NamedTupleDocs = doctest.DocTestSuite(module=collections)
1322    test_classes = [TestNamedTuple, NamedTupleDocs, TestOneTrickPonyABCs,
1323                    TestCollectionABCs, TestCounter,
1324                    TestOrderedDict, GeneralMappingTests, SubclassMappingTests]
1325    test_support.run_unittest(*test_classes)
1326    test_support.run_doctest(collections, verbose)
1327
1328if __name__ == "__main__":
1329    test_main(verbose=True)
Note: See TracBrowser for help on using the repository browser.