mirror of
https://github.com/pybind/pybind11.git
synced 2024-11-25 06:35:12 +00:00
e9b961d9b9
* Reproducer for property setter with return type that is not wrapped.
* Use `py::class_<OptionsBase>()` to work around the return value conversion issue.
* WIP drop_return_value
* Remove struct drop_return_value
* Introduce `return_value_policy::return_none` for use by setters.
* Add `is_setter` to attr.h and use from `.def_property()`
* Merge the new test into test_methods_and_attributes
* Remove return_none return_value_policy again.
* Fix oversight (NOLINTNEXTLINE placement).
* Simplification (for the better) found while searching for a way to resolve GCC build failures.
Example of failure resolved by this change:
g++ (Ubuntu 9.4.0-1ubuntu1~20.04.1) 9.4.0
```
cd /build/tests && /usr/bin/c++ -DPYBIND11_TEST_EIGEN -Dpybind11_tests_EXPORTS -I/mounted_pybind11/include -isystem /usr/include/python3.8 -isystem /build/_deps/eigen-src -g -std=c++17 -fPIC -fvisibility=hidden -Wall -Wextra -Wconversion -Wcast-qual -Wdeprecated -Wundef -Wnon-virtual-dtor -MD -MT tests/CMakeFiles/pybind11_tests.dir/test_buffers.cpp.o -MF CMakeFiles/pybind11_tests.dir/test_buffers.cpp.o.d -o CMakeFiles/pybind11_tests.dir/test_buffers.cpp.o -c /mounted_pybind11/tests/test_buffers.cpp
In file included from /mounted_pybind11/include/pybind11/stl.h:12,
from /mounted_pybind11/tests/test_buffers.cpp:10:
/mounted_pybind11/include/pybind11/pybind11.h: In instantiation of ‘pybind11::class_<type_, options>& pybind11::class_<type_, options>::def_property(const char*, const Getter&, const Setter&, const Extra& ...) [with Getter = pybind11::cpp_function; Setter = std::nullptr_t; Extra = {pybind11::return_value_policy}; type_ = pybind11::buffer_info; options = {}]’:
/mounted_pybind11/include/pybind11/pybind11.h:1716:58: required from ‘pybind11::class_<type_, options>& pybind11::class_<type_, options>::def_property_readonly(const char*, const pybind11::cpp_function&, const Extra& ...) [with Extra = {pybind11::return_value_policy}; type_ = pybind11::buffer_info; options = {}]’
/mounted_pybind11/include/pybind11/pybind11.h:1684:9: required from ‘pybind11::class_<type_, options>& pybind11::class_<type_, options>::def_readonly(const char*, const D C::*, const Extra& ...) [with C = pybind11::buffer_info; D = long int; Extra = {}; type_ = pybind11::buffer_info; options = {}]’
/mounted_pybind11/tests/test_buffers.cpp:209:61: required from here
/mounted_pybind11/include/pybind11/pybind11.h:1740:25: error: call of overloaded ‘cpp_function(std::nullptr_t&, pybind11::is_setter)’ is ambiguous
1740 | name, fget, cpp_function(method_adaptor<type>(fset), is_setter()), extra...);
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/mounted_pybind11/include/pybind11/pybind11.h:101:5: note: candidate: ‘pybind11::cpp_function::cpp_function(Func&&, const Extra& ...) [with Func = std::nullptr_t&; Extra = {pybind11::is_setter}; <template-parameter-1-3> = void]’
101 | cpp_function(Func &&f, const Extra &...extra) {
| ^~~~~~~~~~~~
In file included from /mounted_pybind11/include/pybind11/stl.h:12,
from /mounted_pybind11/tests/test_buffers.cpp:10:
/mounted_pybind11/include/pybind11/pybind11.h:87:5: note: candidate: ‘pybind11::cpp_function::cpp_function(std::nullptr_t, const Extra& ...) [with Extra = {pybind11::is_setter}; std::nullptr_t = std::nullptr_t]’
87 | cpp_function(std::nullptr_t, const Extra &...) {}
| ^~~~~~~~~~~~
```
* Bug fix: obvious in hindsight. I thought the original version was incrementing the reference count for None, but no.
Discovered via many failing tests in the wild (10s of thousands).
It is very tricky to construct a meaningful unit test for this bug specifically. It's unlikely to come back, because 10s of thousands of tests will fail again.
534 lines
18 KiB
Python
534 lines
18 KiB
Python
import sys
|
|
|
|
import pytest
|
|
|
|
import env # noqa: F401
|
|
from pybind11_tests import ConstructorStats
|
|
from pybind11_tests import methods_and_attributes as m
|
|
|
|
NO_GETTER_MSG = (
|
|
"unreadable attribute" if sys.version_info < (3, 11) else "object has no getter"
|
|
)
|
|
NO_SETTER_MSG = (
|
|
"can't set attribute" if sys.version_info < (3, 11) else "object has no setter"
|
|
)
|
|
NO_DELETER_MSG = (
|
|
"can't delete attribute" if sys.version_info < (3, 11) else "object has no deleter"
|
|
)
|
|
|
|
|
|
def test_methods_and_attributes():
|
|
instance1 = m.ExampleMandA()
|
|
instance2 = m.ExampleMandA(32)
|
|
|
|
instance1.add1(instance2)
|
|
instance1.add2(instance2)
|
|
instance1.add3(instance2)
|
|
instance1.add4(instance2)
|
|
instance1.add5(instance2)
|
|
instance1.add6(32)
|
|
instance1.add7(32)
|
|
instance1.add8(32)
|
|
instance1.add9(32)
|
|
instance1.add10(32)
|
|
|
|
assert str(instance1) == "ExampleMandA[value=320]"
|
|
assert str(instance2) == "ExampleMandA[value=32]"
|
|
assert str(instance1.self1()) == "ExampleMandA[value=320]"
|
|
assert str(instance1.self2()) == "ExampleMandA[value=320]"
|
|
assert str(instance1.self3()) == "ExampleMandA[value=320]"
|
|
assert str(instance1.self4()) == "ExampleMandA[value=320]"
|
|
assert str(instance1.self5()) == "ExampleMandA[value=320]"
|
|
|
|
assert instance1.internal1() == 320
|
|
assert instance1.internal2() == 320
|
|
assert instance1.internal3() == 320
|
|
assert instance1.internal4() == 320
|
|
assert instance1.internal5() == 320
|
|
|
|
assert instance1.overloaded() == "()"
|
|
assert instance1.overloaded(0) == "(int)"
|
|
assert instance1.overloaded(1, 1.0) == "(int, float)"
|
|
assert instance1.overloaded(2.0, 2) == "(float, int)"
|
|
assert instance1.overloaded(3, 3) == "(int, int)"
|
|
assert instance1.overloaded(4.0, 4.0) == "(float, float)"
|
|
assert instance1.overloaded_const(-3) == "(int) const"
|
|
assert instance1.overloaded_const(5, 5.0) == "(int, float) const"
|
|
assert instance1.overloaded_const(6.0, 6) == "(float, int) const"
|
|
assert instance1.overloaded_const(7, 7) == "(int, int) const"
|
|
assert instance1.overloaded_const(8.0, 8.0) == "(float, float) const"
|
|
assert instance1.overloaded_float(1, 1) == "(float, float)"
|
|
assert instance1.overloaded_float(1, 1.0) == "(float, float)"
|
|
assert instance1.overloaded_float(1.0, 1) == "(float, float)"
|
|
assert instance1.overloaded_float(1.0, 1.0) == "(float, float)"
|
|
|
|
assert instance1.value == 320
|
|
instance1.value = 100
|
|
assert str(instance1) == "ExampleMandA[value=100]"
|
|
|
|
cstats = ConstructorStats.get(m.ExampleMandA)
|
|
assert cstats.alive() == 2
|
|
del instance1, instance2
|
|
assert cstats.alive() == 0
|
|
assert cstats.values() == ["32"]
|
|
assert cstats.default_constructions == 1
|
|
assert cstats.copy_constructions == 2
|
|
assert cstats.move_constructions >= 2
|
|
assert cstats.copy_assignments == 0
|
|
assert cstats.move_assignments == 0
|
|
|
|
|
|
def test_copy_method():
|
|
"""Issue #443: calling copied methods fails in Python 3"""
|
|
|
|
m.ExampleMandA.add2c = m.ExampleMandA.add2
|
|
m.ExampleMandA.add2d = m.ExampleMandA.add2b
|
|
a = m.ExampleMandA(123)
|
|
assert a.value == 123
|
|
a.add2(m.ExampleMandA(-100))
|
|
assert a.value == 23
|
|
a.add2b(m.ExampleMandA(20))
|
|
assert a.value == 43
|
|
a.add2c(m.ExampleMandA(6))
|
|
assert a.value == 49
|
|
a.add2d(m.ExampleMandA(-7))
|
|
assert a.value == 42
|
|
|
|
|
|
def test_properties():
|
|
instance = m.TestProperties()
|
|
|
|
assert instance.def_readonly == 1
|
|
with pytest.raises(AttributeError):
|
|
instance.def_readonly = 2
|
|
|
|
instance.def_readwrite = 2
|
|
assert instance.def_readwrite == 2
|
|
|
|
assert instance.def_property_readonly == 2
|
|
with pytest.raises(AttributeError):
|
|
instance.def_property_readonly = 3
|
|
|
|
instance.def_property = 3
|
|
assert instance.def_property == 3
|
|
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
dummy = instance.def_property_writeonly # unused var
|
|
assert NO_GETTER_MSG in str(excinfo.value)
|
|
|
|
instance.def_property_writeonly = 4
|
|
assert instance.def_property_readonly == 4
|
|
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
dummy = instance.def_property_impossible # noqa: F841 unused var
|
|
assert NO_GETTER_MSG in str(excinfo.value)
|
|
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
instance.def_property_impossible = 5
|
|
assert NO_SETTER_MSG in str(excinfo.value)
|
|
|
|
|
|
def test_static_properties():
|
|
assert m.TestProperties.def_readonly_static == 1
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
m.TestProperties.def_readonly_static = 2
|
|
assert NO_SETTER_MSG in str(excinfo.value)
|
|
|
|
m.TestProperties.def_readwrite_static = 2
|
|
assert m.TestProperties.def_readwrite_static == 2
|
|
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
dummy = m.TestProperties.def_writeonly_static # unused var
|
|
assert NO_GETTER_MSG in str(excinfo.value)
|
|
|
|
m.TestProperties.def_writeonly_static = 3
|
|
assert m.TestProperties.def_readonly_static == 3
|
|
|
|
assert m.TestProperties.def_property_readonly_static == 3
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
m.TestProperties.def_property_readonly_static = 99
|
|
assert NO_SETTER_MSG in str(excinfo.value)
|
|
|
|
m.TestProperties.def_property_static = 4
|
|
assert m.TestProperties.def_property_static == 4
|
|
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
dummy = m.TestProperties.def_property_writeonly_static
|
|
assert NO_GETTER_MSG in str(excinfo.value)
|
|
|
|
m.TestProperties.def_property_writeonly_static = 5
|
|
assert m.TestProperties.def_property_static == 5
|
|
|
|
# Static property read and write via instance
|
|
instance = m.TestProperties()
|
|
|
|
m.TestProperties.def_readwrite_static = 0
|
|
assert m.TestProperties.def_readwrite_static == 0
|
|
assert instance.def_readwrite_static == 0
|
|
|
|
instance.def_readwrite_static = 2
|
|
assert m.TestProperties.def_readwrite_static == 2
|
|
assert instance.def_readwrite_static == 2
|
|
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
dummy = instance.def_property_writeonly_static # noqa: F841 unused var
|
|
assert NO_GETTER_MSG in str(excinfo.value)
|
|
|
|
instance.def_property_writeonly_static = 4
|
|
assert instance.def_property_static == 4
|
|
|
|
# It should be possible to override properties in derived classes
|
|
assert m.TestPropertiesOverride().def_readonly == 99
|
|
assert m.TestPropertiesOverride.def_readonly_static == 99
|
|
|
|
# Only static attributes can be deleted
|
|
del m.TestPropertiesOverride.def_readonly_static
|
|
assert hasattr(m.TestPropertiesOverride, "def_readonly_static")
|
|
assert (
|
|
m.TestPropertiesOverride.def_readonly_static
|
|
is m.TestProperties.def_readonly_static
|
|
)
|
|
assert "def_readonly_static" not in m.TestPropertiesOverride.__dict__
|
|
properties_override = m.TestPropertiesOverride()
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
del properties_override.def_readonly
|
|
assert NO_DELETER_MSG in str(excinfo.value)
|
|
|
|
|
|
def test_static_cls():
|
|
"""Static property getter and setters expect the type object as the their only argument"""
|
|
|
|
instance = m.TestProperties()
|
|
assert m.TestProperties.static_cls is m.TestProperties
|
|
assert instance.static_cls is m.TestProperties
|
|
|
|
def check_self(self):
|
|
assert self is m.TestProperties
|
|
|
|
m.TestProperties.static_cls = check_self
|
|
instance.static_cls = check_self
|
|
|
|
|
|
def test_metaclass_override():
|
|
"""Overriding pybind11's default metaclass changes the behavior of `static_property`"""
|
|
|
|
assert type(m.ExampleMandA).__name__ == "pybind11_type"
|
|
assert type(m.MetaclassOverride).__name__ == "type"
|
|
|
|
assert m.MetaclassOverride.readonly == 1
|
|
assert (
|
|
type(m.MetaclassOverride.__dict__["readonly"]).__name__
|
|
== "pybind11_static_property"
|
|
)
|
|
|
|
# Regular `type` replaces the property instead of calling `__set__()`
|
|
m.MetaclassOverride.readonly = 2
|
|
assert m.MetaclassOverride.readonly == 2
|
|
assert isinstance(m.MetaclassOverride.__dict__["readonly"], int)
|
|
|
|
|
|
def test_no_mixed_overloads():
|
|
from pybind11_tests import detailed_error_messages_enabled
|
|
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.ExampleMandA.add_mixed_overloads1()
|
|
assert str(
|
|
excinfo.value
|
|
) == "overloading a method with both static and instance methods is not supported; " + (
|
|
"#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for more details"
|
|
if not detailed_error_messages_enabled
|
|
else "error while attempting to bind static method ExampleMandA.overload_mixed1"
|
|
"(arg0: float) -> str"
|
|
)
|
|
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.ExampleMandA.add_mixed_overloads2()
|
|
assert str(
|
|
excinfo.value
|
|
) == "overloading a method with both static and instance methods is not supported; " + (
|
|
"#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for more details"
|
|
if not detailed_error_messages_enabled
|
|
else "error while attempting to bind instance method ExampleMandA.overload_mixed2"
|
|
"(self: pybind11_tests.methods_and_attributes.ExampleMandA, arg0: int, arg1: int)"
|
|
" -> str"
|
|
)
|
|
|
|
|
|
@pytest.mark.parametrize("access", ["ro", "rw", "static_ro", "static_rw"])
|
|
def test_property_return_value_policies(access):
|
|
obj = m.TestPropRVP() if not access.startswith("static") else m.TestPropRVP
|
|
|
|
ref = getattr(obj, access + "_ref")
|
|
assert ref.value == 1
|
|
ref.value = 2
|
|
assert getattr(obj, access + "_ref").value == 2
|
|
ref.value = 1 # restore original value for static properties
|
|
|
|
copy = getattr(obj, access + "_copy")
|
|
assert copy.value == 1
|
|
copy.value = 2
|
|
assert getattr(obj, access + "_copy").value == 1
|
|
|
|
copy = getattr(obj, access + "_func")
|
|
assert copy.value == 1
|
|
copy.value = 2
|
|
assert getattr(obj, access + "_func").value == 1
|
|
|
|
|
|
def test_property_rvalue_policy():
|
|
"""When returning an rvalue, the return value policy is automatically changed from
|
|
`reference(_internal)` to `move`. The following would not work otherwise."""
|
|
|
|
instance = m.TestPropRVP()
|
|
o = instance.rvalue
|
|
assert o.value == 1
|
|
|
|
os = m.TestPropRVP.static_rvalue
|
|
assert os.value == 1
|
|
|
|
|
|
# https://foss.heptapod.net/pypy/pypy/-/issues/2447
|
|
@pytest.mark.xfail("env.PYPY")
|
|
def test_dynamic_attributes():
|
|
instance = m.DynamicClass()
|
|
assert not hasattr(instance, "foo")
|
|
assert "foo" not in dir(instance)
|
|
|
|
# Dynamically add attribute
|
|
instance.foo = 42
|
|
assert hasattr(instance, "foo")
|
|
assert instance.foo == 42
|
|
assert "foo" in dir(instance)
|
|
|
|
# __dict__ should be accessible and replaceable
|
|
assert "foo" in instance.__dict__
|
|
instance.__dict__ = {"bar": True}
|
|
assert not hasattr(instance, "foo")
|
|
assert hasattr(instance, "bar")
|
|
|
|
with pytest.raises(TypeError) as excinfo:
|
|
instance.__dict__ = []
|
|
assert str(excinfo.value) == "__dict__ must be set to a dictionary, not a 'list'"
|
|
|
|
cstats = ConstructorStats.get(m.DynamicClass)
|
|
assert cstats.alive() == 1
|
|
del instance
|
|
assert cstats.alive() == 0
|
|
|
|
# Derived classes should work as well
|
|
class PythonDerivedDynamicClass(m.DynamicClass):
|
|
pass
|
|
|
|
for cls in m.CppDerivedDynamicClass, PythonDerivedDynamicClass:
|
|
derived = cls()
|
|
derived.foobar = 100
|
|
assert derived.foobar == 100
|
|
|
|
assert cstats.alive() == 1
|
|
del derived
|
|
assert cstats.alive() == 0
|
|
|
|
|
|
# https://foss.heptapod.net/pypy/pypy/-/issues/2447
|
|
@pytest.mark.xfail("env.PYPY")
|
|
def test_cyclic_gc():
|
|
# One object references itself
|
|
instance = m.DynamicClass()
|
|
instance.circular_reference = instance
|
|
|
|
cstats = ConstructorStats.get(m.DynamicClass)
|
|
assert cstats.alive() == 1
|
|
del instance
|
|
assert cstats.alive() == 0
|
|
|
|
# Two object reference each other
|
|
i1 = m.DynamicClass()
|
|
i2 = m.DynamicClass()
|
|
i1.cycle = i2
|
|
i2.cycle = i1
|
|
|
|
assert cstats.alive() == 2
|
|
del i1, i2
|
|
assert cstats.alive() == 0
|
|
|
|
|
|
def test_bad_arg_default(msg):
|
|
from pybind11_tests import detailed_error_messages_enabled
|
|
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.bad_arg_def_named()
|
|
assert msg(excinfo.value) == (
|
|
"arg(): could not convert default argument 'a: UnregisteredType' in function "
|
|
"'should_fail' into a Python object (type not registered yet?)"
|
|
if detailed_error_messages_enabled
|
|
else "arg(): could not convert default argument into a Python object (type not registered "
|
|
"yet?). #define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for more information."
|
|
)
|
|
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.bad_arg_def_unnamed()
|
|
assert msg(excinfo.value) == (
|
|
"arg(): could not convert default argument 'UnregisteredType' in function "
|
|
"'should_fail' into a Python object (type not registered yet?)"
|
|
if detailed_error_messages_enabled
|
|
else "arg(): could not convert default argument into a Python object (type not registered "
|
|
"yet?). #define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for more information."
|
|
)
|
|
|
|
|
|
def test_accepts_none(msg):
|
|
a = m.NoneTester()
|
|
assert m.no_none1(a) == 42
|
|
assert m.no_none2(a) == 42
|
|
assert m.no_none3(a) == 42
|
|
assert m.no_none4(a) == 42
|
|
assert m.no_none5(a) == 42
|
|
assert m.ok_none1(a) == 42
|
|
assert m.ok_none2(a) == 42
|
|
assert m.ok_none3(a) == 42
|
|
assert m.ok_none4(a) == 42
|
|
assert m.ok_none5(a) == 42
|
|
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.no_none1(None)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.no_none2(None)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.no_none3(None)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.no_none4(None)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.no_none5(None)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
|
|
# The first one still raises because you can't pass None as a lvalue reference arg:
|
|
with pytest.raises(TypeError) as excinfo:
|
|
assert m.ok_none1(None) == -1
|
|
assert (
|
|
msg(excinfo.value)
|
|
== """
|
|
ok_none1(): incompatible function arguments. The following argument types are supported:
|
|
1. (arg0: m.methods_and_attributes.NoneTester) -> int
|
|
|
|
Invoked with: None
|
|
"""
|
|
)
|
|
|
|
# The rest take the argument as pointer or holder, and accept None:
|
|
assert m.ok_none2(None) == -1
|
|
assert m.ok_none3(None) == -1
|
|
assert m.ok_none4(None) == -1
|
|
assert m.ok_none5(None) == -1
|
|
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.no_none_kwarg(None)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.no_none_kwarg(a=None)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.no_none_kwarg_kw_only(None)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.no_none_kwarg_kw_only(a=None)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
|
|
|
|
def test_casts_none():
|
|
"""#2778: implicit casting from None to object (not pointer)"""
|
|
a = m.NoneCastTester()
|
|
assert m.ok_obj_or_none(a) == -1
|
|
a = m.NoneCastTester(4)
|
|
assert m.ok_obj_or_none(a) == 4
|
|
a = m.NoneCastTester(None)
|
|
assert m.ok_obj_or_none(a) == -1
|
|
assert m.ok_obj_or_none(None) == -1
|
|
|
|
|
|
def test_str_issue(msg):
|
|
"""#283: __str__ called on uninitialized instance when constructor arguments invalid"""
|
|
|
|
assert str(m.StrIssue(3)) == "StrIssue[3]"
|
|
|
|
with pytest.raises(TypeError) as excinfo:
|
|
str(m.StrIssue("no", "such", "constructor"))
|
|
assert (
|
|
msg(excinfo.value)
|
|
== """
|
|
__init__(): incompatible constructor arguments. The following argument types are supported:
|
|
1. m.methods_and_attributes.StrIssue(arg0: int)
|
|
2. m.methods_and_attributes.StrIssue()
|
|
|
|
Invoked with: 'no', 'such', 'constructor'
|
|
"""
|
|
)
|
|
|
|
|
|
def test_unregistered_base_implementations():
|
|
a = m.RegisteredDerived()
|
|
a.do_nothing()
|
|
assert a.rw_value == 42
|
|
assert a.ro_value == 1.25
|
|
a.rw_value += 5
|
|
assert a.sum() == 48.25
|
|
a.increase_value()
|
|
assert a.rw_value == 48
|
|
assert a.ro_value == 1.5
|
|
assert a.sum() == 49.5
|
|
assert a.rw_value_prop == 48
|
|
a.rw_value_prop += 1
|
|
assert a.rw_value_prop == 49
|
|
a.increase_value()
|
|
assert a.ro_value_prop == 1.75
|
|
|
|
|
|
def test_ref_qualified():
|
|
"""Tests that explicit lvalue ref-qualified methods can be called just like their
|
|
non ref-qualified counterparts."""
|
|
|
|
r = m.RefQualified()
|
|
assert r.value == 0
|
|
r.refQualified(17)
|
|
assert r.value == 17
|
|
assert r.constRefQualified(23) == 40
|
|
|
|
|
|
def test_overload_ordering():
|
|
"Check to see if the normal overload order (first defined) and prepend overload order works"
|
|
assert m.overload_order("string") == 1
|
|
assert m.overload_order(0) == 4
|
|
|
|
assert "1. overload_order(arg0: int) -> int" in m.overload_order.__doc__
|
|
assert "2. overload_order(arg0: str) -> int" in m.overload_order.__doc__
|
|
assert "3. overload_order(arg0: str) -> int" in m.overload_order.__doc__
|
|
assert "4. overload_order(arg0: int) -> int" in m.overload_order.__doc__
|
|
|
|
with pytest.raises(TypeError) as err:
|
|
m.overload_order(1.1)
|
|
|
|
assert "1. (arg0: int) -> int" in str(err.value)
|
|
assert "2. (arg0: str) -> int" in str(err.value)
|
|
assert "3. (arg0: str) -> int" in str(err.value)
|
|
assert "4. (arg0: int) -> int" in str(err.value)
|
|
|
|
|
|
def test_rvalue_ref_param():
|
|
r = m.RValueRefParam()
|
|
assert r.func1("123") == 3
|
|
assert r.func2("1234") == 4
|
|
assert r.func3("12345") == 5
|
|
assert r.func4("123456") == 6
|
|
|
|
|
|
def test_is_setter():
|
|
fld = m.exercise_is_setter.Field()
|
|
assert fld.int_value == -99
|
|
setter_return = fld.int_value = 100
|
|
assert isinstance(setter_return, int)
|
|
assert setter_return == 100
|
|
assert fld.int_value == 100
|