#2542: now that issubclass() may call arbitrary code,

make sure that PyErr_ExceptionMatches returns 0 when an exception occurs there.

diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index 8fa466cc888c2978d4b4031ac30b1c9f457522e8..5a0039e168a2ff012610ed4e317176e49c6e4104 100644 (file)
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -6,13 +6,21 @@ import unittest
 import pickle, cPickle
 
 from test.test_support import (TESTFN, unlink, run_unittest,
-                                catch_warning)
+                                catch_warning, captured_output)
 from test.test_pep352 import ignore_message_warning
 
 # XXX This is not really enough, each *operation* should be tested!
 
 class ExceptionTests(unittest.TestCase):
 
+    def test00(self):
+        try:
+            sys.exit(ValueError('aaa'))
+        except SystemExit:
+            pass
+        finally:
+            pass
+
     def testReload(self):
         # Reloading the built-in exceptions module failed prior to Py2.2, while it
         # should act the same as reloading built-in sys.
@@ -344,6 +352,31 @@ class ExceptionTests(unittest.TestCase):
         self.failUnless(unicode(Exception(u'a')))
         self.failUnless(unicode(Exception(u'\xe1')))
 
+    def test_badisinstance(self):
+        # Bug #2542: if issubclass(e, MyException) raises an exception,
+        # it should be ignored
+        class Meta(type):
+            def __subclasscheck__(cls, subclass):
+                raise ValueError()
+
+        class MyException(Exception):
+            __metaclass__ = Meta
+            pass
+
+        with captured_output("stderr") as stderr:
+            try:
+                raise KeyError()
+            except MyException, e:
+                self.fail("exception should not be a MyException")
+            except KeyError:
+                pass
+            except:
+                self.fail("Should have raised TypeError")
+            else:
+                self.fail("Should have raised TypeError")
+        self.assertEqual(stderr.getvalue(),
+                         "Exception ValueError: ValueError() in "
+                         "<type 'exceptions.KeyError'> ignored\n")
 
 def test_main():
     run_unittest(ExceptionTests)

diff --git a/Misc/NEWS b/Misc/NEWS
index d1b5778064cd08b73ee6fef4266e41aa7fbfabae..e93b5fea8eeef7a376f654851f570eff1c08ab42 100644 (file)
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -12,6 +12,9 @@ What's New in Python 2.6 beta 3?
 Core and Builtins
 -----------------
 
+- Issue #2542: Now that issubclass() may call arbitrary code, ensure that
+  PyErr_ExceptionMatches returns 0 when an exception occurs there.
+
 - Issue #1819: function calls with several named parameters are now on
   average 35% faster (as measured by pybench).
 

diff --git a/Python/errors.c b/Python/errors.c
index 8951d5793548573a2ed7a9c7fc2ee407a8a2b83c..5d9cab5a4c13884227269117927b98665822d76a 100644 (file)
--- a/Python/errors.c
+++ b/Python/errors.c
@@ -106,9 +106,18 @@ PyErr_GivenExceptionMatches(PyObject *err, PyObject *exc)
                err = PyExceptionInstance_Class(err);
 
        if (PyExceptionClass_Check(err) && PyExceptionClass_Check(exc)) {
-               /* problems here!?  not sure PyObject_IsSubclass expects to
-                  be called with an exception pending... */
-               return PyObject_IsSubclass(err, exc);
+               int res = 0;
+               PyObject *exception, *value, *tb;
+               PyErr_Fetch(&exception, &value, &tb);
+               res = PyObject_IsSubclass(err, exc);
+               /* This function must not fail, so print the error here */
+               if (res == -1) {
+                       PyErr_WriteUnraisable(err);
+                       /* issubclass did not succeed */
+                       res = 0;
+               }
+               PyErr_Restore(exception, value, tb);
+               return res;
        }
 
        return err == exc;