tests some corner cases with isinstance and issubclass while these tests use new style classes and properties they actually do whitebox testing of error conditions uncovered when using extension types test to make sure that an attributeerror when accessing the instance s class s bases is masked this was actually a bug in python 2 2 and 2 2 1 where the exception wasn t caught but it also wasn t being cleared leading to an undetected error in the debug build set up is isinstanceinst cls where cls isn t a type or a tuple cls has a bases attribute inst has a class attribute inst class as no bases attribute sounds complicated i know but this mimics a situation where an extension type raises an attributeerror when its bases attribute is gotten in that case isinstance should return false this must return an object that has no bases attribute like above except that inst class bases raises an exception other than attributeerror here s a situation where getattrcls bases raises an exception if that exception is not attributeerror it should not get masked like above except that getattrcls bases raises an attributeerror which should get masked as a typeerror check that we don t mask non attributeerrors see http bugs python orgissue1574217 test another code path these tests are similar to above but tickle certain code paths in issubclass instead of isinstance really pyobjectissubclass vs pyobjectisinstance like above but test the second branch where the bases of the second arg the cls arg is tested this means the first arg must return a valid bases and it s okay for it to be a normal unrelated by inheritance class meta classes for creating abstract classes and instances abstract classes normal classes tests to ensure that isinstance and issubclass work on abstract classes and instances before the 2 2 release typeerrors were raised when boolean values should have been returned the bug was triggered by mixing normal classes and instances were with abstract classes and instances this case tries to test all combinations normal instances abstract instances normal classes abstract classes test with a tuple as the second argument classes make sure that issubclass raises recursionerror before the c stack is blown make sure that issubclass raises recursionerror before the c stack is blown bpo39382 abstractissubclass didn t hold item reference while peeking in the bases tuple in the single inheritance case setting this here increases the chances of exhibiting the bug probably due to memory layout changes regression test for bpo30570 class failureobject def getattrself attr return self none with support infiniterecursion with self assertraisesrecursionerror issubclassfailure int def testinfinitecycleinbasesself regression test for bpo30570 class x def getattrself attr self assertequalattr bases class a pass class b pass a getattr b getattr x getattr return a b with support infiniterecursion self assertraisesrecursionerror issubclass x int def blowstackfxn arg compareto make sure that calling isinstance with a deeply nested tuple for its argument will raise recursionerror eventually tuplearg compareto for cnt in rangesupport exceedsrecursionlimit tuplearg tuplearg fxnarg tuplearg if name main unittest main tests some corner cases with isinstance and issubclass while these tests use new style classes and properties they actually do whitebox testing of error conditions uncovered when using extension types test to make sure that an attributeerror when accessing the instance s class s bases is masked this was actually a bug in python 2 2 and 2 2 1 where the exception wasn t caught but it also wasn t being cleared leading to an undetected error in the debug build set up is isinstance inst cls where cls isn t a type or a tuple cls has a __bases__ attribute inst has a __class__ attribute inst __class__ as no __bases__ attribute sounds complicated i know but this mimics a situation where an extension type raises an attributeerror when its __bases__ attribute is gotten in that case isinstance should return false this must return an object that has no __bases__ attribute like above except that inst __class__ __bases__ raises an exception other than attributeerror here s a situation where getattr cls __bases__ raises an exception if that exception is not attributeerror it should not get masked like above except that getattr cls __bases__ raises an attributeerror which should get masked as a typeerror check that we don t mask non attributeerrors see http bugs python org issue1574217 test another code path these tests are similar to above but tickle certain code paths in issubclass instead of isinstance really pyobject_issubclass vs pyobject_isinstance like above but test the second branch where the __bases__ of the second arg the cls arg is tested this means the first arg must return a valid __bases__ and it s okay for it to be a normal unrelated by inheritance class meta classes for creating abstract classes and instances abstract classes normal classes tests to ensure that isinstance and issubclass work on abstract classes and instances before the 2 2 release typeerrors were raised when boolean values should have been returned the bug was triggered by mixing normal classes and instances were with abstract classes and instances this case tries to test all combinations normal instances abstract instances normal classes abstract classes test with a tuple as the second argument classes make sure that issubclass raises recursionerror before the c stack is blown make sure that issubclass raises recursionerror before the c stack is blown bpo 39382 abstract_issubclass didn t hold item reference while peeking in the bases tuple in the single inheritance case setting this here increases the chances of exhibiting the bug probably due to memory layout changes regression test for bpo 30570 regression test for bpo 30570 regression test for bpo 30570 make sure that calling isinstance with a deeply nested tuple for its argument will raise recursionerror eventually
import unittest
import typing
from test import support



