test_builtin_casters.py revision 12391
112391Sjason@lowepower.com# Python < 3 needs this: coding=utf-8 212391Sjason@lowepower.comimport pytest 312391Sjason@lowepower.com 412391Sjason@lowepower.comfrom pybind11_tests import builtin_casters as m 512391Sjason@lowepower.comfrom pybind11_tests import UserType, IncType 612391Sjason@lowepower.com 712391Sjason@lowepower.com 812391Sjason@lowepower.comdef test_simple_string(): 912391Sjason@lowepower.com assert m.string_roundtrip("const char *") == "const char *" 1012391Sjason@lowepower.com 1112391Sjason@lowepower.com 1212391Sjason@lowepower.comdef test_unicode_conversion(): 1312391Sjason@lowepower.com """Tests unicode conversion and error reporting.""" 1412391Sjason@lowepower.com assert m.good_utf8_string() == u"Say utf8‽ " 1512391Sjason@lowepower.com assert m.good_utf16_string() == u"b‽z" 1612391Sjason@lowepower.com assert m.good_utf32_string() == u"a‽z" 1712391Sjason@lowepower.com assert m.good_wchar_string() == u"a⸘z" 1812391Sjason@lowepower.com 1912391Sjason@lowepower.com with pytest.raises(UnicodeDecodeError): 2012391Sjason@lowepower.com m.bad_utf8_string() 2112391Sjason@lowepower.com 2212391Sjason@lowepower.com with pytest.raises(UnicodeDecodeError): 2312391Sjason@lowepower.com m.bad_utf16_string() 2412391Sjason@lowepower.com 2512391Sjason@lowepower.com # These are provided only if they actually fail (they don't when 32-bit and under Python 2.7) 2612391Sjason@lowepower.com if hasattr(m, "bad_utf32_string"): 2712391Sjason@lowepower.com with pytest.raises(UnicodeDecodeError): 2812391Sjason@lowepower.com m.bad_utf32_string() 2912391Sjason@lowepower.com if hasattr(m, "bad_wchar_string"): 3012391Sjason@lowepower.com with pytest.raises(UnicodeDecodeError): 3112391Sjason@lowepower.com m.bad_wchar_string() 3212391Sjason@lowepower.com 3312391Sjason@lowepower.com assert m.u8_Z() == 'Z' 3412391Sjason@lowepower.com assert m.u8_eacute() == u'é' 3512391Sjason@lowepower.com assert m.u16_ibang() == u'‽' 3612391Sjason@lowepower.com assert m.u32_mathbfA() == u'' 3712391Sjason@lowepower.com assert m.wchar_heart() == u'♥' 3812391Sjason@lowepower.com 3912391Sjason@lowepower.com 4012391Sjason@lowepower.comdef test_single_char_arguments(): 4112391Sjason@lowepower.com """Tests failures for passing invalid inputs to char-accepting functions""" 4212391Sjason@lowepower.com def toobig_message(r): 4312391Sjason@lowepower.com return "Character code point not in range({0:#x})".format(r) 4412391Sjason@lowepower.com toolong_message = "Expected a character, but multi-character string found" 4512391Sjason@lowepower.com 4612391Sjason@lowepower.com assert m.ord_char(u'a') == 0x61 # simple ASCII 4712391Sjason@lowepower.com assert m.ord_char(u'é') == 0xE9 # requires 2 bytes in utf-8, but can be stuffed in a char 4812391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 4912391Sjason@lowepower.com assert m.ord_char(u'Ā') == 0x100 # requires 2 bytes, doesn't fit in a char 5012391Sjason@lowepower.com assert str(excinfo.value) == toobig_message(0x100) 5112391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 5212391Sjason@lowepower.com assert m.ord_char(u'ab') 5312391Sjason@lowepower.com assert str(excinfo.value) == toolong_message 5412391Sjason@lowepower.com 5512391Sjason@lowepower.com assert m.ord_char16(u'a') == 0x61 5612391Sjason@lowepower.com assert m.ord_char16(u'é') == 0xE9 5712391Sjason@lowepower.com assert m.ord_char16(u'Ā') == 0x100 5812391Sjason@lowepower.com assert m.ord_char16(u'‽') == 0x203d 5912391Sjason@lowepower.com assert m.ord_char16(u'♥') == 0x2665 6012391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 6112391Sjason@lowepower.com assert m.ord_char16(u'') == 0x1F382 # requires surrogate pair 6212391Sjason@lowepower.com assert str(excinfo.value) == toobig_message(0x10000) 6312391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 6412391Sjason@lowepower.com assert m.ord_char16(u'aa') 6512391Sjason@lowepower.com assert str(excinfo.value) == toolong_message 6612391Sjason@lowepower.com 6712391Sjason@lowepower.com assert m.ord_char32(u'a') == 0x61 6812391Sjason@lowepower.com assert m.ord_char32(u'é') == 0xE9 6912391Sjason@lowepower.com assert m.ord_char32(u'Ā') == 0x100 7012391Sjason@lowepower.com assert m.ord_char32(u'‽') == 0x203d 7112391Sjason@lowepower.com assert m.ord_char32(u'♥') == 0x2665 7212391Sjason@lowepower.com assert m.ord_char32(u'') == 0x1F382 7312391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 7412391Sjason@lowepower.com assert m.ord_char32(u'aa') 7512391Sjason@lowepower.com assert str(excinfo.value) == toolong_message 7612391Sjason@lowepower.com 7712391Sjason@lowepower.com assert m.ord_wchar(u'a') == 0x61 7812391Sjason@lowepower.com assert m.ord_wchar(u'é') == 0xE9 7912391Sjason@lowepower.com assert m.ord_wchar(u'Ā') == 0x100 8012391Sjason@lowepower.com assert m.ord_wchar(u'‽') == 0x203d 8112391Sjason@lowepower.com assert m.ord_wchar(u'♥') == 0x2665 8212391Sjason@lowepower.com if m.wchar_size == 2: 8312391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 8412391Sjason@lowepower.com assert m.ord_wchar(u'') == 0x1F382 # requires surrogate pair 8512391Sjason@lowepower.com assert str(excinfo.value) == toobig_message(0x10000) 8612391Sjason@lowepower.com else: 8712391Sjason@lowepower.com assert m.ord_wchar(u'') == 0x1F382 8812391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 8912391Sjason@lowepower.com assert m.ord_wchar(u'aa') 9012391Sjason@lowepower.com assert str(excinfo.value) == toolong_message 9112391Sjason@lowepower.com 9212391Sjason@lowepower.com 9312391Sjason@lowepower.comdef test_bytes_to_string(): 9412391Sjason@lowepower.com """Tests the ability to pass bytes to C++ string-accepting functions. Note that this is 9512391Sjason@lowepower.com one-way: the only way to return bytes to Python is via the pybind11::bytes class.""" 9612391Sjason@lowepower.com # Issue #816 9712391Sjason@lowepower.com import sys 9812391Sjason@lowepower.com byte = bytes if sys.version_info[0] < 3 else str 9912391Sjason@lowepower.com 10012391Sjason@lowepower.com assert m.strlen(byte("hi")) == 2 10112391Sjason@lowepower.com assert m.string_length(byte("world")) == 5 10212391Sjason@lowepower.com assert m.string_length(byte("a\x00b")) == 3 10312391Sjason@lowepower.com assert m.strlen(byte("a\x00b")) == 1 # C-string limitation 10412391Sjason@lowepower.com 10512391Sjason@lowepower.com # passing in a utf8 encoded string should work 10612391Sjason@lowepower.com assert m.string_length(u''.encode("utf8")) == 4 10712391Sjason@lowepower.com 10812391Sjason@lowepower.com 10912391Sjason@lowepower.com@pytest.mark.skipif(not hasattr(m, "has_string_view"), reason="no <string_view>") 11012391Sjason@lowepower.comdef test_string_view(capture): 11112391Sjason@lowepower.com """Tests support for C++17 string_view arguments and return values""" 11212391Sjason@lowepower.com assert m.string_view_chars("Hi") == [72, 105] 11312391Sjason@lowepower.com assert m.string_view_chars("Hi ") == [72, 105, 32, 0xf0, 0x9f, 0x8e, 0x82] 11412391Sjason@lowepower.com assert m.string_view16_chars("Hi ") == [72, 105, 32, 0xd83c, 0xdf82] 11512391Sjason@lowepower.com assert m.string_view32_chars("Hi ") == [72, 105, 32, 127874] 11612391Sjason@lowepower.com 11712391Sjason@lowepower.com assert m.string_view_return() == "utf8 secret " 11812391Sjason@lowepower.com assert m.string_view16_return() == "utf16 secret " 11912391Sjason@lowepower.com assert m.string_view32_return() == "utf32 secret " 12012391Sjason@lowepower.com 12112391Sjason@lowepower.com with capture: 12212391Sjason@lowepower.com m.string_view_print("Hi") 12312391Sjason@lowepower.com m.string_view_print("utf8 ") 12412391Sjason@lowepower.com m.string_view16_print("utf16 ") 12512391Sjason@lowepower.com m.string_view32_print("utf32 ") 12612391Sjason@lowepower.com assert capture == """ 12712391Sjason@lowepower.com Hi 2 12812391Sjason@lowepower.com utf8 9 12912391Sjason@lowepower.com utf16 8 13012391Sjason@lowepower.com utf32 7 13112391Sjason@lowepower.com """ 13212391Sjason@lowepower.com 13312391Sjason@lowepower.com with capture: 13412391Sjason@lowepower.com m.string_view_print("Hi, ascii") 13512391Sjason@lowepower.com m.string_view_print("Hi, utf8 ") 13612391Sjason@lowepower.com m.string_view16_print("Hi, utf16 ") 13712391Sjason@lowepower.com m.string_view32_print("Hi, utf32 ") 13812391Sjason@lowepower.com assert capture == """ 13912391Sjason@lowepower.com Hi, ascii 9 14012391Sjason@lowepower.com Hi, utf8 13 14112391Sjason@lowepower.com Hi, utf16 12 14212391Sjason@lowepower.com Hi, utf32 11 14312391Sjason@lowepower.com """ 14412391Sjason@lowepower.com 14512391Sjason@lowepower.com 14612391Sjason@lowepower.comdef test_integer_casting(): 14712391Sjason@lowepower.com """Issue #929 - out-of-range integer values shouldn't be accepted""" 14812391Sjason@lowepower.com import sys 14912391Sjason@lowepower.com assert m.i32_str(-1) == "-1" 15012391Sjason@lowepower.com assert m.i64_str(-1) == "-1" 15112391Sjason@lowepower.com assert m.i32_str(2000000000) == "2000000000" 15212391Sjason@lowepower.com assert m.u32_str(2000000000) == "2000000000" 15312391Sjason@lowepower.com if sys.version_info < (3,): 15412391Sjason@lowepower.com assert m.i32_str(long(-1)) == "-1" # noqa: F821 undefined name 'long' 15512391Sjason@lowepower.com assert m.i64_str(long(-1)) == "-1" # noqa: F821 undefined name 'long' 15612391Sjason@lowepower.com assert m.i64_str(long(-999999999999)) == "-999999999999" # noqa: F821 undefined name 15712391Sjason@lowepower.com assert m.u64_str(long(999999999999)) == "999999999999" # noqa: F821 undefined name 'long' 15812391Sjason@lowepower.com else: 15912391Sjason@lowepower.com assert m.i64_str(-999999999999) == "-999999999999" 16012391Sjason@lowepower.com assert m.u64_str(999999999999) == "999999999999" 16112391Sjason@lowepower.com 16212391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 16312391Sjason@lowepower.com m.u32_str(-1) 16412391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 16512391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 16612391Sjason@lowepower.com m.u64_str(-1) 16712391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 16812391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 16912391Sjason@lowepower.com m.i32_str(-3000000000) 17012391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 17112391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 17212391Sjason@lowepower.com m.i32_str(3000000000) 17312391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 17412391Sjason@lowepower.com 17512391Sjason@lowepower.com if sys.version_info < (3,): 17612391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 17712391Sjason@lowepower.com m.u32_str(long(-1)) # noqa: F821 undefined name 'long' 17812391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 17912391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 18012391Sjason@lowepower.com m.u64_str(long(-1)) # noqa: F821 undefined name 'long' 18112391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 18212391Sjason@lowepower.com 18312391Sjason@lowepower.com 18412391Sjason@lowepower.comdef test_tuple(doc): 18512391Sjason@lowepower.com """std::pair <-> tuple & std::tuple <-> tuple""" 18612391Sjason@lowepower.com assert m.pair_passthrough((True, "test")) == ("test", True) 18712391Sjason@lowepower.com assert m.tuple_passthrough((True, "test", 5)) == (5, "test", True) 18812391Sjason@lowepower.com # Any sequence can be cast to a std::pair or std::tuple 18912391Sjason@lowepower.com assert m.pair_passthrough([True, "test"]) == ("test", True) 19012391Sjason@lowepower.com assert m.tuple_passthrough([True, "test", 5]) == (5, "test", True) 19112391Sjason@lowepower.com assert m.empty_tuple() == () 19212391Sjason@lowepower.com 19312391Sjason@lowepower.com assert doc(m.pair_passthrough) == """ 19412391Sjason@lowepower.com pair_passthrough(arg0: Tuple[bool, str]) -> Tuple[str, bool] 19512391Sjason@lowepower.com 19612391Sjason@lowepower.com Return a pair in reversed order 19712391Sjason@lowepower.com """ 19812391Sjason@lowepower.com assert doc(m.tuple_passthrough) == """ 19912391Sjason@lowepower.com tuple_passthrough(arg0: Tuple[bool, str, int]) -> Tuple[int, str, bool] 20012391Sjason@lowepower.com 20112391Sjason@lowepower.com Return a triple in reversed order 20212391Sjason@lowepower.com """ 20312391Sjason@lowepower.com 20412391Sjason@lowepower.com assert m.rvalue_pair() == ("rvalue", "rvalue") 20512391Sjason@lowepower.com assert m.lvalue_pair() == ("lvalue", "lvalue") 20612391Sjason@lowepower.com assert m.rvalue_tuple() == ("rvalue", "rvalue", "rvalue") 20712391Sjason@lowepower.com assert m.lvalue_tuple() == ("lvalue", "lvalue", "lvalue") 20812391Sjason@lowepower.com assert m.rvalue_nested() == ("rvalue", ("rvalue", ("rvalue", "rvalue"))) 20912391Sjason@lowepower.com assert m.lvalue_nested() == ("lvalue", ("lvalue", ("lvalue", "lvalue"))) 21012391Sjason@lowepower.com 21112391Sjason@lowepower.com 21212391Sjason@lowepower.comdef test_builtins_cast_return_none(): 21312391Sjason@lowepower.com """Casters produced with PYBIND11_TYPE_CASTER() should convert nullptr to None""" 21412391Sjason@lowepower.com assert m.return_none_string() is None 21512391Sjason@lowepower.com assert m.return_none_char() is None 21612391Sjason@lowepower.com assert m.return_none_bool() is None 21712391Sjason@lowepower.com assert m.return_none_int() is None 21812391Sjason@lowepower.com assert m.return_none_float() is None 21912391Sjason@lowepower.com 22012391Sjason@lowepower.com 22112391Sjason@lowepower.comdef test_none_deferred(): 22212391Sjason@lowepower.com """None passed as various argument types should defer to other overloads""" 22312391Sjason@lowepower.com assert not m.defer_none_cstring("abc") 22412391Sjason@lowepower.com assert m.defer_none_cstring(None) 22512391Sjason@lowepower.com assert not m.defer_none_custom(UserType()) 22612391Sjason@lowepower.com assert m.defer_none_custom(None) 22712391Sjason@lowepower.com assert m.nodefer_none_void(None) 22812391Sjason@lowepower.com 22912391Sjason@lowepower.com 23012391Sjason@lowepower.comdef test_void_caster(): 23112391Sjason@lowepower.com assert m.load_nullptr_t(None) is None 23212391Sjason@lowepower.com assert m.cast_nullptr_t() is None 23312391Sjason@lowepower.com 23412391Sjason@lowepower.com 23512391Sjason@lowepower.comdef test_reference_wrapper(): 23612391Sjason@lowepower.com """std::reference_wrapper for builtin and user types""" 23712391Sjason@lowepower.com assert m.refwrap_builtin(42) == 420 23812391Sjason@lowepower.com assert m.refwrap_usertype(UserType(42)) == 42 23912391Sjason@lowepower.com 24012391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 24112391Sjason@lowepower.com m.refwrap_builtin(None) 24212391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 24312391Sjason@lowepower.com 24412391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 24512391Sjason@lowepower.com m.refwrap_usertype(None) 24612391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 24712391Sjason@lowepower.com 24812391Sjason@lowepower.com a1 = m.refwrap_list(copy=True) 24912391Sjason@lowepower.com a2 = m.refwrap_list(copy=True) 25012391Sjason@lowepower.com assert [x.value for x in a1] == [2, 3] 25112391Sjason@lowepower.com assert [x.value for x in a2] == [2, 3] 25212391Sjason@lowepower.com assert not a1[0] is a2[0] and not a1[1] is a2[1] 25312391Sjason@lowepower.com 25412391Sjason@lowepower.com b1 = m.refwrap_list(copy=False) 25512391Sjason@lowepower.com b2 = m.refwrap_list(copy=False) 25612391Sjason@lowepower.com assert [x.value for x in b1] == [1, 2] 25712391Sjason@lowepower.com assert [x.value for x in b2] == [1, 2] 25812391Sjason@lowepower.com assert b1[0] is b2[0] and b1[1] is b2[1] 25912391Sjason@lowepower.com 26012391Sjason@lowepower.com assert m.refwrap_iiw(IncType(5)) == 5 26112391Sjason@lowepower.com assert m.refwrap_call_iiw(IncType(10), m.refwrap_iiw) == [10, 10, 10, 10] 26212391Sjason@lowepower.com 26312391Sjason@lowepower.com 26412391Sjason@lowepower.comdef test_complex_cast(): 26512391Sjason@lowepower.com """std::complex casts""" 26612391Sjason@lowepower.com assert m.complex_cast(1) == "1.0" 26712391Sjason@lowepower.com assert m.complex_cast(2j) == "(0.0, 2.0)" 26812391Sjason@lowepower.com 26912391Sjason@lowepower.com 27012391Sjason@lowepower.comdef test_bool_caster(): 27112391Sjason@lowepower.com """Test bool caster implicit conversions.""" 27212391Sjason@lowepower.com convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert 27312391Sjason@lowepower.com 27412391Sjason@lowepower.com def require_implicit(v): 27512391Sjason@lowepower.com pytest.raises(TypeError, noconvert, v) 27612391Sjason@lowepower.com 27712391Sjason@lowepower.com def cant_convert(v): 27812391Sjason@lowepower.com pytest.raises(TypeError, convert, v) 27912391Sjason@lowepower.com 28012391Sjason@lowepower.com # straight up bool 28112391Sjason@lowepower.com assert convert(True) is True 28212391Sjason@lowepower.com assert convert(False) is False 28312391Sjason@lowepower.com assert noconvert(True) is True 28412391Sjason@lowepower.com assert noconvert(False) is False 28512391Sjason@lowepower.com 28612391Sjason@lowepower.com # None requires implicit conversion 28712391Sjason@lowepower.com require_implicit(None) 28812391Sjason@lowepower.com assert convert(None) is False 28912391Sjason@lowepower.com 29012391Sjason@lowepower.com class A(object): 29112391Sjason@lowepower.com def __init__(self, x): 29212391Sjason@lowepower.com self.x = x 29312391Sjason@lowepower.com 29412391Sjason@lowepower.com def __nonzero__(self): 29512391Sjason@lowepower.com return self.x 29612391Sjason@lowepower.com 29712391Sjason@lowepower.com def __bool__(self): 29812391Sjason@lowepower.com return self.x 29912391Sjason@lowepower.com 30012391Sjason@lowepower.com class B(object): 30112391Sjason@lowepower.com pass 30212391Sjason@lowepower.com 30312391Sjason@lowepower.com # Arbitrary objects are not accepted 30412391Sjason@lowepower.com cant_convert(object()) 30512391Sjason@lowepower.com cant_convert(B()) 30612391Sjason@lowepower.com 30712391Sjason@lowepower.com # Objects with __nonzero__ / __bool__ defined can be converted 30812391Sjason@lowepower.com require_implicit(A(True)) 30912391Sjason@lowepower.com assert convert(A(True)) is True 31012391Sjason@lowepower.com assert convert(A(False)) is False 31112391Sjason@lowepower.com 31212391Sjason@lowepower.com 31312391Sjason@lowepower.com@pytest.requires_numpy 31412391Sjason@lowepower.comdef test_numpy_bool(): 31512391Sjason@lowepower.com import numpy as np 31612391Sjason@lowepower.com convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert 31712391Sjason@lowepower.com 31812391Sjason@lowepower.com # np.bool_ is not considered implicit 31912391Sjason@lowepower.com assert convert(np.bool_(True)) is True 32012391Sjason@lowepower.com assert convert(np.bool_(False)) is False 32112391Sjason@lowepower.com assert noconvert(np.bool_(True)) is True 32212391Sjason@lowepower.com assert noconvert(np.bool_(False)) is False 323