526 lines
17 KiB
Python
526 lines
17 KiB
Python
# -*- coding: utf-8 -*-
|
|
import pytest
|
|
|
|
import env # noqa: F401
|
|
from pybind11_tests import ConstructorStats
|
|
from pybind11_tests import methods_and_attributes as m
|
|
|
|
|
|
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 "unreadable attribute" 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 "unreadable attribute" in str(excinfo.value)
|
|
|
|
with pytest.raises(AttributeError) as excinfo:
|
|
instance.def_property_impossible = 5
|
|
assert "can't set attribute" 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 "can't set attribute" 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 "unreadable attribute" 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 "can't set attribute" 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 "unreadable attribute" 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 "unreadable attribute" 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")
|
|
and 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 "can't delete attribute" 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 debug_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; " + (
|
|
"compile in debug mode for more details"
|
|
if not debug_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; " + (
|
|
"compile in debug mode for more details"
|
|
if not debug_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):
|
|
if not access.startswith("static"):
|
|
obj = m.TestPropRVP()
|
|
else:
|
|
obj = 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 debug_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 debug_enabled
|
|
else "arg(): could not convert default argument into a Python object (type not registered "
|
|
"yet?). 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 debug_enabled
|
|
else "arg(): could not convert default argument into a Python object (type not registered "
|
|
"yet?). 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
|
|
|
|
# Different for Python 2 vs. 3
|
|
uni_name = type(u"").__name__
|
|
|
|
assert "1. overload_order(arg0: int) -> int" in m.overload_order.__doc__
|
|
assert (
|
|
"2. overload_order(arg0: {}) -> int".format(uni_name)
|
|
in m.overload_order.__doc__
|
|
)
|
|
assert (
|
|
"3. overload_order(arg0: {}) -> int".format(uni_name)
|
|
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: {}) -> int".format(uni_name) in str(err.value)
|
|
assert "3. (arg0: {}) -> int".format(uni_name) 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
|