Add unit tests showing basic exception as class workflow

Author: jesse-sony

tests/test_exceptions.cpp

@@ -66,7 +66,6 @@ struct PythonCallInDestructor {
 };
 
 
-
 struct PythonAlreadySetInDestructor {
     PythonAlreadySetInDestructor(const py::str &s) : s(s) {}
     ~PythonAlreadySetInDestructor() {
@@ -84,7 +83,30 @@ struct PythonAlreadySetInDestructor {
 };
 
 
+// An Exception that is going to be bound as a py:class_
+class BoundException : public std::exception {
+public:
+  BoundException(const std::string& m, int e) : message{m}, m_errorCode(e) {}
+  virtual const char * what() const noexcept override {return message.c_str();}
+  int errorCode() const noexcept { return m_errorCode;}
+private:
+  std::string message;
+  int m_errorCode;
+};
+
+
+
 TEST_SUBMODULE(exceptions, m) {
+  // Provide a class binding for BoundException. This is providing the
+  // dynamic_attr because the parent type (PyExc_Exception) permits dynamic
+  // attributes. One improvement might be to make is_except force
+  // dynamic_attr
+  auto PyBoundException = py::class_< BoundException>(m, "BoundException", py::is_except(), py::dynamic_attr())
+    .def(py::init< std::string, int>())
+    .def("getErrorCode", &BoundException::errorCode)
+    .def("getMessage", &BoundException::what)
+    .def_property_readonly("message", &BoundException::what);
+
     m.def("throw_std_exception", []() {
         throw std::runtime_error("This exception was intentionally thrown.");
     });
@@ -128,14 +150,29 @@ TEST_SUBMODULE(exceptions, m) {
     // A slightly more complicated one that declares MyException5_1 as a subclass of MyException5
     py::register_exception<MyException5_1>(m, "MyException5_1", ex5.ptr());
 
+    // An exception translator for the exception that is bound as a class
+    // This is using PyErr_SetObject instead of PyErr_SetString.
+    py::register_exception_translator([](std::exception_ptr p) {
+      try {
+          if (p) {
+            std::rethrow_exception(p);
+          }
+      } catch (const BoundException &e) {
+        auto err = py::cast(e);
+        auto errType = err.get_type().ptr();
+        PyErr_SetObject(errType, err.ptr());
+      }
+    });
+
     m.def("throws1", []() { throw MyException("this error should go to a custom type"); });
     m.def("throws2", []() { throw MyException2("this error should go to a standard Python exception"); });
     m.def("throws3", []() { throw MyException3("this error cannot be translated"); });
     m.def("throws4", []() { throw MyException4("this error is rethrown"); });
     m.def("throws5", []() { throw MyException5("this is a helper-defined translated exception"); });
     m.def("throws5_1", []() { throw MyException5_1("MyException5 subclass"); });
     m.def("throws_logic_error", []() { throw std::logic_error("this error should fall through to the standard handler"); });
-    m.def("throws_overflow_error", []() {throw std::overflow_error(""); });
+    m.def("throws_overflow_error", []() { throw std::overflow_error(""); });
+    m.def("throws_bound_exception", []() { throw BoundException("this error is a class", 42); });
     m.def("exception_matches", []() {
         py::dict foo;
         try {

tests/test_exceptions.py

@@ -189,3 +189,18 @@ def __repr__(self):
 
     with pytest.raises(TypeError):
         m.simple_bool_passthrough(MyRepr())
+
+
+def test_bound_exceptions():
+    """Tests throwing/catching an exception bound as a class"""
+    try:
+        m.throws_bound_exception()
+    except m.BoundException as ex:
+        assert ex.message == "this error is a class"
+        assert ex.getErrorCode() == 42
+
+    try:
+        raise m.BoundException("raising from python", 14)
+    except m.BoundException as ex:
+        assert ex.message == "raising from python"
+        assert ex.getErrorCode() == 14