Find more concrete classes that are registered.

src/zope/interface/common/__init__.py

@@ -210,20 +210,25 @@ def getABC(self):
 
     def getRegisteredConformers(self):
         """
-        Return an iterable of the classes that are directly
-        registered to conform to the ABC this interface
-        parallels.
+        Return an iterable of the classes that are known to conform to
+        the ABC this interface parallels.
         """
         based_on = self.__abc
 
+        # The registry only contains things that aren't already
+        # known to be subclasses of the ABC. But the ABC is in charge
+        # of checking that, so its quite possible that registrations
+        # are in fact ignored, winding up just in the _abc_cache.
         try:
-            registered = list(based_on._abc_registry)
+            registered = list(based_on._abc_registry) + list(based_on._abc_cache)
         except AttributeError:
             # Rewritten in C in CPython 3.7.
             # These expose the underlying weakref.
             from abc import _get_dump
-            registry = _get_dump(based_on)[0]
-            registered = [x() for x in registry]
+            data = _get_dump(based_on)
+            registry = data[0]
+            cache = data[1]
+            registered = [x() for x in itertools.chain(registry, cache)]
             registered = [x for x in registered if x is not None]
 
         return set(itertools.chain(registered, self.__extra_classes))

src/zope/interface/common/tests/__init__.py

@@ -82,5 +82,14 @@ class VerifyObjectMixin(VerifyClassMixin):
     }
 
     def _adjust_object_before_verify(self, iface, x):
-        return self.CONSTRUCTORS.get(iface,
-                                     self.CONSTRUCTORS.get(x, x))()
+        constructor = self.CONSTRUCTORS.get(x)
+        if not constructor:
+            constructor = self.CONSTRUCTORS.get(iface)
+        if not constructor:
+            constructor = self.CONSTRUCTORS.get(x.__name__)
+        if not constructor:
+            constructor = x
+        if constructor is unittest.SkipTest:
+            self.skipTest("Cannot create " + str(x))
+
+        return constructor()

src/zope/interface/common/tests/test_collections.py

@@ -25,8 +25,7 @@
     MappingProxyType = object()
 
 from zope.interface import Invalid
-from zope.interface.verify import verifyClass
-from zope.interface.verify import verifyObject
+
 
 # Note that importing z.i.c.collections does work on import.
 from zope.interface.common import collections
@@ -135,6 +134,21 @@ class TestVerifyObject(VerifyObjectMixin,
         range: lambda: range(10),
         MappingProxyType: lambda: MappingProxyType({}),
         collections.UserString: lambda: collections.UserString('abc'),
+        type(iter(bytearray())): lambda: iter(bytearray()),
+        type(iter(b'abc')): lambda: iter(b'abc'),
+        'coroutine': unittest.SkipTest,
+        type(iter({}.keys())): lambda: iter({}.keys()),
+        type(iter({}.items())): lambda: iter({}.items()),
+        type(iter({}.values())): lambda: iter({}.values()),
+        type((i for i in range(1))): lambda: (i for i in range(3)),
+        type(iter([])): lambda: iter([]),
+        type(reversed([])): lambda: reversed([]),
+        'longrange_iterator': unittest.SkipTest,
+        'range_iterator': lambda: iter(range(3)),
+        type(iter(set())): lambda: iter(set()),
+        type(iter('')): lambda: iter(''),
+        'async_generator': unittest.SkipTest,
+        type(iter(tuple())): lambda: iter(tuple()),
     }
 
     if PY2:

src/zope/interface/common/tests/test_io.py

@@ -38,6 +38,7 @@ class TestVerifyObject(VerifyObjectMixin,
         abc.BufferedRandom: lambda: abc.BufferedRandom(abc.BytesIO()),
         abc.BufferedRWPair: lambda: abc.BufferedRWPair(abc.BytesIO(), abc.BytesIO()),
         abc.FileIO: lambda: abc.FileIO(__file__),
+        'WindowsConsoleIO': unittest.SkipTest,
     }
 
     try:

src/zope/interface/tests/test_verify.py

@@ -21,11 +21,8 @@ class Test_verifyClass(unittest.TestCase):
 
     verifier = None
 
-    @classmethod
-    def setUpClass(cls):
-        # zope.testrunner doesn't call setUpClass, so if you get
-        # 'NoneType is not callable', that's why.
-        cls.verifier = staticmethod(cls._get_FUT())
+    def setUp(self):
+        self.verifier = self._get_FUT()
 
     @classmethod
     def _get_FUT(cls):