Dean Moldovan | 83e328f | 2017-06-09 00:44:49 +0200 | [diff] [blame] | 1 | /* |
| 2 | tests/test_builtin_casters.cpp -- Casters available without any additional headers |
| 3 | |
| 4 | Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch> |
| 5 | |
| 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. |
| 8 | */ |
| 9 | |
| 10 | #include "pybind11_tests.h" |
| 11 | #include <pybind11/complex.h> |
| 12 | |
| 13 | #if defined(_MSC_VER) |
| 14 | # pragma warning(push) |
| 15 | # pragma warning(disable: 4127) // warning C4127: Conditional expression is constant |
| 16 | #endif |
| 17 | |
| 18 | TEST_SUBMODULE(builtin_casters, m) { |
| 19 | // test_simple_string |
| 20 | m.def("string_roundtrip", [](const char *s) { return s; }); |
| 21 | |
| 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; |
| 26 | std::wstring wstr; |
| 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 |
| 32 | |
| 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; }); |
| 49 | |
| 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; }); |
| 56 | |
| 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(); }); |
| 60 | |
| 61 | // test_string_view |
| 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"); }); |
| 73 | #endif |
| 74 | |
Jason Rhinelander | 259b2fa | 2017-07-01 16:31:49 -0400 | [diff] [blame] | 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); }); |
| 80 | |
Dean Moldovan | 83e328f | 2017-06-09 00:44:49 +0200 | [diff] [blame] | 81 | // test_tuple |
| 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 | |
| 89 | |
| 90 | // test_builtins_cast_return_none |
| 91 | m.def("return_none_string", []() -> std::string * { return nullptr; }); |
| 92 | m.def("return_none_char", []() -> const char * { return nullptr; }); |
| 93 | m.def("return_none_bool", []() -> bool * { return nullptr; }); |
| 94 | m.def("return_none_int", []() -> int * { return nullptr; }); |
| 95 | m.def("return_none_float", []() -> float * { return nullptr; }); |
| 96 | |
| 97 | // test_none_deferred |
| 98 | m.def("defer_none_cstring", [](char *) { return false; }); |
| 99 | m.def("defer_none_cstring", [](py::none) { return true; }); |
| 100 | m.def("defer_none_custom", [](UserType *) { return false; }); |
| 101 | m.def("defer_none_custom", [](py::none) { return true; }); |
| 102 | m.def("nodefer_none_void", [](void *) { return true; }); |
| 103 | m.def("nodefer_none_void", [](py::none) { return false; }); |
| 104 | |
| 105 | // test_void_caster |
| 106 | m.def("load_nullptr_t", [](std::nullptr_t) {}); // not useful, but it should still compile |
| 107 | m.def("cast_nullptr_t", []() { return std::nullptr_t{}; }); |
| 108 | |
| 109 | // test_reference_wrapper |
| 110 | m.def("refwrap_builtin", [](std::reference_wrapper<int> p) { return 10 * p.get(); }); |
| 111 | m.def("refwrap_usertype", [](std::reference_wrapper<UserType> p) { return p.get().value(); }); |
| 112 | // Not currently supported (std::pair caster has return-by-value cast operator); |
| 113 | // triggers static_assert failure. |
| 114 | //m.def("refwrap_pair", [](std::reference_wrapper<std::pair<int, int>>) { }); |
| 115 | |
| 116 | m.def("refwrap_list", [](bool copy) { |
| 117 | static IncType x1(1), x2(2); |
| 118 | py::list l; |
| 119 | for (auto &f : {std::ref(x1), std::ref(x2)}) { |
| 120 | l.append(py::cast(f, copy ? py::return_value_policy::copy |
| 121 | : py::return_value_policy::reference)); |
| 122 | } |
| 123 | return l; |
| 124 | }, "copy"_a); |
| 125 | |
| 126 | m.def("refwrap_iiw", [](const IncType &w) { return w.value(); }); |
| 127 | m.def("refwrap_call_iiw", [](IncType &w, py::function f) { |
| 128 | py::list l; |
| 129 | l.append(f(std::ref(w))); |
| 130 | l.append(f(std::cref(w))); |
| 131 | IncType x(w.value()); |
| 132 | l.append(f(std::ref(x))); |
| 133 | IncType y(w.value()); |
| 134 | auto r3 = std::ref(y); |
| 135 | l.append(f(r3)); |
| 136 | return l; |
| 137 | }); |
| 138 | |
| 139 | // test_complex |
| 140 | m.def("complex_cast", [](float x) { return "{}"_s.format(x); }); |
| 141 | m.def("complex_cast", [](std::complex<float> x) { return "({}, {})"_s.format(x.real(), x.imag()); }); |
| 142 | } |