test_builtin_casters.py 13.8 KB
Newer Older
1
# -*- coding: utf-8 -*-
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pytest

from pybind11_tests import builtin_casters as m
from pybind11_tests import UserType, IncType


def test_simple_string():
    assert m.string_roundtrip("const char *") == "const char *"


def test_unicode_conversion():
    """Tests unicode conversion and error reporting."""
    assert m.good_utf8_string() == u"Say utf8‽ 🎂 𝐀"
    assert m.good_utf16_string() == u"b‽🎂𝐀z"
    assert m.good_utf32_string() == u"a𝐀🎂‽z"
    assert m.good_wchar_string() == u"a⸘𝐀z"
18
19
    if hasattr(m, "has_u8string"):
        assert m.good_utf8_u8string() == u"Say utf8‽ 🎂 𝐀"
20
21
22
23
24
25
26
27
28
29
30
31
32
33

    with pytest.raises(UnicodeDecodeError):
        m.bad_utf8_string()

    with pytest.raises(UnicodeDecodeError):
        m.bad_utf16_string()

    # These are provided only if they actually fail (they don't when 32-bit and under Python 2.7)
    if hasattr(m, "bad_utf32_string"):
        with pytest.raises(UnicodeDecodeError):
            m.bad_utf32_string()
    if hasattr(m, "bad_wchar_string"):
        with pytest.raises(UnicodeDecodeError):
            m.bad_wchar_string()
34
35
36
    if hasattr(m, "has_u8string"):
        with pytest.raises(UnicodeDecodeError):
            m.bad_utf8_u8string()
37
38
39
40
41
42

    assert m.u8_Z() == 'Z'
    assert m.u8_eacute() == u'é'
    assert m.u16_ibang() == u'‽'
    assert m.u32_mathbfA() == u'𝐀'
    assert m.wchar_heart() == u'♥'
43
44
    if hasattr(m, "has_u8string"):
        assert m.u8_char8_Z() == 'Z'
45
46
47
48
49
50
51
52
53


def test_single_char_arguments():
    """Tests failures for passing invalid inputs to char-accepting functions"""
    def toobig_message(r):
        return "Character code point not in range({0:#x})".format(r)
    toolong_message = "Expected a character, but multi-character string found"

    assert m.ord_char(u'a') == 0x61  # simple ASCII
54
    assert m.ord_char_lv(u'b') == 0x62
55
56
57
58
59
60
61
62
63
64
    assert m.ord_char(u'é') == 0xE9  # requires 2 bytes in utf-8, but can be stuffed in a char
    with pytest.raises(ValueError) as excinfo:
        assert m.ord_char(u'Ā') == 0x100  # requires 2 bytes, doesn't fit in a char
    assert str(excinfo.value) == toobig_message(0x100)
    with pytest.raises(ValueError) as excinfo:
        assert m.ord_char(u'ab')
    assert str(excinfo.value) == toolong_message

    assert m.ord_char16(u'a') == 0x61
    assert m.ord_char16(u'é') == 0xE9
65
    assert m.ord_char16_lv(u'ê') == 0xEA
66
67
68
    assert m.ord_char16(u'Ā') == 0x100
    assert m.ord_char16(u'‽') == 0x203d
    assert m.ord_char16(u'♥') == 0x2665
69
    assert m.ord_char16_lv(u'♡') == 0x2661
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
    with pytest.raises(ValueError) as excinfo:
        assert m.ord_char16(u'🎂') == 0x1F382  # requires surrogate pair
    assert str(excinfo.value) == toobig_message(0x10000)
    with pytest.raises(ValueError) as excinfo:
        assert m.ord_char16(u'aa')
    assert str(excinfo.value) == toolong_message

    assert m.ord_char32(u'a') == 0x61
    assert m.ord_char32(u'é') == 0xE9
    assert m.ord_char32(u'Ā') == 0x100
    assert m.ord_char32(u'‽') == 0x203d
    assert m.ord_char32(u'♥') == 0x2665
    assert m.ord_char32(u'🎂') == 0x1F382
    with pytest.raises(ValueError) as excinfo:
        assert m.ord_char32(u'aa')
    assert str(excinfo.value) == toolong_message

    assert m.ord_wchar(u'a') == 0x61
    assert m.ord_wchar(u'é') == 0xE9
    assert m.ord_wchar(u'Ā') == 0x100
    assert m.ord_wchar(u'‽') == 0x203d
    assert m.ord_wchar(u'♥') == 0x2665
    if m.wchar_size == 2:
        with pytest.raises(ValueError) as excinfo:
            assert m.ord_wchar(u'🎂') == 0x1F382  # requires surrogate pair
        assert str(excinfo.value) == toobig_message(0x10000)
    else:
        assert m.ord_wchar(u'🎂') == 0x1F382
    with pytest.raises(ValueError) as excinfo:
        assert m.ord_wchar(u'aa')
    assert str(excinfo.value) == toolong_message

