roundtrip test via reference passed to aliased class method

Probably the test is failing, because it passes the arguments by value
instead of by reference.

Author: rhaschke

tests/test_class_sh_with_alias.cpp

@@ -73,14 +73,67 @@ void wrap(py::module_ m, const char *py_class_name) {
     m.def("AddInCppUniquePtr", AddInCppUniquePtr<SerNo>, py::arg("obj"), py::arg("other_val"));
 }
 
+
+struct Passenger {
+    std::string mtxt;
+    Passenger(const std::string& txt = "DefaultCtor") : mtxt(txt) {}
+    Passenger(const Passenger &other) { mtxt = other.mtxt + "_CpCtor"; }
+    Passenger(Passenger &&other) { mtxt = other.mtxt + "_MvCtor"; }
+};
+struct ConsumerBase {
+    ConsumerBase() = default;
+    ConsumerBase(const ConsumerBase&) = default;
+    ConsumerBase(ConsumerBase&&) = default;
+    virtual ~ConsumerBase() = default;
+    virtual void pass_uq_cref(const std::unique_ptr<Passenger>& obj) = 0;
+    virtual void pass_lref(Passenger &obj)                           = 0;
+    virtual void pass_cref(const Passenger &obj)                     = 0;
+};
+struct ConsumerBaseAlias : ConsumerBase {
+    using ConsumerBase::ConsumerBase;
+    void pass_uq_cref(const std::unique_ptr<Passenger> &obj) override { PYBIND11_OVERRIDE_PURE(void, ConsumerBase, pass_uq_cref, obj); }
+    void pass_lref(Passenger &obj)                           override { PYBIND11_OVERRIDE_PURE(void, ConsumerBase, pass_lref, obj); }
+    void pass_cref(const Passenger &obj)                     override { PYBIND11_OVERRIDE_PURE(void, ConsumerBase, pass_cref, obj); }
+};
+
+// check roundtrip of Passenger send to ConsumerBaseAlias
+// TODO: Find template magic to avoid code duplication
+std::string check_roundtrip_uq_cref(ConsumerBase &consumer) {
+    std::unique_ptr<Passenger> obj(new Passenger(""));
+    consumer.pass_uq_cref(obj);
+    return obj->mtxt;
+}
+std::string check_roundtrip_lref(ConsumerBase &consumer) {
+    Passenger obj("");
+    consumer.pass_lref(obj);
+    return obj.mtxt;
+}
+std::string check_roundtrip_cref(ConsumerBase &consumer) {
+    Passenger obj("");
+    consumer.pass_cref(obj);
+    return obj.mtxt;
+}
+
 } // namespace test_class_sh_with_alias
 } // namespace pybind11_tests
 
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_with_alias::Abase<0>)
 PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_with_alias::Abase<1>)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_with_alias::Passenger)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(pybind11_tests::test_class_sh_with_alias::ConsumerBase)
 
 TEST_SUBMODULE(class_sh_with_alias, m) {
     using namespace pybind11_tests::test_class_sh_with_alias;
     wrap<0>(m, "Abase0");
     wrap<1>(m, "Abase1");
+
+    py::classh<Passenger>(m, "Passenger")
+        .def_readwrite("mtxt", &Passenger::mtxt);
+
+    py::classh<ConsumerBase, ConsumerBaseAlias>(m, "ConsumerBase")
+        .def(py::init<>());
+
+    m.def("check_roundtrip_uq_cref", check_roundtrip_uq_cref);
+    m.def("check_roundtrip_lref", check_roundtrip_lref);
+    m.def("check_roundtrip_cref", check_roundtrip_cref);
 }

tests/test_class_sh_with_alias.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import pytest
+import env  # noqa: F401
 
 from pybind11_tests import class_sh_with_alias as m
 
@@ -56,3 +57,37 @@ def test_drvd1_add_in_cpp_unique_ptr():
         drvd = PyDrvd1(25)
         assert m.AddInCppUniquePtr(drvd, 83) == ((25 * 10 + 3) * 200 + 83) * 100 + 13
         return  # Comment out for manual leak checking (use `top` command).
+
+
+class PyConsumer(m.ConsumerBase):
+    def __init__(self):
+        super(PyConsumer, self).__init__()
+
+    def pass_uq_cref(self, obj):
+        obj.mtxt = obj.mtxt + "pass_uq_cref"
+
+    def pass_lref(self, obj):
+        obj.mtxt = obj.mtxt + "pass_lref"
+
+    def pass_cref(self, obj):
+        obj.mtxt = obj.mtxt + "pass_cref"
+
+
+# roundtrip tests, creating an object in C++ that is passed by reference
+# to a virtual method of a class derived in Python. Thus:
+# C++ -> Python -> C++
+@pytest.mark.parametrize(
+    "f, expected",
+    [
+        (m.check_roundtrip_uq_cref, "pass_uq_cref"),
+        (m.check_roundtrip_lref, "pass_lref"),  # modification passed through 1:1
+        pytest.param(
+            m.check_roundtrip_cref,
+            "",  # modification lost (forbidden due to constness)
+            marks=[pytest.mark.skipif("env.PYPY")],
+        ),
+    ],
+)
+def test_unique_ptr_consumer_roundtrip(f, expected):
+    c = PyConsumer()
+    assert f(c) == expected