Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2024-11-26 07:02:11 +00:00
Code Issues Packages Projects Releases Wiki Activity
bdfb50f384
pybind11/tests/test_call_policies.py

178 lines
5.0 KiB
Python
Raw Normal View History

WIP: PyPy support (#527) This commit includes modifications that are needed to get pybind11 to work with PyPy. The full test suite compiles and runs except for a last few functions that are commented out (due to problems in PyPy that were reported on the PyPy bugtracker). Two somewhat intrusive changes were needed to make it possible: two new tags ``py::buffer_protocol()`` and ``py::metaclass()`` must now be specified to the ``class_`` constructor if the class uses the buffer protocol and/or requires a metaclass (e.g. for static properties). Note that this is only for the PyPy version based on Python 2.7 for now. When the PyPy 3.x has caught up in terms of cpyext compliance, a PyPy 3.x patch will follow.
2016-12-16 14:00:46 +00:00
import pytest
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
def test_keep_alive_argument(capture):
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
from pybind11_tests import Parent, Child, ConstructorStats
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
n_inst = ConstructorStats.detail_reg_inst()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
with capture:
p = Parent()
assert capture == "Allocating parent."
with capture:
p.addChild(Child())
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst + 1
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == """
Allocating child.
Releasing child.
"""
with capture:
del p
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == "Releasing parent."
with capture:
p = Parent()
assert capture == "Allocating parent."
with capture:
p.addChildKeepAlive(Child())
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst + 2
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == "Allocating child."
with capture:
del p
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == """
Releasing parent.
Releasing child.
"""
def test_keep_alive_return_value(capture):
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
from pybind11_tests import Parent, ConstructorStats
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
n_inst = ConstructorStats.detail_reg_inst()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
with capture:
p = Parent()
assert capture == "Allocating parent."
with capture:
p.returnChild()
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst + 1
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == """
Allocating child.
Releasing child.
"""
with capture:
del p
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == "Releasing parent."
with capture:
p = Parent()
assert capture == "Allocating parent."
with capture:
p.returnChildKeepAlive()
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst + 2
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == "Allocating child."
with capture:
del p
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst
assert capture == """
Releasing parent.
Releasing child.
"""
# https://bitbucket.org/pypy/pypy/issues/2447
@pytest.unsupported_on_pypy
def test_alive_gc(capture):
from pybind11_tests import ParentGC, Child, ConstructorStats
n_inst = ConstructorStats.detail_reg_inst()
p = ParentGC()
p.addChildKeepAlive(Child())
assert ConstructorStats.detail_reg_inst() == n_inst + 2
lst = [p]
lst.append(lst) # creates a circular reference
with capture:
del p, lst
assert ConstructorStats.detail_reg_inst() == n_inst
assert capture == """
Releasing parent.
Releasing child.
"""
def test_alive_gc_derived(capture):
from pybind11_tests import Parent, Child, ConstructorStats
class Derived(Parent):
pass
n_inst = ConstructorStats.detail_reg_inst()
p = Derived()
p.addChildKeepAlive(Child())
assert ConstructorStats.detail_reg_inst() == n_inst + 2
lst = [p]
lst.append(lst) # creates a circular reference
with capture:
del p, lst
assert ConstructorStats.detail_reg_inst() == n_inst
assert capture == """
Releasing parent.
Releasing child.
"""
def test_alive_gc_multi_derived(capture):
from pybind11_tests import Parent, Child, ConstructorStats
class Derived(Parent, Child):
pass
n_inst = ConstructorStats.detail_reg_inst()
p = Derived()
p.addChildKeepAlive(Child())
# +3 rather than +2 because Derived corresponds to two registered instances
assert ConstructorStats.detail_reg_inst() == n_inst + 3
lst = [p]
lst.append(lst) # creates a circular reference
with capture:
del p, lst
assert ConstructorStats.detail_reg_inst() == n_inst
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == """
Releasing parent.
Releasing child.
"""
def test_return_none(capture):
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
from pybind11_tests import Parent, ConstructorStats
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
n_inst = ConstructorStats.detail_reg_inst()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
with capture:
p = Parent()
assert capture == "Allocating parent."
with capture:
p.returnNullChildKeepAliveChild()
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst + 1
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == ""
with capture:
del p
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == "Releasing parent."
with capture:
p = Parent()
assert capture == "Allocating parent."
with capture:
p.returnNullChildKeepAliveParent()
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst + 1
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == ""
with capture:
del p
Hold strong references to keep_alive patients This fixes #856. Instead of the weakref trick, the internals structure holds an unordered_map from PyObject* to a vector of references. To avoid the cost of the unordered_map lookup for objects that don't have any keep_alive patients, a flag is added to each instance to indicate whether there is anything to do.
2017-06-24 12:58:42 +00:00
assert ConstructorStats.detail_reg_inst() == n_inst
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
assert capture == "Releasing parent."
Add a scope guard call policy ```c++ m.def("foo", foo, py::call_guard<T>()); ``` is equivalent to: ```c++ m.def("foo", [](args...) { T scope_guard; return foo(args...); // forwarded arguments }); ```
2017-03-16 10:22:26 +00:00
def test_call_guard():
from pybind11_tests import call_policies
assert call_policies.unguarded_call() == "unguarded"
assert call_policies.guarded_call() == "guarded"
assert call_policies.multiple_guards_correct_order() == "guarded & guarded"
assert call_policies.multiple_guards_wrong_order() == "unguarded & guarded"
if hasattr(call_policies, "with_gil"):
assert call_policies.with_gil() == "GIL held"
assert call_policies.without_gil() == "GIL released"
Reference in New Issue Copy Permalink