diff --git a/Lib/test/libregrtest/refleak.py b/Lib/test/libregrtest/refleak.py
index 2ca9aa8..6724488 100644
--- a/Lib/test/libregrtest/refleak.py
+++ b/Lib/test/libregrtest/refleak.py
@@ -5,6 +5,13 @@
 import warnings
 from inspect import isabstract
 from test import support
+try:
+    from _abc import _get_dump
+except ImportError:
+    def _get_dump(cls):
+        # For legacy Python version
+        return (cls._abc_registry, cls._abc_cache,
+                cls._abc_negative_cache, cls._abc_negative_cache_version)
 
 
 def dash_R(the_module, test, indirect_test, huntrleaks):
@@ -36,7 +43,7 @@
         if not isabstract(abc):
             continue
         for obj in abc.__subclasses__() + [abc]:
-            abcs[obj] = obj._abc_registry.copy()
+            abcs[obj] = _get_dump(obj)[0]
 
     # bpo-31217: Integer pool to get a single integer object for the same
     # value. The pool is used to prevent false alarm when checking for memory
@@ -113,7 +120,6 @@
 def dash_R_cleanup(fs, ps, pic, zdc, abcs):
     import gc, copyreg
     import collections.abc
-    from weakref import WeakSet
 
     # Restore some original values.
     warnings.filters[:] = fs
@@ -137,9 +143,10 @@
     abs_classes = filter(isabstract, abs_classes)
     for abc in abs_classes:
         for obj in abc.__subclasses__() + [abc]:
-            obj._abc_registry = abcs.get(obj, WeakSet()).copy()
-            obj._abc_cache.clear()
-            obj._abc_negative_cache.clear()
+            for ref in abcs.get(obj, set()):
+                if ref() is not None:
+                    obj.register(ref())
+            obj._abc_caches_clear()
 
     clear_caches()
 
diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
index 61c2876..af26c1d 100644
--- a/Lib/test/test_abc.py
+++ b/Lib/test/test_abc.py
@@ -1,422 +1,445 @@
 # Copyright 2007 Google, Inc. All Rights Reserved.
 # Licensed to PSF under a Contributor Agreement.
 
+# Note: each test is run with Python and C versions of ABCMeta. Except for
+# test_ABC_helper(), which assures that abc.ABC is an instance of abc.ABCMeta.
+
 """Unit tests for abc.py."""
 
 import unittest
 
 import abc
+import _py_abc
 from inspect import isabstract
 
+def test_factory(abc_ABCMeta, abc_get_cache_token):
+    class TestLegacyAPI(unittest.TestCase):
 
-class TestLegacyAPI(unittest.TestCase):
-
-    def test_abstractproperty_basics(self):
-        @abc.abstractproperty
-        def foo(self): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        def bar(self): pass
-        self.assertFalse(hasattr(bar, "__isabstractmethod__"))
-
-        class C(metaclass=abc.ABCMeta):
+        def test_abstractproperty_basics(self):
             @abc.abstractproperty
-            def foo(self): return 3
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @property
-            def foo(self): return super().foo
-        self.assertEqual(D().foo, 3)
-        self.assertFalse(getattr(D.foo, "__isabstractmethod__", False))
+            def foo(self): pass
+            self.assertTrue(foo.__isabstractmethod__)
+            def bar(self): pass
+            self.assertFalse(hasattr(bar, "__isabstractmethod__"))
 
