import pytest from pybind11_tests import class_ as m from pybind11_tests import UserType, ConstructorStats def test_repr(): # In Python 3.3+, repr() accesses __qualname__ assert "pybind11_type" in repr(type(UserType)) assert "UserType" in repr(UserType) def test_instance(msg): with pytest.raises(TypeError) as excinfo: m.NoConstructor() assert msg(excinfo.value) == "m.class_.NoConstructor: No constructor defined!" instance = m.NoConstructor.new_instance() cstats = ConstructorStats.get(m.NoConstructor) assert cstats.alive() == 1 del instance assert cstats.alive() == 0 def test_docstrings(doc): assert doc(UserType) == "A `py::class_` type for testing" assert UserType.__name__ == "UserType" assert UserType.__module__ == "pybind11_tests" assert UserType.get_value.__name__ == "get_value" assert UserType.get_value.__module__ == "pybind11_tests" assert doc(UserType.get_value) == """ get_value(self: m.UserType) -> int Get value using a method """ assert doc(UserType.value) == "Get/set value using a property" assert doc(m.NoConstructor.new_instance) == """ new_instance() -> m.class_.NoConstructor Return an instance """ def test_qualname(doc): """Tests that a properly qualified name is set in __qualname__ (even in pre-3.3, where we backport the attribute) and that generated docstrings properly use it and the module name""" assert m.NestBase.__qualname__ == "NestBase" assert m.NestBase.Nested.__qualname__ == "NestBase.Nested" assert doc(m.NestBase.__init__) == """ __init__(self: m.class_.NestBase) -> None """ assert doc(m.NestBase.g) == """ g(self: m.class_.NestBase, arg0: m.class_.NestBase.Nested) -> None """ assert doc(m.NestBase.Nested.__init__) == """ __init__(self: m.class_.NestBase.Nested) -> None """ assert doc(m.NestBase.Nested.fn) == """ fn(self: m.class_.NestBase.Nested, arg0: int, arg1: m.class_.NestBase, arg2: m.class_.NestBase.Nested) -> None """ # noqa: E501 line too long assert doc(m.NestBase.Nested.fa) == """ fa(self: m.class_.NestBase.Nested, a: int, b: m.class_.NestBase, c: m.class_.NestBase.Nested) -> None """ # noqa: E501 line too long assert m.NestBase.__module__ == "pybind11_tests.class_" assert m.NestBase.Nested.__module__ == "pybind11_tests.class_" def test_inheritance(msg): roger = m.Rabbit('Rabbit') assert roger.name() + " is a " + roger.species() == "Rabbit is a parrot" assert m.pet_name_species(roger) == "Rabbit is a parrot" polly = m.Pet('Polly', 'parrot') assert polly.name() + " is a " + polly.species() == "Polly is a parrot" assert m.pet_name_species(polly) == "Polly is a parrot" molly = m.Dog('Molly') assert molly.name() + " is a " + molly.species() == "Molly is a dog" assert m.pet_name_species(molly) == "Molly is a dog" fred = m.Hamster('Fred') assert fred.name() + " is a " + fred.species() == "Fred is a rodent" assert m.dog_bark(molly) == "Woof!" with pytest.raises(TypeError) as excinfo: m.dog_bark(polly) assert msg(excinfo.value) == """ dog_bark(): incompatible function arguments. The following argument types are supported: 1. (arg0: m.class_.Dog) -> str Invoked with: """ with pytest.raises(TypeError) as excinfo: m.Chimera("lion", "goat") assert "No constructor defined!" in str(excinfo.value) def test_automatic_upcasting(): assert type(m.return_class_1()).__name__ == "DerivedClass1" assert type(m.return_class_2()).__name__ == "DerivedClass2" assert type(m.return_none()).__name__ == "NoneType" # Repeat these a few times in a random order to ensure no invalid caching is applied assert type(m.return_class_n(1)).__name__ == "DerivedClass1" assert type(m.return_class_n(2)).__name__ == "DerivedClass2" assert type(m.return_class_n(0)).__name__ == "BaseClass" assert type(m.return_class_n(2)).__name__ == "DerivedClass2" assert type(m.return_class_n(2)).__name__ == "DerivedClass2" assert type(m.return_class_n(0)).__name__ == "BaseClass" assert type(m.return_class_n(1)).__name__ == "DerivedClass1" def test_isinstance(): objects = [tuple(), dict(), m.Pet("Polly", "parrot")] + [m.Dog("Molly")] * 4 expected = (True, True, True, True, True, False, False) assert m.check_instances(objects) == expected def test_mismatched_holder(): import re with pytest.raises(RuntimeError) as excinfo: m.mismatched_holder_1() assert re.match('generic_type: type ".*MismatchDerived1" does not have a non-default ' 'holder type while its base ".*MismatchBase1" does', str(excinfo.value)) with pytest.raises(RuntimeError) as excinfo: m.mismatched_holder_2() assert re.match('generic_type: type ".*MismatchDerived2" has a non-default holder type ' 'while its base ".*MismatchBase2" does not', str(excinfo.value)) def test_override_static(): """#511: problem with inheritance + overwritten def_static""" b = m.MyBase.make() d1 = m.MyDerived.make2() d2 = m.MyDerived.make() assert isinstance(b, m.MyBase) assert isinstance(d1, m.MyDerived) assert isinstance(d2, m.MyDerived) def test_implicit_conversion_life_support(): """Ensure the lifetime of temporary objects created for implicit conversions""" assert m.implicitly_convert_argument(UserType(5)) == 5 assert m.implicitly_convert_variable(UserType(5)) == 5 assert "outside a bound function" in m.implicitly_convert_variable_fail(UserType(5)) def test_operator_new_delete(capture): """Tests that class-specific operator new/delete functions are invoked""" class SubAliased(m.AliasedHasOpNewDelSize): pass with capture: a = m.HasOpNewDel() b = m.HasOpNewDelSize() d = m.HasOpNewDelBoth() assert capture == """ A new 8 B new 4 D new 32 """ sz_alias = str(m.AliasedHasOpNewDelSize.size_alias) sz_noalias = str(m.AliasedHasOpNewDelSize.size_noalias) with capture: c = m.AliasedHasOpNewDelSize() c2 = SubAliased() assert capture == ( "C new " + sz_noalias + "\n" + "C new " + sz_alias + "\n" ) with capture: del a pytest.gc_collect() del b pytest.gc_collect() del d pytest.gc_collect() assert capture == """ A delete B delete 4 D delete """ with capture: del c pytest.gc_collect() del c2 pytest.gc_collect() assert capture == ( "C delete " + sz_noalias + "\n" + "C delete " + sz_alias + "\n" ) def test_bind_protected_functions(): """Expose protected member functions to Python using a helper class""" a = m.ProtectedA() assert a.foo() == 42 b = m.ProtectedB() assert b.foo() == 42 class C(m.ProtectedB): def __init__(self): m.ProtectedB.__init__(self) def foo(self): return 0 c = C() assert c.foo() == 0 def test_brace_initialization(): """ Tests that simple POD classes can be constructed using C++11 brace initialization """ a = m.BraceInitialization(123, "test") assert a.field1 == 123 assert a.field2 == "test" # Tests that a non-simple class doesn't get brace initialization (if the # class defines an initializer_list constructor, in particular, it would # win over the expected constructor). b = m.NoBraceInitialization([123, 456]) assert b.vec == [123, 456] @pytest.unsupported_on_pypy def test_class_refcount(): """Instances must correctly increase/decrease the reference count of their types (#1029)""" from sys import getrefcount class PyDog(m.Dog): pass for cls in m.Dog, PyDog: refcount_1 = getrefcount(cls) molly = [cls("Molly") for _ in range(10)] refcount_2 = getrefcount(cls) del molly pytest.gc_collect() refcount_3 = getrefcount(cls) assert refcount_1 == refcount_3 assert refcount_2 > refcount_1 def test_reentrant_implicit_conversion_failure(msg): # ensure that there is no runaway reentrant implicit conversion (#1035) with pytest.raises(TypeError) as excinfo: m.BogusImplicitConversion(0) assert msg(excinfo.value) == ''' __init__(): incompatible constructor arguments. The following argument types are supported: 1. m.class_.BogusImplicitConversion(arg0: m.class_.BogusImplicitConversion) Invoked with: 0 '''