Backport of _abccoll.py by Benjamin Arangueren, issue 1383.
With some changes of my own thrown in (e.g. backport of r58107).
diff --git a/Lib/test/mapping_tests.py b/Lib/test/mapping_tests.py
index 4b0f797..c6857ab 100644
--- a/Lib/test/mapping_tests.py
+++ b/Lib/test/mapping_tests.py
@@ -557,6 +557,8 @@
class BadEq(object):
def __eq__(self, other):
raise Exc()
+ def __hash__(self):
+ return 24
d = self._empty_mapping()
d[BadEq()] = 42
@@ -642,6 +644,8 @@
class BadCmp(object):
def __eq__(self, other):
raise Exc()
+ def __hash__(self):
+ return 42
d1 = self._full_mapping({BadCmp(): 1})
d2 = self._full_mapping({1: 1})
diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py
index 7973b23..9694e2a 100755
--- a/Lib/test/regrtest.py
+++ b/Lib/test/regrtest.py
@@ -648,7 +648,7 @@
def dash_R(the_module, test, indirect_test, huntrleaks):
# This code is hackish and inelegant, but it seems to do the job.
- import copy_reg
+ import copy_reg, _abcoll
if not hasattr(sys, 'gettotalrefcount'):
raise Exception("Tracking reference leaks requires a debug build "
@@ -658,6 +658,12 @@
fs = warnings.filters[:]
ps = copy_reg.dispatch_table.copy()
pic = sys.path_importer_cache.copy()
+ abcs = {}
+ for abc in [getattr(_abcoll, a) for a in _abcoll.__all__]:
+ for obj in abc.__subclasses__() + [abc]:
+ abcs[obj] = obj._abc_registry.copy()
+
+ print >> sys.stderr, abcs
if indirect_test:
def run_the_test():
@@ -671,12 +677,12 @@
repcount = nwarmup + ntracked
print >> sys.stderr, "beginning", repcount, "repetitions"
print >> sys.stderr, ("1234567890"*(repcount//10 + 1))[:repcount]
- dash_R_cleanup(fs, ps, pic)
+ dash_R_cleanup(fs, ps, pic, abcs)
for i in range(repcount):
rc = sys.gettotalrefcount()
run_the_test()
sys.stderr.write('.')
- dash_R_cleanup(fs, ps, pic)
+ dash_R_cleanup(fs, ps, pic, abcs)
if i >= nwarmup:
deltas.append(sys.gettotalrefcount() - rc - 2)
print >> sys.stderr
@@ -687,11 +693,11 @@
print >> refrep, msg
refrep.close()
-def dash_R_cleanup(fs, ps, pic):
+def dash_R_cleanup(fs, ps, pic, abcs):
import gc, copy_reg
import _strptime, linecache, dircache
import urlparse, urllib, urllib2, mimetypes, doctest
- import struct, filecmp
+ import struct, filecmp, _abcoll
from distutils.dir_util import _path_created
# Restore some original values.
@@ -701,6 +707,13 @@
sys.path_importer_cache.clear()
sys.path_importer_cache.update(pic)
+ # Clear ABC registries, restoring previously saved ABC registries.
+ for abc in [getattr(_abcoll, a) for a in _abcoll.__all__]:
+ for obj in abc.__subclasses__() + [abc]:
+ obj._abc_registry = abcs.get(obj, {}).copy()
+ obj._abc_cache.clear()
+ obj._abc_negative_cache.clear()
+
# Clear assorted module caches.
_path_created.clear()
re.purge()
diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
index 3fd9bde..c760356 100644
--- a/Lib/test/test_abc.py
+++ b/Lib/test/test_abc.py
@@ -133,6 +133,20 @@
self.failUnless(issubclass(MyInt, A))
self.failUnless(isinstance(42, A))
+ def test_all_new_methods_are_called(self):
+ class A:
+ __metaclass__ = abc.ABCMeta
+ class B:
+ counter = 0
+ def __new__(cls):
+ B.counter += 1
+ return super(B, cls).__new__(cls)
+ class C(A, B):
+ pass
+ self.assertEqual(B.counter, 0)
+ C()
+ self.assertEqual(B.counter, 1)
+
def test_main():
test_support.run_unittest(TestABC)
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index 7c5b2dc..52bae9a 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -1,6 +1,12 @@
import unittest
from test import test_support
from collections import namedtuple
+from collections import Hashable, Iterable, Iterator
+from collections import Sized, Container, Callable
+from collections import Set, MutableSet
+from collections import Mapping, MutableMapping
+from collections import Sequence, MutableSequence
+
class TestNamedTuple(unittest.TestCase):
@@ -86,9 +92,187 @@
Dot = namedtuple('Dot', 'd')
self.assertEqual(Dot(1), (1,))
+
+class TestOneTrickPonyABCs(unittest.TestCase):
+
+ def test_Hashable(self):
+ # Check some non-hashables
+ non_samples = [list(), set(), dict()]
+ for x in non_samples:
+ self.failIf(isinstance(x, Hashable), repr(x))
+ self.failIf(issubclass(type(x), Hashable), repr(type(x)))
+ # Check some hashables
+ samples = [None,
+ int(), float(), complex(),
+ str(),
+ tuple(), frozenset(),
+ int, list, object, type,
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Hashable), repr(x))
+ self.failUnless(issubclass(type(x), Hashable), repr(type(x)))
+ self.assertRaises(TypeError, Hashable)
+ # Check direct subclassing
+ class H(Hashable):
+ def __hash__(self):
+ return super(H, self).__hash__()
+ self.assertEqual(hash(H()), 0)
+ self.failIf(issubclass(int, H))
+
+ def test_Iterable(self):
+ # Check some non-iterables
+ non_samples = [None, 42, 3.14, 1j]
+ for x in non_samples:
+ self.failIf(isinstance(x, Iterable), repr(x))
+ self.failIf(issubclass(type(x), Iterable), repr(type(x)))
+ # Check some iterables
+ samples = [str(),
+ tuple(), list(), set(), frozenset(), dict(),
+ dict().keys(), dict().items(), dict().values(),
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Iterable), repr(x))
+ self.failUnless(issubclass(type(x), Iterable), repr(type(x)))
+ # Check direct subclassing
+ class I(Iterable):
+ def __iter__(self):
+ return super(I, self).__iter__()
+ self.assertEqual(list(I()), [])
+ self.failIf(issubclass(str, I))
+
+ def test_Iterator(self):
+ non_samples = [None, 42, 3.14, 1j, "".encode('ascii'), "", (), [],
+ {}, set()]
+ for x in non_samples:
+ self.failIf(isinstance(x, Iterator), repr(x))
+ self.failIf(issubclass(type(x), Iterator), repr(type(x)))
+ samples = [iter(str()),
+ iter(tuple()), iter(list()), iter(dict()),
+ iter(set()), iter(frozenset()),
+ iter(dict().keys()), iter(dict().items()),
+ iter(dict().values()),
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Iterator), repr(x))
+ self.failUnless(issubclass(type(x), Iterator), repr(type(x)))
+
+ def test_Sized(self):
+ non_samples = [None, 42, 3.14, 1j,
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in non_samples:
+ self.failIf(isinstance(x, Sized), repr(x))
+ self.failIf(issubclass(type(x), Sized), repr(type(x)))
+ samples = [str(),
+ tuple(), list(), set(), frozenset(), dict(),
+ dict().keys(), dict().items(), dict().values(),
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Sized), repr(x))
+ self.failUnless(issubclass(type(x), Sized), repr(type(x)))
+
+ def test_Container(self):
+ non_samples = [None, 42, 3.14, 1j,
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in non_samples:
+ self.failIf(isinstance(x, Container), repr(x))
+ self.failIf(issubclass(type(x), Container), repr(type(x)))
+ samples = [str(),
+ tuple(), list(), set(), frozenset(), dict(),
+ dict().keys(), dict().items(),
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Container), repr(x))
+ self.failUnless(issubclass(type(x), Container), repr(type(x)))
+
+ def test_Callable(self):
+ non_samples = [None, 42, 3.14, 1j,
+ "", "".encode('ascii'), (), [], {}, set(),
+ (lambda: (yield))(),
+ (x for x in []),
+ ]
+ for x in non_samples:
+ self.failIf(isinstance(x, Callable), repr(x))
+ self.failIf(issubclass(type(x), Callable), repr(type(x)))
+ samples = [lambda: None,
+ type, int, object,
+ len,
+ list.append, [].append,
+ ]
+ for x in samples:
+ self.failUnless(isinstance(x, Callable), repr(x))
+ self.failUnless(issubclass(type(x), Callable), repr(type(x)))
+
+ def test_direct_subclassing(self):
+ for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
+ class C(B):
+ pass
+ self.failUnless(issubclass(C, B))
+ self.failIf(issubclass(int, C))
+
+ def test_registration(self):
+ for B in Hashable, Iterable, Iterator, Sized, Container, Callable:
+ class C:
+ __metaclass__ = type
+ __hash__ = None # Make sure it isn't hashable by default
+ self.failIf(issubclass(C, B), B.__name__)
+ B.register(C)
+ self.failUnless(issubclass(C, B))
+
+
+class TestCollectionABCs(unittest.TestCase):
+
+ # XXX For now, we only test some virtual inheritance properties.
+ # We should also test the proper behavior of the collection ABCs
+ # as real base classes or mix-in classes.
+
+ def test_Set(self):
+ for sample in [set, frozenset]:
+ self.failUnless(isinstance(sample(), Set))
+ self.failUnless(issubclass(sample, Set))
+
+ def test_MutableSet(self):
+ self.failUnless(isinstance(set(), MutableSet))
+ self.failUnless(issubclass(set, MutableSet))
+ self.failIf(isinstance(frozenset(), MutableSet))
+ self.failIf(issubclass(frozenset, MutableSet))
+
+ def test_Mapping(self):
+ for sample in [dict]:
+ self.failUnless(isinstance(sample(), Mapping))
+ self.failUnless(issubclass(sample, Mapping))
+
+ def test_MutableMapping(self):
+ for sample in [dict]:
+ self.failUnless(isinstance(sample(), MutableMapping))
+ self.failUnless(issubclass(sample, MutableMapping))
+
+ def test_Sequence(self):
+ for sample in [tuple, list, str]:
+ self.failUnless(isinstance(sample(), Sequence))
+ self.failUnless(issubclass(sample, Sequence))
+ self.failUnless(issubclass(basestring, Sequence))
+
+ def test_MutableSequence(self):
+ for sample in [tuple, str]:
+ self.failIf(isinstance(sample(), MutableSequence))
+ self.failIf(issubclass(sample, MutableSequence))
+ for sample in [list]:
+ self.failUnless(isinstance(sample(), MutableSequence))
+ self.failUnless(issubclass(sample, MutableSequence))
+ self.failIf(issubclass(basestring, MutableSequence))
+
+
def test_main(verbose=None):
import collections as CollectionsModule
- test_classes = [TestNamedTuple]
+ test_classes = [TestNamedTuple, TestOneTrickPonyABCs, TestCollectionABCs]
test_support.run_unittest(*test_classes)
test_support.run_doctest(CollectionsModule, verbose)
diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py
index 9f049ad..342e775 100644
--- a/Lib/test/test_dict.py
+++ b/Lib/test/test_dict.py
@@ -86,6 +86,8 @@
class BadEq(object):
def __eq__(self, other):
raise Exc()
+ def __hash__(self):
+ return 24
d = {}
d[BadEq()] = 42
@@ -397,6 +399,8 @@
class BadCmp(object):
def __eq__(self, other):
raise Exc()
+ def __hash__(self):
+ return 42
d1 = {BadCmp(): 1}
d2 = {1: 1}