mirror of
https://github.com/pybind/pybind11.git
synced 2024-11-25 22:52:01 +00:00
1682b67326
`error_already_set` is more complicated than it needs to be, partly because it manages reference counts itself rather than using `py::object`, and partly because it tries to do more exception clearing than is needed. This commit greatly simplifies it, and fixes #927. Using `py::object` instead of `PyObject *` means we can rely on implicit copy/move constructors. The current logic did both a `PyErr_Clear` on deletion *and* a `PyErr_Fetch` on creation. I can't see how the `PyErr_Clear` on deletion is ever useful: the `Fetch` on creation itself clears the error, so the only way doing a `PyErr_Clear` on deletion could do anything if is some *other* exception was raised while the `error_already_set` object was alive--but in that case, clearing some other exception seems wrong. (Code that is worried about an exception handler raising another exception would already catch a second `error_already_set` from exception code). The destructor itself called `clear()`, but `clear()` was a little bit more paranoid that needed: it called `restore()` to restore the currently captured error, but then immediately cleared it, using the `PyErr_Restore` to release the references. That's unnecessary: it's valid for us to release the references manually. This updates the code to simply release the references on the three objects (preserving the gil acquire). `clear()`, however, also had the side effect of clearing the current error, even if the current `error_already_set` didn't have a current error (e.g. because of a previous `restore()` or `clear()` call). I don't really see how clearing the error here can ever actually be useful: the only way the current error could be set is if you called `restore()` (in which case the current stored error-related members have already been released), or if some *other* code raised the error, in which case `clear()` on *this* object is clearing an error for which it shouldn't be responsible. Neither of those seem like intentional or desirable features, and manually requesting deletion of the stored references similarly seems pointless, so I've just made `clear()` an empty method and marked it deprecated. This also fixes a minor potential issue with the destruction: it is technically possible for `value` to be null (though this seems likely to be rare in practice); this updates the check to look at `type` which will always be non-null for a `Fetch`ed exception. This also adds error_already_set round-trip throw tests to the test suite.
123 lines
3.9 KiB
Python
123 lines
3.9 KiB
Python
import pytest
|
|
|
|
from pybind11_tests import exceptions as m
|
|
|
|
|
|
def test_std_exception(msg):
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.throw_std_exception()
|
|
assert msg(excinfo.value) == "This exception was intentionally thrown."
|
|
|
|
|
|
def test_error_already_set(msg):
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.throw_already_set(False)
|
|
assert msg(excinfo.value) == "Unknown internal error occurred"
|
|
|
|
with pytest.raises(ValueError) as excinfo:
|
|
m.throw_already_set(True)
|
|
assert msg(excinfo.value) == "foo"
|
|
|
|
|
|
def test_python_call_in_catch():
|
|
d = {}
|
|
assert m.python_call_in_destructor(d) is True
|
|
assert d["good"] is True
|
|
|
|
|
|
def test_exception_matches():
|
|
m.exception_matches()
|
|
|
|
|
|
def test_custom(msg):
|
|
# Can we catch a MyException?
|
|
with pytest.raises(m.MyException) as excinfo:
|
|
m.throws1()
|
|
assert msg(excinfo.value) == "this error should go to a custom type"
|
|
|
|
# Can we translate to standard Python exceptions?
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.throws2()
|
|
assert msg(excinfo.value) == "this error should go to a standard Python exception"
|
|
|
|
# Can we handle unknown exceptions?
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.throws3()
|
|
assert msg(excinfo.value) == "Caught an unknown exception!"
|
|
|
|
# Can we delegate to another handler by rethrowing?
|
|
with pytest.raises(m.MyException) as excinfo:
|
|
m.throws4()
|
|
assert msg(excinfo.value) == "this error is rethrown"
|
|
|
|
# Can we fall-through to the default handler?
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.throws_logic_error()
|
|
assert msg(excinfo.value) == "this error should fall through to the standard handler"
|
|
|
|
# Can we handle a helper-declared exception?
|
|
with pytest.raises(m.MyException5) as excinfo:
|
|
m.throws5()
|
|
assert msg(excinfo.value) == "this is a helper-defined translated exception"
|
|
|
|
# Exception subclassing:
|
|
with pytest.raises(m.MyException5) as excinfo:
|
|
m.throws5_1()
|
|
assert msg(excinfo.value) == "MyException5 subclass"
|
|
assert isinstance(excinfo.value, m.MyException5_1)
|
|
|
|
with pytest.raises(m.MyException5_1) as excinfo:
|
|
m.throws5_1()
|
|
assert msg(excinfo.value) == "MyException5 subclass"
|
|
|
|
with pytest.raises(m.MyException5) as excinfo:
|
|
try:
|
|
m.throws5()
|
|
except m.MyException5_1:
|
|
raise RuntimeError("Exception error: caught child from parent")
|
|
assert msg(excinfo.value) == "this is a helper-defined translated exception"
|
|
|
|
|
|
def test_nested_throws(capture):
|
|
"""Tests nested (e.g. C++ -> Python -> C++) exception handling"""
|
|
|
|
def throw_myex():
|
|
raise m.MyException("nested error")
|
|
|
|
def throw_myex5():
|
|
raise m.MyException5("nested error 5")
|
|
|
|
# In the comments below, the exception is caught in the first step, thrown in the last step
|
|
|
|
# C++ -> Python
|
|
with capture:
|
|
m.try_catch(m.MyException5, throw_myex5)
|
|
assert str(capture).startswith("MyException5: nested error 5")
|
|
|
|
# Python -> C++ -> Python
|
|
with pytest.raises(m.MyException) as excinfo:
|
|
m.try_catch(m.MyException5, throw_myex)
|
|
assert str(excinfo.value) == "nested error"
|
|
|
|
def pycatch(exctype, f, *args):
|
|
try:
|
|
f(*args)
|
|
except m.MyException as e:
|
|
print(e)
|
|
|
|
# C++ -> Python -> C++ -> Python
|
|
with capture:
|
|
m.try_catch(
|
|
m.MyException5, pycatch, m.MyException, m.try_catch, m.MyException, throw_myex5)
|
|
assert str(capture).startswith("MyException5: nested error 5")
|
|
|
|
# C++ -> Python -> C++
|
|
with capture:
|
|
m.try_catch(m.MyException, pycatch, m.MyException5, m.throws4)
|
|
assert capture == "this error is rethrown"
|
|
|
|
# Python -> C++ -> Python -> C++
|
|
with pytest.raises(m.MyException5) as excinfo:
|
|
m.try_catch(m.MyException, pycatch, m.MyException, m.throws5)
|
|
assert str(excinfo.value) == "this is a helper-defined translated exception"
|