github.com/kaydxh/golang@v0.0.131/pkg/gocv/cgo/third_path/pybind11/tests/pybind11_cross_module_tests.cpp (about)

     1  /*
     2      tests/pybind11_cross_module_tests.cpp -- contains tests that require multiple modules
     3  
     4      Copyright (c) 2017 Jason Rhinelander <jason@imaginary.ca>
     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/stl_bind.h>
    11  
    12  #include "local_bindings.h"
    13  #include "pybind11_tests.h"
    14  #include "test_exceptions.h"
    15  
    16  #include <numeric>
    17  #include <utility>
    18  
    19  PYBIND11_MODULE(pybind11_cross_module_tests, m) {
    20      m.doc() = "pybind11 cross-module test module";
    21  
    22      // test_local_bindings.py tests:
    23      //
    24      // Definitions here are tested by importing both this module and the
    25      // relevant pybind11_tests submodule from a test_whatever.py
    26  
    27      // test_load_external
    28      bind_local<ExternalType1>(m, "ExternalType1", py::module_local());
    29      bind_local<ExternalType2>(m, "ExternalType2", py::module_local());
    30  
    31      // test_exceptions.py
    32      py::register_local_exception<LocalSimpleException>(m, "LocalSimpleException");
    33      m.def("raise_runtime_error", []() {
    34          PyErr_SetString(PyExc_RuntimeError, "My runtime error");
    35          throw py::error_already_set();
    36      });
    37      m.def("raise_value_error", []() {
    38          PyErr_SetString(PyExc_ValueError, "My value error");
    39          throw py::error_already_set();
    40      });
    41      m.def("throw_pybind_value_error", []() { throw py::value_error("pybind11 value error"); });
    42      m.def("throw_pybind_type_error", []() { throw py::type_error("pybind11 type error"); });
    43      m.def("throw_stop_iteration", []() { throw py::stop_iteration(); });
    44      m.def("throw_local_error", []() { throw LocalException("just local"); });
    45      m.def("throw_local_simple_error", []() { throw LocalSimpleException("external mod"); });
    46      py::register_exception_translator([](std::exception_ptr p) {
    47          try {
    48              if (p) {
    49                  std::rethrow_exception(p);
    50              }
    51          } catch (const shared_exception &e) {
    52              PyErr_SetString(PyExc_KeyError, e.what());
    53          }
    54      });
    55  
    56      // translate the local exception into a key error but only in this module
    57      py::register_local_exception_translator([](std::exception_ptr p) {
    58          try {
    59              if (p) {
    60                  std::rethrow_exception(p);
    61              }
    62          } catch (const LocalException &e) {
    63              PyErr_SetString(PyExc_KeyError, e.what());
    64          }
    65      });
    66  
    67      // test_local_bindings.py
    68      // Local to both:
    69      bind_local<LocalType, 1>(m, "LocalType", py::module_local()).def("get2", [](LocalType &t) {
    70          return t.i + 2;
    71      });
    72  
    73      // Can only be called with our python type:
    74      m.def("local_value", [](LocalType &l) { return l.i; });
    75  
    76      // test_nonlocal_failure
    77      // This registration will fail (global registration when LocalFail is already registered
    78      // globally in the main test module):
    79      m.def("register_nonlocal", [m]() { bind_local<NonLocalType, 0>(m, "NonLocalType"); });
    80  
    81      // test_stl_bind_local
    82      // stl_bind.h binders defaults to py::module_local if the types are local or converting:
    83      py::bind_vector<LocalVec>(m, "LocalVec");
    84      py::bind_map<LocalMap>(m, "LocalMap");
    85  
    86      // test_stl_bind_global
    87      // and global if the type (or one of the types, for the map) is global (so these will fail,
    88      // assuming pybind11_tests is already loaded):
    89      m.def("register_nonlocal_vec", [m]() { py::bind_vector<NonLocalVec>(m, "NonLocalVec"); });
    90      m.def("register_nonlocal_map", [m]() { py::bind_map<NonLocalMap>(m, "NonLocalMap"); });
    91      // The default can, however, be overridden to global using `py::module_local()` or
    92      // `py::module_local(false)`.
    93      // Explicitly made local:
    94      py::bind_vector<NonLocalVec2>(m, "NonLocalVec2", py::module_local());
    95      // Explicitly made global (and so will fail to bind):
    96      m.def("register_nonlocal_map2",
    97            [m]() { py::bind_map<NonLocalMap2>(m, "NonLocalMap2", py::module_local(false)); });
    98  
    99      // test_mixed_local_global
   100      // We try this both with the global type registered first and vice versa (the order shouldn't
   101      // matter).
   102      m.def("register_mixed_global_local",
   103            [m]() { bind_local<MixedGlobalLocal, 200>(m, "MixedGlobalLocal", py::module_local()); });
   104      m.def("register_mixed_local_global", [m]() {
   105          bind_local<MixedLocalGlobal, 2000>(m, "MixedLocalGlobal", py::module_local(false));
   106      });
   107      m.def("get_mixed_gl", [](int i) { return MixedGlobalLocal(i); });
   108      m.def("get_mixed_lg", [](int i) { return MixedLocalGlobal(i); });
   109  
   110      // test_internal_locals_differ
   111      m.def("local_cpp_types_addr",
   112            []() { return (uintptr_t) &py::detail::get_local_internals().registered_types_cpp; });
   113  
   114      // test_stl_caster_vs_stl_bind
   115      py::bind_vector<std::vector<int>>(m, "VectorInt");
   116  
   117      m.def("load_vector_via_binding",
   118            [](std::vector<int> &v) { return std::accumulate(v.begin(), v.end(), 0); });
   119  
   120      // test_cross_module_calls
   121      m.def("return_self", [](LocalVec *v) { return v; });
   122      m.def("return_copy", [](const LocalVec &v) { return LocalVec(v); });
   123  
   124      class Dog : public pets::Pet {
   125      public:
   126          explicit Dog(std::string name) : Pet(std::move(name)) {}
   127      };
   128      py::class_<pets::Pet>(m, "Pet", py::module_local()).def("name", &pets::Pet::name);
   129      // Binding for local extending class:
   130      py::class_<Dog, pets::Pet>(m, "Dog").def(py::init<std::string>());
   131      m.def("pet_name", [](pets::Pet &p) { return p.name(); });
   132  
   133      py::class_<MixGL>(m, "MixGL", py::module_local()).def(py::init<int>());
   134      m.def("get_gl_value", [](MixGL &o) { return o.i + 100; });
   135  
   136      py::class_<MixGL2>(m, "MixGL2", py::module_local()).def(py::init<int>());
   137  
   138      // test_vector_bool
   139      // We can't test both stl.h and stl_bind.h conversions of `std::vector<bool>` within
   140      // the same module (it would be an ODR violation). Therefore `bind_vector` of `bool`
   141      // is defined here and tested in `test_stl_binders.py`.
   142      py::bind_vector<std::vector<bool>>(m, "VectorBool");
   143  
   144      // test_missing_header_message
   145      // The main module already includes stl.h, but we need to test the error message
   146      // which appears when this header is missing.
   147      m.def("missing_header_arg", [](const std::vector<float> &) {});
   148      m.def("missing_header_return", []() { return std::vector<float>(); });
   149  }