From 9c95dc4d8f02c9b78ea2ca1970dc070285b75c8f Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Wed, 3 Feb 2021 22:03:52 -0800 Subject: [PATCH] Factoring out struct and class definitions into anonymous namespace. Preparation for building with PYBIND11_USE_SMART_HOLDER_AS_DEFAULT. --- tests/test_smart_ptr.cpp | 279 +++++++++++++++++++++------------------ 1 file changed, 148 insertions(+), 131 deletions(-) diff --git a/tests/test_smart_ptr.cpp b/tests/test_smart_ptr.cpp index 59996edeb..cf31b8386 100644 --- a/tests/test_smart_ptr.cpp +++ b/tests/test_smart_ptr.cpp @@ -85,15 +85,7 @@ public: }; PYBIND11_DECLARE_HOLDER_TYPE(T, unique_ptr_with_addressof_operator); - -TEST_SUBMODULE(smart_ptr, m) { - - // test_smart_ptr - - // Object implementation in `object.h` - py::class_> obj(m, "Object"); - obj.def("getRefCount", &Object::getRefCount); - +namespace { // Custom object with builtin reference counting (see 'object.h' for the implementation) class MyObject1 : public Object { public: @@ -104,26 +96,6 @@ TEST_SUBMODULE(smart_ptr, m) { private: int value; }; - py::class_>(m, "MyObject1", obj) - .def(py::init()); - py::implicitly_convertible(); - - m.def("make_object_1", []() -> Object * { return new MyObject1(1); }); - m.def("make_object_2", []() -> ref { return new MyObject1(2); }); - m.def("make_myobject1_1", []() -> MyObject1 * { return new MyObject1(4); }); - m.def("make_myobject1_2", []() -> ref { return new MyObject1(5); }); - m.def("print_object_1", [](const Object *obj) { py::print(obj->toString()); }); - m.def("print_object_2", [](ref obj) { py::print(obj->toString()); }); - m.def("print_object_3", [](const ref &obj) { py::print(obj->toString()); }); - m.def("print_object_4", [](const ref *obj) { py::print((*obj)->toString()); }); - m.def("print_myobject1_1", [](const MyObject1 *obj) { py::print(obj->toString()); }); - m.def("print_myobject1_2", [](ref obj) { py::print(obj->toString()); }); - m.def("print_myobject1_3", [](const ref &obj) { py::print(obj->toString()); }); - m.def("print_myobject1_4", [](const ref *obj) { py::print((*obj)->toString()); }); - - // Expose constructor stats for the ref type - m.def("cstats_ref", &ConstructorStats::get); - // Object managed by a std::shared_ptr<> class MyObject2 { @@ -135,14 +107,6 @@ TEST_SUBMODULE(smart_ptr, m) { private: int value; }; - py::class_>(m, "MyObject2") - .def(py::init()); - m.def("make_myobject2_1", []() { return new MyObject2(6); }); - m.def("make_myobject2_2", []() { return std::make_shared(7); }); - m.def("print_myobject2_1", [](const MyObject2 *obj) { py::print(obj->toString()); }); - m.def("print_myobject2_2", [](std::shared_ptr obj) { py::print(obj->toString()); }); - m.def("print_myobject2_3", [](const std::shared_ptr &obj) { py::print(obj->toString()); }); - m.def("print_myobject2_4", [](const std::shared_ptr *obj) { py::print((*obj)->toString()); }); // Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<> class MyObject3 : public std::enable_shared_from_this { @@ -154,25 +118,6 @@ TEST_SUBMODULE(smart_ptr, m) { private: int value; }; - py::class_>(m, "MyObject3") - .def(py::init()); - m.def("make_myobject3_1", []() { return new MyObject3(8); }); - m.def("make_myobject3_2", []() { return std::make_shared(9); }); - m.def("print_myobject3_1", [](const MyObject3 *obj) { py::print(obj->toString()); }); - m.def("print_myobject3_2", [](std::shared_ptr obj) { py::print(obj->toString()); }); - m.def("print_myobject3_3", [](const std::shared_ptr &obj) { py::print(obj->toString()); }); - m.def("print_myobject3_4", [](const std::shared_ptr *obj) { py::print((*obj)->toString()); }); - - // test_smart_ptr_refcounting - m.def("test_object1_refcounting", []() { - ref o = new MyObject1(0); - bool good = o->getRefCount() == 1; - py::object o2 = py::cast(o, py::return_value_policy::reference); - // always request (partial) ownership for objects with intrusive - // reference counting even when using the 'reference' RVP - good &= o->getRefCount() == 2; - return good; - }); // test_unique_nodelete // Object with a private destructor @@ -198,10 +143,6 @@ TEST_SUBMODULE(smart_ptr, m) { print_destroyed(this); } }; - py::class_>(m, "MyObject4") - .def(py::init()) - .def_readwrite("value", &MyObject4::value) - .def_static("cleanup_all_instances", &MyObject4::cleanupAllInstances); // test_unique_deleter // Object with std::unique_ptr where D is not matching the base class @@ -229,10 +170,6 @@ TEST_SUBMODULE(smart_ptr, m) { print_destroyed(this); } }; - py::class_>(m, "MyObject4a") - .def(py::init()) - .def_readwrite("value", &MyObject4a::value) - .def_static("cleanup_all_instances", &MyObject4a::cleanupAllInstances); // Object derived but with public destructor and no Deleter in default holder class MyObject4b : public MyObject4a { @@ -240,8 +177,6 @@ TEST_SUBMODULE(smart_ptr, m) { MyObject4b(int i) : MyObject4a(i) { print_created(this); } ~MyObject4b() override { print_destroyed(this); } }; - py::class_(m, "MyObject4b") - .def(py::init()); // test_large_holder class MyObject5 { // managed by huge_unique_ptr @@ -250,9 +185,6 @@ TEST_SUBMODULE(smart_ptr, m) { ~MyObject5() { print_destroyed(this); } int value; }; - py::class_>(m, "MyObject5") - .def(py::init()) - .def_readwrite("value", &MyObject5::value); // test_shared_ptr_and_references struct SharedPtrRef { @@ -266,18 +198,6 @@ TEST_SUBMODULE(smart_ptr, m) { A value = {}; std::shared_ptr shared = std::make_shared(); }; - using A = SharedPtrRef::A; - py::class_>(m, "A"); - py::class_(m, "SharedPtrRef") - .def(py::init<>()) - .def_readonly("ref", &SharedPtrRef::value) - .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; }, - py::return_value_policy::copy) - .def_readonly("holder_ref", &SharedPtrRef::shared) - .def_property_readonly("holder_copy", [](const SharedPtrRef &s) { return s.shared; }, - py::return_value_policy::copy) - .def("set_ref", [](SharedPtrRef &, const A &) { return true; }) - .def("set_holder", [](SharedPtrRef &, std::shared_ptr) { return true; }); // test_shared_ptr_from_this_and_references struct SharedFromThisRef { @@ -291,6 +211,153 @@ TEST_SUBMODULE(smart_ptr, m) { B value = {}; std::shared_ptr shared = std::make_shared(); }; + + // Issue #865: shared_from_this doesn't work with virtual inheritance + struct SharedFromThisVBase : std::enable_shared_from_this { + SharedFromThisVBase() = default; + SharedFromThisVBase(const SharedFromThisVBase &) = default; + virtual ~SharedFromThisVBase() = default; + }; + struct SharedFromThisVirt : virtual SharedFromThisVBase {}; + + // test_move_only_holder + struct C { + C() { print_created(this); } + ~C() { print_destroyed(this); } + }; + + // test_holder_with_addressof_operator + struct TypeForHolderWithAddressOf { + TypeForHolderWithAddressOf() { print_created(this); } + TypeForHolderWithAddressOf(const TypeForHolderWithAddressOf &) { print_copy_created(this); } + TypeForHolderWithAddressOf(TypeForHolderWithAddressOf &&) { print_move_created(this); } + ~TypeForHolderWithAddressOf() { print_destroyed(this); } + std::string toString() const { + return "TypeForHolderWithAddressOf[" + std::to_string(value) + "]"; + } + int value = 42; + }; + + // test_move_only_holder_with_addressof_operator + struct TypeForMoveOnlyHolderWithAddressOf { + TypeForMoveOnlyHolderWithAddressOf(int value) : value{value} { print_created(this); } + ~TypeForMoveOnlyHolderWithAddressOf() { print_destroyed(this); } + std::string toString() const { + return "MoveOnlyHolderWithAddressOf[" + std::to_string(value) + "]"; + } + int value; + }; + + // test_smart_ptr_from_default + struct HeldByDefaultHolder { }; + + // test_shared_ptr_gc + // #187: issue involving std::shared_ptr<> return value policy & garbage collection + struct ElementBase { + virtual ~ElementBase() = default; /* Force creation of virtual table */ + ElementBase() = default; + ElementBase(const ElementBase&) = delete; + }; + + struct ElementA : ElementBase { + ElementA(int v) : v(v) { } + int value() { return v; } + int v; + }; + + struct ElementList { + void add(std::shared_ptr e) { l.push_back(e); } + std::vector> l; + }; +} + +TEST_SUBMODULE(smart_ptr, m) { + + // test_smart_ptr + + // Object implementation in `object.h` + py::class_> obj(m, "Object"); + obj.def("getRefCount", &Object::getRefCount); + + py::class_>(m, "MyObject1", obj) + .def(py::init()); + py::implicitly_convertible(); + + m.def("make_object_1", []() -> Object * { return new MyObject1(1); }); + m.def("make_object_2", []() -> ref { return new MyObject1(2); }); + m.def("make_myobject1_1", []() -> MyObject1 * { return new MyObject1(4); }); + m.def("make_myobject1_2", []() -> ref { return new MyObject1(5); }); + m.def("print_object_1", [](const Object *obj) { py::print(obj->toString()); }); + m.def("print_object_2", [](ref obj) { py::print(obj->toString()); }); + m.def("print_object_3", [](const ref &obj) { py::print(obj->toString()); }); + m.def("print_object_4", [](const ref *obj) { py::print((*obj)->toString()); }); + m.def("print_myobject1_1", [](const MyObject1 *obj) { py::print(obj->toString()); }); + m.def("print_myobject1_2", [](ref obj) { py::print(obj->toString()); }); + m.def("print_myobject1_3", [](const ref &obj) { py::print(obj->toString()); }); + m.def("print_myobject1_4", [](const ref *obj) { py::print((*obj)->toString()); }); + + // Expose constructor stats for the ref type + m.def("cstats_ref", &ConstructorStats::get); + + py::class_>(m, "MyObject2") + .def(py::init()); + m.def("make_myobject2_1", []() { return new MyObject2(6); }); + m.def("make_myobject2_2", []() { return std::make_shared(7); }); + m.def("print_myobject2_1", [](const MyObject2 *obj) { py::print(obj->toString()); }); + m.def("print_myobject2_2", [](std::shared_ptr obj) { py::print(obj->toString()); }); + m.def("print_myobject2_3", [](const std::shared_ptr &obj) { py::print(obj->toString()); }); + m.def("print_myobject2_4", [](const std::shared_ptr *obj) { py::print((*obj)->toString()); }); + + py::class_>(m, "MyObject3") + .def(py::init()); + m.def("make_myobject3_1", []() { return new MyObject3(8); }); + m.def("make_myobject3_2", []() { return std::make_shared(9); }); + m.def("print_myobject3_1", [](const MyObject3 *obj) { py::print(obj->toString()); }); + m.def("print_myobject3_2", [](std::shared_ptr obj) { py::print(obj->toString()); }); + m.def("print_myobject3_3", [](const std::shared_ptr &obj) { py::print(obj->toString()); }); + m.def("print_myobject3_4", [](const std::shared_ptr *obj) { py::print((*obj)->toString()); }); + + // test_smart_ptr_refcounting + m.def("test_object1_refcounting", []() { + ref o = new MyObject1(0); + bool good = o->getRefCount() == 1; + py::object o2 = py::cast(o, py::return_value_policy::reference); + // always request (partial) ownership for objects with intrusive + // reference counting even when using the 'reference' RVP + good &= o->getRefCount() == 2; + return good; + }); + + py::class_>(m, "MyObject4") + .def(py::init()) + .def_readwrite("value", &MyObject4::value) + .def_static("cleanup_all_instances", &MyObject4::cleanupAllInstances); + + py::class_>(m, "MyObject4a") + .def(py::init()) + .def_readwrite("value", &MyObject4a::value) + .def_static("cleanup_all_instances", &MyObject4a::cleanupAllInstances); + + py::class_(m, "MyObject4b") + .def(py::init()); + + py::class_>(m, "MyObject5") + .def(py::init()) + .def_readwrite("value", &MyObject5::value); + + using A = SharedPtrRef::A; + py::class_>(m, "A"); + py::class_(m, "SharedPtrRef") + .def(py::init<>()) + .def_readonly("ref", &SharedPtrRef::value) + .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; }, + py::return_value_policy::copy) + .def_readonly("holder_ref", &SharedPtrRef::shared) + .def_property_readonly("holder_copy", [](const SharedPtrRef &s) { return s.shared; }, + py::return_value_policy::copy) + .def("set_ref", [](SharedPtrRef &, const A &) { return true; }) + .def("set_holder", [](SharedPtrRef &, std::shared_ptr) { return true; }); + using B = SharedFromThisRef::B; py::class_>(m, "B"); py::class_(m, "SharedFromThisRef") @@ -305,37 +372,14 @@ TEST_SUBMODULE(smart_ptr, m) { .def("set_ref", [](SharedFromThisRef &, const B &) { return true; }) .def("set_holder", [](SharedFromThisRef &, std::shared_ptr) { return true; }); - // Issue #865: shared_from_this doesn't work with virtual inheritance - struct SharedFromThisVBase : std::enable_shared_from_this { - SharedFromThisVBase() = default; - SharedFromThisVBase(const SharedFromThisVBase &) = default; - virtual ~SharedFromThisVBase() = default; - }; - struct SharedFromThisVirt : virtual SharedFromThisVBase {}; static std::shared_ptr sft(new SharedFromThisVirt()); py::class_>(m, "SharedFromThisVirt") .def_static("get", []() { return sft.get(); }); - // test_move_only_holder - struct C { - C() { print_created(this); } - ~C() { print_destroyed(this); } - }; py::class_>(m, "TypeWithMoveOnlyHolder") .def_static("make", []() { return custom_unique_ptr(new C); }) .def_static("make_as_object", []() { return py::cast(custom_unique_ptr(new C)); }); - // test_holder_with_addressof_operator - struct TypeForHolderWithAddressOf { - TypeForHolderWithAddressOf() { print_created(this); } - TypeForHolderWithAddressOf(const TypeForHolderWithAddressOf &) { print_copy_created(this); } - TypeForHolderWithAddressOf(TypeForHolderWithAddressOf &&) { print_move_created(this); } - ~TypeForHolderWithAddressOf() { print_destroyed(this); } - std::string toString() const { - return "TypeForHolderWithAddressOf[" + std::to_string(value) + "]"; - } - int value = 42; - }; using HolderWithAddressOf = shared_ptr_with_addressof_operator; py::class_(m, "TypeForHolderWithAddressOf") .def_static("make", []() { return HolderWithAddressOf(new TypeForHolderWithAddressOf); }) @@ -345,49 +389,22 @@ TEST_SUBMODULE(smart_ptr, m) { .def("print_object_3", [](const HolderWithAddressOf &obj) { py::print(obj.get()->toString()); }) .def("print_object_4", [](const HolderWithAddressOf *obj) { py::print((*obj).get()->toString()); }); - // test_move_only_holder_with_addressof_operator - struct TypeForMoveOnlyHolderWithAddressOf { - TypeForMoveOnlyHolderWithAddressOf(int value) : value{value} { print_created(this); } - ~TypeForMoveOnlyHolderWithAddressOf() { print_destroyed(this); } - std::string toString() const { - return "MoveOnlyHolderWithAddressOf[" + std::to_string(value) + "]"; - } - int value; - }; using MoveOnlyHolderWithAddressOf = unique_ptr_with_addressof_operator; py::class_(m, "TypeForMoveOnlyHolderWithAddressOf") .def_static("make", []() { return MoveOnlyHolderWithAddressOf(new TypeForMoveOnlyHolderWithAddressOf(0)); }) .def_readwrite("value", &TypeForMoveOnlyHolderWithAddressOf::value) .def("print_object", [](const TypeForMoveOnlyHolderWithAddressOf *obj) { py::print(obj->toString()); }); - // test_smart_ptr_from_default - struct HeldByDefaultHolder { }; py::class_(m, "HeldByDefaultHolder") .def(py::init<>()) .def_static("load_shared_ptr", [](std::shared_ptr) {}); - // test_shared_ptr_gc - // #187: issue involving std::shared_ptr<> return value policy & garbage collection - struct ElementBase { - virtual ~ElementBase() = default; /* Force creation of virtual table */ - ElementBase() = default; - ElementBase(const ElementBase&) = delete; - }; py::class_>(m, "ElementBase"); - struct ElementA : ElementBase { - ElementA(int v) : v(v) { } - int value() { return v; } - int v; - }; py::class_>(m, "ElementA") .def(py::init()) .def("value", &ElementA::value); - struct ElementList { - void add(std::shared_ptr e) { l.push_back(e); } - std::vector> l; - }; py::class_>(m, "ElementList") .def(py::init<>()) .def("add", &ElementList::add)