test_builtin_casters.py 17.4 KB
Newer Older
1
# -*- coding: utf-8 -*-
2
3
import pytest

4
import env
5
from pybind11_tests import IncType, UserType
6
7
8
9
10
11
12
13
14
15
16
17
18
from pybind11_tests import builtin_casters as m


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"
19
20
    if hasattr(m, "has_u8string"):
        assert m.good_utf8_u8string() == u"Say utf8‽ 🎂 𝐀"
21
22
23
24
25
26
27
28
29
30
31
32
33
34

    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()
35
36
37
    if hasattr(m, "has_u8string"):
        with pytest.raises(UnicodeDecodeError):
            m.bad_utf8_u8string()
38

39
40
41
42
43
    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"♥"
44
    if hasattr(m, "has_u8string"):
45
        assert m.u8_char8_Z() == "Z"
46
47
48
49


def test_single_char_arguments():
    """Tests failures for passing invalid inputs to char-accepting functions"""
50

51
    def toobig_message(r):
52
        return "Character code point not in range({:#x})".format(r)
53

54
55
    toolong_message = "Expected a character, but multi-character string found"

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

68
69
70
71
72
73
74
    assert m.ord_char16(u"a") == 0x61
    assert m.ord_char16(u"é") == 0xE9
    assert m.ord_char16_lv(u"ê") == 0xEA
    assert m.ord_char16(u"Ā") == 0x100
    assert m.ord_char16(u"‽") == 0x203D
    assert m.ord_char16(u"♥") == 0x2665
    assert m.ord_char16_lv(u"♡") == 0x2661
75
    with pytest.raises(ValueError) as excinfo:
76
        assert m.ord_char16(u"🎂") == 0x1F382  # requires surrogate pair
77
78
    assert str(excinfo.value) == toobig_message(0x10000)
    with pytest.raises(ValueError) as excinfo:
79
        assert m.ord_char16(u"aa")
80
81
    assert str(excinfo.value) == toolong_message

82
83
84
85
86
87
    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
88
    with pytest.raises(ValueError) as excinfo:
89
        assert m.ord_char32(u"aa")
90
91
    assert str(excinfo.value) == toolong_message

92
93
94
95
96
    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
97
98
    if m.wchar_size == 2:
        with pytest.raises(ValueError) as excinfo:
99
            assert m.ord_wchar(u"🎂") == 0x1F382  # requires surrogate pair
100
101
        assert str(excinfo.value) == toobig_message(0x10000)
    else:
102
        assert m.ord_wchar(u"🎂") == 0x1F382
103
    with pytest.raises(ValueError) as excinfo:
104
        assert m.ord_wchar(u"aa")
105
106
    assert str(excinfo.value) == toolong_message

107
    if hasattr(m, "has_u8string"):
108
109
110
111
112
        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
113
        with pytest.raises(ValueError) as excinfo:
114
            assert m.ord_char8(u"Ā") == 0x100  # requires 2 bytes, doesn't fit in a char
115
116
        assert str(excinfo.value) == toobig_message(0x100)
        with pytest.raises(ValueError) as excinfo:
117
            assert m.ord_char8(u"ab")
118
119
        assert str(excinfo.value) == toolong_message

120
121
122
123
124
125

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

126
    def to_bytes(s):
127
        b = s if env.PY2 else s.encode("utf8")
128
129
130
131
132
133
134
        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
135
136

    # passing in a utf8 encoded string should work
137
    assert m.string_length(u"💩".encode("utf8")) == 4
138
139
140
141
142
143


@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]
144
145
    assert m.string_view_chars("Hi 🎂") == [72, 105, 32, 0xF0, 0x9F, 0x8E, 0x82]
    assert m.string_view16_chars(u"Hi 🎂") == [72, 105, 32, 0xD83C, 0xDF82]
146
    assert m.string_view32_chars(u"Hi 🎂") == [72, 105, 32, 127874]
147
148
    if hasattr(m, "has_u8string"):
        assert m.string_view8_chars("Hi") == [72, 105]
149
        assert m.string_view8_chars(u"Hi 🎂") == [72, 105, 32, 0xF0, 0x9F, 0x8E, 0x82]
150