102
103
104
105
106
107
108
109
110
111
112
    if hasattr(m, "has_u8string"):
        assert m.ord_char8(u'a') == 0x61  # simple ASCII
        assert m.ord_char8_lv(u'b') == 0x62
        assert m.ord_char8(u'é') == 0xE9  # requires 2 bytes in utf-8, but can be stuffed in a char
        with pytest.raises(ValueError) as excinfo:
            assert m.ord_char8(u'Ā') == 0x100  # requires 2 bytes, doesn't fit in a char
        assert str(excinfo.value) == toobig_message(0x100)
        with pytest.raises(ValueError) as excinfo:
            assert m.ord_char8(u'ab')
        assert str(excinfo.value) == toolong_message

113
114
115
116
117
118

def test_bytes_to_string():
    """Tests the ability to pass bytes to C++ string-accepting functions.  Note that this is
    one-way: the only way to return bytes to Python is via the pybind11::bytes class."""
    # Issue #816

119
120
121
122
123
124
125
126
127
128
129
130
    def to_bytes(s):
        if pytest.PY2:
            b = s
        else:
            b = s.encode("utf8")
        assert isinstance(b, bytes)
        return b

    assert m.strlen(to_bytes("hi")) == 2
    assert m.string_length(to_bytes("world")) == 5
    assert m.string_length(to_bytes("a\x00b")) == 3
    assert m.strlen(to_bytes("a\x00b")) == 1  # C-string limitation
131
132
133
134
135
136
137
138
139
140

    # passing in a utf8 encoded string should work
    assert m.string_length(u'💩'.encode("utf8")) == 4


@pytest.mark.skipif(not hasattr(m, "has_string_view"), reason="no <string_view>")
def test_string_view(capture):
    """Tests support for C++17 string_view arguments and return values"""
    assert m.string_view_chars("Hi") == [72, 105]
    assert m.string_view_chars("Hi 🎂") == [72, 105, 32, 0xf0, 0x9f, 0x8e, 0x82]
141
142
    assert m.string_view16_chars(u"Hi 🎂") == [72, 105, 32, 0xd83c, 0xdf82]
    assert m.string_view32_chars(u"Hi 🎂") == [72, 105, 32, 127874]
143
144
    if hasattr(m, "has_u8string"):
        assert m.string_view8_chars("Hi") == [72, 105]
145
        assert m.string_view8_chars(u"Hi 🎂") == [72, 105, 32, 0xf0, 0x9f, 0x8e, 0x82]
146

147
148
149
    assert m.string_view_return() == u"utf8 secret 🎂"
    assert m.string_view16_return() == u"utf16 secret 🎂"
    assert m.string_view32_return() == u"utf32 secret 🎂"
150
    if hasattr(m, "has_u8string"):
151
        assert m.string_view8_return() == u"utf8 secret 🎂"
152
153
154
155

    with capture:
        m.string_view_print("Hi")
        m.string_view_print("utf8 🎂")
156
157
158
        m.string_view16_print(u"utf16 🎂")
        m.string_view32_print(u"utf32 🎂")
    assert capture == u"""
159
160
161
162
163
        Hi 2
        utf8 🎂 9
        utf16 🎂 8
        utf32 🎂 7
    """
164
165
166
    if hasattr(m, "has_u8string"):
        with capture:
            m.string_view8_print("Hi")
167
168
            m.string_view8_print(u"utf8 🎂")
        assert capture == u"""
169
170
171
            Hi 2
            utf8 🎂 9
        """
