def test_basic(self):
import _abc
class SomeABC:
pass
_abc._abc_init(SomeABC)
assert hasattr(SomeABC, '__abstractmethods__')
class SomeConcreteSubClass:
pass
_abc._abc_register(SomeABC, SomeConcreteSubClass)
# _abc._abc_instancecheck calls cls.__subclasscheck__, but since
# we've only called _abc_init and haven't set the metaclass, we
# need to monkeypatch SomeABC before calling _abc_instancecheck
from types import MethodType
SomeABC.__subclasscheck__ = MethodType(_abc._abc_subclasscheck,
SomeABC)
assert _abc._abc_instancecheck(SomeABC, SomeConcreteSubClass())
assert _abc._abc_subclasscheck(SomeABC, SomeConcreteSubClass)
class SomeOtherClass:
pass
assert not _abc._abc_instancecheck(SomeABC, SomeOtherClass())
assert not _abc._abc_subclasscheck(SomeABC, SomeOtherClass)
_abc._reset_registry(SomeABC)
_abc._reset_caches(SomeABC)
assert not _abc._abc_instancecheck(SomeABC, SomeConcreteSubClass())
assert not _abc._abc_subclasscheck(SomeABC, SomeConcreteSubClass)
def test_cache(self):
import _abc
class SomeABC:
pass
token_before = _abc.get_cache_token()
assert _abc.get_cache_token() == token_before
_abc._abc_init(SomeABC)
assert _abc.get_cache_token() == token_before
class SomeConcreteSubClass:
pass
_abc._abc_register(SomeABC, SomeConcreteSubClass)
assert _abc.get_cache_token() != token_before
registry, cache, negative_cache, negative_cache_version = _abc._get_dump(
SomeABC)
assert len(registry) == 1
assert len(cache) == 0
assert len(negative_cache) == 0
assert negative_cache_version == token_before
assert _abc._abc_subclasscheck(SomeABC, SomeConcreteSubClass)
registry, cache, negative_cache, negative_cache_version = _abc._get_dump(
SomeABC)
assert len(registry) == 1
assert len(cache) == 1
assert len(negative_cache) == 0
assert negative_cache_version == _abc.get_cache_token()
class SomeOtherClass:
pass
assert not _abc._abc_subclasscheck(SomeABC, SomeOtherClass)
registry, cache, negative_cache, negative_cache_version = _abc._get_dump(
SomeABC)
assert len(registry) == 1
assert len(cache) == 1
assert len(negative_cache) == 1
assert negative_cache_version == _abc.get_cache_token()
_abc._reset_caches(SomeABC)
registry, cache, negative_cache, negative_cache_version = _abc._get_dump(
SomeABC)
assert len(registry) == 1
assert len(cache) == 0
assert len(negative_cache) == 0
assert negative_cache_version == _abc.get_cache_token()
_abc._reset_registry(SomeABC)
registry, cache, negative_cache, negative_cache_version = _abc._get_dump(
SomeABC)
assert len(registry) == 0
assert len(cache) == 0
assert len(negative_cache) == 0
assert negative_cache_version == _abc.get_cache_token()
class ABCMeta(type):
"""Metaclass for defining Abstract Base Classes (ABCs).
Use this metaclass to create an ABC. An ABC can be subclassed
directly, and then acts as a mix-in class. You can also register
unrelated concrete classes (even built-in classes) and unrelated
ABCs as 'virtual subclasses' -- these and their descendants will
be considered subclasses of the registering ABC by the built-in
issubclass() function, but the registering ABC won't show up in
their MRO (Method Resolution Order) nor will method
implementations defined by the registering ABC be callable (not
even via super()).
"""
def __new__(mcls, name, bases, namespace, /, **kwargs):
cls = super().__new__(mcls, name, bases, namespace, **kwargs)
_abc_init(cls)
return cls
def __new__(mcls, name, bases, namespace, **kwargs):
cls = super().__new__(mcls, name, bases, namespace, **kwargs)
_abc_init(cls)
return cls
def __new__(mcls, name, bases, namespace, **kwargs):
cls = super().__new__(mcls, name, bases, namespace, **kwargs)
_abc_init(cls)
return cls