d-mercator/python/pybind11/tests/test_callbacks.cpp at main · networkgeometry/d-mercator · GitHub

History

243 lines (213 loc) · 9.03 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

tests/test_callbacks.cpp -- callbacks

BSD-style license that can be found in the LICENSE file.

#include <pybind11/functional.h>

#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", [](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")); });

// test_keyword_args_and_generalized_unpacking

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", [](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);

return f("positional", 1, **d1, **d2, **d3);

});

m.def("test_keyword_args", [](const py::function &f) { return f("x"_a = 10, "y"_a = 20); });

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);

});

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),

*py::make_tuple(3, 4),

"key"_a = "value",

**kwargs1,

"b"_a = 2,

**kwargs2,

"e"_a = 5);

});

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", [](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",

[](const py::function &f) { f(234, 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

struct Payload {

Payload() { print_default_created(this); }

~Payload() { print_destroyed(this); }

Payload(const Payload &) { print_copy_created(this); }

Payload(Payload &&) noexcept { print_move_created(this); }

};

// Export the payload constructor statistics for testing purposes:

m.def("payload_cstats", &ConstructorStats::get<Payload>);

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("test_dummy_function", [](const std::function<int(int)> &f) -> std::string {

using fn_type = int (*)(int);

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);

}

if (*result == dummy_function) {

auto r = (*result)(1);

return "matches dummy_function: eval(1) = " + std::to_string(r);

}

return "argument does NOT match dummy_function. This should never happen!";

});

class AbstractBase {

public:

// [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",

[](const std::function<double(AbstractBase &)> &) {});

struct MovableObject {

bool valid = true;

MovableObject() = default;

MovableObject(const MovableObject &) = default;

MovableObject &operator=(const MovableObject &) = default;

MovableObject(MovableObject &&o) noexcept : valid(o.valid) { o.valid = false; }

MovableObject &operator=(MovableObject &&o) noexcept {

valid = o.valid;

o.valid = false;

return *this;

}

};

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

// test_movable_object

m.def("callback_with_movable", [](const std::function<void(MovableObject &)> &f) {

auto x = MovableObject();

f(x); // lvalue reference shouldn't move out object

return x.valid; // must still return `true`

});

// test_bound_method_callback

struct CppBoundMethodTest {};

py::class_<CppBoundMethodTest>(m, "CppBoundMethodTest")

.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", [](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] {

std::this_thread::sleep_for(std::chrono::milliseconds(50));

f(j);

};

auto t = std::thread(std::move(invoke_f));

t.detach();

};

// spawn worker threads

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();

}

});

}

d-mercator/python/pybind11/tests/test_callbacks.cpp at main · networkgeometry/d-mercator · GitHub

Uh oh!

Expand file tree

Breadcrumbs

test_callbacks.cpp

Latest commit

History

Breadcrumbs

test_callbacks.cpp

File metadata and controls