Zengtudor
/
pybind11
mirror of https://github.com/pybind/pybind11.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
pybind11/tests/test_class_sh_trampoline_sh...

144 lines
4.4 KiB
Python
Raw Normal View History

First fully successful attempt to make `shared_from_this` and trampolines play nicely. Now also passes the open_spiel iterated_prisoners_dilemma_test ASAN clean, in addition to all pybind11 and PyCLIF unit tests. The problem was that calling `std::shared_ptr<void>::reset()` with a `void` pointer cannot possibly update the `shared_from_this` `weak_ptr`. The solution is to store a `shd_ptr_reset` function pointer in `guarded_deleter` (similar in idea to the stored function pointer for calling `delete`). This commit still includes all debugging code, i.e. is "dirty". The code will be cleaned up after the GitHub CI is fully successful.
2021-06-20 01:13:27 +00:00
# -*- coding: utf-8 -*-
Adding `test_pass_released_shared_ptr_as_unique_ptr`, exercising new guard in smart_holder_type_casters.h.
2021-06-21 23:16:37 +00:00
import pytest
First fully successful attempt to make `shared_from_this` and trampolines play nicely. Now also passes the open_spiel iterated_prisoners_dilemma_test ASAN clean, in addition to all pybind11 and PyCLIF unit tests. The problem was that calling `std::shared_ptr<void>::reset()` with a `void` pointer cannot possibly update the `shared_from_this` `weak_ptr`. The solution is to store a `shd_ptr_reset` function pointer in `guarded_deleter` (similar in idea to the stored function pointer for calling `delete`). This commit still includes all debugging code, i.e. is "dirty". The code will be cleaned up after the GitHub CI is fully successful.
2021-06-20 01:13:27 +00:00
import pybind11_tests.class_sh_trampoline_shared_from_this as m
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
class PySft(m.Sft):
First fully successful attempt to make `shared_from_this` and trampolines play nicely. Now also passes the open_spiel iterated_prisoners_dilemma_test ASAN clean, in addition to all pybind11 and PyCLIF unit tests. The problem was that calling `std::shared_ptr<void>::reset()` with a `void` pointer cannot possibly update the `shared_from_this` `weak_ptr`. The solution is to store a `shd_ptr_reset` function pointer in `guarded_deleter` (similar in idea to the stored function pointer for calling `delete`). This commit still includes all debugging code, i.e. is "dirty". The code will be cleaned up after the GitHub CI is fully successful.
2021-06-20 01:13:27 +00:00
pass
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
def test_release_and_shared_from_this():
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
obj = PySft("PySft")
assert obj.history == "PySft"
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert m.use_count(obj) == 1
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
assert m.pass_shared_ptr(obj) == 2
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
assert obj.history == "PySft_PassSharedPtr"
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert m.use_count(obj) == 1
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
assert m.pass_shared_ptr(obj) == 2
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
assert obj.history == "PySft_PassSharedPtr_PassSharedPtr"
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert m.use_count(obj) == 1
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
def test_release_and_shared_from_this_leak():
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
obj = PySft("")
while True:
m.pass_shared_ptr(obj)
assert obj.history == ""
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert m.use_count(obj) == 1
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
break # Comment out for manual leak checking (use `top` command).
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
def test_release_and_stash():
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
obj = PySft("PySft")
stash1 = m.SftSharedPtrStash(1)
stash1.Add(obj)
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
exp_hist = "PySft_Stash1Add"
assert obj.history == exp_hist
assert m.use_count(obj) == 2
assert stash1.history(0) == exp_hist
assert stash1.use_count(0) == 1
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
assert m.pass_shared_ptr(obj) == 3
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
exp_hist += "_PassSharedPtr"
assert obj.history == exp_hist
assert m.use_count(obj) == 2
assert stash1.history(0) == exp_hist
Leveraging new `noop_deleter_acting_as_weak_ptr_owner` to retrieve released `vptr`. The placeholder `vptr` is never exposed anymore, therefore the externally visible `use_count`s are more intuitive.
2021-06-22 01:09:14 +00:00
assert stash1.use_count(0) == 1
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
stash2 = m.SftSharedPtrStash(2)
stash2.Add(obj)
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
exp_hist += "_Stash2Add"
assert obj.history == exp_hist
assert m.use_count(obj) == 3
assert stash2.history(0) == exp_hist
Leveraging new `noop_deleter_acting_as_weak_ptr_owner` to retrieve released `vptr`. The placeholder `vptr` is never exposed anymore, therefore the externally visible `use_count`s are more intuitive.
2021-06-22 01:09:14 +00:00
assert stash2.use_count(0) == 2
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
stash2.Add(obj)
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
exp_hist += "_Stash2Add"
assert obj.history == exp_hist
assert m.use_count(obj) == 4
assert stash1.history(0) == exp_hist
Leveraging new `noop_deleter_acting_as_weak_ptr_owner` to retrieve released `vptr`. The placeholder `vptr` is never exposed anymore, therefore the externally visible `use_count`s are more intuitive.
2021-06-22 01:09:14 +00:00
assert stash1.use_count(0) == 3
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert stash2.history(0) == exp_hist
Leveraging new `noop_deleter_acting_as_weak_ptr_owner` to retrieve released `vptr`. The placeholder `vptr` is never exposed anymore, therefore the externally visible `use_count`s are more intuitive.
2021-06-22 01:09:14 +00:00
assert stash2.use_count(0) == 3
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert stash2.history(1) == exp_hist
Leveraging new `noop_deleter_acting_as_weak_ptr_owner` to retrieve released `vptr`. The placeholder `vptr` is never exposed anymore, therefore the externally visible `use_count`s are more intuitive.
2021-06-22 01:09:14 +00:00
assert stash2.use_count(1) == 3
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
del obj
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert stash2.history(0) == exp_hist
Leveraging new `noop_deleter_acting_as_weak_ptr_owner` to retrieve released `vptr`. The placeholder `vptr` is never exposed anymore, therefore the externally visible `use_count`s are more intuitive.
2021-06-22 01:09:14 +00:00
assert stash2.use_count(0) == 3
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert stash2.history(1) == exp_hist
Leveraging new `noop_deleter_acting_as_weak_ptr_owner` to retrieve released `vptr`. The placeholder `vptr` is never exposed anymore, therefore the externally visible `use_count`s are more intuitive.
2021-06-22 01:09:14 +00:00
assert stash2.use_count(1) == 3
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
stash2.Clear()
assert stash1.history(0) == exp_hist
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
assert stash1.use_count(0) == 1
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
def test_release_and_stash_leak():
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
obj = PySft("")
while True:
stash1 = m.SftSharedPtrStash(1)
stash1.Add(obj)
assert obj.history == ""
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert m.use_count(obj) == 2
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
assert stash1.use_count(0) == 1
stash1.Add(obj)
assert obj.history == ""
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert m.use_count(obj) == 3
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
assert stash1.use_count(0) == 2
assert stash1.use_count(1) == 2
break # Comment out for manual leak checking (use `top` command).
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
def test_release_and_stash_via_shared_from_this():
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
obj = PySft("PySft")
stash1 = m.SftSharedPtrStash(1)
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
with pytest.raises(RuntimeError) as exc_info:
stash1.AddSharedFromThis(obj)
assert str(exc_info.value) == "bad_weak_ptr"
stash1.Add(obj)
assert obj.history == "PySft_Stash1Add"
assert stash1.use_count(0) == 1
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
stash1.AddSharedFromThis(obj)
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert obj.history == "PySft_Stash1Add_Stash1AddSharedFromThis"
Adding tests involving stashing `shared_ptr`s. WIP.
2021-06-20 15:35:51 +00:00
assert stash1.use_count(0) == 2
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
assert stash1.use_count(1) == 2
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
def test_release_and_stash_via_shared_from_this_leak():
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
obj = PySft("")
while True:
stash1 = m.SftSharedPtrStash(1)
Simpler and safe implementation based on new requirement: C++ (outside of the Python object) needs to hold a shared_ptr before shared_from_this is called. This is more similar to the existing implementation on current smart_holder HEAD, but still uses a weak_ptr to always return the same shared_ptr as long as C++ does not let it expire.
2021-06-23 14:00:44 +00:00
with pytest.raises(RuntimeError) as exc_info:
stash1.AddSharedFromThis(obj)
assert str(exc_info.value) == "bad_weak_ptr"
Partial cleanup of tests. WIP. The cleanup uncovered a major problem.
2021-06-22 18:01:48 +00:00
stash1.Add(obj)
assert obj.history == ""
assert stash1.use_count(0) == 1
stash1.AddSharedFromThis(obj)
assert obj.history == ""
assert stash1.use_count(0) == 2
assert stash1.use_count(1) == 2
break # Comment out for manual leak checking (use `top` command).
Adding `test_pass_released_shared_ptr_as_unique_ptr`, exercising new guard in smart_holder_type_casters.h.
2021-06-21 23:16:37 +00:00
def test_pass_released_shared_ptr_as_unique_ptr():
obj = PySft("PySft")
stash1 = m.SftSharedPtrStash(1)
stash1.Add(obj) # Releases shared_ptr to C++.
with pytest.raises(ValueError) as exc_info:
m.pass_unique_ptr(obj)
assert str(exc_info.value) == (
"Python instance is currently owned by a std::shared_ptr."
)
Adding test_pure_cpp_sft_raw_ptr (with 3 TODO: Fix), test_pure_cpp_sft_shd_ptr (works as desired).
2021-06-23 23:35:27 +00:00
Use casting to `void *` to evade to shared_from_this mechanism only if `pointee_depends_on_holder_owner`, but currently only for `from_raw_ptr_take_ownership`.
2021-06-24 00:43:29 +00:00
@pytest.mark.parametrize(
"make_f", [m.make_pure_cpp_sft_raw_ptr, m.make_pure_cpp_sft_shd_ptr]
)
def test_pure_cpp_sft_raw_ptr(make_f):
obj = make_f("PureCppSft")
Adding test_pure_cpp_sft_raw_ptr (with 3 TODO: Fix), test_pure_cpp_sft_shd_ptr (works as desired).
2021-06-23 23:35:27 +00:00
assert m.pass_shared_ptr(obj) == 3
assert obj.history == "PureCppSft_PassSharedPtr"
Use casting to `void *` to evade to shared_from_this mechanism only if `pointee_depends_on_holder_owner`, but currently only for `from_raw_ptr_take_ownership`.
2021-06-24 00:43:29 +00:00
obj = make_f("PureCppSft")
Adding test_pure_cpp_sft_raw_ptr (with 3 TODO: Fix), test_pure_cpp_sft_shd_ptr (works as desired).
2021-06-23 23:35:27 +00:00
stash1 = m.SftSharedPtrStash(1)
stash1.AddSharedFromThis(obj)
assert obj.history == "PureCppSft_Stash1AddSharedFromThis"