8 from pybind11_tests
import detailed_error_messages_enabled
9 from pybind11_tests
import pytypes
as m
13 assert m.obj_class_name(
None) ==
"NoneType"
14 assert m.obj_class_name(list) ==
"list"
15 assert m.obj_class_name([]) ==
"list"
19 assert m.handle_from_move_only_type_with_operator_PyObject_ncnst()
20 assert m.handle_from_move_only_type_with_operator_PyObject_const()
24 assert doc(m.get_bool) ==
"get_bool() -> bool"
28 assert doc(m.get_int) ==
"get_int() -> int"
32 assert doc(m.get_iterator) ==
"get_iterator() -> Iterator"
35 @pytest.mark.parametrize(
36 (
"pytype",
"from_iter_func"),
38 (frozenset, m.get_frozenset_from_iterable),
39 (list, m.get_list_from_iterable),
40 (set, m.get_set_from_iterable),
41 (tuple, m.get_tuple_from_iterable),
46 s = from_iter_func(my_iter)
47 assert type(s) == pytype
48 assert s == pytype(
range(10))
52 assert doc(m.get_iterable) ==
"get_iterable() -> Iterable"
56 assert doc(m.get_float) ==
"get_float() -> float"
60 assert m.list_no_args() == []
61 assert m.list_ssize_t() == []
62 assert m.list_size_t() == []
64 m.list_insert_ssize_t(lins)
65 assert lins == [1, 83, 2]
66 m.list_insert_size_t(lins)
67 assert lins == [1, 83, 2, 57]
71 assert lst == [
"inserted-0",
"overwritten",
"inserted-2"]
78 Entry at position 0: value
79 list item 0: inserted-0
80 list item 1: overwritten
81 list item 2: inserted-2
86 assert doc(m.get_list) ==
"get_list() -> list"
87 assert doc(m.print_list) ==
"print_list(arg0: list) -> None"
91 assert doc(m.get_none) ==
"get_none() -> None"
92 assert doc(m.print_none) ==
"print_none(arg0: None) -> None"
98 assert s == {
"key1",
"key2",
"key3"}
114 assert m.anyset_size(s) == 5
117 assert m.anyset_empty(s)
119 assert not m.anyset_contains(
set(), 42)
120 assert m.anyset_contains({42}, 42)
121 assert m.anyset_contains({
"foo"},
"foo")
123 assert doc(m.get_set) ==
"get_set() -> set"
124 assert doc(m.print_anyset) ==
"print_anyset(arg0: anyset) -> None"
128 s = m.get_frozenset()
130 assert s ==
frozenset({
"key1",
"key2",
"key3"})
142 assert m.anyset_size(s) == 3
143 assert not m.anyset_empty(s)
145 assert not m.anyset_contains(
frozenset(), 42)
146 assert m.anyset_contains(
frozenset({42}), 42)
147 assert m.anyset_contains(
frozenset({
"foo"}),
"foo")
149 assert doc(m.get_frozenset) ==
"get_frozenset() -> frozenset"
154 assert d == {
"key":
"value"}
162 key: key, value=value
163 key: key2, value=value2
167 assert not m.dict_contains({}, 42)
168 assert m.dict_contains({42:
None}, 42)
169 assert m.dict_contains({
"foo":
None},
"foo")
171 assert doc(m.get_dict) ==
"get_dict() -> dict"
172 assert doc(m.print_dict) ==
"print_dict(arg0: dict) -> None"
174 assert m.dict_keyword_constructor() == {
"x": 1,
"y": 2,
"z": 3}
184 @pytest.mark.parametrize(
187 (
set(), m.anyset_contains),
188 ({}, m.dict_contains),
192 @pytest.mark.xfail(
"env.PYPY and sys.pypy_version_info < (7, 3, 10)", strict=
False)
197 with pytest.raises(TypeError)
as exc_info:
198 func(arg, Unhashable())
199 assert "unhashable type:" in str(exc_info.value)
203 assert m.tuple_no_args() == ()
204 assert m.tuple_ssize_t() == ()
205 assert m.tuple_size_t() == ()
206 assert m.get_tuple() == (42,
None,
"spam")
210 ns = m.get_simple_namespace()
214 assert not hasattr(ns,
"wrong")
218 assert m.str_from_char_ssize_t().
encode().
decode() ==
"red"
219 assert m.str_from_char_size_t().
encode().
decode() ==
"blue"
223 assert doc(m.str_from_bytes) ==
"str_from_bytes() -> str"
227 return "this is a str"
230 return "this is a repr"
232 assert m.str_from_object(
A()) ==
"this is a str"
233 assert m.repr_from_object(
A()) ==
"this is a repr"
234 assert m.str_from_handle(
A()) ==
"this is a str"
236 s1, s2 = m.str_format()
237 assert s1 ==
"1 + 2 = 3"
240 malformed_utf8 = b
"\x80"
241 if hasattr(m,
"PYBIND11_STR_LEGACY_PERMISSIVE"):
242 assert m.str_from_object(malformed_utf8)
is malformed_utf8
244 assert m.str_from_object(malformed_utf8) ==
"b'\\x80'"
245 assert m.str_from_handle(malformed_utf8) ==
"b'\\x80'"
247 assert m.str_from_string_from_str(
"this is a str") ==
"this is a str"
248 ucs_surrogates_str =
"\udcc3"
249 with pytest.raises(UnicodeEncodeError):
250 m.str_from_string_from_str(ucs_surrogates_str)
253 @pytest.mark.parametrize(
256 m.str_from_bytes_input,
257 m.str_from_cstr_input,
258 m.str_from_std_string_input,
262 input_str =
"\ud83d\ude4f".
encode(
"utf-8",
"surrogatepass")
263 with pytest.raises(UnicodeDecodeError):
268 assert m.bytes_from_char_ssize_t().
decode() ==
"green"
269 assert m.bytes_from_char_size_t().
decode() ==
"purple"
270 assert m.bytes_from_string().
decode() ==
"foo"
271 assert m.bytes_from_str().
decode() ==
"bar"
273 assert doc(m.bytes_from_str) ==
"bytes_from_str() -> bytes"
277 assert m.bytearray_from_char_ssize_t().
decode() ==
"$%"
278 assert m.bytearray_from_char_size_t().
decode() ==
"@$!"
279 assert m.bytearray_from_string().
decode() ==
"foo"
280 assert m.bytearray_size() ==
len(
"foo")
286 a = m.return_capsule_with_destructor()
298 a = m.return_renamed_capsule_with_destructor()
311 a = m.return_capsule_with_destructor_2()
318 destructing capsule: 1234
323 a = m.return_capsule_with_destructor_3()
330 destructing capsule: 1233
336 a = m.return_renamed_capsule_with_destructor_2()
344 destructing capsule: 1234
349 a = m.return_capsule_with_name_and_destructor()
355 created capsule (1234, 'pointer type description')
356 destructing capsule (1234, 'pointer type description')
361 a = m.return_capsule_with_explicit_nullptr_dtor()
367 creating capsule with explicit nullptr dtor
379 begin_end = [1, 2, 3]
380 d = {
"operator[object]": 1,
"operator[char *]": 2}
381 sub = SubTestObject()
383 def func(self, x, *args):
384 return self.basic_attr + x + sum(args)
386 d = m.accessor_api(TestObject())
387 assert d[
"basic_attr"] == 1
388 assert d[
"begin_end"] == [1, 2, 3]
389 assert d[
"operator[object]"] == 1
390 assert d[
"operator[char *]"] == 2
391 assert d[
"attr(object)"] == 1
392 assert d[
"attr(char *)"] == 2
393 assert d[
"missing_attr_ptr"] ==
"raised"
394 assert d[
"missing_attr_chain"] ==
"raised"
395 assert d[
"is_none"]
is False
396 assert d[
"operator()"] == 2
397 assert d[
"operator*"] == 7
398 assert d[
"implicit_list"] == [1, 2, 3]
399 assert all(x
in TestObject.__dict__
for x
in d[
"implicit_dict"])
401 assert m.tuple_accessor(()) == (0, 1, 2)
403 d = m.accessor_assignment()
405 assert d[
"deferred_get"] == 0
407 assert d[
"deferred_set"] == 1
408 assert d[
"var"] == 99
412 inc_refs = m.accessor_moves()
414 assert inc_refs == [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0]
416 pytest.skip(
"Not defined: PYBIND11_HANDLE_REF_DEBUG")
420 """C++ default and converting constructors are equivalent to type calls in Python"""
421 types = [bytes, bytearray, str, bool, int, float, tuple, list, dict, set]
422 expected = {t.__name__:
t()
for t
in types}
423 assert m.default_constructors() == expected
434 dict: [(
"two", 2), (
"one", 1), (
"three", 3)],
435 set: [4, 4, 5, 6, 6, 6],
436 frozenset: [4, 4, 5, 6, 6, 6],
439 inputs = {k.__name__: v
for k, v
in data.items()}
440 expected = {k.__name__: k(v)
for k, v
in data.items()}
442 assert m.converting_constructors(inputs) == expected
443 assert m.cast_functions(inputs) == expected
447 noconv1 = m.converting_constructors(expected)
449 assert noconv1[k]
is expected[k]
451 noconv2 = m.cast_functions(expected)
453 assert noconv2[k]
is expected[k]
457 non_converting_test_cases = [
458 (
"bytes",
range(10)),
463 for t, v
in non_converting_test_cases:
464 for move
in [
True,
False]:
465 with pytest.raises(TypeError)
as excinfo:
466 m.nonconverting_constructor(t, v, move)
468 f
"Object of type '{type(v).__name__}' is not an instance of '{t}'"
470 assert str(excinfo.value) == expected_error
475 cvt = m.convert_to_pybind11_str
476 assert cvt(
"Str") ==
"Str"
477 assert cvt(b
"Bytes") ==
"b'Bytes'"
478 assert cvt(
None) ==
"None"
479 assert cvt(
False) ==
"False"
480 assert cvt(
True) ==
"True"
481 assert cvt(42) ==
"42"
482 assert cvt(2**65) ==
"36893488147419103232"
483 assert cvt(-1.50) ==
"-1.5"
484 assert cvt(()) ==
"()"
485 assert cvt((18,)) ==
"(18,)"
486 assert cvt([]) ==
"[]"
487 assert cvt([28]) ==
"[28]"
488 assert cvt({}) ==
"{}"
489 assert cvt({3: 4}) ==
"{3: 4}"
490 assert cvt(
set()) ==
"set()"
491 assert cvt({3}) ==
"{3}"
494 valid_utf8 = valid_orig.encode(
"utf-8")
495 valid_cvt = cvt(valid_utf8)
496 if hasattr(m,
"PYBIND11_STR_LEGACY_PERMISSIVE"):
497 assert valid_cvt
is valid_utf8
499 assert type(valid_cvt)
is str
500 assert valid_cvt ==
"b'\\xc7\\xb1'"
502 malformed_utf8 = b
"\x80"
503 if hasattr(m,
"PYBIND11_STR_LEGACY_PERMISSIVE"):
504 assert cvt(malformed_utf8)
is malformed_utf8
506 malformed_cvt = cvt(malformed_utf8)
507 assert type(malformed_cvt)
is str
508 assert malformed_cvt ==
"b'\\x80'"
512 """Tests implicit casting when assigning or appending to dicts and lists."""
513 z = m.get_implicit_casting()
528 assert z[
"l"] == [3, 6, 9, 12, 15]
538 1 2.0 three True -- multiple args
539 *args-and-a-custom-separator
540 no new line here -- next print
542 py::print + str.format = this
545 assert capture.stderr ==
"this goes to stderr"
547 with pytest.raises(RuntimeError)
as excinfo:
549 assert str(excinfo.value) ==
"Unable to convert call argument " + (
550 "'1' of type 'UnregisteredType' to Python object"
551 if detailed_error_messages_enabled
552 else "'1' to Python object (#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for details)"
567 assert m.hash_function(Hashable(42)) == 42
568 with pytest.raises(TypeError):
569 m.hash_function(Unhashable())
573 for a, b
in [(1, 1), (3, 5)]:
591 assert m.test_number_protocol(a, b) == li
596 assert li[::2] == m.test_list_slicing(li)
601 assert m.issue2361_str_implicit_copy_none() ==
"None"
602 with pytest.raises(TypeError)
as excinfo:
603 assert m.issue2361_dict_implicit_copy_none()
604 assert "NoneType" in str(excinfo.value)
605 assert "iterable" in str(excinfo.value)
608 @pytest.mark.parametrize(
609 (
"method",
"args",
"fmt",
"expected_view"),
611 (m.test_memoryview_object, (b
"red",),
"B", b
"red"),
612 (m.test_memoryview_buffer_info, (b
"green",),
"B", b
"green"),
613 (m.test_memoryview_from_buffer, (
False,),
"h", [3, 1, 4, 1, 5]),
614 (m.test_memoryview_from_buffer, (
True,),
"H", [2, 7, 1, 8]),
615 (m.test_memoryview_from_buffer_nativeformat, (),
"@i", [4, 7, 5]),
621 assert view.format == fmt
622 assert list(view) ==
list(expected_view)
625 @pytest.mark.xfail(
"env.PYPY", reason=
"getrefcount is not available")
626 @pytest.mark.parametrize(
629 m.test_memoryview_object,
630 m.test_memoryview_buffer_info,
634 buf = b
"\x0a\x0b\x0c\x0d"
635 ref_before = sys.getrefcount(buf)
637 ref_after = sys.getrefcount(buf)
638 assert ref_before < ref_after
643 view = m.test_memoryview_from_buffer_empty_shape()
645 assert view.format ==
"B"
646 assert bytes(view) == b
""
650 with pytest.raises(RuntimeError):
651 m.test_memoryview_from_buffer_invalid_strides()
655 with pytest.raises(ValueError):
656 m.test_memoryview_from_buffer_nullptr()
660 view = m.test_memoryview_from_memory()
662 assert view.format ==
"B"
663 assert bytes(view) == b
"\xff\xe1\xab\x37"
668 with pytest.raises(TypeError)
as exc_info:
669 m.get_len(i
for i
in range(42))
670 assert str(exc_info.value)
in [
671 "object of type 'generator' has no len()",
672 "'generator' has no length",
677 assert m.isinstance_pybind11_bytes(b
"")
678 assert not m.isinstance_pybind11_bytes(
"")
680 assert m.isinstance_pybind11_str(
"")
681 if hasattr(m,
"PYBIND11_STR_LEGACY_PERMISSIVE"):
682 assert m.isinstance_pybind11_str(b
"")
684 assert not m.isinstance_pybind11_str(b
"")
688 assert m.pass_to_pybind11_bytes(b
"Bytes") == 5
689 with pytest.raises(TypeError):
690 m.pass_to_pybind11_bytes(
"Str")
692 if hasattr(m,
"PYBIND11_STR_LEGACY_PERMISSIVE"):
693 assert m.pass_to_pybind11_str(b
"Bytes") == 5
695 with pytest.raises(TypeError):
696 m.pass_to_pybind11_str(b
"Bytes")
697 assert m.pass_to_pybind11_str(
"Str") == 3
699 assert m.pass_to_std_string(b
"Bytes") == 5
700 assert m.pass_to_std_string(
"Str") == 3
702 malformed_utf8 = b
"\x80"
703 if hasattr(m,
"PYBIND11_STR_LEGACY_PERMISSIVE"):
704 assert m.pass_to_pybind11_str(malformed_utf8) == 1
706 with pytest.raises(TypeError):
707 m.pass_to_pybind11_str(malformed_utf8)
710 @pytest.mark.parametrize(
711 (
"create_weakref",
"create_weakref_with_callback"),
713 (m.weakref_from_handle, m.weakref_from_handle_and_function),
714 (m.weakref_from_object, m.weakref_from_object_and_function),
718 from weakref
import getweakrefcount
721 class WeaklyReferenced:
724 callback_called =
False
727 nonlocal callback_called
728 callback_called =
True
730 obj = WeaklyReferenced()
731 assert getweakrefcount(obj) == 0
732 wr = create_weakref(obj)
733 assert getweakrefcount(obj) == 1
735 obj = WeaklyReferenced()
736 assert getweakrefcount(obj) == 0
737 wr = create_weakref_with_callback(obj, callback)
738 assert getweakrefcount(obj) == 1
739 assert not callback_called
742 assert callback_called
745 @pytest.mark.parametrize(
746 (
"create_weakref",
"has_callback"),
748 (m.weakref_from_handle,
False),
749 (m.weakref_from_object,
False),
750 (m.weakref_from_handle_and_function,
True),
751 (m.weakref_from_object_and_function,
True),
763 with pytest.raises(TypeError)
if not env.PYPY
else contextlib.nullcontext():
764 _ = create_weakref(ob, callback)
if has_callback
else create_weakref(ob)
768 assert m.tuple_iterator() == 12
769 assert m.dict_iterator() == 305 + 711
770 assert m.passed_iterator(
iter((-7, 3))) == -4
774 lst = [39, 43, 92, 49, 22, 29, 93, 98, 26, 57, 8]
776 assert m.sequence_item_get_ssize_t(lst) == 43
777 assert m.sequence_item_set_ssize_t(lst)
is None
778 assert lst[1] ==
"peppa"
779 assert m.sequence_item_get_size_t(lst) == 92
780 assert m.sequence_item_set_size_t(lst)
is None
781 assert lst[2] ==
"george"
782 assert m.list_item_get_ssize_t(lst) == 49
783 assert m.list_item_set_ssize_t(lst)
is None
784 assert lst[3] ==
"rebecca"
785 assert m.list_item_get_size_t(lst) == 22
786 assert m.list_item_set_size_t(lst)
is None
787 assert lst[4] ==
"richard"
788 assert m.tuple_item_get_ssize_t(tup) == 29
789 assert m.tuple_item_set_ssize_t() == (
"emely",
"edmond")
790 assert m.tuple_item_get_size_t(tup) == 93
791 assert m.tuple_item_set_size_t() == (
"candy",
"cat")
795 r1 = m.square_float_(2.0)
802 m.tuple_rvalue_getter(tup)
808 m.list_rvalue_getter(my_list)
813 my_dict = {i: i
for i
in range(pop)}
814 assert m.populate_dict_rvalue(pop) == my_dict
819 o = types.SimpleNamespace(**{
str(i): i
for i
in range(pop)})
820 new_o = m.populate_obj_str_attrs(o, pop)
821 new_attrs = {k: v
for k, v
in new_o.__dict__.items()
if not k.startswith(
"_")}
823 assert len(new_attrs) == pop
826 @pytest.mark.parametrize(
832 assert m.inplace_append(a, b) == expected
835 @pytest.mark.parametrize(
840 assert m.inplace_subtract(a, b) == expected
843 @pytest.mark.parametrize((
"a",
"b"), [(3, 2), (3.0, 2.0), ([1], 3)])
846 assert m.inplace_multiply(a, b) == expected
849 @pytest.mark.parametrize((
"a",
"b"), [(6, 3), (6.0, 3.0)])
852 assert m.inplace_divide(a, b) == expected
855 @pytest.mark.parametrize(
869 assert m.inplace_or(a, b) == expected
872 @pytest.mark.parametrize(
886 assert m.inplace_and(a, b) == expected
889 @pytest.mark.parametrize((
"a",
"b"), [(8, 1), (-3, 2)])
892 assert m.inplace_lshift(a, b) == expected
895 @pytest.mark.parametrize((
"a",
"b"), [(8, 1), (-2, 2)])
898 assert m.inplace_rshift(a, b) == expected