class TestIsInstanceExceptions(unittest.TestCase):
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    def test_class_has_no_bases(self):
        class I(object):
            def getclass(self):
                
                return None
            __class__ = property(getclass)

        class C(object):
            def getbases(self):
                return ()
            __bases__ = property(getbases)

        self.assertEqual(False, isinstance(I(), C()))

    
    
    def test_bases_raises_other_than_attribute_error(self):
        class E(object):
            def getbases(self):
                raise RuntimeError
            __bases__ = property(getbases)

        class I(object):
            def getclass(self):
                return E()
            __class__ = property(getclass)

        class C(object):
            def getbases(self):
                return ()
            __bases__ = property(getbases)

        self.assertRaises(RuntimeError, isinstance, I(), C())

    
    
    def test_dont_mask_non_attribute_error(self):
        class I: pass

        class C(object):
            def getbases(self):
                raise RuntimeError
            __bases__ = property(getbases)

        self.assertRaises(RuntimeError, isinstance, I(), C())

    
    
    def test_mask_attribute_error(self):
        class I: pass

        class C(object):
            def getbases(self):
                raise AttributeError
            __bases__ = property(getbases)

        self.assertRaises(TypeError, isinstance, I(), C())

    
    
    def test_isinstance_dont_mask_non_attribute_error(self):
        class C(object):
            def getclass(self):
                raise RuntimeError
            __class__ = property(getclass)

        c = C()
        self.assertRaises(RuntimeError, isinstance, c, bool)

        
        class D: pass
        self.assertRaises(RuntimeError, isinstance, c, D)





class TestIsSubclassExceptions(unittest.TestCase):
    def test_dont_mask_non_attribute_error(self):
        class C(object):
            def getbases(self):
                raise RuntimeError
            __bases__ = property(getbases)

        class S(C): pass

        self.assertRaises(RuntimeError, issubclass, C(), S())

    def test_mask_attribute_error(self):
        class C(object):
            def getbases(self):
                raise AttributeError
            __bases__ = property(getbases)

        class S(C): pass

        self.assertRaises(TypeError, issubclass, C(), S())

    
    
    
    
    def test_dont_mask_non_attribute_error_in_cls_arg(self):
        class B: pass

        class C(object):
            def getbases(self):
                raise RuntimeError
            __bases__ = property(getbases)

        self.assertRaises(RuntimeError, issubclass, B, C())

    def test_mask_attribute_error_in_cls_arg(self):
        class B: pass

        class C(object):
            def getbases(self):
                raise AttributeError
            __bases__ = property(getbases)

        self.assertRaises(TypeError, issubclass, B, C())




class AbstractClass(object):
    def __init__(self, bases):
        self.bases = bases

    def getbases(self):
        return self.bases
    __bases__ = property(getbases)

    def __call__(self):
        return AbstractInstance(self)

class AbstractInstance(object):
    def __init__(self, klass):
        self.klass = klass

    def getclass(self):
        return self.klass
    __class__ = property(getclass)


AbstractSuper = AbstractClass(bases=())

AbstractChild = AbstractClass(bases=(AbstractSuper,))


class Super:
    pass

class Child(Super):
    pass