-    def test_abstractclassmethod_basics(self):
-        @abc.abstractclassmethod
-        def foo(cls): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        @classmethod
-        def bar(cls): pass
-        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
-
-        class C(metaclass=abc.ABCMeta):
-            @abc.abstractclassmethod
-            def foo(cls): return cls.__name__
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @classmethod
-            def foo(cls): return super().foo()
-        self.assertEqual(D.foo(), 'D')
-        self.assertEqual(D().foo(), 'D')
-
-    def test_abstractstaticmethod_basics(self):
-        @abc.abstractstaticmethod
-        def foo(): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        @staticmethod
-        def bar(): pass
-        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
-
-        class C(metaclass=abc.ABCMeta):
-            @abc.abstractstaticmethod
-            def foo(): return 3
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @staticmethod
-            def foo(): return 4
-        self.assertEqual(D.foo(), 4)
-        self.assertEqual(D().foo(), 4)
-
-
-class TestABC(unittest.TestCase):
-
-    def test_ABC_helper(self):
-        # create an ABC using the helper class and perform basic checks
-        class C(abc.ABC):
-            @classmethod
-            @abc.abstractmethod
-            def foo(cls): return cls.__name__
-        self.assertEqual(type(C), abc.ABCMeta)
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @classmethod
-            def foo(cls): return super().foo()
-        self.assertEqual(D.foo(), 'D')
-
-    def test_abstractmethod_basics(self):
-        @abc.abstractmethod
-        def foo(self): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        def bar(self): pass
-        self.assertFalse(hasattr(bar, "__isabstractmethod__"))
-
-    def test_abstractproperty_basics(self):
-        @property
-        @abc.abstractmethod
-        def foo(self): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        def bar(self): pass
-        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
-
-        class C(metaclass=abc.ABCMeta):
-            @property
-            @abc.abstractmethod
-            def foo(self): return 3
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @C.foo.getter
-            def foo(self): return super().foo
-        self.assertEqual(D().foo, 3)
-
-    def test_abstractclassmethod_basics(self):
-        @classmethod
-        @abc.abstractmethod
-        def foo(cls): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        @classmethod
-        def bar(cls): pass
-        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
-
-        class C(metaclass=abc.ABCMeta):
-            @classmethod
-            @abc.abstractmethod
-            def foo(cls): return cls.__name__
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @classmethod
-            def foo(cls): return super().foo()
-        self.assertEqual(D.foo(), 'D')
-        self.assertEqual(D().foo(), 'D')
-
-    def test_abstractstaticmethod_basics(self):
-        @staticmethod
-        @abc.abstractmethod
-        def foo(): pass
-        self.assertTrue(foo.__isabstractmethod__)
-        @staticmethod
-        def bar(): pass
-        self.assertFalse(getattr(bar, "__isabstractmethod__", False))
-
-        class C(metaclass=abc.ABCMeta):
-            @staticmethod
-            @abc.abstractmethod
-            def foo(): return 3
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @staticmethod
-            def foo(): return 4
-        self.assertEqual(D.foo(), 4)
-        self.assertEqual(D().foo(), 4)
-
-    def test_abstractmethod_integration(self):
-        for abstractthing in [abc.abstractmethod, abc.abstractproperty,
-                              abc.abstractclassmethod,
-                              abc.abstractstaticmethod]:
-            class C(metaclass=abc.ABCMeta):
-                @abstractthing
-                def foo(self): pass  # abstract
-                def bar(self): pass  # concrete
-            self.assertEqual(C.__abstractmethods__, {"foo"})
-            self.assertRaises(TypeError, C)  # because foo is abstract
-            self.assertTrue(isabstract(C))
+            class C(metaclass=abc_ABCMeta):
+                @abc.abstractproperty
+                def foo(self): return 3
+            self.assertRaises(TypeError, C)
             class D(C):
