21 m.def(
"test_callback1", [](
const py::object &
func) {
return func(); });
22 m.def(
"test_callback2", [](
const py::object &func) {
return func(
"Hello",
'x',
true, 5); });
23 m.def(
"test_callback3", [](
const std::function<
int(
int)> &func) {
24 return "func(43) = " + std::to_string(
func(43));
26 m.def(
"test_callback4",
27 []() -> std::function<
int(
int)> {
return [](
int i) {
return i + 1; }; });
28 m.def(
"test_callback5",
29 []() {
return py::cpp_function([](
int i) {
return i + 1; },
py::arg(
"number")); });
32 m.def(
"test_tuple_unpacking", [](
const py::function &
f) {
35 return f(
"positional", 1, *t1, 4, *t2);
38 m.def(
"test_dict_unpacking", [](
const py::function &f) {
39 auto d1 = py::dict(
"key"_a =
"value",
"a"_a = 1);
41 auto d3 = py::dict(
"b"_a = 2);
42 return f(
"positional", 1, **d1, **
d2, **d3);
45 m.def(
"test_keyword_args", [](
const py::function &f) {
return f(
"x"_a = 10,
"y"_a = 20); });
47 m.def(
"test_unpacking_and_keywords1", [](
const py::function &f) {
49 auto kwargs = py::dict(
"d"_a = 4);
53 m.def(
"test_unpacking_and_keywords2", [](
const py::function &f) {
54 auto kwargs1 = py::dict(
"a"_a = 1);
55 auto kwargs2 = py::dict(
"c"_a = 3,
"d"_a = 4);
56 return f(
"positional",
68 m.def(
"test_unpacking_error1", [](
const py::function &f) {
69 auto kwargs = py::dict(
"x"_a = 3);
70 return f(
"x"_a = 1,
"y"_a = 2, **
kwargs);
73 m.def(
"test_unpacking_error2", [](
const py::function &f) {
74 auto kwargs = py::dict(
"x"_a = 3);
78 m.def(
"test_arg_conversion_error1",
81 m.def(
"test_arg_conversion_error2", [](
const py::function &f) {
93 m.def(
"payload_cstats", &ConstructorStats::get<Payload>);
94 m.def(
"test_lambda_closure_cleanup", []() -> std::function<
void()> {
114 m.def(
"test_cpp_callable_cleanup", []() {
117 py::list alive_counts;
118 ConstructorStats &stat = ConstructorStats::get<CppCallable>();
119 alive_counts.append(stat.alive());
121 CppCallable cpp_callable;
122 alive_counts.append(stat.alive());
127 py::cpp_function py_func(cpp_callable);
129 alive_counts.append(stat.alive());
131 alive_counts.append(stat.alive());
133 py::cpp_function py_func(std::move(cpp_callable));
135 alive_counts.append(stat.alive());
137 alive_counts.append(stat.alive());
139 alive_counts.append(stat.alive());
146 m.def(
"dummy_function_overloaded", [](
int i,
int j) {
return i +
j; });
148 m.def(
"dummy_function2", [](
int i,
int j) {
return i +
j; });
151 [](std::function<
int(
int)> f,
bool expect_none =
false) {
152 if (expect_none && f) {
153 throw std::runtime_error(
"Expected None to be converted to empty std::function");
158 py::arg(
"expect_none") =
false);
159 m.def(
"test_dummy_function", [](
const std::function<
int(
int)> &f) -> std::string {
160 using fn_type =
int (*)(
int);
161 const auto *
result = f.target<fn_type>();
164 return "can't convert to function pointer: eval(1) = " + std::to_string(r);
167 auto r = (*result)(1);
168 return "matches dummy_function: eval(1) = " + std::to_string(r);
170 return "argument does NOT match dummy_function. This should never happen!";
178 virtual ~AbstractBase() {}
179 virtual unsigned int func() = 0;
181 m.def(
"func_accepting_func_accepting_base",
182 [](
const std::function<
double(AbstractBase &)> &) {});
184 struct MovableObject {
187 MovableObject() =
default;
188 MovableObject(
const MovableObject &) =
default;
189 MovableObject &operator=(
const MovableObject &) =
default;
190 MovableObject(MovableObject &&o) noexcept : valid(o.valid) { o.valid =
false; }
191 MovableObject &operator=(MovableObject &&o) noexcept {
197 py::class_<MovableObject>(
m,
"MovableObject");
200 m.def(
"callback_with_movable", [](
const std::function<
void(MovableObject &)> &f) {
201 auto x = MovableObject();
207 struct CppBoundMethodTest {};
208 py::class_<CppBoundMethodTest>(
m,
"CppBoundMethodTest")
210 .def(
"triple", [](CppBoundMethodTest &,
int val) {
return 3 * val; });
214 m.def(
"test_sum_builtin",
215 [](
const std::function<
double(py::iterable)> &sum_builtin,
const py::iterable &i) {
216 return sum_builtin(i);
220 using callback_f = std::function<void(int)>;
221 m.def(
"test_async_callback", [](
const callback_f &f,
const py::list &work) {
223 auto start_f = [
f](
int j) {
224 auto invoke_f = [
f,
j] {
225 std::this_thread::sleep_for(std::chrono::milliseconds(50));
228 auto t = std::thread(std::move(invoke_f));
233 for (
auto i : work) {
234 start_f(py::cast<int>(i));
238 m.def(
"callback_num_times", [](
const py::function &f,
std::size_t num) {
void silence_unused_warnings(Args &&...)
void print_destroyed(T *inst, Values &&...values)
void print_copy_created(T *inst, Values &&...values)
Dummy type which is not exported anywhere – something to trigger a conversion error.
void track_move_created(T *inst)
void print_default_created(T *inst, Values &&...values)
int dummy_function(int i)
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ArgReturnType arg() const
Point2(* f)(const Point3 &, OptionalJacobian< 2, 3 >)
void track_copy_created(T *inst)
void track_destroyed(T *inst)
TEST_SUBMODULE(callbacks, m)
void print_move_created(T *inst, Values &&...values)
set noclip points set clip one set noclip two set bar set border lt lw set xdata set ydata set zdata set x2data set y2data set boxwidth set dummy x
internal::enable_if< internal::valid_indexed_view_overload< RowIndices, ColIndices >::value &&internal::traits< typename EIGEN_INDEXED_VIEW_METHOD_TYPE< RowIndices, ColIndices >::type >::ReturnAsIndexedView, typename EIGEN_INDEXED_VIEW_METHOD_TYPE< RowIndices, ColIndices >::type >::type operator()(const RowIndices &rowIndices, const ColIndices &colIndices) EIGEN_INDEXED_VIEW_METHOD_CONST
void track_default_created(T *inst, Values &&...values)