test_callbacks.cpp 5.69 KB
Newer Older
Wenzel Jakob's avatar
Wenzel Jakob committed
1
/*
Dean Moldovan's avatar
Dean Moldovan committed
2
    tests/test_callbacks.cpp -- callbacks
Wenzel Jakob's avatar
Wenzel Jakob committed
3

4
    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
Wenzel Jakob's avatar
Wenzel Jakob committed
5
6
7
8
9

    All rights reserved. Use of this source code is governed by a
    BSD-style license that can be found in the LICENSE file.
*/

Dean Moldovan's avatar
Dean Moldovan committed
10
11
#include "pybind11_tests.h"
#include "constructor_stats.h"
12
#include <pybind11/functional.h>
Wenzel Jakob's avatar
Wenzel Jakob committed
13
14


15
16
py::object test_callback1(py::object func) {
    return func();
Wenzel Jakob's avatar
Wenzel Jakob committed
17
18
}

19
20
py::tuple test_callback2(py::object func) {
    return func("Hello", 'x', true, 5);
Wenzel Jakob's avatar
Wenzel Jakob committed
21
22
}

23
24
std::string test_callback3(const std::function<int(int)> &func) {
    return "func(43) = " + std::to_string(func(43));
25
26
}

27
std::function<int(int)> test_callback4() {
28
29
30
    return [](int i) { return i+1; };
}

31
32
33
34
35
py::cpp_function test_callback5() {
    return py::cpp_function([](int i) { return i+1; },
       py::arg("number"));
}

36
37
int dummy_function(int i) { return i + 1; }
int dummy_function2(int i, int j) { return i + j; }
38
39
40
41
std::function<int(int)> 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");
    }
42
43
44
    return f;
}

45
std::string test_dummy_function(const std::function<int(int)> &f) {
46
47
48
49
    using fn_type = int (*)(int);
    auto result = f.target<fn_type>();
    if (!result) {
        auto r = f(1);
50
        return "can't convert to function pointer: eval(1) = " + std::to_string(r);
51
52
    } else if (*result == dummy_function) {
        auto r = (*result)(1);
53
        return "matches dummy_function: eval(1) = " + std::to_string(r);
54
    } else {
55
        return "argument does NOT match dummy_function. This should never happen!";
56
57
58
    }
}

59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
struct Payload {
    Payload() {
        print_default_created(this);
    }
    ~Payload() {
        print_destroyed(this);
    }
    Payload(const Payload &) {
        print_copy_created(this);
    }
    Payload(Payload &&) {
        print_move_created(this);
    }
};

74
75
76
/// Something to trigger a conversion error
struct Unregistered {};

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
class AbstractBase {
public:
  virtual unsigned int func() = 0;
};

void func_accepting_func_accepting_base(std::function<double(AbstractBase&)>) { }

struct MovableObject {
  bool valid = true;

  MovableObject() = default;
  MovableObject(const MovableObject &) = default;
  MovableObject &operator=(const MovableObject &) = default;
  MovableObject(MovableObject &&o) : valid(o.valid) { o.valid = false; }
  MovableObject &operator=(MovableObject &&o) {
    valid = o.valid;
    o.valid = false;
    return *this;
  }
};

98
test_initializer callbacks([](py::module &m) {
Wenzel Jakob's avatar
Wenzel Jakob committed
99
100
101
    m.def("test_callback1", &test_callback1);
    m.def("test_callback2", &test_callback2);
    m.def("test_callback3", &test_callback3);
102
    m.def("test_callback4", &test_callback4);
103
    m.def("test_callback5", &test_callback5);
104

105
106
107
108
109
110
111
112
    // Test keyword args and generalized unpacking
    m.def("test_tuple_unpacking", [](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) {
113
        auto d1 = py::dict("key"_a="value", "a"_a=1);
114
        auto d2 = py::dict();
115
        auto d3 = py::dict("b"_a=2);
116
117
118
119
120
121
122
123
124
        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_unpacking_and_keywords1", [](py::function f) {
        auto args = py::make_tuple(2);
125
        auto kwargs = py::dict("d"_a=4);
126
127
128
129
        return f(1, *args, "c"_a=3, **kwargs);
    });

    m.def("test_unpacking_and_keywords2", [](py::function f) {
130
131
        auto kwargs1 = py::dict("a"_a=1);
        auto kwargs2 = py::dict("c"_a=3, "d"_a=4);
132
133
134
135
136
        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) {
137
        auto kwargs = py::dict("x"_a=3);
138
139
140
141
        return f("x"_a=1, "y"_a=2, **kwargs); // duplicate ** after keyword
    });

    m.def("test_unpacking_error2", [](py::function f) {
142
        auto kwargs = py::dict("x"_a=3);
143
144
        return f(**kwargs, "x"_a=1); // duplicate keyword after **
    });
145

146
147
148
149
150
151
152
153
154
    m.def("test_arg_conversion_error1", [](py::function f) {
        f(234, Unregistered(), "kw"_a=567);
    });

    m.def("test_arg_conversion_error2", [](py::function f) {
        f(234, "expected_name"_a=Unregistered(), "kw"_a=567);
    });

    /* Test cleanup of lambda closure */
Wenzel Jakob's avatar
Wenzel Jakob committed
155
    m.def("test_cleanup", []() -> std::function<void(void)> {
156
157
158
159
        Payload p;

        return [p]() {
            /* p should be cleaned up when the returned function is garbage collected */
160
            (void) p;
161
162
        };
    });
163
164
165
166

    /* Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer */
    m.def("dummy_function", &dummy_function);
    m.def("dummy_function2", &dummy_function2);
167
    m.def("roundtrip", &roundtrip, py::arg("f"), py::arg("expect_none")=false);
168
    m.def("test_dummy_function", &test_dummy_function);
169
170
    // Export the payload constructor statistics for testing purposes:
    m.def("payload_cstats", &ConstructorStats::get<Payload>);
171
172
173
174
175
176
177
178
179
180
181

    m.def("func_accepting_func_accepting_base",
          func_accepting_func_accepting_base);

    py::class_<MovableObject>(m, "MovableObject");

    m.def("callback_with_movable", [](std::function<void(MovableObject &)> f) {
        auto x = MovableObject();
        f(x); // lvalue reference shouldn't move out object
        return x.valid; // must still return `true`
      });
182
183
184
185
186

    struct CppBoundMethodTest {};
    py::class_<CppBoundMethodTest>(m, "CppBoundMethodTest")
        .def(py::init<>())
        .def("triple", [](CppBoundMethodTest &, int val) { return 3 * val; });
187
});