class TestIsInstanceIsSubclass(unittest.TestCase):
    
    
    
    
    
    

    def test_isinstance_normal(self):
        
        self.assertEqual(True, isinstance(Super(), Super))
        self.assertEqual(False, isinstance(Super(), Child))
        self.assertEqual(False, isinstance(Super(), AbstractSuper))
        self.assertEqual(False, isinstance(Super(), AbstractChild))

        self.assertEqual(True, isinstance(Child(), Super))
        self.assertEqual(False, isinstance(Child(), AbstractSuper))

    def test_isinstance_abstract(self):
        
        self.assertEqual(True, isinstance(AbstractSuper(), AbstractSuper))
        self.assertEqual(False, isinstance(AbstractSuper(), AbstractChild))
        self.assertEqual(False, isinstance(AbstractSuper(), Super))
        self.assertEqual(False, isinstance(AbstractSuper(), Child))

        self.assertEqual(True, isinstance(AbstractChild(), AbstractChild))
        self.assertEqual(True, isinstance(AbstractChild(), AbstractSuper))
        self.assertEqual(False, isinstance(AbstractChild(), Super))
        self.assertEqual(False, isinstance(AbstractChild(), Child))

    def test_isinstance_with_or_union(self):
        self.assertTrue(isinstance(Super(), Super | int))
        self.assertFalse(isinstance(None, str | int))
        self.assertTrue(isinstance(3, str | int))
        self.assertTrue(isinstance("", str | int))
        self.assertTrue(isinstance([], typing.List | typing.Tuple))
        self.assertTrue(isinstance(2, typing.List | int))
        self.assertFalse(isinstance(2, typing.List | typing.Tuple))
        self.assertTrue(isinstance(None, int | None))
        self.assertFalse(isinstance(3.14, int | str))
        with self.assertRaises(TypeError):
            isinstance(2, list[int])
        with self.assertRaises(TypeError):
            isinstance(2, list[int] | int)
        with self.assertRaises(TypeError):
            isinstance(2, float | str | list[int] | int)



    def test_subclass_normal(self):
        
        self.assertEqual(True, issubclass(Super, Super))
        self.assertEqual(False, issubclass(Super, AbstractSuper))
        self.assertEqual(False, issubclass(Super, Child))

        self.assertEqual(True, issubclass(Child, Child))
        self.assertEqual(True, issubclass(Child, Super))
        self.assertEqual(False, issubclass(Child, AbstractSuper))
        self.assertTrue(issubclass(typing.List, typing.List|typing.Tuple))
        self.assertFalse(issubclass(int, typing.List|typing.Tuple))

    def test_subclass_abstract(self):
        
        self.assertEqual(True, issubclass(AbstractSuper, AbstractSuper))
        self.assertEqual(False, issubclass(AbstractSuper, AbstractChild))
        self.assertEqual(False, issubclass(AbstractSuper, Child))

        self.assertEqual(True, issubclass(AbstractChild, AbstractChild))
        self.assertEqual(True, issubclass(AbstractChild, AbstractSuper))
        self.assertEqual(False, issubclass(AbstractChild, Super))
        self.assertEqual(False, issubclass(AbstractChild, Child))

    def test_subclass_tuple(self):
        
        self.assertEqual(True, issubclass(Child, (Child,)))
        self.assertEqual(True, issubclass(Child, (Super,)))
        self.assertEqual(False, issubclass(Super, (Child,)))
        self.assertEqual(True, issubclass(Super, (Child, Super)))
        self.assertEqual(False, issubclass(Child, ()))
        self.assertEqual(True, issubclass(Super, (Child, (Super,))))

        self.assertEqual(True, issubclass(int, (int, (float, int))))
        self.assertEqual(True, issubclass(str, (str, (Child, str))))

    def test_subclass_recursion_limit(self):
        
        
        with support.infinite_recursion():
            self.assertRaises(RecursionError, blowstack, issubclass, str, str)

    def test_isinstance_recursion_limit(self):
        
        
        with support.infinite_recursion():
            self.assertRaises(RecursionError, blowstack, isinstance, '', str)

    def test_subclass_with_union(self):
        self.assertTrue(issubclass(int, int | float | int))
        self.assertTrue(issubclass(str, str | Child | str))
        self.assertFalse(issubclass(dict, float|str))
        self.assertFalse(issubclass(object, float|str))
        with self.assertRaises(TypeError):
            issubclass(2, Child | Super)
        with self.assertRaises(TypeError):
            issubclass(int, list[int] | Child)

    def test_issubclass_refcount_handling(self):
        
        
        class A:
            @property
            def __bases__(self):
                return (int, )

        class B:
            def __init__(self):
                
                
                self.x = 1

            @property
            def __bases__(self):
                return (A(), )

        self.assertEqual(True, issubclass(B(), int))

    def test_infinite_recursion_in_bases(self):
        class X:
            @property
            def __bases__(self):
                return self.__bases__
        with support.infinite_recursion():
            self.assertRaises(RecursionError, issubclass, X(), int)
            self.assertRaises(RecursionError, issubclass, int, X())
            self.assertRaises(RecursionError, isinstance, 1, X())

    def test_infinite_recursion_via_bases_tuple(self):
        
        class Failure(object):
            def __getattr__(self, attr):
                return (self, None)
        with support.infinite_recursion():
            with self.assertRaises(RecursionError):
                issubclass(Failure(), int)

    def test_infinite_cycle_in_bases(self):
        
        class X:
            @property
            def __bases__(self):
                return (self, self, self)
        with support.infinite_recursion():
            self.assertRaises(RecursionError, issubclass, X(), int)

    def test_infinitely_many_bases(self):
        
        class X:
            def __getattr__(self, attr):
                self.assertEqual(attr, "__bases__")
                class A:
                    pass
                class B:
                    pass
                A.__getattr__ = B.__getattr__ = X.__getattr__
                return (A(), B())
        with support.infinite_recursion():
            self.assertRaises(RecursionError, issubclass, X(), int)


def blowstack(fxn, arg, compare_to):
    
    
    tuple_arg = (compare_to,)
    for cnt in range(support.EXCEEDS_RECURSION_LIMIT):
        tuple_arg = (tuple_arg,)
        fxn(arg, tuple_arg)


if __name__ == '__main__':
    unittest.main()