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,74 @@ 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) { obj->mtxt += "_base"; };
+    virtual void pass_lref(Passenger &obj) { obj.mtxt += "_base"; };
+    virtual void pass_cref(const Passenger &obj) { const_cast<Passenger &>(obj).mtxt += "_base"; };
+};
+struct ConsumerBaseAlias : ConsumerBase {
+    using ConsumerBase::ConsumerBase;
+    void pass_uq_cref(const std::unique_ptr<Passenger> &obj) override {
+        PYBIND11_OVERRIDE(void, ConsumerBase, pass_uq_cref, obj);
+    }
+    void pass_lref(Passenger &obj) override {
+        PYBIND11_OVERRIDE(void, ConsumerBase, pass_lref, obj);
+    }
+    void pass_cref(const Passenger &obj) override {
+        PYBIND11_OVERRIDE(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<>())
+        .def("pass_uq_cref", &ConsumerBase::pass_uq_cref)
+        .def("pass_lref", &ConsumerBase::pass_lref)
+        .def("pass_cref", &ConsumerBase::pass_cref);
+
+    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,75 @@ 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 PyConsumer1(m.ConsumerBase):
+    def __init__(self):
+        m.ConsumerBase.__init__(self)
+
+    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"
+
+
+class PyConsumer2(m.ConsumerBase):
+    """This one, additionally to PyConsumer1 calls its base methods"""
+
+    def __init__(self):
+        m.ConsumerBase.__init__(self)
+
+    def pass_uq_cref(self, obj):
+        obj.mtxt = obj.mtxt + "pass_uq_cref"
+        m.ConsumerBase.pass_uq_cref(self, obj)
+
+    def pass_lref(self, obj):
+        obj.mtxt = obj.mtxt + "pass_lref"
+        m.ConsumerBase.pass_lref(self, obj)
+
+    def pass_cref(self, obj):
+        obj.mtxt = obj.mtxt + "pass_cref"
+        m.ConsumerBase.pass_cref(self, obj)
+
+
+# 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_consumer1_roundtrip(f, expected):
+    c = PyConsumer1()
+    assert f(c) == expected
+
+
+@pytest.mark.parametrize(
+    "f, expected",
+    [
+        pytest.param(  # cannot (yet) pass unowned const unique_ptr&
+            m.check_roundtrip_uq_cref, "pass_uq_cref_base", marks=pytest.mark.xfail
+        ),
+        (m.check_roundtrip_lref, "pass_lref_base"),  # modification passed through 1:1
+        pytest.param(  # PYPY always copies the argument instead of passing the reference
+            m.check_roundtrip_cref,
+            "",  # modification lost (forbidden due to constness)
+            marks=pytest.mark.skipif("env.PYPY"),
+        ),
+    ],
+)
+def test_unique_ptr_consumer2_roundtrip(f, expected):
+    c = PyConsumer2()
+    assert f(c) == expected