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 4714299Sbbruce@ucdavis.edu assert m.ord_char_lv(u'b') == 0x62 4812391Sjason@lowepower.com assert m.ord_char(u'é') == 0xE9 # requires 2 bytes in utf-8, but can be stuffed in a char 4912391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 5012391Sjason@lowepower.com assert m.ord_char(u'Ā') == 0x100 # requires 2 bytes, doesn't fit in a char 5112391Sjason@lowepower.com assert str(excinfo.value) == toobig_message(0x100) 5212391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 5312391Sjason@lowepower.com assert m.ord_char(u'ab') 5412391Sjason@lowepower.com assert str(excinfo.value) == toolong_message 5512391Sjason@lowepower.com 5612391Sjason@lowepower.com assert m.ord_char16(u'a') == 0x61 5712391Sjason@lowepower.com assert m.ord_char16(u'é') == 0xE9 5814299Sbbruce@ucdavis.edu assert m.ord_char16_lv(u'ê') == 0xEA 5912391Sjason@lowepower.com assert m.ord_char16(u'Ā') == 0x100 6012391Sjason@lowepower.com assert m.ord_char16(u'‽') == 0x203d 6112391Sjason@lowepower.com assert m.ord_char16(u'♥') == 0x2665 6214299Sbbruce@ucdavis.edu assert m.ord_char16_lv(u'♡') == 0x2661 6312391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 6412391Sjason@lowepower.com assert m.ord_char16(u'') == 0x1F382 # requires surrogate pair 6512391Sjason@lowepower.com assert str(excinfo.value) == toobig_message(0x10000) 6612391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 6712391Sjason@lowepower.com assert m.ord_char16(u'aa') 6812391Sjason@lowepower.com assert str(excinfo.value) == toolong_message 6912391Sjason@lowepower.com 7012391Sjason@lowepower.com assert m.ord_char32(u'a') == 0x61 7112391Sjason@lowepower.com assert m.ord_char32(u'é') == 0xE9 7212391Sjason@lowepower.com assert m.ord_char32(u'Ā') == 0x100 7312391Sjason@lowepower.com assert m.ord_char32(u'‽') == 0x203d 7412391Sjason@lowepower.com assert m.ord_char32(u'♥') == 0x2665 7512391Sjason@lowepower.com assert m.ord_char32(u'') == 0x1F382 7612391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 7712391Sjason@lowepower.com assert m.ord_char32(u'aa') 7812391Sjason@lowepower.com assert str(excinfo.value) == toolong_message 7912391Sjason@lowepower.com 8012391Sjason@lowepower.com assert m.ord_wchar(u'a') == 0x61 8112391Sjason@lowepower.com assert m.ord_wchar(u'é') == 0xE9 8212391Sjason@lowepower.com assert m.ord_wchar(u'Ā') == 0x100 8312391Sjason@lowepower.com assert m.ord_wchar(u'‽') == 0x203d 8412391Sjason@lowepower.com assert m.ord_wchar(u'♥') == 0x2665 8512391Sjason@lowepower.com if m.wchar_size == 2: 8612391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 8712391Sjason@lowepower.com assert m.ord_wchar(u'') == 0x1F382 # requires surrogate pair 8812391Sjason@lowepower.com assert str(excinfo.value) == toobig_message(0x10000) 8912391Sjason@lowepower.com else: 9012391Sjason@lowepower.com assert m.ord_wchar(u'') == 0x1F382 9112391Sjason@lowepower.com with pytest.raises(ValueError) as excinfo: 9212391Sjason@lowepower.com assert m.ord_wchar(u'aa') 9312391Sjason@lowepower.com assert str(excinfo.value) == toolong_message 9412391Sjason@lowepower.com 9512391Sjason@lowepower.com 9612391Sjason@lowepower.comdef test_bytes_to_string(): 9712391Sjason@lowepower.com """Tests the ability to pass bytes to C++ string-accepting functions. Note that this is 9812391Sjason@lowepower.com one-way: the only way to return bytes to Python is via the pybind11::bytes class.""" 9912391Sjason@lowepower.com # Issue #816 10012391Sjason@lowepower.com import sys 10112391Sjason@lowepower.com byte = bytes if sys.version_info[0] < 3 else str 10212391Sjason@lowepower.com 10312391Sjason@lowepower.com assert m.strlen(byte("hi")) == 2 10412391Sjason@lowepower.com assert m.string_length(byte("world")) == 5 10512391Sjason@lowepower.com assert m.string_length(byte("a\x00b")) == 3 10612391Sjason@lowepower.com assert m.strlen(byte("a\x00b")) == 1 # C-string limitation 10712391Sjason@lowepower.com 10812391Sjason@lowepower.com # passing in a utf8 encoded string should work 10912391Sjason@lowepower.com assert m.string_length(u''.encode("utf8")) == 4 11012391Sjason@lowepower.com 11112391Sjason@lowepower.com 11212391Sjason@lowepower.com@pytest.mark.skipif(not hasattr(m, "has_string_view"), reason="no <string_view>") 11312391Sjason@lowepower.comdef test_string_view(capture): 11412391Sjason@lowepower.com """Tests support for C++17 string_view arguments and return values""" 11512391Sjason@lowepower.com assert m.string_view_chars("Hi") == [72, 105] 11612391Sjason@lowepower.com assert m.string_view_chars("Hi ") == [72, 105, 32, 0xf0, 0x9f, 0x8e, 0x82] 11712391Sjason@lowepower.com assert m.string_view16_chars("Hi ") == [72, 105, 32, 0xd83c, 0xdf82] 11812391Sjason@lowepower.com assert m.string_view32_chars("Hi ") == [72, 105, 32, 127874] 11912391Sjason@lowepower.com 12012391Sjason@lowepower.com assert m.string_view_return() == "utf8 secret " 12112391Sjason@lowepower.com assert m.string_view16_return() == "utf16 secret " 12212391Sjason@lowepower.com assert m.string_view32_return() == "utf32 secret " 12312391Sjason@lowepower.com 12412391Sjason@lowepower.com with capture: 12512391Sjason@lowepower.com m.string_view_print("Hi") 12612391Sjason@lowepower.com m.string_view_print("utf8 ") 12712391Sjason@lowepower.com m.string_view16_print("utf16 ") 12812391Sjason@lowepower.com m.string_view32_print("utf32 ") 12912391Sjason@lowepower.com assert capture == """ 13012391Sjason@lowepower.com Hi 2 13112391Sjason@lowepower.com utf8 9 13212391Sjason@lowepower.com utf16 8 13312391Sjason@lowepower.com utf32 7 13412391Sjason@lowepower.com """ 13512391Sjason@lowepower.com 13612391Sjason@lowepower.com with capture: 13712391Sjason@lowepower.com m.string_view_print("Hi, ascii") 13812391Sjason@lowepower.com m.string_view_print("Hi, utf8 ") 13912391Sjason@lowepower.com m.string_view16_print("Hi, utf16 ") 14012391Sjason@lowepower.com m.string_view32_print("Hi, utf32 ") 14112391Sjason@lowepower.com assert capture == """ 14212391Sjason@lowepower.com Hi, ascii 9 14312391Sjason@lowepower.com Hi, utf8 13 14412391Sjason@lowepower.com Hi, utf16 12 14512391Sjason@lowepower.com Hi, utf32 11 14612391Sjason@lowepower.com """ 14712391Sjason@lowepower.com 14812391Sjason@lowepower.com 14912391Sjason@lowepower.comdef test_integer_casting(): 15012391Sjason@lowepower.com """Issue #929 - out-of-range integer values shouldn't be accepted""" 15112391Sjason@lowepower.com import sys 15212391Sjason@lowepower.com assert m.i32_str(-1) == "-1" 15312391Sjason@lowepower.com assert m.i64_str(-1) == "-1" 15412391Sjason@lowepower.com assert m.i32_str(2000000000) == "2000000000" 15512391Sjason@lowepower.com assert m.u32_str(2000000000) == "2000000000" 15612391Sjason@lowepower.com if sys.version_info < (3,): 15712391Sjason@lowepower.com assert m.i32_str(long(-1)) == "-1" # noqa: F821 undefined name 'long' 15812391Sjason@lowepower.com assert m.i64_str(long(-1)) == "-1" # noqa: F821 undefined name 'long' 15912391Sjason@lowepower.com assert m.i64_str(long(-999999999999)) == "-999999999999" # noqa: F821 undefined name 16012391Sjason@lowepower.com assert m.u64_str(long(999999999999)) == "999999999999" # noqa: F821 undefined name 'long' 16112391Sjason@lowepower.com else: 16212391Sjason@lowepower.com assert m.i64_str(-999999999999) == "-999999999999" 16312391Sjason@lowepower.com assert m.u64_str(999999999999) == "999999999999" 16412391Sjason@lowepower.com 16512391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 16612391Sjason@lowepower.com m.u32_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.u64_str(-1) 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 with pytest.raises(TypeError) as excinfo: 17512391Sjason@lowepower.com m.i32_str(3000000000) 17612391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 17712391Sjason@lowepower.com 17812391Sjason@lowepower.com if sys.version_info < (3,): 17912391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 18012391Sjason@lowepower.com m.u32_str(long(-1)) # noqa: F821 undefined name 'long' 18112391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 18212391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 18312391Sjason@lowepower.com m.u64_str(long(-1)) # noqa: F821 undefined name 'long' 18412391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 18512391Sjason@lowepower.com 18612391Sjason@lowepower.com 18712391Sjason@lowepower.comdef test_tuple(doc): 18812391Sjason@lowepower.com """std::pair <-> tuple & std::tuple <-> 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 # Any sequence can be cast to a std::pair or std::tuple 19212391Sjason@lowepower.com assert m.pair_passthrough([True, "test"]) == ("test", True) 19312391Sjason@lowepower.com assert m.tuple_passthrough([True, "test", 5]) == (5, "test", True) 19412391Sjason@lowepower.com assert m.empty_tuple() == () 19512391Sjason@lowepower.com 19612391Sjason@lowepower.com assert doc(m.pair_passthrough) == """ 19712391Sjason@lowepower.com pair_passthrough(arg0: Tuple[bool, str]) -> Tuple[str, bool] 19812391Sjason@lowepower.com 19912391Sjason@lowepower.com Return a pair in reversed order 20012391Sjason@lowepower.com """ 20112391Sjason@lowepower.com assert doc(m.tuple_passthrough) == """ 20212391Sjason@lowepower.com tuple_passthrough(arg0: Tuple[bool, str, int]) -> Tuple[int, str, bool] 20312391Sjason@lowepower.com 20412391Sjason@lowepower.com Return a triple in reversed order 20512391Sjason@lowepower.com """ 20612391Sjason@lowepower.com 20712391Sjason@lowepower.com assert m.rvalue_pair() == ("rvalue", "rvalue") 20812391Sjason@lowepower.com assert m.lvalue_pair() == ("lvalue", "lvalue") 20912391Sjason@lowepower.com assert m.rvalue_tuple() == ("rvalue", "rvalue", "rvalue") 21012391Sjason@lowepower.com assert m.lvalue_tuple() == ("lvalue", "lvalue", "lvalue") 21112391Sjason@lowepower.com assert m.rvalue_nested() == ("rvalue", ("rvalue", ("rvalue", "rvalue"))) 21212391Sjason@lowepower.com assert m.lvalue_nested() == ("lvalue", ("lvalue", ("lvalue", "lvalue"))) 21312391Sjason@lowepower.com 21412391Sjason@lowepower.com 21512391Sjason@lowepower.comdef test_builtins_cast_return_none(): 21612391Sjason@lowepower.com """Casters produced with PYBIND11_TYPE_CASTER() should convert nullptr to None""" 21712391Sjason@lowepower.com assert m.return_none_string() is None 21812391Sjason@lowepower.com assert m.return_none_char() is None 21912391Sjason@lowepower.com assert m.return_none_bool() is None 22012391Sjason@lowepower.com assert m.return_none_int() is None 22112391Sjason@lowepower.com assert m.return_none_float() is None 22212391Sjason@lowepower.com 22312391Sjason@lowepower.com 22412391Sjason@lowepower.comdef test_none_deferred(): 22512391Sjason@lowepower.com """None passed as various argument types should defer to other overloads""" 22612391Sjason@lowepower.com assert not m.defer_none_cstring("abc") 22712391Sjason@lowepower.com assert m.defer_none_cstring(None) 22812391Sjason@lowepower.com assert not m.defer_none_custom(UserType()) 22912391Sjason@lowepower.com assert m.defer_none_custom(None) 23012391Sjason@lowepower.com assert m.nodefer_none_void(None) 23112391Sjason@lowepower.com 23212391Sjason@lowepower.com 23312391Sjason@lowepower.comdef test_void_caster(): 23412391Sjason@lowepower.com assert m.load_nullptr_t(None) is None 23512391Sjason@lowepower.com assert m.cast_nullptr_t() is None 23612391Sjason@lowepower.com 23712391Sjason@lowepower.com 23812391Sjason@lowepower.comdef test_reference_wrapper(): 23912391Sjason@lowepower.com """std::reference_wrapper for builtin and user types""" 24012391Sjason@lowepower.com assert m.refwrap_builtin(42) == 420 24112391Sjason@lowepower.com assert m.refwrap_usertype(UserType(42)) == 42 24212391Sjason@lowepower.com 24312391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 24412391Sjason@lowepower.com m.refwrap_builtin(None) 24512391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 24612391Sjason@lowepower.com 24712391Sjason@lowepower.com with pytest.raises(TypeError) as excinfo: 24812391Sjason@lowepower.com m.refwrap_usertype(None) 24912391Sjason@lowepower.com assert "incompatible function arguments" in str(excinfo.value) 25012391Sjason@lowepower.com 25112391Sjason@lowepower.com a1 = m.refwrap_list(copy=True) 25212391Sjason@lowepower.com a2 = m.refwrap_list(copy=True) 25312391Sjason@lowepower.com assert [x.value for x in a1] == [2, 3] 25412391Sjason@lowepower.com assert [x.value for x in a2] == [2, 3] 25512391Sjason@lowepower.com assert not a1[0] is a2[0] and not a1[1] is a2[1] 25612391Sjason@lowepower.com 25712391Sjason@lowepower.com b1 = m.refwrap_list(copy=False) 25812391Sjason@lowepower.com b2 = m.refwrap_list(copy=False) 25912391Sjason@lowepower.com assert [x.value for x in b1] == [1, 2] 26012391Sjason@lowepower.com assert [x.value for x in b2] == [1, 2] 26112391Sjason@lowepower.com assert b1[0] is b2[0] and b1[1] is b2[1] 26212391Sjason@lowepower.com 26312391Sjason@lowepower.com assert m.refwrap_iiw(IncType(5)) == 5 26412391Sjason@lowepower.com assert m.refwrap_call_iiw(IncType(10), m.refwrap_iiw) == [10, 10, 10, 10] 26512391Sjason@lowepower.com 26612391Sjason@lowepower.com 26712391Sjason@lowepower.comdef test_complex_cast(): 26812391Sjason@lowepower.com """std::complex casts""" 26912391Sjason@lowepower.com assert m.complex_cast(1) == "1.0" 27012391Sjason@lowepower.com assert m.complex_cast(2j) == "(0.0, 2.0)" 27112391Sjason@lowepower.com 27212391Sjason@lowepower.com 27312391Sjason@lowepower.comdef test_bool_caster(): 27412391Sjason@lowepower.com """Test bool caster implicit conversions.""" 27512391Sjason@lowepower.com convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert 27612391Sjason@lowepower.com 27712391Sjason@lowepower.com def require_implicit(v): 27812391Sjason@lowepower.com pytest.raises(TypeError, noconvert, v) 27912391Sjason@lowepower.com 28012391Sjason@lowepower.com def cant_convert(v): 28112391Sjason@lowepower.com pytest.raises(TypeError, convert, v) 28212391Sjason@lowepower.com 28312391Sjason@lowepower.com # straight up bool 28412391Sjason@lowepower.com assert convert(True) is True 28512391Sjason@lowepower.com assert convert(False) is False 28612391Sjason@lowepower.com assert noconvert(True) is True 28712391Sjason@lowepower.com assert noconvert(False) is False 28812391Sjason@lowepower.com 28912391Sjason@lowepower.com # None requires implicit conversion 29012391Sjason@lowepower.com require_implicit(None) 29112391Sjason@lowepower.com assert convert(None) is False 29212391Sjason@lowepower.com 29312391Sjason@lowepower.com class A(object): 29412391Sjason@lowepower.com def __init__(self, x): 29512391Sjason@lowepower.com self.x = x 29612391Sjason@lowepower.com 29712391Sjason@lowepower.com def __nonzero__(self): 29812391Sjason@lowepower.com return self.x 29912391Sjason@lowepower.com 30012391Sjason@lowepower.com def __bool__(self): 30112391Sjason@lowepower.com return self.x 30212391Sjason@lowepower.com 30312391Sjason@lowepower.com class B(object): 30412391Sjason@lowepower.com pass 30512391Sjason@lowepower.com 30612391Sjason@lowepower.com # Arbitrary objects are not accepted 30712391Sjason@lowepower.com cant_convert(object()) 30812391Sjason@lowepower.com cant_convert(B()) 30912391Sjason@lowepower.com 31012391Sjason@lowepower.com # Objects with __nonzero__ / __bool__ defined can be converted 31112391Sjason@lowepower.com require_implicit(A(True)) 31212391Sjason@lowepower.com assert convert(A(True)) is True 31312391Sjason@lowepower.com assert convert(A(False)) is False 31412391Sjason@lowepower.com 31512391Sjason@lowepower.com 31612391Sjason@lowepower.com@pytest.requires_numpy 31712391Sjason@lowepower.comdef test_numpy_bool(): 31812391Sjason@lowepower.com import numpy as np 31912391Sjason@lowepower.com convert, noconvert = m.bool_passthrough, m.bool_passthrough_noconvert 32012391Sjason@lowepower.com 32112391Sjason@lowepower.com # np.bool_ is not considered implicit 32212391Sjason@lowepower.com assert convert(np.bool_(True)) is True 32312391Sjason@lowepower.com assert convert(np.bool_(False)) is False 32412391Sjason@lowepower.com assert noconvert(np.bool_(True)) is True 32512391Sjason@lowepower.com assert noconvert(np.bool_(False)) is False 32614299Sbbruce@ucdavis.edu 32714299Sbbruce@ucdavis.edu 32814299Sbbruce@ucdavis.edudef test_int_long(): 32914299Sbbruce@ucdavis.edu """In Python 2, a C++ int should return a Python int rather than long 33014299Sbbruce@ucdavis.edu if possible: longs are not always accepted where ints are used (such 33114299Sbbruce@ucdavis.edu as the argument to sys.exit()). A C++ long long is always a Python 33214299Sbbruce@ucdavis.edu long.""" 33314299Sbbruce@ucdavis.edu 33414299Sbbruce@ucdavis.edu import sys 33514299Sbbruce@ucdavis.edu must_be_long = type(getattr(sys, 'maxint', 1) + 1) 33614299Sbbruce@ucdavis.edu assert isinstance(m.int_cast(), int) 33714299Sbbruce@ucdavis.edu assert isinstance(m.long_cast(), int) 33814299Sbbruce@ucdavis.edu assert isinstance(m.longlong_cast(), must_be_long) 33914299Sbbruce@ucdavis.edu 34014299Sbbruce@ucdavis.edu 34114299Sbbruce@ucdavis.edudef test_void_caster_2(): 34214299Sbbruce@ucdavis.edu assert m.test_void_caster() 343