Upgrade test_isinstance to 3.13.5

youknowone · youknowone · commit acca386252fd · 2025-06-28T11:21:19.000+09:00
diff --git a/Lib/test/test_isinstance.py b/Lib/test/test_isinstance.py
@@ -3,12 +3,11 @@
 # testing of error conditions uncovered when using extension types.
 
 import unittest
-import sys
 import typing
 from test import support
 
 
-
+
 class TestIsInstanceExceptions(unittest.TestCase):
     # 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
@@ -97,7 +96,7 @@ def getclass(self):
         class D: pass
         self.assertRaises(RuntimeError, isinstance, c, D)
 
-
+
 # These tests are similar to above, but tickle certain code paths in
 # issubclass() instead of isinstance() -- really PyObject_IsSubclass()
 # vs. PyObject_IsInstance().
@@ -147,7 +146,7 @@ def getbases(self):
         self.assertRaises(TypeError, issubclass, B, C())
 
 
-
+
 # meta classes for creating abstract classes and instances
 class AbstractClass(object):
     def __init__(self, bases):
@@ -179,7 +178,7 @@ class Super:
 
 class Child(Super):
     pass
-
+
 class TestIsInstanceIsSubclass(unittest.TestCase):
     # Tests to ensure that isinstance and issubclass work on abstract
     # classes and instances.  Before the 2.2 release, TypeErrors were
@@ -225,7 +224,7 @@ def test_isinstance_with_or_union(self):
         with self.assertRaises(TypeError):
             isinstance(2, list[int] | int)
         with self.assertRaises(TypeError):
-            isinstance(2, int | str | list[int] | float)
+            isinstance(2, float | str | list[int] | int)
 
 
 
@@ -311,7 +310,7 @@ class X:
             @property
             def __bases__(self):
                 return self.__bases__
-        with support.infinite_recursion():
+        with support.infinite_recursion(25):
             self.assertRaises(RecursionError, issubclass, X(), int)
             self.assertRaises(RecursionError, issubclass, int, X())
             self.assertRaises(RecursionError, isinstance, 1, X())
@@ -345,18 +344,18 @@ class B:
                     pass
                 A.__getattr__ = B.__getattr__ = X.__getattr__
                 return (A(), B())
-        with support.infinite_recursion():
+        with support.infinite_recursion(25):
             self.assertRaises(RecursionError, issubclass, X(), int)
 
 
 def blowstack(fxn, arg, compare_to):
     # Make sure that calling isinstance with a deeply nested tuple for its
     # argument will raise RecursionError eventually.
     tuple_arg = (compare_to,)
-    for cnt in range(sys.getrecursionlimit()+5):
+    for cnt in range(support.exceeds_recursion_limit()):
         tuple_arg = (tuple_arg,)
         fxn(arg, tuple_arg)
 
-
+
 if __name__ == '__main__':
     unittest.main()
diff --git a/vm/src/protocol/object.rs b/vm/src/protocol/object.rs
@@ -428,30 +428,51 @@ impl PyObject {
         if let (Ok(obj), Ok(cls)) = (self.try_to_ref::<PyType>(vm), cls.try_to_ref::<PyType>(vm)) {
             Ok(obj.fast_issubclass(cls))
         } else {
+            // Check if derived is a class
             self.check_cls(self, vm, || {
                 format!("issubclass() arg 1 must be a class, not {}", self.class())
-            })
-            .and(self.check_cls(cls, vm, || {
-                format!(
-                    "issubclass() arg 2 must be a class, a tuple of classes, or a union, not {}",
-                    cls.class()
-                )
-            }))
-            .and(self.abstract_issubclass(cls, vm))
+            })?;
+
+            // Check if cls is a class, tuple, or union
+            if !cls.class().is(vm.ctx.types.union_type) {
+                self.check_cls(cls, vm, || {
+                    format!(
+                        "issubclass() arg 2 must be a class, a tuple of classes, or a union, not {}",
+                        cls.class()
+                    )
+                })?;
+            }
+
+            self.abstract_issubclass(cls, vm)
         }
     }
 
     /// Determines if `self` is a subclass of `cls`, either directly, indirectly or virtually
     /// via the __subclasscheck__ magic method.
+    /// PyObject_IsSubclass/object_issubclass
     pub fn is_subclass(&self, cls: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
+        // PyType_CheckExact(cls)
         if cls.class().is(vm.ctx.types.type_type) {
             if self.is(cls) {
                 return Ok(true);
             }
             return self.recursive_issubclass(cls, vm);
         }
 
-        if let Ok(tuple) = cls.try_to_value::<&Py<PyTuple>>(vm) {
+        // Check for Union type - CPython handles this before tuple
+        let cls_to_check = if cls.class().is(vm.ctx.types.union_type) {
+            // Get the __args__ attribute which contains the union members
+            if let Ok(args) = cls.get_attr(identifier!(vm, __args__), vm) {
+                args
+            } else {
+                cls.to_owned()
+            }
+        } else {
+            cls.to_owned()
+        };
+
+        // Check if cls_to_check is a tuple
+        if let Ok(tuple) = cls_to_check.try_to_value::<&Py<PyTuple>>(vm) {
             for typ in tuple {
                 if vm.with_recursion("in __subclasscheck__", || self.is_subclass(typ, vm))? {
                     return Ok(true);
@@ -460,6 +481,7 @@ impl PyObject {
             return Ok(false);
         }
 
+        // Check for __subclasscheck__ method
         if let Some(meth) = vm.get_special_method(cls, identifier!(vm, __subclasscheck__))? {
             let ret = vm.with_recursion("in __subclasscheck__", || {
                 meth.invoke((self.to_owned(),), vm)
@@ -514,38 +536,6 @@ impl PyObject {
         }
     }
 
-    fn abstract_isinstance(&self, cls: &PyObject, vm: &VirtualMachine) -> PyResult<bool> {
-        let r = if let Ok(typ) = cls.try_to_ref::<PyType>(vm) {
-            if self.class().fast_issubclass(typ) {
-                true
-            } else if let Ok(i_cls) =
-                PyTypeRef::try_from_object(vm, self.get_attr(identifier!(vm, __class__), vm)?)
-            {
-                if i_cls.is(self.class()) {
-                    false
-                } else {
-                    i_cls.fast_issubclass(typ)
-                }
-            } else {
-                false
-            }
-        } else {
-            self.check_cls(cls, vm, || {
-                format!(
-                    "isinstance() arg 2 must be a type or tuple of types, not {}",
-                    cls.class()
-                )
-            })?;
-            let i_cls: PyObjectRef = self.get_attr(identifier!(vm, __class__), vm)?;
-            if vm.is_none(&i_cls) {
-                false
-            } else {
-                i_cls.abstract_issubclass(cls, vm)?
-            }
-        };
-        Ok(r)
-    }
-
     /// Determines if `self` is an instance of `cls`, either directly, indirectly or virtually via
     /// the __instancecheck__ magic method.
     // This is object_recursive_isinstance from CPython's Objects/abstract.c
@@ -563,7 +553,7 @@ impl PyObject {
             return self.real_is_instance(cls, vm);
         }
 
-        // Check for Union type (e.g., int | str)
+        // Check for Union type (e.g., int | str) - CPython checks this before tuple
         if cls.class().is(vm.ctx.types.union_type) {
             if let Ok(args) = cls.get_attr(identifier!(vm, __args__), vm) {
                 if let Ok(tuple) = args.try_to_ref::<PyTuple>(vm) {
