"""Unit tests for collections.py."""
-import unittest, doctest, operator
-from test.support import TESTFN, forget, unlink
-import inspect
-from test import support
-from collections import namedtuple, Counter, OrderedDict, _count_elements
-from test import mapping_tests
-import pickle, copy
-from random import randrange, shuffle
+import collections
+import copy
+import doctest
import keyword
+import operator
+import pickle
+from random import choice, randrange
import re
+import string
import sys
+from test import support
+import unittest
+
+from collections import namedtuple, Counter, OrderedDict, _count_elements
from collections import UserDict
from collections import ChainMap
from collections.abc import Hashable, Iterable, Iterator
# n = 5000
n = 254 # SyntaxError: more than 255 arguments:
- import string, random
- names = list(set(''.join([random.choice(string.ascii_letters)
+ names = list(set(''.join([choice(string.ascii_letters)
for j in range(10)]) for i in range(n)))
n = len(names)
Big = namedtuple('Big', names)
self.assertEqual(dict(c), {'a': 5, 'b': 2, 'c': 1, 'd': 1, 'r':2 })
-################################################################################
-### OrderedDict
-################################################################################
-
-class TestOrderedDict(unittest.TestCase):
-
- def test_init(self):
- with self.assertRaises(TypeError):
- OrderedDict([('a', 1), ('b', 2)], None) # too many args
- pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
- self.assertEqual(sorted(OrderedDict(dict(pairs)).items()), pairs) # dict input
- self.assertEqual(sorted(OrderedDict(**dict(pairs)).items()), pairs) # kwds input
- self.assertEqual(list(OrderedDict(pairs).items()), pairs) # pairs input
- self.assertEqual(list(OrderedDict([('a', 1), ('b', 2), ('c', 9), ('d', 4)],
- c=3, e=5).items()), pairs) # mixed input
-
- # make sure no positional args conflict with possible kwdargs
- self.assertEqual(list(OrderedDict(self=42).items()), [('self', 42)])
- self.assertEqual(list(OrderedDict(other=42).items()), [('other', 42)])
- self.assertRaises(TypeError, OrderedDict, 42)
- self.assertRaises(TypeError, OrderedDict, (), ())
- self.assertRaises(TypeError, OrderedDict.__init__)
-
- # Make sure that direct calls to __init__ do not clear previous contents
- d = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 44), ('e', 55)])
- d.__init__([('e', 5), ('f', 6)], g=7, d=4)
- self.assertEqual(list(d.items()),
- [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])
-
- def test_update(self):
- with self.assertRaises(TypeError):
- OrderedDict().update([('a', 1), ('b', 2)], None) # too many args
- pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
- od = OrderedDict()
- od.update(dict(pairs))
- self.assertEqual(sorted(od.items()), pairs) # dict input
- od = OrderedDict()
- od.update(**dict(pairs))
- self.assertEqual(sorted(od.items()), pairs) # kwds input
- od = OrderedDict()
- od.update(pairs)
- self.assertEqual(list(od.items()), pairs) # pairs input
- od = OrderedDict()
- od.update([('a', 1), ('b', 2), ('c', 9), ('d', 4)], c=3, e=5)
- self.assertEqual(list(od.items()), pairs) # mixed input
-
- # Issue 9137: Named argument called 'other' or 'self'
- # shouldn't be treated specially.
- od = OrderedDict()
- od.update(self=23)
- self.assertEqual(list(od.items()), [('self', 23)])
- od = OrderedDict()
- od.update(other={})
- self.assertEqual(list(od.items()), [('other', {})])
- od = OrderedDict()
- od.update(red=5, blue=6, other=7, self=8)
- self.assertEqual(sorted(list(od.items())),
- [('blue', 6), ('other', 7), ('red', 5), ('self', 8)])
-
- # Make sure that direct calls to update do not clear previous contents
- # add that updates items are not moved to the end
- d = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 44), ('e', 55)])
- d.update([('e', 5), ('f', 6)], g=7, d=4)
- self.assertEqual(list(d.items()),
- [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])
-
- self.assertRaises(TypeError, OrderedDict().update, 42)
- self.assertRaises(TypeError, OrderedDict().update, (), ())
- self.assertRaises(TypeError, OrderedDict.update)
-
- def test_abc(self):
- self.assertIsInstance(OrderedDict(), MutableMapping)
- self.assertTrue(issubclass(OrderedDict, MutableMapping))
-
- def test_clear(self):
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- shuffle(pairs)
- od = OrderedDict(pairs)
- self.assertEqual(len(od), len(pairs))
- od.clear()
- self.assertEqual(len(od), 0)
-
- def test_delitem(self):
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- od = OrderedDict(pairs)
- del od['a']
- self.assertNotIn('a', od)
- with self.assertRaises(KeyError):
- del od['a']
- self.assertEqual(list(od.items()), pairs[:2] + pairs[3:])
-
- def test_setitem(self):
- od = OrderedDict([('d', 1), ('b', 2), ('c', 3), ('a', 4), ('e', 5)])
- od['c'] = 10 # existing element
- od['f'] = 20 # new element
- self.assertEqual(list(od.items()),
- [('d', 1), ('b', 2), ('c', 10), ('a', 4), ('e', 5), ('f', 20)])
-
- def test_iterators(self):
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- shuffle(pairs)
- od = OrderedDict(pairs)
- self.assertEqual(list(od), [t[0] for t in pairs])
- self.assertEqual(list(od.keys()), [t[0] for t in pairs])
- self.assertEqual(list(od.values()), [t[1] for t in pairs])
- self.assertEqual(list(od.items()), pairs)
- self.assertEqual(list(reversed(od)),
- [t[0] for t in reversed(pairs)])
-
- def test_popitem(self):
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- shuffle(pairs)
- od = OrderedDict(pairs)
- while pairs:
- self.assertEqual(od.popitem(), pairs.pop())
- with self.assertRaises(KeyError):
- od.popitem()
- self.assertEqual(len(od), 0)
-
- def test_pop(self):
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- shuffle(pairs)
- od = OrderedDict(pairs)
- shuffle(pairs)
- while pairs:
- k, v = pairs.pop()
- self.assertEqual(od.pop(k), v)
- with self.assertRaises(KeyError):
- od.pop('xyz')
- self.assertEqual(len(od), 0)
- self.assertEqual(od.pop(k, 12345), 12345)
-
- # make sure pop still works when __missing__ is defined
- class Missing(OrderedDict):
- def __missing__(self, key):
- return 0
- m = Missing(a=1)
- self.assertEqual(m.pop('b', 5), 5)
- self.assertEqual(m.pop('a', 6), 1)
- self.assertEqual(m.pop('a', 6), 6)
- with self.assertRaises(KeyError):
- m.pop('a')
-
- def test_equality(self):
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- shuffle(pairs)
- od1 = OrderedDict(pairs)
- od2 = OrderedDict(pairs)
- self.assertEqual(od1, od2) # same order implies equality
- pairs = pairs[2:] + pairs[:2]
- od2 = OrderedDict(pairs)
- self.assertNotEqual(od1, od2) # different order implies inequality
- # comparison to regular dict is not order sensitive
- self.assertEqual(od1, dict(od2))
- self.assertEqual(dict(od2), od1)
- # different length implied inequality
- self.assertNotEqual(od1, OrderedDict(pairs[:-1]))
-
- def test_copying(self):
- # Check that ordered dicts are copyable, deepcopyable, picklable,
- # and have a repr/eval round-trip
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- od = OrderedDict(pairs)
- def check(dup):
- msg = "\ncopy: %s\nod: %s" % (dup, od)
- self.assertIsNot(dup, od, msg)
- self.assertEqual(dup, od)
- check(od.copy())
- check(copy.copy(od))
- check(copy.deepcopy(od))
- for proto in range(pickle.HIGHEST_PROTOCOL + 1):
- with self.subTest(proto=proto):
- check(pickle.loads(pickle.dumps(od, proto)))
- check(eval(repr(od)))
- update_test = OrderedDict()
- update_test.update(od)
- check(update_test)
- check(OrderedDict(od))
-
- def test_yaml_linkage(self):
- # Verify that __reduce__ is setup in a way that supports PyYAML's dump() feature.
- # In yaml, lists are native but tuples are not.
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- od = OrderedDict(pairs)
- # yaml.dump(od) -->
- # '!!python/object/apply:__main__.OrderedDict\n- - [a, 1]\n - [b, 2]\n'
- self.assertTrue(all(type(pair)==list for pair in od.__reduce__()[1]))
-
- def test_reduce_not_too_fat(self):
- # do not save instance dictionary if not needed
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- od = OrderedDict(pairs)
- self.assertIsNone(od.__reduce__()[2])
- od.x = 10
- self.assertIsNotNone(od.__reduce__()[2])
-
- def test_pickle_recursive(self):
- od = OrderedDict()
- od[1] = od
- for proto in range(-1, pickle.HIGHEST_PROTOCOL + 1):
- dup = pickle.loads(pickle.dumps(od, proto))
- self.assertIsNot(dup, od)
- self.assertEqual(list(dup.keys()), [1])
- self.assertIs(dup[1], dup)
-
- def test_repr(self):
- od = OrderedDict([('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)])
- self.assertEqual(repr(od),
- "OrderedDict([('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)])")
- self.assertEqual(eval(repr(od)), od)
- self.assertEqual(repr(OrderedDict()), "OrderedDict()")
-
- def test_repr_recursive(self):
- # See issue #9826
- od = OrderedDict.fromkeys('abc')
- od['x'] = od
- self.assertEqual(repr(od),
- "OrderedDict([('a', None), ('b', None), ('c', None), ('x', ...)])")
-
- def test_setdefault(self):
- pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
- shuffle(pairs)
- od = OrderedDict(pairs)
- pair_order = list(od.items())
- self.assertEqual(od.setdefault('a', 10), 3)
- # make sure order didn't change
- self.assertEqual(list(od.items()), pair_order)
- self.assertEqual(od.setdefault('x', 10), 10)
- # make sure 'x' is added to the end
- self.assertEqual(list(od.items())[-1], ('x', 10))
-
- # make sure setdefault still works when __missing__ is defined
- class Missing(OrderedDict):
- def __missing__(self, key):
- return 0
- self.assertEqual(Missing().setdefault(5, 9), 9)
-
- def test_reinsert(self):
- # Given insert a, insert b, delete a, re-insert a,
- # verify that a is now later than b.
- od = OrderedDict()
- od['a'] = 1
- od['b'] = 2
- del od['a']
- od['a'] = 1
- self.assertEqual(list(od.items()), [('b', 2), ('a', 1)])
-
- def test_move_to_end(self):
- od = OrderedDict.fromkeys('abcde')
- self.assertEqual(list(od), list('abcde'))
- od.move_to_end('c')
- self.assertEqual(list(od), list('abdec'))
- od.move_to_end('c', 0)
- self.assertEqual(list(od), list('cabde'))
- od.move_to_end('c', 0)
- self.assertEqual(list(od), list('cabde'))
- od.move_to_end('e')
- self.assertEqual(list(od), list('cabde'))
- with self.assertRaises(KeyError):
- od.move_to_end('x')
-
- def test_sizeof(self):
- # Wimpy test: Just verify the reported size is larger than a regular dict
- d = dict(a=1)
- od = OrderedDict(**d)
- self.assertGreater(sys.getsizeof(od), sys.getsizeof(d))
-
- def test_override_update(self):
- # Verify that subclasses can override update() without breaking __init__()
- class MyOD(OrderedDict):
- def update(self, *args, **kwds):
- raise Exception()
- items = [('a', 1), ('c', 3), ('b', 2)]
- self.assertEqual(list(MyOD(items).items()), items)
-
-class GeneralMappingTests(mapping_tests.BasicTestMappingProtocol):
- type2test = OrderedDict
-
- def test_popitem(self):
- d = self._empty_mapping()
- self.assertRaises(KeyError, d.popitem)
-
-class MyOrderedDict(OrderedDict):
- pass
-
-class SubclassMappingTests(mapping_tests.BasicTestMappingProtocol):
- type2test = MyOrderedDict
-
- def test_popitem(self):
- d = self._empty_mapping()
- self.assertRaises(KeyError, d.popitem)
-
-
################################################################################
### Run tests
################################################################################
-import doctest, collections
-
def test_main(verbose=None):
NamedTupleDocs = doctest.DocTestSuite(module=collections)
test_classes = [TestNamedTuple, NamedTupleDocs, TestOneTrickPonyABCs,
- TestCollectionABCs, TestCounter, TestChainMap,
- TestOrderedDict, GeneralMappingTests, SubclassMappingTests]
+ TestCollectionABCs, TestCounter, TestChainMap]
support.run_unittest(*test_classes)
support.run_doctest(collections, verbose)
--- /dev/null
+import contextlib
+import copy
+import pickle
+from random import shuffle
+import sys
+import unittest
+from collections import OrderedDict
+from collections.abc import MutableMapping
+from test import mapping_tests, support
+
+
+class TestOrderedDict(unittest.TestCase):
+
+ def test_init(self):
+ with self.assertRaises(TypeError):
+ OrderedDict([('a', 1), ('b', 2)], None) # too many args
+ pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
+ self.assertEqual(sorted(OrderedDict(dict(pairs)).items()), pairs) # dict input
+ self.assertEqual(sorted(OrderedDict(**dict(pairs)).items()), pairs) # kwds input
+ self.assertEqual(list(OrderedDict(pairs).items()), pairs) # pairs input
+ self.assertEqual(list(OrderedDict([('a', 1), ('b', 2), ('c', 9), ('d', 4)],
+ c=3, e=5).items()), pairs) # mixed input
+
+ # make sure no positional args conflict with possible kwdargs
+ self.assertEqual(list(OrderedDict(self=42).items()), [('self', 42)])
+ self.assertEqual(list(OrderedDict(other=42).items()), [('other', 42)])
+ self.assertRaises(TypeError, OrderedDict, 42)
+ self.assertRaises(TypeError, OrderedDict, (), ())
+ self.assertRaises(TypeError, OrderedDict.__init__)
+
+ # Make sure that direct calls to __init__ do not clear previous contents
+ d = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 44), ('e', 55)])
+ d.__init__([('e', 5), ('f', 6)], g=7, d=4)
+ self.assertEqual(list(d.items()),
+ [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])
+
+ def test_update(self):
+ with self.assertRaises(TypeError):
+ OrderedDict().update([('a', 1), ('b', 2)], None) # too many args
+ pairs = [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5)]
+ od = OrderedDict()
+ od.update(dict(pairs))
+ self.assertEqual(sorted(od.items()), pairs) # dict input
+ od = OrderedDict()
+ od.update(**dict(pairs))
+ self.assertEqual(sorted(od.items()), pairs) # kwds input
+ od = OrderedDict()
+ od.update(pairs)
+ self.assertEqual(list(od.items()), pairs) # pairs input
+ od = OrderedDict()
+ od.update([('a', 1), ('b', 2), ('c', 9), ('d', 4)], c=3, e=5)
+ self.assertEqual(list(od.items()), pairs) # mixed input
+
+ # Issue 9137: Named argument called 'other' or 'self'
+ # shouldn't be treated specially.
+ od = OrderedDict()
+ od.update(self=23)
+ self.assertEqual(list(od.items()), [('self', 23)])
+ od = OrderedDict()
+ od.update(other={})
+ self.assertEqual(list(od.items()), [('other', {})])
+ od = OrderedDict()
+ od.update(red=5, blue=6, other=7, self=8)
+ self.assertEqual(sorted(list(od.items())),
+ [('blue', 6), ('other', 7), ('red', 5), ('self', 8)])
+
+ # Make sure that direct calls to update do not clear previous contents
+ # add that updates items are not moved to the end
+ d = OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 44), ('e', 55)])
+ d.update([('e', 5), ('f', 6)], g=7, d=4)
+ self.assertEqual(list(d.items()),
+ [('a', 1), ('b', 2), ('c', 3), ('d', 4), ('e', 5), ('f', 6), ('g', 7)])
+
+ self.assertRaises(TypeError, OrderedDict().update, 42)
+ self.assertRaises(TypeError, OrderedDict().update, (), ())
+ self.assertRaises(TypeError, OrderedDict.update)
+
+ def test_abc(self):
+ self.assertIsInstance(OrderedDict(), MutableMapping)
+ self.assertTrue(issubclass(OrderedDict, MutableMapping))
+
+ def test_clear(self):
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ shuffle(pairs)
+ od = OrderedDict(pairs)
+ self.assertEqual(len(od), len(pairs))
+ od.clear()
+ self.assertEqual(len(od), 0)
+
+ def test_delitem(self):
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ od = OrderedDict(pairs)
+ del od['a']
+ self.assertNotIn('a', od)
+ with self.assertRaises(KeyError):
+ del od['a']
+ self.assertEqual(list(od.items()), pairs[:2] + pairs[3:])
+
+ def test_setitem(self):
+ od = OrderedDict([('d', 1), ('b', 2), ('c', 3), ('a', 4), ('e', 5)])
+ od['c'] = 10 # existing element
+ od['f'] = 20 # new element
+ self.assertEqual(list(od.items()),
+ [('d', 1), ('b', 2), ('c', 10), ('a', 4), ('e', 5), ('f', 20)])
+
+ def test_iterators(self):
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ shuffle(pairs)
+ od = OrderedDict(pairs)
+ self.assertEqual(list(od), [t[0] for t in pairs])
+ self.assertEqual(list(od.keys()), [t[0] for t in pairs])
+ self.assertEqual(list(od.values()), [t[1] for t in pairs])
+ self.assertEqual(list(od.items()), pairs)
+ self.assertEqual(list(reversed(od)),
+ [t[0] for t in reversed(pairs)])
+
+ def test_popitem(self):
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ shuffle(pairs)
+ od = OrderedDict(pairs)
+ while pairs:
+ self.assertEqual(od.popitem(), pairs.pop())
+ with self.assertRaises(KeyError):
+ od.popitem()
+ self.assertEqual(len(od), 0)
+
+ def test_pop(self):
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ shuffle(pairs)
+ od = OrderedDict(pairs)
+ shuffle(pairs)
+ while pairs:
+ k, v = pairs.pop()
+ self.assertEqual(od.pop(k), v)
+ with self.assertRaises(KeyError):
+ od.pop('xyz')
+ self.assertEqual(len(od), 0)
+ self.assertEqual(od.pop(k, 12345), 12345)
+
+ # make sure pop still works when __missing__ is defined
+ class Missing(OrderedDict):
+ def __missing__(self, key):
+ return 0
+ m = Missing(a=1)
+ self.assertEqual(m.pop('b', 5), 5)
+ self.assertEqual(m.pop('a', 6), 1)
+ self.assertEqual(m.pop('a', 6), 6)
+ with self.assertRaises(KeyError):
+ m.pop('a')
+
+ def test_equality(self):
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ shuffle(pairs)
+ od1 = OrderedDict(pairs)
+ od2 = OrderedDict(pairs)
+ self.assertEqual(od1, od2) # same order implies equality
+ pairs = pairs[2:] + pairs[:2]
+ od2 = OrderedDict(pairs)
+ self.assertNotEqual(od1, od2) # different order implies inequality
+ # comparison to regular dict is not order sensitive
+ self.assertEqual(od1, dict(od2))
+ self.assertEqual(dict(od2), od1)
+ # different length implied inequality
+ self.assertNotEqual(od1, OrderedDict(pairs[:-1]))
+
+ def test_copying(self):
+ # Check that ordered dicts are copyable, deepcopyable, picklable,
+ # and have a repr/eval round-trip
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ od = OrderedDict(pairs)
+ def check(dup):
+ msg = "\ncopy: %s\nod: %s" % (dup, od)
+ self.assertIsNot(dup, od, msg)
+ self.assertEqual(dup, od)
+ check(od.copy())
+ check(copy.copy(od))
+ check(copy.deepcopy(od))
+ for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+ with self.subTest(proto=proto):
+ check(pickle.loads(pickle.dumps(od, proto)))
+ check(eval(repr(od)))
+ update_test = OrderedDict()
+ update_test.update(od)
+ check(update_test)
+ check(OrderedDict(od))
+
+ def test_yaml_linkage(self):
+ # Verify that __reduce__ is setup in a way that supports PyYAML's dump() feature.
+ # In yaml, lists are native but tuples are not.
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ od = OrderedDict(pairs)
+ # yaml.dump(od) -->
+ # '!!python/object/apply:__main__.OrderedDict\n- - [a, 1]\n - [b, 2]\n'
+ self.assertTrue(all(type(pair)==list for pair in od.__reduce__()[1]))
+
+ def test_reduce_not_too_fat(self):
+ # do not save instance dictionary if not needed
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ od = OrderedDict(pairs)
+ self.assertIsNone(od.__reduce__()[2])
+ od.x = 10
+ self.assertIsNotNone(od.__reduce__()[2])
+
+ def test_pickle_recursive(self):
+ od = OrderedDict()
+ od[1] = od
+ for proto in range(-1, pickle.HIGHEST_PROTOCOL + 1):
+ dup = pickle.loads(pickle.dumps(od, proto))
+ self.assertIsNot(dup, od)
+ self.assertEqual(list(dup.keys()), [1])
+ self.assertIs(dup[1], dup)
+
+ def test_repr(self):
+ od = OrderedDict([('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)])
+ self.assertEqual(repr(od),
+ "OrderedDict([('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)])")
+ self.assertEqual(eval(repr(od)), od)
+ self.assertEqual(repr(OrderedDict()), "OrderedDict()")
+
+ def test_repr_recursive(self):
+ # See issue #9826
+ od = OrderedDict.fromkeys('abc')
+ od['x'] = od
+ self.assertEqual(repr(od),
+ "OrderedDict([('a', None), ('b', None), ('c', None), ('x', ...)])")
+
+ def test_setdefault(self):
+ pairs = [('c', 1), ('b', 2), ('a', 3), ('d', 4), ('e', 5), ('f', 6)]
+ shuffle(pairs)
+ od = OrderedDict(pairs)
+ pair_order = list(od.items())
+ self.assertEqual(od.setdefault('a', 10), 3)
+ # make sure order didn't change
+ self.assertEqual(list(od.items()), pair_order)
+ self.assertEqual(od.setdefault('x', 10), 10)
+ # make sure 'x' is added to the end
+ self.assertEqual(list(od.items())[-1], ('x', 10))
+
+ # make sure setdefault still works when __missing__ is defined
+ class Missing(OrderedDict):
+ def __missing__(self, key):
+ return 0
+ self.assertEqual(Missing().setdefault(5, 9), 9)
+
+ def test_reinsert(self):
+ # Given insert a, insert b, delete a, re-insert a,
+ # verify that a is now later than b.
+ od = OrderedDict()
+ od['a'] = 1
+ od['b'] = 2
+ del od['a']
+ od['a'] = 1
+ self.assertEqual(list(od.items()), [('b', 2), ('a', 1)])
+
+ def test_move_to_end(self):
+ od = OrderedDict.fromkeys('abcde')
+ self.assertEqual(list(od), list('abcde'))
+ od.move_to_end('c')
+ self.assertEqual(list(od), list('abdec'))
+ od.move_to_end('c', 0)
+ self.assertEqual(list(od), list('cabde'))
+ od.move_to_end('c', 0)
+ self.assertEqual(list(od), list('cabde'))
+ od.move_to_end('e')
+ self.assertEqual(list(od), list('cabde'))
+ with self.assertRaises(KeyError):
+ od.move_to_end('x')
+
+ def test_sizeof(self):
+ # Wimpy test: Just verify the reported size is larger than a regular dict
+ d = dict(a=1)
+ od = OrderedDict(**d)
+ self.assertGreater(sys.getsizeof(od), sys.getsizeof(d))
+
+ def test_override_update(self):
+ # Verify that subclasses can override update() without breaking __init__()
+ class MyOD(OrderedDict):
+ def update(self, *args, **kwds):
+ raise Exception()
+ items = [('a', 1), ('c', 3), ('b', 2)]
+ self.assertEqual(list(MyOD(items).items()), items)
+
+class GeneralMappingTests(mapping_tests.BasicTestMappingProtocol):
+ type2test = OrderedDict
+
+ def test_popitem(self):
+ d = self._empty_mapping()
+ self.assertRaises(KeyError, d.popitem)
+
+class MyOrderedDict(OrderedDict):
+ pass
+
+class SubclassMappingTests(mapping_tests.BasicTestMappingProtocol):
+ type2test = MyOrderedDict
+
+ def test_popitem(self):
+ d = self._empty_mapping()
+ self.assertRaises(KeyError, d.popitem)
+
+
+if __name__ == "__main__":
+ unittest.main()
projects / python / commitdiff