Add simple trampoline state assertions.

Author: rwgk

tests/test_potentially_slicing_shared_ptr.cpp

@@ -18,12 +18,50 @@ struct VirtBase {
 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 {
+// Similar to trampoline_self_life_support
+struct trampoline_is_alive_simple {
+    std::uint64_t magic_token = 197001010000u;
+
+    trampoline_is_alive_simple() = default;
+
+    ~trampoline_is_alive_simple() { magic_token = 20380118191407u; }
+
+    trampoline_is_alive_simple(const trampoline_is_alive_simple &other) {
+        magic_token = other.magic_token;
+    }
+    trampoline_is_alive_simple(trampoline_is_alive_simple &&other) noexcept {
+        magic_token = other.magic_token;
+        other.magic_token = 20380118191407u;
+    }
+
+    trampoline_is_alive_simple &operator=(const trampoline_is_alive_simple &) = delete;
+    trampoline_is_alive_simple &operator=(trampoline_is_alive_simple &&) = delete;
+};
+
+template <typename VB>
+const char *determine_trampoline_state(const std::shared_ptr<VB> &sp) {
+    if (!sp) {
+        return "sp nullptr";
+    }
+    auto *tias = dynamic_cast<trampoline_is_alive_simple *>(sp.get());
+    if (!tias) {
+        return "dynamic_cast failed";
+    }
+    if (tias->magic_token == 197001010000u) {
+        return "trampoline alive";
+    }
+    if (tias->magic_token == 20380118191407u) {
+        return "trampoline DEAD";
+    }
+    return "UNDEFINED BEHAVIOR";
+}
+
+struct PyVirtBaseSH : VirtBaseSH, py::trampoline_self_life_support, trampoline_is_alive_simple {
     using VirtBaseSH::VirtBaseSH;
     int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSH, get_code); }
 };
 
-struct PyVirtBaseSP : VirtBaseSP { // self-life-support not available
+struct PyVirtBaseSP : VirtBaseSP, trampoline_is_alive_simple { // self-life-support not available
     using VirtBaseSP::VirtBaseSP;
     int get_code() override { PYBIND11_OVERRIDE(int, VirtBaseSP, get_code); }
 };
@@ -42,13 +80,15 @@ template <typename VB>
 struct SpOwner {
     void set_sp(const std::shared_ptr<VB> &sp_) { sp = sp_; }
 
-    int get_code() {
+    int get_code() const {
         if (!sp) {
             return -888;
         }
         return sp->get_code();
     }
 
+    const char *get_trampoline_state() const { return determine_trampoline_state(sp); }
+
 private:
     std::shared_ptr<VB> sp;
 };
@@ -57,14 +97,16 @@ template <typename VB>
 struct WpOwner {
     void set_wp(const std::shared_ptr<VB> &sp) { wp = sp; }
 
-    int get_code() {
+    int get_code() const {
         auto sp = wp.lock();
         if (!sp) {
             return -999;
         }
         return sp->get_code();
     }
 
+    const char *get_trampoline_state() const { return determine_trampoline_state(wp.lock()); }
+
 private:
     std::weak_ptr<VB> wp;
 };
@@ -81,7 +123,8 @@ void wrap(py::module_ &m,
     py::classh<SpOwner<VB>>(m, spo_pyname)
         .def(py::init<>())
         .def("set_sp", &SpOwner<VB>::set_sp)
-        .def("get_code", &SpOwner<VB>::get_code);
+        .def("get_code", &SpOwner<VB>::get_code)
+        .def("get_trampoline_state", &SpOwner<VB>::get_trampoline_state);
 
     py::classh<WpOwner<VB>>(m, wpo_pyname)
         .def(py::init<>())
@@ -90,7 +133,8 @@ void wrap(py::module_ &m,
              [](WpOwner<VB> &self, py::handle obj) {
                  self.set_wp(py::potentially_slicing_shared_ptr<VB>(obj));
              })
-        .def("get_code", &WpOwner<VB>::get_code);
+        .def("get_code", &WpOwner<VB>::get_code)
+        .def("get_trampoline_state", &WpOwner<VB>::get_trampoline_state);
 }
 
 } // namespace potentially_slicing_shared_ptr

tests/test_potentially_slicing_shared_ptr.py

@@ -71,12 +71,17 @@ def test_rtrn_obj_cast_shared_ptr(holder_kind, rtrn_kind, expected_code):
 def test_with_sp_owner(holder_kind, expected_code):
     spo = SP_OWNER_TYPES[holder_kind]()
     assert spo.get_code() == -888
+    assert spo.get_trampoline_state() == "sp nullptr"
 
     obj = VIRT_BASE_TYPES[holder_kind][expected_code]()
     assert obj.get_code() == expected_code
 
     spo.set_sp(obj)
     assert spo.get_code() == expected_code
+    expected_trampoline_state = (
+        "dynamic_cast failed" if expected_code == 100 else "trampoline alive"
+    )
+    assert spo.get_trampoline_state() == expected_trampoline_state
 
     del obj
     gc.collect()
@@ -86,6 +91,7 @@ def test_with_sp_owner(holder_kind, expected_code):
         assert (
             spo.get_code() == 100
         )  # see issue #1333 (inheritance slicing) and PR #5624
+    assert spo.get_trampoline_state() == expected_trampoline_state
 
 
 @pytest.mark.parametrize("expected_code", [100, 200])
@@ -94,6 +100,7 @@ def test_with_sp_owner(holder_kind, expected_code):
 def test_with_wp_owner(holder_kind, set_meth, expected_code):
     wpo = WP_OWNER_TYPES[holder_kind]()
     assert wpo.get_code() == -999
+    assert wpo.get_trampoline_state() == "sp nullptr"
 
     obj = VIRT_BASE_TYPES[holder_kind][expected_code]()
     assert obj.get_code() == expected_code
@@ -107,6 +114,13 @@ def test_with_wp_owner(holder_kind, set_meth, expected_code):
         assert wpo.get_code() == expected_code
     else:
         assert wpo.get_code() == -999  # see issue #5623 (weak_ptr expired) and PR #5624
+    if expected_code == 100:
+        expected_trampoline_state = "dynamic_cast failed"
+    elif holder_kind == "SH" and set_meth == "set_wp":
+        expected_trampoline_state = "sp nullptr"
+    else:
+        expected_trampoline_state = "trampoline alive"
+    assert wpo.get_trampoline_state() == expected_trampoline_state
 
     del obj
     gc.collect()