-                def bar(self): pass  # concrete override of concrete
-            self.assertEqual(D.__abstractmethods__, {"foo"})
-            self.assertRaises(TypeError, D)  # because foo is still abstract
-            self.assertTrue(isabstract(D))
+                @property
+                def foo(self): return super().foo
+            self.assertEqual(D().foo, 3)
+            self.assertFalse(getattr(D.foo, "__isabstractmethod__", False))
+
+        def test_abstractclassmethod_basics(self):
+            @abc.abstractclassmethod
+            def foo(cls): pass
+            self.assertTrue(foo.__isabstractmethod__)
+            @classmethod
+            def bar(cls): pass
+            self.assertFalse(getattr(bar, "__isabstractmethod__", False))
+
+            class C(metaclass=abc_ABCMeta):
+                @abc.abstractclassmethod
+                def foo(cls): return cls.__name__
+            self.assertRaises(TypeError, C)
+            class D(C):
+                @classmethod
+                def foo(cls): return super().foo()
+            self.assertEqual(D.foo(), 'D')
+            self.assertEqual(D().foo(), 'D')
+
+        def test_abstractstaticmethod_basics(self):
+            @abc.abstractstaticmethod
+            def foo(): pass
+            self.assertTrue(foo.__isabstractmethod__)
+            @staticmethod
+            def bar(): pass
+            self.assertFalse(getattr(bar, "__isabstractmethod__", False))
+
+            class C(metaclass=abc_ABCMeta):
+                @abc.abstractstaticmethod
+                def foo(): return 3
+            self.assertRaises(TypeError, C)
+            class D(C):
+                @staticmethod
+                def foo(): return 4
+            self.assertEqual(D.foo(), 4)
+            self.assertEqual(D().foo(), 4)
+
+
+    class TestABC(unittest.TestCase):
+
+        def test_ABC_helper(self):
+            # create an ABC using the helper class and perform basic checks
+            class C(abc.ABC):
+                @classmethod
+                @abc.abstractmethod
+                def foo(cls): return cls.__name__
+            self.assertEqual(type(C), abc.ABCMeta)
+            self.assertRaises(TypeError, C)
+            class D(C):
+                @classmethod
+                def foo(cls): return super().foo()
+            self.assertEqual(D.foo(), 'D')
+
+        def test_abstractmethod_basics(self):
+            @abc.abstractmethod
+            def foo(self): pass
+            self.assertTrue(foo.__isabstractmethod__)
+            def bar(self): pass
+            self.assertFalse(hasattr(bar, "__isabstractmethod__"))
+
+        def test_abstractproperty_basics(self):
+            @property
+            @abc.abstractmethod
+            def foo(self): pass
+            self.assertTrue(foo.__isabstractmethod__)
+            def bar(self): pass
+            self.assertFalse(getattr(bar, "__isabstractmethod__", False))
+
+            class C(metaclass=abc_ABCMeta):
+                @property
+                @abc.abstractmethod
+                def foo(self): return 3
+            self.assertRaises(TypeError, C)
+            class D(C):
+                @C.foo.getter
+                def foo(self): return super().foo
+            self.assertEqual(D().foo, 3)
+
+        def test_abstractclassmethod_basics(self):
+            @classmethod
+            @abc.abstractmethod
+            def foo(cls): pass
+            self.assertTrue(foo.__isabstractmethod__)
+            @classmethod
+            def bar(cls): pass
+            self.assertFalse(getattr(bar, "__isabstractmethod__", False))
+
+            class C(metaclass=abc_ABCMeta):
+                @classmethod
+                @abc.abstractmethod
+                def foo(cls): return cls.__name__
+            self.assertRaises(TypeError, C)
+            class D(C):
+                @classmethod
+                def foo(cls): return super().foo()
+            self.assertEqual(D.foo(), 'D')
+            self.assertEqual(D().foo(), 'D')
+
+        def test_abstractstaticmethod_basics(self):
+            @staticmethod
+            @abc.abstractmethod
+            def foo(): pass
+            self.assertTrue(foo.__isabstractmethod__)
+            @staticmethod
+            def bar(): pass
+            self.assertFalse(getattr(bar, "__isabstractmethod__", False))
+
+            class C(metaclass=abc_ABCMeta):
+                @staticmethod
+                @abc.abstractmethod
+                def foo(): return 3
+            self.assertRaises(TypeError, C)
+            class D(C):
+                @staticmethod
+                def foo(): return 4
+            self.assertEqual(D.foo(), 4)
+            self.assertEqual(D().foo(), 4)
+
+        def test_abstractmethod_integration(self):
+            for abstractthing in [abc.abstractmethod, abc.abstractproperty,
+                                  abc.abstractclassmethod,
+                                  abc.abstractstaticmethod]:
+                class C(metaclass=abc_ABCMeta):
+                    @abstractthing
+                    def foo(self): pass  # abstract
+                    def bar(self): pass  # concrete
+                self.assertEqual(C.__abstractmethods__, {"foo"})
+                self.assertRaises(TypeError, C)  # because foo is abstract
+                self.assertTrue(isabstract(C))
+                class D(C):
+                    def bar(self): pass  # concrete override of concrete
+                self.assertEqual(D.__abstractmethods__, {"foo"})
+                self.assertRaises(TypeError, D)  # because foo is still abstract
+                self.assertTrue(isabstract(D))
+                class E(D):
+                    def foo(self): pass
+                self.assertEqual(E.__abstractmethods__, set())
+                E()  # now foo is concrete, too
+                self.assertFalse(isabstract(E))
+                class F(E):
+                    @abstractthing
+                    def bar(self): pass  # abstract override of concrete
+                self.assertEqual(F.__abstractmethods__, {"bar"})
+                self.assertRaises(TypeError, F)  # because bar is abstract now
+                self.assertTrue(isabstract(F))
+
+        def test_descriptors_with_abstractmethod(self):
+            class C(metaclass=abc_ABCMeta):
+                @property
+                @abc.abstractmethod
+                def foo(self): return 3
+                @foo.setter
+                @abc.abstractmethod
+                def foo(self, val): pass
+            self.assertRaises(TypeError, C)
+            class D(C):
+                @C.foo.getter
+                def foo(self): return super().foo
+            self.assertRaises(TypeError, D)
             class E(D):