172
173
174
175

    with capture:
        m.string_view_print("Hi, ascii")
        m.string_view_print("Hi, utf8 🎂")
176
177
178
        m.string_view16_print(u"Hi, utf16 🎂")
        m.string_view32_print(u"Hi, utf32 🎂")
    assert capture == u"""
179
180
181
182
183
        Hi, ascii 9
        Hi, utf8 🎂 13
        Hi, utf16 🎂 12
        Hi, utf32 🎂 11
    """
184
185
186
    if hasattr(m, "has_u8string"):
        with capture:
            m.string_view8_print("Hi, ascii")
187
188
            m.string_view8_print(u"Hi, utf8 🎂")
        assert capture == u"""
189
190
191
            Hi, ascii 9
            Hi, utf8 🎂 13
        """
192
193


194
195
196
197
198
199
def test_integer_casting():
    """Issue #929 - out-of-range integer values shouldn't be accepted"""
    assert m.i32_str(-1) == "-1"
    assert m.i64_str(-1) == "-1"
    assert m.i32_str(2000000000) == "2000000000"
    assert m.u32_str(2000000000) == "2000000000"
200
    if pytest.PY2:
201
202
203
204
        assert m.i32_str(long(-1)) == "-1"  # noqa: F821 undefined name 'long'
        assert m.i64_str(long(-1)) == "-1"  # noqa: F821 undefined name 'long'
        assert m.i64_str(long(-999999999999)) == "-999999999999"  # noqa: F821 undefined name
        assert m.u64_str(long(999999999999)) == "999999999999"  # noqa: F821 undefined name 'long'
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
    else:
        assert m.i64_str(-999999999999) == "-999999999999"
        assert m.u64_str(999999999999) == "999999999999"

    with pytest.raises(TypeError) as excinfo:
        m.u32_str(-1)
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
        m.u64_str(-1)
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
        m.i32_str(-3000000000)
    assert "incompatible function arguments" in str(excinfo.value)
    with pytest.raises(TypeError) as excinfo:
        m.i32_str(3000000000)
    assert "incompatible function arguments" in str(excinfo.value)

222
    if pytest.PY2:
223
        with pytest.raises(TypeError) as excinfo:
224
            m.u32_str(long(-1))  # noqa: F821 undefined name 'long'
225
226
        assert "incompatible function arguments" in str(excinfo.value)
        with pytest.raises(TypeError) as excinfo:
227
            m.u64_str(long(-1))  # noqa: F821 undefined name 'long'
228
229
230
        assert "incompatible function arguments" in str(excinfo.value)


231
232
233
234
235
236
237
def test_tuple(doc):
    """std::pair <-> tuple & std::tuple <-> tuple"""
    assert m.pair_passthrough((True, "test")) == ("test", True)
    assert m.tuple_passthrough((True, "test", 5)) == (5, "test", True)
    # Any sequence can be cast to a std::pair or std::tuple
    assert m.pair_passthrough([True, "test"]) == ("test", True)
    assert m.tuple_passthrough([True, "test", 5]) == (5, "test", True)
238
    assert m.empty_tuple() == ()
239
240
241
242
243
244
245
246
247
248
249
250

    assert doc(m.pair_passthrough) == """
        pair_passthrough(arg0: Tuple[bool, str]) -> Tuple[str, bool]

        Return a pair in reversed order
    """
    assert doc(m.tuple_passthrough) == """
        tuple_passthrough(arg0: Tuple[bool, str, int]) -> Tuple[int, str, bool]

        Return a triple in reversed order
    """

251
252
253
254
255
256
257
    assert m.rvalue_pair() == ("rvalue", "rvalue")
    assert m.lvalue_pair() == ("lvalue", "lvalue")
    assert m.rvalue_tuple() == ("rvalue", "rvalue", "rvalue")
    assert m.lvalue_tuple() == ("lvalue", "lvalue", "lvalue")
    assert m.rvalue_nested() == ("rvalue", ("rvalue", ("rvalue", "rvalue")))
    assert m.lvalue_nested() == ("lvalue", ("lvalue", ("lvalue", "lvalue")))

258
259
    assert m.int_string_pair() == (2, "items")

260
261
262
263
264
265
266
267

