Patch # 1026 by Benjamin Aranguren (with Alex Martelli):
Backport abc.py and isinstance/issubclass overloading to 2.6.
I had to backport test_typechecks.py myself, and make one small change
to abc.py to avoid duplicate work when x.__class__ and type(x) are the
same.
diff --git a/Lib/test/test_abc.py b/Lib/test/test_abc.py
new file mode 100644
index 0000000..3fd9bde
--- /dev/null
+++ b/Lib/test/test_abc.py
@@ -0,0 +1,142 @@
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Unit tests for abc.py."""
+
+import sys
+import unittest
+from test import test_support
+
+import abc
+__metaclass__ = type
+
+
+class TestABC(unittest.TestCase):
+
+ def test_abstractmethod_basics(self):
+ @abc.abstractmethod
+ def foo(self): pass
+ self.assertEqual(foo.__isabstractmethod__, True)
+ def bar(self): pass
+ self.assertEqual(hasattr(bar, "__isabstractmethod__"), False)
+
+ def test_abstractproperty_basics(self):
+ @abc.abstractproperty
+ def foo(self): pass
+ self.assertEqual(foo.__isabstractmethod__, True)
+ def bar(self): pass
+ self.assertEqual(hasattr(bar, "__isabstractmethod__"), False)
+
+ class C:
+ __metaclass__ = abc.ABCMeta
+ @abc.abstractproperty
+ def foo(self): return 3
+ class D(C):
+ @property
+ def foo(self): return super(D, self).foo
+ self.assertEqual(D().foo, 3)
+
+ def test_abstractmethod_integration(self):
+ for abstractthing in [abc.abstractmethod, abc.abstractproperty]:
+ class C:
+ __metaclass__ = abc.ABCMeta
+ @abstractthing
+ def foo(self): pass # abstract
+ def bar(self): pass # concrete
+ self.assertEqual(C.__abstractmethods__, set(["foo"]))
+ self.assertRaises(TypeError, C) # because foo is abstract
+ class D(C):
+ def bar(self): pass # concrete override of concrete
+ self.assertEqual(D.__abstractmethods__, set(["foo"]))
+ self.assertRaises(TypeError, D) # because foo is still abstract
+ class E(D):
+ def foo(self): pass
+ self.assertEqual(E.__abstractmethods__, set())
+ E() # now foo is concrete, too
+ class F(E):
+ @abstractthing
+ def bar(self): pass # abstract override of concrete
+ self.assertEqual(F.__abstractmethods__, set(["bar"]))
+ self.assertRaises(TypeError, F) # because bar is abstract now
+
+ def test_registration_basics(self):
+ class A:
+ __metaclass__ = abc.ABCMeta
+ class B:
+ pass
+ b = B()
+ self.assertEqual(issubclass(B, A), False)
+ self.assertEqual(isinstance(b, A), False)
+ A.register(B)
+ self.assertEqual(issubclass(B, A), True)
+ self.assertEqual(isinstance(b, A), True)
+ class C(B):
+ pass
+ c = C()
+ self.assertEqual(issubclass(C, A), True)
+ self.assertEqual(isinstance(c, A), True)
+
+ def test_registration_builtins(self):
+ class A:
+ __metaclass__ = abc.ABCMeta
+ A.register(int)
+ self.assertEqual(isinstance(42, A), True)
+ self.assertEqual(issubclass(int, A), True)
+ class B(A):
+ pass
+ B.register(basestring)
+ self.assertEqual(isinstance("", A), True)
+ self.assertEqual(issubclass(str, A), True)
+
+ def test_registration_edge_cases(self):
+ class A:
+ __metaclass__ = abc.ABCMeta
+ A.register(A) # should pass silently
+ class A1(A):
+ pass
+ self.assertRaises(RuntimeError, A1.register, A) # cycles not allowed
+ class B:
+ 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_transitiveness(self):
+ class A:
+ __metaclass__ = abc.ABCMeta
+ self.failUnless(issubclass(A, A))
+ class B:
+ __metaclass__ = abc.ABCMeta
+ self.failIf(issubclass(A, B))
+ self.failIf(issubclass(B, A))
+ class C:
+ __metaclass__ = abc.ABCMeta
+ A.register(B)
+ class B1(B):
+ pass
+ self.failUnless(issubclass(B1, A))
+ class C1(C):
+ pass
+ B1.register(C1)
+ self.failIf(issubclass(C, B))
+ self.failIf(issubclass(C, B1))
+ self.failUnless(issubclass(C1, A))
+ self.failUnless(issubclass(C1, B))
+ self.failUnless(issubclass(C1, B1))
+ C1.register(int)
+ class MyInt(int):
+ pass
+ self.failUnless(issubclass(MyInt, A))
+ self.failUnless(isinstance(42, A))
+
+
+def test_main():
+ test_support.run_unittest(TestABC)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/Lib/test/test_typechecks.py b/Lib/test/test_typechecks.py
new file mode 100644
index 0000000..21be62d
--- /dev/null
+++ b/Lib/test/test_typechecks.py
@@ -0,0 +1,77 @@
+"""Unit tests for __instancecheck__ and __subclasscheck__."""
+
+import unittest
+from test import test_support
+
+
+class ABC(type):
+
+ def __instancecheck__(cls, inst):
+ """Implement isinstance(inst, cls)."""
+ return any(cls.__subclasscheck__(c)
+ for c in set([type(inst), inst.__class__]))
+
+ def __subclasscheck__(cls, sub):
+ """Implement issubclass(sub, cls)."""
+ candidates = cls.__dict__.get("__subclass__", set()) | set([cls])
+ return any(c in candidates for c in sub.mro())
+
+
+class Integer:
+
+ __metaclass__ = ABC
+
+ __subclass__ = set([int])
+
+
+class SubInt(Integer):
+
+ pass
+
+
+class Evil:
+ def __instancecheck__(self, inst): return False
+
+
+class TypeChecksTest(unittest.TestCase):
+
+ def testIsSubclassInternal(self):
+ self.assertEqual(Integer.__subclasscheck__(int), True)
+ self.assertEqual(Integer.__subclasscheck__(float), False)
+
+ def testIsSubclassBuiltin(self):
+ self.assertEqual(issubclass(int, Integer), True)
+ self.assertEqual(issubclass(float, Integer), False)
+
+ def testIsInstanceBuiltin(self):
+ self.assertEqual(isinstance(42, Integer), True)
+ self.assertEqual(isinstance(3.14, Integer), False)
+
+ def testIsInstanceActual(self):
+ self.assertEqual(isinstance(Integer(), Integer), True)
+
+ def testIsSubclassActual(self):
+ self.assertEqual(issubclass(Integer, Integer), True)
+
+ def testSubclassBehavior(self):
+ self.assertEqual(issubclass(SubInt, Integer), True)
+ self.assertEqual(issubclass(SubInt, SubInt), True)
+ self.assertEqual(issubclass(Integer, SubInt), False)
+ self.assertEqual(issubclass(int, SubInt), False)
+ self.assertEqual(isinstance(SubInt(), Integer), True)
+ self.assertEqual(isinstance(SubInt(), SubInt), True)
+ self.assertEqual(isinstance(42, SubInt), False)
+
+ def testInfiniteRecursionCaughtProperly(self):
+ e = Evil()
+ # This invokes isinstance() recursively, until the stack is exhausted.
+ self.assertRaises(RuntimeError, isinstance, e, Evil)
+ # XXX How to check the same situation for issubclass()?
+
+
+def test_main():
+ test_support.run_unittest(TypeChecksTest)
+
+
+if __name__ == "__main__":
+ unittest.main()