-                def foo(self): pass
-            self.assertEqual(E.__abstractmethods__, set())
-            E()  # now foo is concrete, too
-            self.assertFalse(isabstract(E))
-            class F(E):
-                @abstractthing
-                def bar(self): pass  # abstract override of concrete
-            self.assertEqual(F.__abstractmethods__, {"bar"})
-            self.assertRaises(TypeError, F)  # because bar is abstract now
-            self.assertTrue(isabstract(F))
+                @D.foo.setter
+                def foo(self, val): pass
+            self.assertEqual(E().foo, 3)
+            # check that the property's __isabstractmethod__ descriptor does the
+            # right thing when presented with a value that fails truth testing:
+            class NotBool(object):
+                def __bool__(self):
+                    raise ValueError()
+                __len__ = __bool__
+            with self.assertRaises(ValueError):
+                class F(C):
+                    def bar(self):
+                        pass
+                    bar.__isabstractmethod__ = NotBool()
+                    foo = property(bar)
 
-    def test_descriptors_with_abstractmethod(self):
-        class C(metaclass=abc.ABCMeta):
-            @property
-            @abc.abstractmethod
-            def foo(self): return 3
-            @foo.setter
-            @abc.abstractmethod
-            def foo(self, val): pass
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @C.foo.getter
-            def foo(self): return super().foo
-        self.assertRaises(TypeError, D)
-        class E(D):
-            @D.foo.setter
-            def foo(self, val): pass
-        self.assertEqual(E().foo, 3)
-        # check that the property's __isabstractmethod__ descriptor does the
-        # right thing when presented with a value that fails truth testing:
-        class NotBool(object):
-            def __bool__(self):
-                raise ValueError()
-            __len__ = __bool__
-        with self.assertRaises(ValueError):
-            class F(C):
-                def bar(self):
+
+        def test_customdescriptors_with_abstractmethod(self):
+            class Descriptor:
+                def __init__(self, fget, fset=None):
+                    self._fget = fget
+                    self._fset = fset
+                def getter(self, callable):
+                    return Descriptor(callable, self._fget)
+                def setter(self, callable):
+                    return Descriptor(self._fget, callable)
+                @property
+                def __isabstractmethod__(self):
+                    return (getattr(self._fget, '__isabstractmethod__', False)
+                            or getattr(self._fset, '__isabstractmethod__', False))
+            class C(metaclass=abc_ABCMeta):
+                @Descriptor
+                @abc.abstractmethod
+                def foo(self): return 3
+                @foo.setter
+                @abc.abstractmethod
+                def foo(self, val): pass
+            self.assertRaises(TypeError, C)
+            class D(C):
+                @C.foo.getter
+                def foo(self): return super().foo
+            self.assertRaises(TypeError, D)
+            class E(D):
+                @D.foo.setter
+                def foo(self, val): pass
+            self.assertFalse(E.foo.__isabstractmethod__)
+
+        def test_metaclass_abc(self):
+            # Metaclasses can be ABCs, too.
+            class A(metaclass=abc_ABCMeta):
+                @abc.abstractmethod
+                def x(self):
                     pass