def test_builtins_cast_return_none():
    """Casters produced with PYBIND11_TYPE_CASTER() should convert nullptr to None"""
    assert m.return_none_string() is None
    assert m.return_none_char() is None
    assert m.return_none_bool() is None
    assert m.return_none_int() is None
    assert m.return_none_float() is None
268
    assert m.return_none_pair() is None
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317


def test_none_deferred():
    """None passed as various argument types should defer to other overloads"""
    assert not m.defer_none_cstring("abc")
    assert m.defer_none_cstring(None)
    assert not m.defer_none_custom(UserType())
    assert m.defer_none_custom(None)
    assert m.nodefer_none_void(None)


def test_void_caster():
    assert m.load_nullptr_t(None) is None
    assert m.cast_nullptr_t() is None


def test_reference_wrapper():
    """std::reference_wrapper for builtin and user types"""
    assert m.refwrap_builtin(42) == 420
    assert m.refwrap_usertype(UserType(42)) == 42

    with pytest.raises(TypeError) as excinfo:
        m.refwrap_builtin(None)
    assert "incompatible function arguments" in str(excinfo.value)

    with pytest.raises(TypeError) as excinfo:
        m.refwrap_usertype(None)
    assert "incompatible function arguments" in str(excinfo.value)

    a1 = m.refwrap_list(copy=True)
    a2 = m.refwrap_list(copy=True)
    assert [x.value for x in a1] == [2, 3]
    assert [x.value for x in a2] == [2, 3]
    assert not a1[0] is a2[0] and not a1[1] is a2[1]

    b1 = m.refwrap_list(copy=False)
    b2 = m.refwrap_list(copy=False)
    assert [x.value for x in b1] == [1, 2]
    assert [x.value for x in b2] == [1, 2]
    assert b1[0] is b2[0] and b1[1] is b2[1]

    assert m.refwrap_iiw(IncType(5)) == 5
    assert m.refwrap_call_iiw(IncType(10), m.refwrap_iiw) == [10, 10, 10, 10]


def test_complex_cast():
    """std::complex casts"""
    assert m.complex_cast(1) == "1.0"
    assert m.complex_cast(2j) == "(0.0, 2.0)"
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367


def test_bool_caster():
    """Test bool caster implicit conversions."""
    convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert

    def require_implicit(v):
        pytest.raises(TypeError, noconvert, v)

    def cant_convert(v):
        pytest.raises(TypeError, convert, v)

    # straight up bool
    assert convert(True) is True
    assert convert(False) is False
    assert noconvert(True) is True
    assert noconvert(False) is False

    # None requires implicit conversion
    require_implicit(None)
    assert convert(None) is False

    class A(object):
        def __init__(self, x):
            self.x = x

        def __nonzero__(self):
            return self.x

        def __bool__(self):
            return self.x

    class B(object):
        pass

    # Arbitrary objects are not accepted
    cant_convert(object())
    cant_convert(B())

    # Objects with __nonzero__ / __bool__ defined can be converted
    require_implicit(A(True))
    assert convert(A(True)) is True
    assert convert(A(False)) is False


@pytest.requires_numpy
def test_numpy_bool():
    import numpy as np
    convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert

368
369
370
    def cant_convert(v):
        pytest.raises(TypeError, convert, v)

371
372
373
374
375
    # np.bool_ is not considered implicit
    assert convert(np.bool_(True)) is True
    assert convert(np.bool_(False)) is False
    assert noconvert(np.bool_(True)) is True
    assert noconvert(np.bool_(False)) is False
376
    cant_convert(np.zeros(2, dtype='int'))
377
378
379
380
381
382
383
384
385
386
387
388
389


def test_int_long():
    """In Python 2, a C++ int should return a Python int rather than long
    if possible: longs are not always accepted where ints are used (such
    as the argument to sys.exit()). A C++ long long is always a Python
    long."""

    import sys
    must_be_long = type(getattr(sys, 'maxint', 1) + 1)
    assert isinstance(m.int_cast(), int)
    assert isinstance(m.long_cast(), int)
    assert isinstance(m.longlong_cast(), must_be_long)
Wenzel Jakob's avatar
Wenzel Jakob committed
390
391
392
393


def test_void_caster_2():
    assert m.test_void_caster()