151
152
153
    assert m.string_view_return() == u"utf8 secret 🎂"
    assert m.string_view16_return() == u"utf16 secret 🎂"
    assert m.string_view32_return() == u"utf32 secret 🎂"
154
    if hasattr(m, "has_u8string"):
155
        assert m.string_view8_return() == u"utf8 secret 🎂"
156
157
158
159

    with capture:
        m.string_view_print("Hi")
        m.string_view_print("utf8 🎂")
160
161
        m.string_view16_print(u"utf16 🎂")
        m.string_view32_print(u"utf32 🎂")
162
163
164
    assert (
        capture
        == u"""
165
166
167
168
169
        Hi 2
        utf8 🎂 9
        utf16 🎂 8
        utf32 🎂 7
    """
170
    )
171
172
173
    if hasattr(m, "has_u8string"):
        with capture:
            m.string_view8_print("Hi")
174
            m.string_view8_print(u"utf8 🎂")
175
176
177
        assert (
            capture
            == u"""
178
179
180
            Hi 2
            utf8 🎂 9
        """
181
        )
182
183
184
185

    with capture:
        m.string_view_print("Hi, ascii")
        m.string_view_print("Hi, utf8 🎂")
186
187
        m.string_view16_print(u"Hi, utf16 🎂")
        m.string_view32_print(u"Hi, utf32 🎂")
188
189
190
    assert (
        capture
        == u"""
191
192
193
194
195
        Hi, ascii 9
        Hi, utf8 🎂 13
        Hi, utf16 🎂 12
        Hi, utf32 🎂 11
    """
196
    )
197
198
199
    if hasattr(m, "has_u8string"):
        with capture:
            m.string_view8_print("Hi, ascii")
200
            m.string_view8_print(u"Hi, utf8 🎂")
201
202
203
        assert (
            capture
            == u"""
204
205
206
            Hi, ascii 9
            Hi, utf8 🎂 13
        """
207
        )
208
209


210
211
212
213
214
215
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"
216
    if env.PY2:
217
218
        assert m.i32_str(long(-1)) == "-1"  # noqa: F821 undefined name 'long'
        assert m.i64_str(long(-1)) == "-1"  # noqa: F821 undefined name 'long'
219
220
221
222
223
224
225
226
        assert (
            m.i64_str(long(-999999999999))  # noqa: F821 undefined name 'long'
            == "-999999999999"
        )
        assert (
            m.u64_str(long(999999999999))  # noqa: F821 undefined name 'long'
            == "999999999999"
        )
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
    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)

244
    if env.PY2:
245
        with pytest.raises(TypeError) as excinfo:
246
            m.u32_str(long(-1))  # noqa: F821 undefined name 'long'
247
248
        assert "incompatible function arguments" in str(excinfo.value)
        with pytest.raises(TypeError) as excinfo:
249
            m.u64_str(long(-1))  # noqa: F821 undefined name 'long'
250
251
252
        assert "incompatible function arguments" in str(excinfo.value)


253
def test_int_convert():
254
    class Int(object):
255
256
257
        def __int__(self):
            return 42

258
    class NotInt(object):
259
260
        pass

261
    class Float(object):
262
263
264
        def __float__(self):
            return 41.99999

265
    class Index(object):
266
267
268
        def __index__(self):
            return 42

269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
    class IntAndIndex(object):
        def __int__(self):
            return 42

        def __index__(self):
            return 0

    class RaisingTypeErrorOnIndex(object):
        def __index__(self):
            raise TypeError

        def __int__(self):
            return 42

    class RaisingValueErrorOnIndex(object):
284
285
286
287
288
289
290
291
        def __index__(self):
            raise ValueError

        def __int__(self):
            return 42

    convert, noconvert = m.int_passthrough, m.int_passthrough_noconvert

292
    def requires_conversion(v):
293
294
295
296
297
298
299
300
        pytest.raises(TypeError, noconvert, v)

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

    assert convert(7) == 7
    assert noconvert(7) == 7
    cant_convert(3.14159)
301
    # TODO: Avoid DeprecationWarning in `PyLong_AsLong` (and similar)
302
303
    # TODO: PyPy 3.8 does not behave like CPython 3.8 here yet (7.3.7)
    if (3, 8) <= env.PY < (3, 10) and env.CPYTHON:
304
        with env.deprecated_call():
305
306
307
            assert convert(Int()) == 42
    else:
        assert convert(Int()) == 42
308
309
310
311
312
313
314
315
316
317
318
319
320
321
    requires_conversion(Int())
    cant_convert(NotInt())
    cant_convert(Float())

    # Before Python 3.8, `PyLong_AsLong` does not pick up on `obj.__index__`,
    # but pybind11 "backports" this behavior.
    assert convert(Index()) == 42
    assert noconvert(Index()) == 42
    assert convert(IntAndIndex()) == 0  # Fishy; `int(DoubleThought)` == 42
    assert noconvert(IntAndIndex()) == 0
    assert convert(RaisingTypeErrorOnIndex()) == 42
    requires_conversion(RaisingTypeErrorOnIndex())
    assert convert(RaisingValueErrorOnIndex()) == 42
    requires_conversion(RaisingValueErrorOnIndex())
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336


def test_numpy_int_convert():
    np = pytest.importorskip("numpy")

    convert, noconvert = m.int_passthrough, m.int_passthrough_noconvert

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

    # `np.intc` is an alias that corresponds to a C++ `int`
    assert convert(np.intc(42)) == 42
    assert noconvert(np.intc(42)) == 42

    # The implicit conversion from np.float32 is undesirable but currently accepted.
337
    # TODO: Avoid DeprecationWarning in `PyLong_AsLong` (and similar)
338
339
340
    # TODO: PyPy 3.8 does not behave like CPython 3.8 here yet (7.3.7)
    # https://github.com/pybind/pybind11/issues/3408
    if (3, 8) <= env.PY < (3, 10) and env.CPYTHON:
341
        with env.deprecated_call():
342
343
344
            assert convert(np.float32(3.14159)) == 3
    else:
        assert convert(np.float32(3.14159)) == 3
345
346
347
    require_implicit(np.float32(3.14159))


348
349
350
351
352
353
354
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)
355
    assert m.empty_tuple() == ()
356

357
358
359
    assert (
        doc(m.pair_passthrough)
        == """
360
361
362
363
        pair_passthrough(arg0: Tuple[bool, str]) -> Tuple[str, bool]

        Return a pair in reversed order
    """
364
365
366
367
    )
    assert (
        doc(m.tuple_passthrough)
        == """
368
369
370
371
        tuple_passthrough(arg0: Tuple[bool, str, int]) -> Tuple[int, str, bool]

        Return a triple in reversed order
    """
372
    )
373

374
375
376
377
378
379
380
    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")))

381
382
    assert m.int_string_pair() == (2, "items")

383
384
385
386
387
388
389
390

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
391
    assert m.return_none_pair() is None
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411


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
412
    assert m.refwrap_usertype_const(UserType(42)) == 42
413
414
415
416
417
418
419
420
421

    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)

422
423
424
    assert m.refwrap_lvalue().value == 1
    assert m.refwrap_lvalue_const().value == 1

425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
    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)"
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490


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


def test_numpy_bool():
491
492
    np = pytest.importorskip("numpy")

493
494
    convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert

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

498
499
500
501
502
    # 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
503
    cant_convert(np.zeros(2, dtype="int"))
504
505
506
507
508
509
510
511
512


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
513
514

    must_be_long = type(getattr(sys, "maxint", 1) + 1)
515
516
517
    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
518
519
520
521


def test_void_caster_2():
    assert m.test_void_caster()
522
523
524
525


def test_const_ref_caster():
    """Verifies that const-ref is propagated through type_caster cast_op.
luzpaz's avatar
luzpaz committed
526
    The returned ConstRefCasted type is a minimal type that is constructed to
527
528
529
530
531
532
533
534
535
536
537
538
539
    reference the casting mode used.
    """
    x = False
    assert m.takes(x) == 1
    assert m.takes_move(x) == 1

    assert m.takes_ptr(x) == 3
    assert m.takes_ref(x) == 2
    assert m.takes_ref_wrap(x) == 2

    assert m.takes_const_ptr(x) == 5
    assert m.takes_const_ref(x) == 4
    assert m.takes_const_ref_wrap(x) == 4