-                bar.__isabstractmethod__ = NotBool()
-                foo = property(bar)
-
-
-    def test_customdescriptors_with_abstractmethod(self):
-        class Descriptor:
-            def __init__(self, fget, fset=None):
-                self._fget = fget
-                self._fset = fset
-            def getter(self, callable):
-                return Descriptor(callable, self._fget)
-            def setter(self, callable):
-                return Descriptor(self._fget, callable)
-            @property
-            def __isabstractmethod__(self):
-                return (getattr(self._fget, '__isabstractmethod__', False)
-                        or getattr(self._fset, '__isabstractmethod__', False))
-        class C(metaclass=abc.ABCMeta):
-            @Descriptor
-            @abc.abstractmethod
-            def foo(self): return 3
-            @foo.setter
-            @abc.abstractmethod
-            def foo(self, val): pass
-        self.assertRaises(TypeError, C)
-        class D(C):
-            @C.foo.getter
-            def foo(self): return super().foo
-        self.assertRaises(TypeError, D)
-        class E(D):
-            @D.foo.setter
-            def foo(self, val): pass
-        self.assertFalse(E.foo.__isabstractmethod__)
-
-    def test_metaclass_abc(self):
-        # Metaclasses can be ABCs, too.
-        class A(metaclass=abc.ABCMeta):
-            @abc.abstractmethod
-            def x(self):
+            self.assertEqual(A.__abstractmethods__, {"x"})
+            class meta(type, A):
+                def x(self):
+                    return 1
+            class C(metaclass=meta):
                 pass
-        self.assertEqual(A.__abstractmethods__, {"x"})
-        class meta(type, A):
-            def x(self):
-                return 1
-        class C(metaclass=meta):
-            pass
 
-    def test_registration_basics(self):
-        class A(metaclass=abc.ABCMeta):
-            pass
-        class B(object):
-            pass
-        b = B()
-        self.assertFalse(issubclass(B, A))
-        self.assertFalse(issubclass(B, (A,)))
-        self.assertNotIsInstance(b, A)
-        self.assertNotIsInstance(b, (A,))
-        B1 = A.register(B)
-        self.assertTrue(issubclass(B, A))
-        self.assertTrue(issubclass(B, (A,)))
-        self.assertIsInstance(b, A)
-        self.assertIsInstance(b, (A,))
-        self.assertIs(B1, B)
-        class C(B):
-            pass
-        c = C()
-        self.assertTrue(issubclass(C, A))
-        self.assertTrue(issubclass(C, (A,)))
-        self.assertIsInstance(c, A)
-        self.assertIsInstance(c, (A,))
+        def test_registration_basics(self):
+            class A(metaclass=abc_ABCMeta):
+                pass
+            class B(object):
+                pass
+            b = B()
+            self.assertFalse(issubclass(B, A))
+            self.assertFalse(issubclass(B, (A,)))
+            self.assertNotIsInstance(b, A)
+            self.assertNotIsInstance(b, (A,))
+            B1 = A.register(B)
+            self.assertTrue(issubclass(B, A))
+            self.assertTrue(issubclass(B, (A,)))
+            self.assertIsInstance(b, A)
+            self.assertIsInstance(b, (A,))
+            self.assertIs(B1, B)
+            class C(B):
+                pass
+            c = C()
+            self.assertTrue(issubclass(C, A))
+            self.assertTrue(issubclass(C, (A,)))
+            self.assertIsInstance(c, A)
+            self.assertIsInstance(c, (A,))
 
