23 static constexpr
auto name = const_name<ConstRefCasted>();
32 return std::move(
value);
53 template <
typename T_>
80 m.def(
"string_roundtrip", [](
const char *
s) {
return s; });
85 char32_t a32 = 0x61 , z32 = 0x7a , ib32 = 0x203d , cake32 = 0x1f382 ,
87 char16_t b16 = 0x62 , z16 = 0x7a, ib16 = 0x203d, cake16_1 = 0xd83c, cake16_2 = 0xdf82,
88 mathbfA16_1 = 0xd835, mathbfA16_2 = 0xdc00;
91 wstr.push_back(0x2e18);
92 if (
sizeof(
wchar_t) == 2) {
93 wstr.push_back(mathbfA16_1);
94 wstr.push_back(mathbfA16_2);
97 wstr.push_back((
wchar_t) mathbfA32);
101 m.def(
"good_utf8_string", []() {
102 return std::string((
const char *) u8
"Say utf8\u203d \U0001f382 \U0001d400");
104 m.def(
"good_utf16_string", [=]() {
105 return std::u16string({b16, ib16, cake16_1, cake16_2, mathbfA16_1, mathbfA16_2, z16});
107 m.def(
"good_utf32_string", [=]() {
108 return std::u32string({a32, mathbfA32, cake32, ib32, z32});
110 m.def(
"good_wchar_string", [=]() {
return wstr; });
111 m.def(
"bad_utf8_string", []() {
112 return std::string(
"abc\xd0"
115 m.def(
"bad_utf16_string", [=]() {
return std::u16string({b16, char16_t(0xd800), z16}); });
118 m.def(
"bad_utf32_string", [=]() {
return std::u32string({a32, char32_t(0xd800), z32}); });
119 if (
sizeof(
wchar_t) == 2) {
120 m.def(
"bad_wchar_string", [=]() {
121 return std::wstring({wchar_t(0x61), wchar_t(0xd800)});
124 m.def(
"u8_Z", []() ->
char {
return 'Z'; });
125 m.def(
"u8_eacute", []() ->
char {
return '\xe9'; });
126 m.def(
"u16_ibang", [=]() -> char16_t {
return ib16; });
127 m.def(
"u32_mathbfA", [=]() -> char32_t {
return mathbfA32; });
128 m.def(
"wchar_heart", []() ->
wchar_t {
return 0x2665; });
131 m.attr(
"wchar_size") =
py::cast(
sizeof(
wchar_t));
132 m.def(
"ord_char", [](
char c) ->
int {
return static_cast<unsigned char>(
c); });
133 m.def(
"ord_char_lv", [](
char &
c) ->
int {
return static_cast<unsigned char>(
c); });
134 m.def(
"ord_char16", [](char16_t
c) ->
uint16_t {
return c; });
135 m.def(
"ord_char16_lv", [](char16_t &
c) ->
uint16_t {
return c; });
136 m.def(
"ord_char32", [](char32_t
c) ->
uint32_t {
return c; });
137 m.def(
"ord_wchar", [](
wchar_t c) ->
int {
return c; });
140 m.def(
"strlen", [](
char *
s) {
return strlen(
s); });
141 m.def(
"string_length", [](
const std::string &
s) {
return s.length(); });
143 #ifdef PYBIND11_HAS_U8STRING
144 m.attr(
"has_u8string") =
true;
145 m.def(
"good_utf8_u8string", []() {
146 return std::u8string(u8
"Say utf8\u203d \U0001f382 \U0001d400");
148 m.def(
"bad_utf8_u8string", []() {
149 return std::u8string((
const char8_t *)
"abc\xd0"
153 m.def(
"u8_char8_Z", []() -> char8_t {
return u8
'Z'; });
156 m.def(
"ord_char8", [](char8_t
c) ->
int {
return static_cast<unsigned char>(
c); });
157 m.def(
"ord_char8_lv", [](char8_t &
c) ->
int {
return static_cast<unsigned char>(
c); });
161 #ifdef PYBIND11_HAS_STRING_VIEW
162 m.attr(
"has_string_view") =
true;
163 m.def(
"string_view_print", [](std::string_view
s) {
py::print(
s,
s.size()); });
164 m.def(
"string_view16_print", [](std::u16string_view
s) {
py::print(
s,
s.size()); });
165 m.def(
"string_view32_print", [](std::u32string_view
s) {
py::print(
s,
s.size()); });
166 m.def(
"string_view_chars", [](std::string_view
s) {
173 m.def(
"string_view16_chars", [](std::u16string_view
s) {
180 m.def(
"string_view32_chars", [](std::u32string_view
s) {
187 m.def(
"string_view_return",
188 []() {
return std::string_view((
const char *) u8
"utf8 secret \U0001f382"); });
189 m.def(
"string_view16_return",
190 []() {
return std::u16string_view(u
"utf16 secret \U0001f382"); });
191 m.def(
"string_view32_return",
192 []() {
return std::u32string_view(
U"utf32 secret \U0001f382"); });
195 using namespace std::literals;
196 m.def(
"string_view_bytes",
197 []() {
return [](py::bytes
b) {
return b; }(
"abc \x80\x80 def"sv); });
198 m.def(
"string_view_str",
199 []() {
return [](
py::str s) {
return s; }(
"abc \342\200\275 def"sv); });
200 m.def(
"string_view_from_bytes",
201 [](
const py::bytes &
b) {
return [](std::string_view
s) {
return s; }(
b); });
202 m.def(
"string_view_memoryview", []() {
203 static constexpr
auto val =
"Have some \360\237\216\202"sv;
204 return py::memoryview::from_memory(val);
207 # ifdef PYBIND11_HAS_U8STRING
208 m.def(
"string_view8_print", [](std::u8string_view
s) {
py::print(
s,
s.size()); });
209 m.def(
"string_view8_chars", [](std::u8string_view
s) {
215 m.def(
"string_view8_return", []() {
return std::u8string_view(u8
"utf8 secret \U0001f382"); });
216 m.def(
"string_view8_str", []() {
return py::str{std::u8string_view{u8
"abc β½ def"}}; });
219 struct TypeWithBothOperatorStringAndStringView {
221 operator std::string()
const {
return "success"; }
223 operator std::string_view()
const {
return "failure"; }
225 m.def(
"bytes_from_type_with_both_operator_string_and_string_view",
226 []() {
return py::bytes(TypeWithBothOperatorStringAndStringView()); });
227 m.def(
"str_from_type_with_both_operator_string_and_string_view",
228 []() {
return py::str(TypeWithBothOperatorStringAndStringView()); });
238 m.def(
"int_passthrough", [](
int arg) {
return arg; });
240 "int_passthrough_noconvert", [](
int arg) {
return arg; },
py::arg{}.noconvert());
245 [](
const std::pair<bool, std::string> &input) {
246 return std::make_pair(input.second, input.first);
248 "Return a pair in reversed order");
251 [](std::tuple<bool, std::string, int> input) {
252 return std::make_tuple(std::get<2>(input), std::get<1>(input), std::get<0>(input));
254 "Return a triple in reversed order");
255 m.def(
"empty_tuple", []() {
return std::tuple<>(); });
256 static std::pair<RValueCaster, RValueCaster> lvpair;
257 static std::tuple<RValueCaster, RValueCaster, RValueCaster> lvtuple;
258 static std::pair<RValueCaster, std::tuple<RValueCaster, std::pair<RValueCaster, RValueCaster>>>
261 m.def(
"lvalue_pair", []() ->
const decltype(lvpair) & {
return lvpair; });
262 m.def(
"rvalue_tuple",
264 m.def(
"lvalue_tuple", []() ->
const decltype(lvtuple) & {
return lvtuple; });
265 m.def(
"rvalue_nested", []() {
266 return std::make_pair(
270 m.def(
"lvalue_nested", []() ->
const decltype(lvnested) & {
return lvnested; });
276 static auto *int_string_pair =
new std::pair<int, std::string>{2,
"items"};
277 return int_string_pair;
279 py::return_value_policy::reference);
282 m.def(
"return_none_string", []() -> std::string * {
return nullptr; });
283 m.def(
"return_none_char", []() ->
const char * {
return nullptr; });
284 m.def(
"return_none_bool", []() ->
bool * {
return nullptr; });
285 m.def(
"return_none_int", []() ->
int * {
return nullptr; });
286 m.def(
"return_none_float", []() ->
float * {
return nullptr; });
287 m.def(
"return_none_pair", []() -> std::pair<int, int> * {
return nullptr; });
290 m.def(
"defer_none_cstring", [](
char *) {
return false; });
291 m.def(
"defer_none_cstring", [](
const py::none &) {
return true; });
292 m.def(
"defer_none_custom", [](UserType *) {
return false; });
293 m.def(
"defer_none_custom", [](
const py::none &) {
return true; });
294 m.def(
"nodefer_none_void", [](
void *) {
return true; });
295 m.def(
"nodefer_none_void", [](
const py::none &) {
return false; });
298 m.def(
"load_nullptr_t", [](std::nullptr_t) {});
299 m.def(
"cast_nullptr_t", []() {
return std::nullptr_t{}; });
304 m.def(
"bool_passthrough", [](
bool arg) {
return arg; });
306 "bool_passthrough_noconvert", [](
bool arg) {
return arg; },
py::arg{}.noconvert());
309 #if !defined(__INTEL_COMPILER)
315 "bool_passthrough_noconvert2", [](
bool arg) {
return arg; },
py::arg().noconvert());
319 m.def(
"refwrap_builtin", [](std::reference_wrapper<int>
p) {
return 10 *
p.get(); });
320 m.def(
"refwrap_usertype", [](std::reference_wrapper<UserType>
p) {
return p.get().value(); });
321 m.def(
"refwrap_usertype_const",
322 [](std::reference_wrapper<const UserType>
p) {
return p.get().value(); });
324 m.def(
"refwrap_lvalue", []() -> std::reference_wrapper<UserType> {
325 static UserType
x(1);
328 m.def(
"refwrap_lvalue_const", []() -> std::reference_wrapper<const UserType> {
329 static UserType
x(1);
340 static IncType
x1(1),
x2(2);
350 m.def(
"refwrap_iiw", [](
const IncType &
w) {
return w.value(); });
351 m.def(
"refwrap_call_iiw", [](IncType &
w,
const py::function &
f) {
354 l.append(
f(std::cref(
w)));
355 IncType
x(
w.value());
357 IncType
y(
w.value());
364 m.def(
"complex_cast", [](
float x) {
return "{}"_s.format(
x); });
365 m.def(
"complex_cast",
366 [](std::complex<float>
x) {
return "({}, {})"_s.format(
x.real(),
x.imag()); });
369 m.def(
"int_cast", []() {
return (
int) 42; });
370 m.def(
"long_cast", []() {
return (
long) 42; });
371 m.def(
"longlong_cast", []() {
return ULLONG_MAX; });
374 m.def(
"test_void_caster", []() ->
bool {
375 void *
v = (
void *) 0xabcd;
377 return py::cast<void *>(o) ==
v;
385 m.def(
"takes_ref_wrap", [](std::reference_wrapper<ConstRefCasted>
x) {
return x.get().tag; });
388 m.def(
"takes_const_ref_wrap",
389 [](std::reference_wrapper<const ConstRefCasted>
x) {
return x.get().tag; });