b73e96ea5781b5ab6ef262f260a20838c0978e05
2 tests/test_builtin_casters.cpp -- Casters available without any additional headers
4 Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
6 All rights reserved. Use of this source code is governed by a
7 BSD-style license that can be found in the LICENSE file.
10 #include "pybind11_tests.h"
11 #include <pybind11/complex.h>
14 # pragma warning(push)
15 # pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
18 TEST_SUBMODULE(builtin_casters
, m
) {
20 m
.def("string_roundtrip", [](const char *s
) { return s
; });
22 // test_unicode_conversion
23 // Some test characters in utf16 and utf32 encodings. The last one (the π) contains a null byte
24 char32_t a32
= 0x61 /*a*/, z32
= 0x7a /*z*/, ib32
= 0x203d /*β½*/, cake32
= 0x1f382 /*π*/, mathbfA32
= 0x1d400 /*π*/;
25 char16_t b16
= 0x62 /*b*/, z16
= 0x7a, ib16
= 0x203d, cake16_1
= 0xd83c, cake16_2
= 0xdf82, mathbfA16_1
= 0xd835, mathbfA16_2
= 0xdc00;
27 wstr
.push_back(0x61); // a
28 wstr
.push_back(0x2e18); // βΈ
29 if (sizeof(wchar_t) == 2) { wstr
.push_back(mathbfA16_1
); wstr
.push_back(mathbfA16_2
); } // π, utf16
30 else { wstr
.push_back((wchar_t) mathbfA32
); } // π, utf32
31 wstr
.push_back(0x7a); // z
33 m
.def("good_utf8_string", []() { return std::string(u8
"Say utf8\u203d \U0001f382 \U0001d400"); }); // Say utf8β½ π π
34 m
.def("good_utf16_string", [=]() { return std::u16string({ b16
, ib16
, cake16_1
, cake16_2
, mathbfA16_1
, mathbfA16_2
, z16
}); }); // bβ½ππz
35 m
.def("good_utf32_string", [=]() { return std::u32string({ a32
, mathbfA32
, cake32
, ib32
, z32
}); }); // aππβ½z
36 m
.def("good_wchar_string", [=]() { return wstr
; }); // aβ½πz
37 m
.def("bad_utf8_string", []() { return std::string("abc\xd0" "def"); });
38 m
.def("bad_utf16_string", [=]() { return std::u16string({ b16
, char16_t(0xd800), z16
}); });
39 // Under Python 2.7, invalid unicode UTF-32 characters don't appear to trigger UnicodeDecodeError
40 if (PY_MAJOR_VERSION
>= 3)
41 m
.def("bad_utf32_string", [=]() { return std::u32string({ a32
, char32_t(0xd800), z32
}); });
42 if (PY_MAJOR_VERSION
>= 3 || sizeof(wchar_t) == 2)
43 m
.def("bad_wchar_string", [=]() { return std::wstring({ wchar_t(0x61), wchar_t(0xd800) }); });
44 m
.def("u8_Z", []() -> char { return 'Z'; });
45 m
.def("u8_eacute", []() -> char { return '\xe9'; });
46 m
.def("u16_ibang", [=]() -> char16_t
{ return ib16
; });
47 m
.def("u32_mathbfA", [=]() -> char32_t
{ return mathbfA32
; });
48 m
.def("wchar_heart", []() -> wchar_t { return 0x2665; });
50 // test_single_char_arguments
51 m
.attr("wchar_size") = py::cast(sizeof(wchar_t));
52 m
.def("ord_char", [](char c
) -> int { return static_cast<unsigned char>(c
); });
53 m
.def("ord_char16", [](char16_t c
) -> uint16_t { return c
; });
54 m
.def("ord_char32", [](char32_t c
) -> uint32_t { return c
; });
55 m
.def("ord_wchar", [](wchar_t c
) -> int { return c
; });
57 // test_bytes_to_string
58 m
.def("strlen", [](char *s
) { return strlen(s
); });
59 m
.def("string_length", [](std::string s
) { return s
.length(); });
62 #ifdef PYBIND11_HAS_STRING_VIEW
63 m
.attr("has_string_view") = true;
64 m
.def("string_view_print", [](std::string_view s
) { py::print(s
, s
.size()); });
65 m
.def("string_view16_print", [](std::u16string_view s
) { py::print(s
, s
.size()); });
66 m
.def("string_view32_print", [](std::u32string_view s
) { py::print(s
, s
.size()); });
67 m
.def("string_view_chars", [](std::string_view s
) { py::list l
; for (auto c
: s
) l
.append((std::uint8_t) c
); return l
; });
68 m
.def("string_view16_chars", [](std::u16string_view s
) { py::list l
; for (auto c
: s
) l
.append((int) c
); return l
; });
69 m
.def("string_view32_chars", [](std::u32string_view s
) { py::list l
; for (auto c
: s
) l
.append((int) c
); return l
; });
70 m
.def("string_view_return", []() { return std::string_view(u8
"utf8 secret \U0001f382"); });
71 m
.def("string_view16_return", []() { return std::u16string_view(u
"utf16 secret \U0001f382"); });
72 m
.def("string_view32_return", []() { return std::u32string_view(U
"utf32 secret \U0001f382"); });
75 // test_integer_casting
76 m
.def("i32_str", [](std::int32_t v
) { return std::to_string(v
); });
77 m
.def("u32_str", [](std::uint32_t v
) { return std::to_string(v
); });
78 m
.def("i64_str", [](std::int64_t v
) { return std::to_string(v
); });
79 m
.def("u64_str", [](std::uint64_t v
) { return std::to_string(v
); });
82 m
.def("pair_passthrough", [](std::pair
<bool, std::string
> input
) {
83 return std::make_pair(input
.second
, input
.first
);
84 }, "Return a pair in reversed order");
85 m
.def("tuple_passthrough", [](std::tuple
<bool, std::string
, int> input
) {
86 return std::make_tuple(std::get
<2>(input
), std::get
<1>(input
), std::get
<0>(input
));
87 }, "Return a triple in reversed order");
88 m
.def("empty_tuple", []() { return std::tuple
<>(); });
89 static std::pair
<RValueCaster
, RValueCaster
> lvpair
;
90 static std::tuple
<RValueCaster
, RValueCaster
, RValueCaster
> lvtuple
;
91 static std::pair
<RValueCaster
, std::tuple
<RValueCaster
, std::pair
<RValueCaster
, RValueCaster
>>> lvnested
;
92 m
.def("rvalue_pair", []() { return std::make_pair(RValueCaster
{}, RValueCaster
{}); });
93 m
.def("lvalue_pair", []() -> const decltype(lvpair
) & { return lvpair
; });
94 m
.def("rvalue_tuple", []() { return std::make_tuple(RValueCaster
{}, RValueCaster
{}, RValueCaster
{}); });
95 m
.def("lvalue_tuple", []() -> const decltype(lvtuple
) & { return lvtuple
; });
96 m
.def("rvalue_nested", []() {
97 return std::make_pair(RValueCaster
{}, std::make_tuple(RValueCaster
{}, std::make_pair(RValueCaster
{}, RValueCaster
{}))); });
98 m
.def("lvalue_nested", []() -> const decltype(lvnested
) & { return lvnested
; });
100 // test_builtins_cast_return_none
101 m
.def("return_none_string", []() -> std::string
* { return nullptr; });
102 m
.def("return_none_char", []() -> const char * { return nullptr; });
103 m
.def("return_none_bool", []() -> bool * { return nullptr; });
104 m
.def("return_none_int", []() -> int * { return nullptr; });
105 m
.def("return_none_float", []() -> float * { return nullptr; });
107 // test_none_deferred
108 m
.def("defer_none_cstring", [](char *) { return false; });
109 m
.def("defer_none_cstring", [](py::none
) { return true; });
110 m
.def("defer_none_custom", [](UserType
*) { return false; });
111 m
.def("defer_none_custom", [](py::none
) { return true; });
112 m
.def("nodefer_none_void", [](void *) { return true; });
113 m
.def("nodefer_none_void", [](py::none
) { return false; });
116 m
.def("load_nullptr_t", [](std::nullptr_t
) {}); // not useful, but it should still compile
117 m
.def("cast_nullptr_t", []() { return std::nullptr_t
{}; });
120 m
.def("bool_passthrough", [](bool arg
) { return arg
; });
121 m
.def("bool_passthrough_noconvert", [](bool arg
) { return arg
; }, py::arg().noconvert());
123 // test_reference_wrapper
124 m
.def("refwrap_builtin", [](std::reference_wrapper
<int> p
) { return 10 * p
.get(); });
125 m
.def("refwrap_usertype", [](std::reference_wrapper
<UserType
> p
) { return p
.get().value(); });
126 // Not currently supported (std::pair caster has return-by-value cast operator);
127 // triggers static_assert failure.
128 //m.def("refwrap_pair", [](std::reference_wrapper<std::pair<int, int>>) { });
130 m
.def("refwrap_list", [](bool copy
) {
131 static IncType
x1(1), x2(2);
133 for (auto &f
: {std::ref(x1
), std::ref(x2
)}) {
134 l
.append(py::cast(f
, copy
? py::return_value_policy::copy
135 : py::return_value_policy::reference
));
140 m
.def("refwrap_iiw", [](const IncType
&w
) { return w
.value(); });
141 m
.def("refwrap_call_iiw", [](IncType
&w
, py::function f
) {
143 l
.append(f(std::ref(w
)));
144 l
.append(f(std::cref(w
)));
145 IncType
x(w
.value());
146 l
.append(f(std::ref(x
)));
147 IncType
y(w
.value());
148 auto r3
= std::ref(y
);
154 m
.def("complex_cast", [](float x
) { return "{}"_s
.format(x
); });
155 m
.def("complex_cast", [](std::complex<float> x
) { return "({}, {})"_s
.format(x
.real(), x
.imag()); });