diff options
Diffstat (limited to '3rdparty/pybind11/tests/test_callbacks.cpp')
| -rw-r--r-- | 3rdparty/pybind11/tests/test_callbacks.cpp | 181 |
1 files changed, 126 insertions, 55 deletions
diff --git a/3rdparty/pybind11/tests/test_callbacks.cpp b/3rdparty/pybind11/tests/test_callbacks.cpp index 683dfb3e..92b8053d 100644 --- a/3rdparty/pybind11/tests/test_callbacks.cpp +++ b/3rdparty/pybind11/tests/test_callbacks.cpp @@ -7,72 +7,79 @@ BSD-style license that can be found in the LICENSE file. */ -#include "pybind11_tests.h" -#include "constructor_stats.h" #include <pybind11/functional.h> -#include <thread> +#include "constructor_stats.h" +#include "pybind11_tests.h" + +#include <thread> int dummy_function(int i) { return i + 1; } TEST_SUBMODULE(callbacks, m) { // test_callbacks, test_function_signatures - m.def("test_callback1", [](py::object func) { return func(); }); - m.def("test_callback2", [](py::object func) { return func("Hello", 'x', true, 5); }); + m.def("test_callback1", [](const py::object &func) { return func(); }); + m.def("test_callback2", [](const py::object &func) { return func("Hello", 'x', true, 5); }); m.def("test_callback3", [](const std::function<int(int)> &func) { - return "func(43) = " + std::to_string(func(43)); }); - m.def("test_callback4", []() -> std::function<int(int)> { return [](int i) { return i+1; }; }); - m.def("test_callback5", []() { - return py::cpp_function([](int i) { return i+1; }, py::arg("number")); + return "func(43) = " + std::to_string(func(43)); }); + m.def("test_callback4", + []() -> std::function<int(int)> { return [](int i) { return i + 1; }; }); + m.def("test_callback5", + []() { return py::cpp_function([](int i) { return i + 1; }, py::arg("number")); }); // test_keyword_args_and_generalized_unpacking - m.def("test_tuple_unpacking", [](py::function f) { + m.def("test_tuple_unpacking", [](const py::function &f) { auto t1 = py::make_tuple(2, 3); auto t2 = py::make_tuple(5, 6); return f("positional", 1, *t1, 4, *t2); }); - m.def("test_dict_unpacking", [](py::function f) { - auto d1 = py::dict("key"_a="value", "a"_a=1); + m.def("test_dict_unpacking", [](const py::function &f) { + auto d1 = py::dict("key"_a = "value", "a"_a = 1); auto d2 = py::dict(); - auto d3 = py::dict("b"_a=2); + auto d3 = py::dict("b"_a = 2); return f("positional", 1, **d1, **d2, **d3); }); - m.def("test_keyword_args", [](py::function f) { - return f("x"_a=10, "y"_a=20); - }); + m.def("test_keyword_args", [](const py::function &f) { return f("x"_a = 10, "y"_a = 20); }); - m.def("test_unpacking_and_keywords1", [](py::function f) { + m.def("test_unpacking_and_keywords1", [](const py::function &f) { auto args = py::make_tuple(2); - auto kwargs = py::dict("d"_a=4); - return f(1, *args, "c"_a=3, **kwargs); + auto kwargs = py::dict("d"_a = 4); + return f(1, *args, "c"_a = 3, **kwargs); }); - m.def("test_unpacking_and_keywords2", [](py::function f) { - auto kwargs1 = py::dict("a"_a=1); - auto kwargs2 = py::dict("c"_a=3, "d"_a=4); - return f("positional", *py::make_tuple(1), 2, *py::make_tuple(3, 4), 5, - "key"_a="value", **kwargs1, "b"_a=2, **kwargs2, "e"_a=5); + m.def("test_unpacking_and_keywords2", [](const py::function &f) { + auto kwargs1 = py::dict("a"_a = 1); + auto kwargs2 = py::dict("c"_a = 3, "d"_a = 4); + return f("positional", + *py::make_tuple(1), + 2, + *py::make_tuple(3, 4), + 5, + "key"_a = "value", + **kwargs1, + "b"_a = 2, + **kwargs2, + "e"_a = 5); }); - m.def("test_unpacking_error1", [](py::function f) { - auto kwargs = py::dict("x"_a=3); - return f("x"_a=1, "y"_a=2, **kwargs); // duplicate ** after keyword + m.def("test_unpacking_error1", [](const py::function &f) { + auto kwargs = py::dict("x"_a = 3); + return f("x"_a = 1, "y"_a = 2, **kwargs); // duplicate ** after keyword }); - m.def("test_unpacking_error2", [](py::function f) { - auto kwargs = py::dict("x"_a=3); - return f(**kwargs, "x"_a=1); // duplicate keyword after ** + m.def("test_unpacking_error2", [](const py::function &f) { + auto kwargs = py::dict("x"_a = 3); + return f(**kwargs, "x"_a = 1); // duplicate keyword after ** }); - m.def("test_arg_conversion_error1", [](py::function f) { - f(234, UnregisteredType(), "kw"_a=567); - }); + m.def("test_arg_conversion_error1", + [](const py::function &f) { f(234, UnregisteredType(), "kw"_a = 567); }); - m.def("test_arg_conversion_error2", [](py::function f) { - f(234, "expected_name"_a=UnregisteredType(), "kw"_a=567); + m.def("test_arg_conversion_error2", [](const py::function &f) { + f(234, "expected_name"_a = UnregisteredType(), "kw"_a = 567); }); // test_lambda_closure_cleanup @@ -80,49 +87,99 @@ TEST_SUBMODULE(callbacks, m) { Payload() { print_default_created(this); } ~Payload() { print_destroyed(this); } Payload(const Payload &) { print_copy_created(this); } - Payload(Payload &&) { print_move_created(this); } + Payload(Payload &&) noexcept { print_move_created(this); } }; // Export the payload constructor statistics for testing purposes: m.def("payload_cstats", &ConstructorStats::get<Payload>); - /* Test cleanup of lambda closure */ - m.def("test_cleanup", []() -> std::function<void(void)> { + m.def("test_lambda_closure_cleanup", []() -> std::function<void()> { Payload p; + // In this situation, `Func` in the implementation of + // `cpp_function::initialize` is NOT trivially destructible. return [p]() { /* p should be cleaned up when the returned function is garbage collected */ (void) p; }; }); + class CppCallable { + public: + CppCallable() { track_default_created(this); } + ~CppCallable() { track_destroyed(this); } + CppCallable(const CppCallable &) { track_copy_created(this); } + CppCallable(CppCallable &&) noexcept { track_move_created(this); } + void operator()() {} + }; + + m.def("test_cpp_callable_cleanup", []() { + // Related issue: https://github.com/pybind/pybind11/issues/3228 + // Related PR: https://github.com/pybind/pybind11/pull/3229 + py::list alive_counts; + ConstructorStats &stat = ConstructorStats::get<CppCallable>(); + alive_counts.append(stat.alive()); + { + CppCallable cpp_callable; + alive_counts.append(stat.alive()); + { + // In this situation, `Func` in the implementation of + // `cpp_function::initialize` IS trivially destructible, + // only `capture` is not. + py::cpp_function py_func(cpp_callable); + py::detail::silence_unused_warnings(py_func); + alive_counts.append(stat.alive()); + } + alive_counts.append(stat.alive()); + { + py::cpp_function py_func(std::move(cpp_callable)); + py::detail::silence_unused_warnings(py_func); + alive_counts.append(stat.alive()); + } + alive_counts.append(stat.alive()); + } + alive_counts.append(stat.alive()); + return alive_counts; + }); + // test_cpp_function_roundtrip /* Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer */ m.def("dummy_function", &dummy_function); + m.def("dummy_function_overloaded", [](int i, int j) { return i + j; }); + m.def("dummy_function_overloaded", &dummy_function); m.def("dummy_function2", [](int i, int j) { return i + j; }); - m.def("roundtrip", [](std::function<int(int)> f, bool expect_none = false) { - if (expect_none && f) - throw std::runtime_error("Expected None to be converted to empty std::function"); - return f; - }, py::arg("f"), py::arg("expect_none")=false); + m.def( + "roundtrip", + [](std::function<int(int)> f, bool expect_none = false) { + if (expect_none && f) { + throw std::runtime_error("Expected None to be converted to empty std::function"); + } + return f; + }, + py::arg("f"), + py::arg("expect_none") = false); m.def("test_dummy_function", [](const std::function<int(int)> &f) -> std::string { using fn_type = int (*)(int); - auto result = f.target<fn_type>(); + const auto *result = f.target<fn_type>(); if (!result) { auto r = f(1); return "can't convert to function pointer: eval(1) = " + std::to_string(r); - } else if (*result == dummy_function) { + } + if (*result == dummy_function) { auto r = (*result)(1); return "matches dummy_function: eval(1) = " + std::to_string(r); - } else { - return "argument does NOT match dummy_function. This should never happen!"; } + return "argument does NOT match dummy_function. This should never happen!"; }); class AbstractBase { public: - virtual ~AbstractBase() = default; + // [workaround(intel)] = default does not work here + // Defaulting this destructor results in linking errors with the Intel compiler + // (in Debug builds only, tested with icpc (ICC) 2021.1 Beta 20200827) + virtual ~AbstractBase() {} // NOLINT(modernize-use-equals-default) virtual unsigned int func() = 0; }; - m.def("func_accepting_func_accepting_base", [](std::function<double(AbstractBase&)>) { }); + m.def("func_accepting_func_accepting_base", + [](const std::function<double(AbstractBase &)> &) {}); struct MovableObject { bool valid = true; @@ -130,8 +187,8 @@ TEST_SUBMODULE(callbacks, m) { MovableObject() = default; MovableObject(const MovableObject &) = default; MovableObject &operator=(const MovableObject &) = default; - MovableObject(MovableObject &&o) : valid(o.valid) { o.valid = false; } - MovableObject &operator=(MovableObject &&o) { + MovableObject(MovableObject &&o) noexcept : valid(o.valid) { o.valid = false; } + MovableObject &operator=(MovableObject &&o) noexcept { valid = o.valid; o.valid = false; return *this; @@ -140,9 +197,9 @@ TEST_SUBMODULE(callbacks, m) { py::class_<MovableObject>(m, "MovableObject"); // test_movable_object - m.def("callback_with_movable", [](std::function<void(MovableObject &)> f) { + m.def("callback_with_movable", [](const std::function<void(MovableObject &)> &f) { auto x = MovableObject(); - f(x); // lvalue reference shouldn't move out object + f(x); // lvalue reference shouldn't move out object return x.valid; // must still return `true` }); @@ -152,9 +209,16 @@ TEST_SUBMODULE(callbacks, m) { .def(py::init<>()) .def("triple", [](CppBoundMethodTest &, int val) { return 3 * val; }); + // This checks that builtin functions can be passed as callbacks + // rather than throwing RuntimeError due to trying to extract as capsule + m.def("test_sum_builtin", + [](const std::function<double(py::iterable)> &sum_builtin, const py::iterable &i) { + return sum_builtin(i); + }); + // test async Python callbacks using callback_f = std::function<void(int)>; - m.def("test_async_callback", [](callback_f f, py::list work) { + m.def("test_async_callback", [](const callback_f &f, const py::list &work) { // make detached thread that calls `f` with piece of work after a little delay auto start_f = [f](int j) { auto invoke_f = [f, j] { @@ -166,7 +230,14 @@ TEST_SUBMODULE(callbacks, m) { }; // spawn worker threads - for (auto i : work) + for (auto i : work) { start_f(py::cast<int>(i)); + } + }); + + m.def("callback_num_times", [](const py::function &f, std::size_t num) { + for (std::size_t i = 0; i < num; i++) { + f(); + } }); } |