Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2025-01-31 15:20:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

Experiments: 1. disabling enable_shared_from_this, 2. using smart_holder in test_class_sh_shared_from_this.cpp

Browse Source
This commit is contained in:
Ralf W. Grosse-Kunstleve 2021-05-27 16:33:22 -07:00 committed by Ralf W. Grosse-Kunstleve
parent 252b6aefb8
commit 94523e8a02
4 changed files with 33 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/pybind11/pybind11.h
View File

@ -1577,6 +1577,7 @@ private:
}
// clang-format off
#ifdef JUNK
/// Initialize holder object, variant 1: object derives from enable_shared_from_this
template <typename T>
static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
@ -1594,6 +1595,7 @@ private:
v_h.set_holder_constructed();
}
}
#endif
static void init_holder_from_existing(const detail::value_and_holder &v_h,
const holder_type *holder_ptr, std::true_type /*is_copy_constructible*/) {

24
tests/test_class_sh_shared_from_this.cpp
View File

@ -1,6 +1,8 @@
#include "pybind11_tests.h"
#include "object.h"
#include <pybind11/smart_holder.h>
namespace test_class_sh_shared_from_this {
class MyObject3 : public std::enable_shared_from_this<MyObject3> {
@ -37,36 +39,36 @@ struct SharedFromThisVirt : virtual SharedFromThisVBase {};
using namespace test_class_sh_shared_from_this;
PYBIND11_TYPE_CASTER_BASE_HOLDER(MyObject3, std::shared_ptr<MyObject3>)
PYBIND11_TYPE_CASTER_BASE_HOLDER(SharedFromThisRef::B, std::shared_ptr<SharedFromThisRef::B>)
PYBIND11_TYPE_CASTER_BASE_HOLDER(SharedFromThisRef, std::unique_ptr<SharedFromThisRef>)
PYBIND11_TYPE_CASTER_BASE_HOLDER(SharedFromThisVirt, std::shared_ptr<SharedFromThisVirt>)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(MyObject3)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(SharedFromThisRef::B)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(SharedFromThisRef)
PYBIND11_SMART_HOLDER_TYPE_CASTERS(SharedFromThisVirt)
TEST_SUBMODULE(class_sh_shared_from_this, m) {
py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3")
py::classh<MyObject3>(m, "MyObject3")
.def(py::init<int>());
m.def("make_myobject3_1", []() { return new MyObject3(8); });
m.def("make_myobject3_2", []() { return std::make_shared<MyObject3>(9); });
m.def("print_myobject3_1", [](const MyObject3 *obj) { py::print(obj->toString()); });
m.def("print_myobject3_2", [](std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); });
m.def("print_myobject3_3", [](const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); });
m.def("print_myobject3_4", [](const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); });
//m.def("print_myobject3_4", [](const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); });
using B = SharedFromThisRef::B;
py::class_<B, std::shared_ptr<B>>(m, "B");
py::class_<SharedFromThisRef, std::unique_ptr<SharedFromThisRef>>(m, "SharedFromThisRef")
py::classh<B>(m, "B");
py::classh<SharedFromThisRef>(m, "SharedFromThisRef")
.def(py::init<>())
.def_readonly("bad_wp", &SharedFromThisRef::value)
.def_property_readonly("ref", [](const SharedFromThisRef &s) -> const B & { return *s.shared; })
.def_property_readonly("copy", [](const SharedFromThisRef &s) { return s.value; },
py::return_value_policy::copy)
py::return_value_policy::automatic) // XXX XXX XXX copy)
.def_readonly("holder_ref", &SharedFromThisRef::shared)
.def_property_readonly("holder_copy", [](const SharedFromThisRef &s) { return s.shared; },
py::return_value_policy::copy)
py::return_value_policy::automatic) // XXX XXX XXX copy)
.def("set_ref", [](SharedFromThisRef &, const B &) { return true; })
.def("set_holder", [](SharedFromThisRef &, std::shared_ptr<B>) { return true; });
static std::shared_ptr<SharedFromThisVirt> sft(new SharedFromThisVirt());
py::class_<SharedFromThisVirt, std::shared_ptr<SharedFromThisVirt>>(m, "SharedFromThisVirt")
py::classh<SharedFromThisVirt>(m, "SharedFromThisVirt")
.def_static("get", []() { return sft.get(); });
}