-    def test_register_as_class_deco(self):
-        class A(metaclass=abc.ABCMeta):
-            pass
-        @A.register
-        class B(object):
-            pass
-        b = B()
-        self.assertTrue(issubclass(B, A))
-        self.assertTrue(issubclass(B, (A,)))
-        self.assertIsInstance(b, A)
-        self.assertIsInstance(b, (A,))
-        @A.register
-        class C(B):
-            pass
-        c = C()
-        self.assertTrue(issubclass(C, A))
-        self.assertTrue(issubclass(C, (A,)))
-        self.assertIsInstance(c, A)
-        self.assertIsInstance(c, (A,))
-        self.assertIs(C, A.register(C))
+        def test_register_as_class_deco(self):
+            class A(metaclass=abc_ABCMeta):
+                pass
+            @A.register
+            class B(object):
+                pass
+            b = B()
+            self.assertTrue(issubclass(B, A))
+            self.assertTrue(issubclass(B, (A,)))
+            self.assertIsInstance(b, A)
+            self.assertIsInstance(b, (A,))
+            @A.register
+            class C(B):
+                pass
+            c = C()
+            self.assertTrue(issubclass(C, A))
+            self.assertTrue(issubclass(C, (A,)))
+            self.assertIsInstance(c, A)
+            self.assertIsInstance(c, (A,))
+            self.assertIs(C, A.register(C))
 
-    def test_isinstance_invalidation(self):
-        class A(metaclass=abc.ABCMeta):
-            pass
-        class B:
-            pass
-        b = B()
-        self.assertFalse(isinstance(b, A))
-        self.assertFalse(isinstance(b, (A,)))
-        token_old = abc.get_cache_token()
-        A.register(B)
-        token_new = abc.get_cache_token()
-        self.assertNotEqual(token_old, token_new)
-        self.assertTrue(isinstance(b, A))
-        self.assertTrue(isinstance(b, (A,)))
+        def test_isinstance_invalidation(self):
+            class A(metaclass=abc_ABCMeta):
+                pass
+            class B:
+                pass
+            b = B()
+            self.assertFalse(isinstance(b, A))
+            self.assertFalse(isinstance(b, (A,)))
+            token_old = abc_get_cache_token()
+            A.register(B)
+            token_new = abc_get_cache_token()
+            self.assertNotEqual(token_old, token_new)
+            self.assertTrue(isinstance(b, A))
+            self.assertTrue(isinstance(b, (A,)))
 
-    def test_registration_builtins(self):
-        class A(metaclass=abc.ABCMeta):
-            pass
-        A.register(int)
-        self.assertIsInstance(42, A)
-        self.assertIsInstance(42, (A,))
-        self.assertTrue(issubclass(int, A))
-        self.assertTrue(issubclass(int, (A,)))
-        class B(A):
-            pass
-        B.register(str)
-        class C(str): pass
-        self.assertIsInstance("", A)
-        self.assertIsInstance("", (A,))
-        self.assertTrue(issubclass(str, A))
-        self.assertTrue(issubclass(str, (A,)))
-        self.assertTrue(issubclass(C, A))
-        self.assertTrue(issubclass(C, (A,)))
+        def test_registration_builtins(self):
+            class A(metaclass=abc_ABCMeta):
+                pass
+            A.register(int)
+            self.assertIsInstance(42, A)
+            self.assertIsInstance(42, (A,))
+            self.assertTrue(issubclass(int, A))
+            self.assertTrue(issubclass(int, (A,)))
+            class B(A):
+                pass
+            B.register(str)
+            class C(str): pass
+            self.assertIsInstance("", A)
+            self.assertIsInstance("", (A,))
+            self.assertTrue(issubclass(str, A))
+            self.assertTrue(issubclass(str, (A,)))
+            self.assertTrue(issubclass(C, A))
+            self.assertTrue(issubclass(C, (A,)))
 
