aboutsummaryrefslogtreecommitdiff
path: root/tests/test_callbacks.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/test_callbacks.cpp')
-rw-r--r--tests/test_callbacks.cpp215
1 files changed, 160 insertions, 55 deletions
diff --git a/tests/test_callbacks.cpp b/tests/test_callbacks.cpp
index dffe538f..2fd05dec 100644
--- a/tests/test_callbacks.cpp
+++ b/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,41 +87,87 @@ 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 {
@@ -122,10 +175,11 @@ TEST_SUBMODULE(callbacks, m) {
// [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 ~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;
@@ -133,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;
@@ -143,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`
});
@@ -155,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] {
@@ -169,7 +230,51 @@ 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();
+ }
});
+
+ auto *custom_def = []() {
+ static PyMethodDef def;
+ def.ml_name = "example_name";
+ def.ml_doc = "Example doc";
+ def.ml_meth = [](PyObject *, PyObject *args) -> PyObject * {
+ if (PyTuple_Size(args) != 1) {
+ throw std::runtime_error("Invalid number of arguments for example_name");
+ }
+ PyObject *first = PyTuple_GetItem(args, 0);
+ if (!PyLong_Check(first)) {
+ throw std::runtime_error("Invalid argument to example_name");
+ }
+ auto result = py::cast(PyLong_AsLong(first) * 9);
+ return result.release().ptr();
+ };
+ def.ml_flags = METH_VARARGS;
+ return &def;
+ }();
+
+ // rec_capsule with name that has the same value (but not pointer) as our internal one
+ // This capsule should be detected by our code as foreign and not inspected as the pointers
+ // shouldn't match
+ constexpr const char *rec_capsule_name
+ = pybind11::detail::internals_function_record_capsule_name;
+ py::capsule rec_capsule(std::malloc(1), [](void *data) { std::free(data); });
+ rec_capsule.set_name(rec_capsule_name);
+ m.add_object("custom_function", PyCFunction_New(custom_def, rec_capsule.ptr()));
+
+ // This test requires a new ABI version to pass
+#if PYBIND11_INTERNALS_VERSION > 4
+ // rec_capsule with nullptr name
+ py::capsule rec_capsule2(std::malloc(1), [](void *data) { std::free(data); });
+ m.add_object("custom_function2", PyCFunction_New(custom_def, rec_capsule2.ptr()));
+#else
+ m.add_object("custom_function2", py::none());
+#endif
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-06-06 12:02:13 +0000