Generalize test_potentially_slicing_shared_ptr.cpp,py for testing with smart_holder and std::shared_ptr as holder.

Author: rwgk

tests/test_potentially_slicing_shared_ptr.cpp

@@ -9,26 +9,38 @@
 namespace pybind11_tests {
 namespace potentially_slicing_shared_ptr {
 
+template <int> // Using int as a trick to easily generate multiple types.
 struct VirtBase {
     virtual ~VirtBase() = default;
     virtual int get_code() { return 100; }
 };
 
-struct PyVirtBase : VirtBase, py::trampoline_self_life_support {
-    using VirtBase::VirtBase;
-    int get_code() override { PYBIND11_OVERRIDE(int, VirtBase, get_code); }
+using VirtBaseSH = VirtBase<0>; // for testing with py::smart_holder
+using VirtBaseSP = VirtBase<1>; // for testing with std::shared_ptr as holder
+
+struct PyVirtBaseSH : VirtBaseSH, py::trampoline_self_life_support {
+    using VirtBaseSH::VirtBaseSH;
+    int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSH, get_code); }
+};
+
+struct PyVirtBaseSP : VirtBaseSP { // self-life-support not available
+    using VirtBaseSP::VirtBaseSP;
+    int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSP, get_code); }
 };
 
-std::shared_ptr<VirtBase> rtrn_obj_cast_shared_ptr(py::handle obj) {
-    return obj.cast<std::shared_ptr<VirtBase>>();
+template <typename VB>
+std::shared_ptr<VB> rtrn_obj_cast_shared_ptr(py::handle obj) {
+    return obj.cast<std::shared_ptr<VB>>();
 }
 
-std::shared_ptr<VirtBase> rtrn_potentially_slicing_shared_ptr(py::handle obj) {
-    return py::potentially_slicing_shared_ptr<VirtBase>(obj);
+template <typename VB>
+std::shared_ptr<VB> rtrn_potentially_slicing_shared_ptr(py::handle obj) {
+    return py::potentially_slicing_shared_ptr<VB>(obj);
 }
 
+template <typename VB>
 struct SpOwner {
-    void set_sp(const std::shared_ptr<VirtBase> &sp_) { sp = sp_; }
+    void set_sp(const std::shared_ptr<VB> &sp_) { sp = sp_; }
 
     int get_code() {
         if (!sp) {
@@ -38,11 +50,12 @@ struct SpOwner {
     }
 
 private:
-    std::shared_ptr<VirtBase> sp;
+    std::shared_ptr<VB> sp;
 };
 
+template <typename VB>
 struct WpOwner {
-    void set_wp(const std::shared_ptr<VirtBase> &sp) { wp = sp; }
+    void set_wp(const std::shared_ptr<VB> &sp) { wp = sp; }
 
     int get_code() {
         auto sp = wp.lock();
@@ -53,33 +66,56 @@ struct WpOwner {
     }
 
 private:
-    std::weak_ptr<VirtBase> wp;
+    std::weak_ptr<VB> wp;
 };
 
+template <typename VB>
+void wrap(py::module_ &m,
+          const char *roc_pyname,
+          const char *rps_pyname,
+          const char *spo_pyname,
+          const char *wpo_pyname) {
+    m.def(roc_pyname, rtrn_obj_cast_shared_ptr<VB>);
+    m.def(rps_pyname, rtrn_potentially_slicing_shared_ptr<VB>);
+
+    py::classh<SpOwner<VB>>(m, spo_pyname)
+        .def(py::init<>())
+        .def("set_sp", &SpOwner<VB>::set_sp)
+        .def("get_code", &SpOwner<VB>::get_code);
+
+    py::classh<WpOwner<VB>>(m, wpo_pyname)
+        .def(py::init<>())
+        .def("set_wp", &WpOwner<VB>::set_wp)
+        .def("set_wp_potentially_slicing",
+             [](WpOwner<VB> &self, py::handle obj) {
+                 self.set_wp(py::potentially_slicing_shared_ptr<VB>(obj));
+             })
+        .def("get_code", &WpOwner<VB>::get_code);
+}
+
 } // namespace potentially_slicing_shared_ptr
 } // namespace pybind11_tests
 
 using namespace pybind11_tests::potentially_slicing_shared_ptr;
 
 TEST_SUBMODULE(potentially_slicing_shared_ptr, m) {
-    py::classh<VirtBase, PyVirtBase>(m, "VirtBase")
-        .def(py::init<>())
-        .def("get_code", &VirtBase::get_code);
-
-    m.def("rtrn_obj_cast_shared_ptr", rtrn_obj_cast_shared_ptr);
-    m.def("rtrn_potentially_slicing_shared_ptr", rtrn_potentially_slicing_shared_ptr);
-
-    py::classh<SpOwner>(m, "SpOwner")
+    py::classh<VirtBaseSH, PyVirtBaseSH>(m, "VirtBaseSH")
         .def(py::init<>())
-        .def("set_sp", &SpOwner::set_sp)
-        .def("get_code", &SpOwner::get_code);
+        .def("get_code", &VirtBaseSH::get_code);
 
-    py::classh<WpOwner>(m, "WpOwner")
+    py::class_<VirtBaseSP, std::shared_ptr<VirtBaseSP>, PyVirtBaseSP>(m, "VirtBaseSP")
         .def(py::init<>())
-        .def("set_wp", &WpOwner::set_wp)
-        .def("set_wp_potentially_slicing",
-             [](WpOwner &self, py::handle obj) {
-                 self.set_wp(py::potentially_slicing_shared_ptr<VirtBase>(obj));
-             })
-        .def("get_code", &WpOwner::get_code);
+        .def("get_code", &VirtBaseSP::get_code);
+
+    wrap<VirtBaseSH>(m,
+                     "SH_rtrn_obj_cast_shared_ptr",
+                     "SH_rtrn_potentially_slicing_shared_ptr",
+                     "SH_SpOwner",
+                     "SH_WpOwner");
+
+    wrap<VirtBaseSP>(m,
+                     "SP_rtrn_obj_cast_shared_ptr",
+                     "SP_rtrn_potentially_slicing_shared_ptr",
+                     "SP_SpOwner",
+                     "SP_WpOwner");
 }

tests/test_potentially_slicing_shared_ptr.py

@@ -9,18 +9,51 @@
 import pybind11_tests.potentially_slicing_shared_ptr as m
 
 
-class PyDrvd(m.VirtBase):
+class PyDrvdSH(m.VirtBaseSH):
     def get_code(self):
         return 200
 
 
-@pytest.mark.parametrize(("vtype", "expected_code"), [(m.VirtBase, 100), (PyDrvd, 200)])
-@pytest.mark.parametrize(
-    "rtrn_meth", ["rtrn_obj_cast_shared_ptr", "rtrn_potentially_slicing_shared_ptr"]
-)
-def test_rtrn_obj_cast_shared_ptr(vtype, rtrn_meth, expected_code):
-    obj = vtype()
-    ptr = getattr(m, rtrn_meth)(obj)
+class PyDrvdSP(m.VirtBaseSP):
+    def get_code(self):
+        return 200
+
+
+VIRT_BASE_TYPES = {
+    "SH": {100: m.VirtBaseSH, 200: PyDrvdSH},
+    "SP": {100: m.VirtBaseSP, 200: PyDrvdSP},
+}
+
+RTRN_FUNCS = {
+    "SH": {
+        "oc": m.SH_rtrn_obj_cast_shared_ptr,
+        "ps": m.SH_rtrn_potentially_slicing_shared_ptr,
+    },
+    "SP": {
+        "oc": m.SP_rtrn_obj_cast_shared_ptr,
+        "ps": m.SP_rtrn_potentially_slicing_shared_ptr,
+    },
+}
+
+SP_OWNER_TYPES = {
+    "SH": m.SH_SpOwner,
+    "SP": m.SP_SpOwner,
+}
+
+WP_OWNER_TYPES = {
+    "SH": m.SH_WpOwner,
+    "SP": m.SP_WpOwner,
+}
+
+GC_IS_RELIABLE = not (env.PYPY or env.GRAALPY)
+
+
+@pytest.mark.parametrize("expected_code", [100, 200])
+@pytest.mark.parametrize("rtrn_kind", ["oc", "ps"])
+@pytest.mark.parametrize("holder_kind", ["SH", "SP"])
+def test_rtrn_obj_cast_shared_ptr(holder_kind, rtrn_kind, expected_code):
+    obj = VIRT_BASE_TYPES[holder_kind][expected_code]()
+    ptr = RTRN_FUNCS[holder_kind][rtrn_kind](obj)
     assert ptr.get_code() == expected_code
     objref = weakref.ref(obj)
     del obj
@@ -29,41 +62,53 @@ def test_rtrn_obj_cast_shared_ptr(vtype, rtrn_meth, expected_code):
     assert objref() is not None
     del ptr
     gc.collect()
-    assert objref() is None
+    if GC_IS_RELIABLE:
+        assert objref() is None
 
 
-@pytest.mark.parametrize(("vtype", "expected_code"), [(m.VirtBase, 100), (PyDrvd, 200)])
-def test_with_sp_owner(vtype, expected_code):
-    spo = m.SpOwner()
+@pytest.mark.parametrize("expected_code", [100, 200])
+@pytest.mark.parametrize("holder_kind", ["SH", "SP"])
+def test_with_sp_owner(holder_kind, expected_code):
+    spo = SP_OWNER_TYPES[holder_kind]()
     assert spo.get_code() == -888
 
-    obj = vtype()
+    obj = VIRT_BASE_TYPES[holder_kind][expected_code]()
     assert obj.get_code() == expected_code
 
     spo.set_sp(obj)
     assert spo.get_code() == expected_code
 
     del obj
     gc.collect()
-    assert spo.get_code() == expected_code
+    if holder_kind == "SH":
+        assert spo.get_code() == expected_code
+    elif GC_IS_RELIABLE:
+        assert (
+            spo.get_code() == 100
+        )  # see issue #1333 (inheritance slicing) and PR #5624
 
 
-@pytest.mark.parametrize(("vtype", "expected_code"), [(m.VirtBase, 100), (PyDrvd, 200)])
+@pytest.mark.parametrize("expected_code", [100, 200])
 @pytest.mark.parametrize("set_meth", ["set_wp", "set_wp_potentially_slicing"])
-def test_with_wp_owner(vtype, set_meth, expected_code):
-    wpo = m.WpOwner()
+@pytest.mark.parametrize("holder_kind", ["SH", "SP"])
+def test_with_wp_owner(holder_kind, set_meth, expected_code):
+    wpo = WP_OWNER_TYPES[holder_kind]()
     assert wpo.get_code() == -999
 
-    obj = vtype()
+    obj = VIRT_BASE_TYPES[holder_kind][expected_code]()
     assert obj.get_code() == expected_code
 
     getattr(wpo, set_meth)(obj)
-    if vtype is m.VirtBase or set_meth == "set_wp_potentially_slicing":
+    if (
+        holder_kind == "SP"
+        or expected_code == 100
+        or set_meth == "set_wp_potentially_slicing"
+    ):
         assert wpo.get_code() == expected_code
     else:
-        assert wpo.get_code() == -999  # see PR #5624
+        assert wpo.get_code() == -999  # see issue #5623 (weak_ptr expired) and PR #5624
 
     del obj
     gc.collect()
-    if not (env.PYPY or env.GRAALPY):
+    if GC_IS_RELIABLE:
         assert wpo.get_code() == -999