-    def test_registration_edge_cases(self):
-        class A(metaclass=abc.ABCMeta):
-            pass
-        A.register(A)  # should pass silently
-        class A1(A):
-            pass
-        self.assertRaises(RuntimeError, A1.register, A)  # cycles not allowed
-        class B(object):
-            pass
-        A1.register(B)  # ok
-        A1.register(B)  # should pass silently
-        class C(A):
-            pass
-        A.register(C)  # should pass silently
-        self.assertRaises(RuntimeError, C.register, A)  # cycles not allowed
-        C.register(B)  # ok
+        def test_registration_edge_cases(self):
+            class A(metaclass=abc_ABCMeta):
+                pass
+            A.register(A)  # should pass silently
+            class A1(A):
+                pass
+            self.assertRaises(RuntimeError, A1.register, A)  # cycles not allowed
+            class B(object):
+                pass
+            A1.register(B)  # ok
+            A1.register(B)  # should pass silently
+            class C(A):
+                pass
+            A.register(C)  # should pass silently
+            self.assertRaises(RuntimeError, C.register, A)  # cycles not allowed
+            C.register(B)  # ok
 
-    def test_register_non_class(self):
-        class A(metaclass=abc.ABCMeta):
-            pass
-        self.assertRaisesRegex(TypeError, "Can only register classes",
-                               A.register, 4)
+        def test_register_non_class(self):
+            class A(metaclass=abc_ABCMeta):
+                pass
+            self.assertRaisesRegex(TypeError, "Can only register classes",
+                                   A.register, 4)
 
-    def test_registration_transitiveness(self):
-        class A(metaclass=abc.ABCMeta):
-            pass
-        self.assertTrue(issubclass(A, A))
-        self.assertTrue(issubclass(A, (A,)))
-        class B(metaclass=abc.ABCMeta):
-            pass
-        self.assertFalse(issubclass(A, B))
-        self.assertFalse(issubclass(A, (B,)))
-        self.assertFalse(issubclass(B, A))
-        self.assertFalse(issubclass(B, (A,)))
-        class C(metaclass=abc.ABCMeta):
-            pass
-        A.register(B)
-        class B1(B):
-            pass
-        self.assertTrue(issubclass(B1, A))
-        self.assertTrue(issubclass(B1, (A,)))
-        class C1(C):
-            pass
-        B1.register(C1)
-        self.assertFalse(issubclass(C, B))
-        self.assertFalse(issubclass(C, (B,)))
-        self.assertFalse(issubclass(C, B1))
-        self.assertFalse(issubclass(C, (B1,)))
-        self.assertTrue(issubclass(C1, A))
-        self.assertTrue(issubclass(C1, (A,)))
-        self.assertTrue(issubclass(C1, B))
-        self.assertTrue(issubclass(C1, (B,)))
-        self.assertTrue(issubclass(C1, B1))
-        self.assertTrue(issubclass(C1, (B1,)))
-        C1.register(int)
-        class MyInt(int):
-            pass
-        self.assertTrue(issubclass(MyInt, A))
-        self.assertTrue(issubclass(MyInt, (A,)))
-        self.assertIsInstance(42, A)
-        self.assertIsInstance(42, (A,))
+        def test_registration_transitiveness(self):
+            class A(metaclass=abc_ABCMeta):
+                pass
+            self.assertTrue(issubclass(A, A))
+            self.assertTrue(issubclass(A, (A,)))
+            class B(metaclass=abc_ABCMeta):
+                pass
+            self.assertFalse(issubclass(A, B))
+            self.assertFalse(issubclass(A, (B,)))
+            self.assertFalse(issubclass(B, A))
+            self.assertFalse(issubclass(B, (A,)))
+            class C(metaclass=abc_ABCMeta):
+                pass
+            A.register(B)
+            class B1(B):
+                pass
+            self.assertTrue(issubclass(B1, A))
+            self.assertTrue(issubclass(B1, (A,)))
+            class C1(C):
+                pass
+            B1.register(C1)
+            self.assertFalse(issubclass(C, B))
+            self.assertFalse(issubclass(C, (B,)))
+            self.assertFalse(issubclass(C, B1))
+            self.assertFalse(issubclass(C, (B1,)))
+            self.assertTrue(issubclass(C1, A))
+            self.assertTrue(issubclass(C1, (A,)))
+            self.assertTrue(issubclass(C1, B))
+            self.assertTrue(issubclass(C1, (B,)))
+            self.assertTrue(issubclass(C1, B1))
+            self.assertTrue(issubclass(C1, (B1,)))
+            C1.register(int)
+            class MyInt(int):
+                pass
+            self.assertTrue(issubclass(MyInt, A))
+            self.assertTrue(issubclass(MyInt, (A,)))
+            self.assertIsInstance(42, A)
+            self.assertIsInstance(42, (A,))
 