11
tests/test_class_sh_shared_from_this.py
View File

@ -1,5 +1,5 @@
# -*- coding: utf-8 -*-
import pytest
# import pytest
from pybind11_tests import class_sh_shared_from_this as m
from pybind11_tests import ConstructorStats
@ -15,7 +15,7 @@ def test_smart_ptr(capture):
m.print_myobject3_1(o)
m.print_myobject3_2(o)
m.print_myobject3_3(o)
m.print_myobject3_4(o)
m.print_myobject3_3(o) # XXX XXX XXX print_myobject3_4
assert capture == "MyObject3[{i}]\n".format(i=i) * 4
cstats = ConstructorStats.get(m.MyObject3)
@ -45,11 +45,13 @@ def test_shared_ptr_from_this_and_references():
bad_wp = s.bad_wp # init_holder_helper(holder_ptr=false, owned=false, bad_wp=true)
assert stats.alive() == 2
assert s.set_ref(bad_wp)
with pytest.raises(RuntimeError) as excinfo:
# with pytest.raises(RuntimeError) as excinfo:
if 1:
assert s.set_holder(bad_wp)
assert "Unable to cast from non-held to held instance" in str(excinfo.value)
# assert "Unable to cast from non-held to held instance" in str(excinfo.value)
copy = s.copy # init_holder_helper(holder_ptr=false, owned=true, bad_wp=false)
# RuntimeError: Invalid return_value_policy for shared_ptr.
assert stats.alive() == 3
assert s.set_ref(copy)
assert s.set_holder(copy)
@ -62,6 +64,7 @@ def test_shared_ptr_from_this_and_references():
assert s.set_holder(holder_ref)
holder_copy = (
# RuntimeError: Invalid return_value_policy for shared_ptr.
s.holder_copy
) # init_holder_helper(holder_ptr=true, owned=true, bad_wp=false)
assert stats.alive() == 3

16
tests/test_smart_ptr.py
View File

@ -205,9 +205,11 @@ def test_shared_ptr_from_this_and_references():
ref = s.ref # init_holder_helper(holder_ptr=false, owned=false, bad_wp=false)
assert stats.alive() == 2
assert s.set_ref(ref)
assert s.set_holder(
ref
) # std::enable_shared_from_this can create a holder from a reference
# assert s.set_holder(
# ref
# ) # std::enable_shared_from_this can create a holder from a reference
# RuntimeError: Unable to cast from non-held to held instance (T& to Holder<T>) of type
# 'std::shared_ptr<(anonymous namespace)::SharedFromThisRef::B>''
bad_wp = s.bad_wp # init_holder_helper(holder_ptr=false, owned=false, bad_wp=true)
assert stats.alive() == 2
@ -226,14 +228,18 @@ def test_shared_ptr_from_this_and_references():
) # init_holder_helper(holder_ptr=true, owned=false, bad_wp=false)
assert stats.alive() == 3
assert s.set_ref(holder_ref)
assert s.set_holder(holder_ref)
# assert s.set_holder(holder_ref)
# RuntimeError: Unable to cast from non-held to held instance (T& to Holder<T>) of type
# 'std::shared_ptr<(anonymous namespace)::SharedFromThisRef::B>''
holder_copy = (
s.holder_copy
) # init_holder_helper(holder_ptr=true, owned=true, bad_wp=false)
assert stats.alive() == 3
assert s.set_ref(holder_copy)
assert s.set_holder(holder_copy)
# assert s.set_holder(holder_copy)
# RuntimeError: Unable to cast from non-held to held instance (T& to Holder<T>) of type
# 'std::shared_ptr<(anonymous namespace)::SharedFromThisRef::B>''
del ref, bad_wp, copy, holder_ref, holder_copy, s
assert stats.alive() == 0