test_exceptions.cpp revision 12391:ceeca8b41e4b
1/* 2 tests/test_custom-exceptions.cpp -- exception translation 3 4 Copyright (c) 2016 Pim Schellart <P.Schellart@princeton.edu> 5 6 All rights reserved. Use of this source code is governed by a 7 BSD-style license that can be found in the LICENSE file. 8*/ 9 10#include "pybind11_tests.h" 11 12// A type that should be raised as an exeption in Python 13class MyException : public std::exception { 14public: 15 explicit MyException(const char * m) : message{m} {} 16 virtual const char * what() const noexcept override {return message.c_str();} 17private: 18 std::string message = ""; 19}; 20 21// A type that should be translated to a standard Python exception 22class MyException2 : public std::exception { 23public: 24 explicit MyException2(const char * m) : message{m} {} 25 virtual const char * what() const noexcept override {return message.c_str();} 26private: 27 std::string message = ""; 28}; 29 30// A type that is not derived from std::exception (and is thus unknown) 31class MyException3 { 32public: 33 explicit MyException3(const char * m) : message{m} {} 34 virtual const char * what() const noexcept {return message.c_str();} 35private: 36 std::string message = ""; 37}; 38 39// A type that should be translated to MyException 40// and delegated to its exception translator 41class MyException4 : public std::exception { 42public: 43 explicit MyException4(const char * m) : message{m} {} 44 virtual const char * what() const noexcept override {return message.c_str();} 45private: 46 std::string message = ""; 47}; 48 49 50// Like the above, but declared via the helper function 51class MyException5 : public std::logic_error { 52public: 53 explicit MyException5(const std::string &what) : std::logic_error(what) {} 54}; 55 56// Inherits from MyException5 57class MyException5_1 : public MyException5 { 58 using MyException5::MyException5; 59}; 60 61struct PythonCallInDestructor { 62 PythonCallInDestructor(const py::dict &d) : d(d) {} 63 ~PythonCallInDestructor() { d["good"] = true; } 64 65 py::dict d; 66}; 67 68TEST_SUBMODULE(exceptions, m) { 69 m.def("throw_std_exception", []() { 70 throw std::runtime_error("This exception was intentionally thrown."); 71 }); 72 73 // make a new custom exception and use it as a translation target 74 static py::exception<MyException> ex(m, "MyException"); 75 py::register_exception_translator([](std::exception_ptr p) { 76 try { 77 if (p) std::rethrow_exception(p); 78 } catch (const MyException &e) { 79 // Set MyException as the active python error 80 ex(e.what()); 81 } 82 }); 83 84 // register new translator for MyException2 85 // no need to store anything here because this type will 86 // never by visible from Python 87 py::register_exception_translator([](std::exception_ptr p) { 88 try { 89 if (p) std::rethrow_exception(p); 90 } catch (const MyException2 &e) { 91 // Translate this exception to a standard RuntimeError 92 PyErr_SetString(PyExc_RuntimeError, e.what()); 93 } 94 }); 95 96 // register new translator for MyException4 97 // which will catch it and delegate to the previously registered 98 // translator for MyException by throwing a new exception 99 py::register_exception_translator([](std::exception_ptr p) { 100 try { 101 if (p) std::rethrow_exception(p); 102 } catch (const MyException4 &e) { 103 throw MyException(e.what()); 104 } 105 }); 106 107 // A simple exception translation: 108 auto ex5 = py::register_exception<MyException5>(m, "MyException5"); 109 // A slightly more complicated one that declares MyException5_1 as a subclass of MyException5 110 py::register_exception<MyException5_1>(m, "MyException5_1", ex5.ptr()); 111 112 m.def("throws1", []() { throw MyException("this error should go to a custom type"); }); 113 m.def("throws2", []() { throw MyException2("this error should go to a standard Python exception"); }); 114 m.def("throws3", []() { throw MyException3("this error cannot be translated"); }); 115 m.def("throws4", []() { throw MyException4("this error is rethrown"); }); 116 m.def("throws5", []() { throw MyException5("this is a helper-defined translated exception"); }); 117 m.def("throws5_1", []() { throw MyException5_1("MyException5 subclass"); }); 118 m.def("throws_logic_error", []() { throw std::logic_error("this error should fall through to the standard handler"); }); 119 m.def("exception_matches", []() { 120 py::dict foo; 121 try { foo["bar"]; } 122 catch (py::error_already_set& ex) { 123 if (!ex.matches(PyExc_KeyError)) throw; 124 } 125 }); 126 127 m.def("throw_already_set", [](bool err) { 128 if (err) 129 PyErr_SetString(PyExc_ValueError, "foo"); 130 try { 131 throw py::error_already_set(); 132 } catch (const std::runtime_error& e) { 133 if ((err && e.what() != std::string("ValueError: foo")) || 134 (!err && e.what() != std::string("Unknown internal error occurred"))) 135 { 136 PyErr_Clear(); 137 throw std::runtime_error("error message mismatch"); 138 } 139 } 140 PyErr_Clear(); 141 if (err) 142 PyErr_SetString(PyExc_ValueError, "foo"); 143 throw py::error_already_set(); 144 }); 145 146 m.def("python_call_in_destructor", [](py::dict d) { 147 try { 148 PythonCallInDestructor set_dict_in_destructor(d); 149 PyErr_SetString(PyExc_ValueError, "foo"); 150 throw py::error_already_set(); 151 } catch (const py::error_already_set&) { 152 return true; 153 } 154 return false; 155 }); 156 157 // test_nested_throws 158 m.def("try_catch", [m](py::object exc_type, py::function f, py::args args) { 159 try { f(*args); } 160 catch (py::error_already_set &ex) { 161 if (ex.matches(exc_type)) 162 py::print(ex.what()); 163 else 164 throw; 165 } 166 }); 167 168} 169