-    def test_all_new_methods_are_called(self):
-        class A(metaclass=abc.ABCMeta):
-            pass
-        class B(object):
-            counter = 0
-            def __new__(cls):
-                B.counter += 1
-                return super().__new__(cls)
-        class C(A, B):
-            pass
-        self.assertEqual(B.counter, 0)
-        C()
-        self.assertEqual(B.counter, 1)
+        def test_all_new_methods_are_called(self):
+            class A(metaclass=abc_ABCMeta):
+                pass
+            class B(object):
+                counter = 0
+                def __new__(cls):
+                    B.counter += 1
+                    return super().__new__(cls)
+            class C(A, B):
+                pass
+            self.assertEqual(B.counter, 0)
+            C()
+            self.assertEqual(B.counter, 1)
 
-    def test_ABC_has___slots__(self):
-        self.assertTrue(hasattr(abc.ABC, '__slots__'))
+        def test_ABC_has___slots__(self):
+            self.assertTrue(hasattr(abc.ABC, '__slots__'))
+
+        def test_tricky_new_works(self):
+            def with_metaclass(meta, *bases):
+                class metaclass(type):
+                    def __new__(cls, name, this_bases, d):
+                        return meta(name, bases, d)
+                return type.__new__(metaclass, 'temporary_class', (), {})
+            class A: ...
+            class B: ...
+            class C(with_metaclass(abc_ABCMeta, A, B)):
+                pass
+            self.assertEqual(C.__class__, abc_ABCMeta)
 
 
-class TestABCWithInitSubclass(unittest.TestCase):
-    def test_works_with_init_subclass(self):
-        saved_kwargs = {}
-        class ReceivesClassKwargs:
-            def __init_subclass__(cls, **kwargs):
-                super().__init_subclass__()
-                saved_kwargs.update(kwargs)
-        class Receiver(ReceivesClassKwargs, abc.ABC, x=1, y=2, z=3):
-            pass
-        self.assertEqual(saved_kwargs, dict(x=1, y=2, z=3))
+    class TestABCWithInitSubclass(unittest.TestCase):
+        def test_works_with_init_subclass(self):
+            class abc_ABC(metaclass=abc_ABCMeta):
+                __slots__ = ()
+            saved_kwargs = {}
+            class ReceivesClassKwargs:
+                def __init_subclass__(cls, **kwargs):
+                    super().__init_subclass__()
+                    saved_kwargs.update(kwargs)
+            class Receiver(ReceivesClassKwargs, abc_ABC, x=1, y=2, z=3):
+                pass
+            self.assertEqual(saved_kwargs, dict(x=1, y=2, z=3))
+    return TestLegacyAPI, TestABC, TestABCWithInitSubclass
 
+TestLegacyAPI_Py, TestABC_Py, TestABCWithInitSubclass_Py = test_factory(abc.ABCMeta,
+                                                                        abc.get_cache_token)
+TestLegacyAPI_C, TestABC_C, TestABCWithInitSubclass_C = test_factory(_py_abc.ABCMeta,
+                                                                     _py_abc.get_cache_token)
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py
index 3f24faf..f56caa1 100644
--- a/Lib/test/test_typing.py
+++ b/Lib/test/test_typing.py
@@ -761,8 +761,8 @@
         self.assertIsInstance(1, C)
         C[int]
         self.assertIsInstance(1, C)
-        C._abc_registry.clear()
-        C._abc_cache.clear()  # To keep refleak hunting mode clean
+        C._abc_registry_clear()
+        C._abc_caches_clear()  # To keep refleak hunting mode clean
 
     def test_false_subclasses(self):
         class MyMapping(MutableMapping[str, str]): pass