ext/pybind11/tests/test_class.py - public/gem5 - Git at Google

 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: <m.class_.Pet object at 0>
     """

     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
     '''


 def test_error_after_conversions():
     with pytest.raises(TypeError) as exc_info:
         m.test_error_after_conversions("hello")
     assert str(exc_info.value).startswith(
         "Unable to convert function return value to a Python type!")


 def test_aligned():
     if hasattr(m, "Aligned"):
         p = m.Aligned().ptr()
         assert p % 1024 == 0
	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: <m.class_.Pet object at 0>
	"""

	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
	'''


	def test_error_after_conversions():
	with pytest.raises(TypeError) as exc_info:
	m.test_error_after_conversions("hello")
	assert str(exc_info.value).startswith(
	"Unable to convert function return value to a Python type!")


	def test_aligned():
	if hasattr(m, "Aligned"):
	p = m.Aligned().ptr()
	assert p % 1024 == 0