Issue #25616: Tests for OrderedDict are extracted from test_collections
into separate file test_ordered_dict.
This commit is contained in:
Serhiy Storchaka
parent
1c855f4602
commit
33e7ea5ad6
|
|
@ -1,16 +1,19 @@
|
||||||
"""Unit tests for collections.py."""
|
"""Unit tests for collections.py."""
|
||||||
|
|
||||||
import unittest, doctest, operator
|
import collections
|
||||||
from test.support import TESTFN, forget, unlink
|
import copy
|
||||||
import inspect
|
import doctest
|
||||||
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 keyword
|
import keyword
|
||||||
|
import operator
|
||||||
|
import pickle
|
||||||
|
from random import choice, randrange
|
||||||
import re
|
import re
|
||||||
|
import string
|
||||||
import sys
|
import sys
|
||||||
|
from test import support
|
||||||
|
import unittest
|
||||||
|
|
||||||
|
from collections import namedtuple, Counter, OrderedDict, _count_elements
|
||||||
from collections import UserDict
|
from collections import UserDict
|
||||||
from collections import ChainMap
|
from collections import ChainMap
|
||||||
from collections.abc import Hashable, Iterable, Iterator
|
from collections.abc import Hashable, Iterable, Iterator
|
||||||
|
|
@ -281,8 +284,7 @@ class TestNamedTuple(unittest.TestCase):
|
||||||
|
|
||||||
# n = 5000
|
# n = 5000
|
||||||
n = 254 # SyntaxError: more than 255 arguments:
|
n = 254 # SyntaxError: more than 255 arguments:
|
||||||
import string, random
|
names = list(set(''.join([choice(string.ascii_letters)
|
||||||
names = list(set(''.join([random.choice(string.ascii_letters)
|
|
||||||
for j in range(10)]) for i in range(n)))
|
for j in range(10)]) for i in range(n)))
|
||||||
n = len(names)
|
n = len(names)
|
||||||
Big = namedtuple('Big', names)
|
Big = namedtuple('Big', names)
|
||||||
|
|
@ -1280,310 +1282,14 @@ class TestCounter(unittest.TestCase):
|
||||||
self.assertEqual(dict(c), {'a': 5, 'b': 2, 'c': 1, 'd': 1, 'r':2 })
|
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
|
### Run tests
|
||||||
################################################################################
|
################################################################################
|
||||||
|
|
||||||
import doctest, collections
|
|
||||||
|
|
||||||
def test_main(verbose=None):
|
def test_main(verbose=None):
|
||||||
NamedTupleDocs = doctest.DocTestSuite(module=collections)
|
NamedTupleDocs = doctest.DocTestSuite(module=collections)
|
||||||
test_classes = [TestNamedTuple, NamedTupleDocs, TestOneTrickPonyABCs,
|
test_classes = [TestNamedTuple, NamedTupleDocs, TestOneTrickPonyABCs,
|
||||||
TestCollectionABCs, TestCounter, TestChainMap,
|
TestCollectionABCs, TestCounter, TestChainMap]
|
||||||
TestOrderedDict, GeneralMappingTests, SubclassMappingTests]
|
|
||||||
support.run_unittest(*test_classes)
|
support.run_unittest(*test_classes)
|
||||||
support.run_doctest(collections, verbose)
|
support.run_doctest(collections, verbose)
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,302 @@
|
||||||
|
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()
|
||||||
|
|
@ -694,6 +694,9 @@ IDLE
|
||||||
Tests
|
Tests
|
||||||
-----
|
-----
|
||||||
|
|
||||||
|
- Issue #25616: Tests for OrderedDict are extracted from test_collections
|
||||||
|
into separate file test_ordered_dict.
|
||||||
|
|
||||||
- Issue #25099: Make test_compileall not fail when an entry on sys.path cannot
|
- Issue #25099: Make test_compileall not fail when an entry on sys.path cannot
|
||||||
be written to (commonly seen in administrative installs on Windows).
|
be written to (commonly seen in administrative installs on Windows).
|
||||||
|
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue