From 54fa191f20b51332b8620c19f3b75e4c62f4dec9 Mon Sep 17 00:00:00 2001 From: "Ralf W. Grosse-Kunstleve" Date: Sat, 23 Jan 2021 08:27:03 -0800 Subject: [PATCH] Pure renaming of function names in test_classh_inheritance, similar to the systematic approach used in test_class_wip. NO functional changes. --- tests/test_classh_inheritance.cpp | 45 +++++++++++++++++-------------- tests/test_classh_inheritance.py | 34 +++++++++++------------ 2 files changed, 42 insertions(+), 37 deletions(-) diff --git a/tests/test_classh_inheritance.cpp b/tests/test_classh_inheritance.cpp index ed801fc65..fa7f9aadd 100644 --- a/tests/test_classh_inheritance.cpp +++ b/tests/test_classh_inheritance.cpp @@ -20,11 +20,11 @@ struct drvd : base { }; // clang-format off -inline drvd *make_drvd() { return new drvd; } -inline base *make_drvd_up_cast() { return new drvd; } +inline drvd *rtrn_mptr_drvd() { return new drvd; } +inline base *rtrn_mptr_drvd_up_cast() { return new drvd; } -inline int pass_base(const base *b) { return b->id() + 11; } -inline int pass_drvd(const drvd *d) { return d->id() + 12; } +inline int pass_cptr_base(const base *b) { return b->id() + 11; } +inline int pass_cptr_drvd(const drvd *d) { return d->id() + 12; } // clang-format on using base1 = base_template<110>; @@ -36,13 +36,13 @@ struct drvd2 : base1, base2 { }; // clang-format off -inline drvd2 *make_drvd2() { return new drvd2; } -inline base1 *make_drvd2_up_cast1() { return new drvd2; } -inline base2 *make_drvd2_up_cast2() { return new drvd2; } +inline drvd2 *rtrn_mptr_drvd2() { return new drvd2; } +inline base1 *rtrn_mptr_drvd2_up_cast1() { return new drvd2; } +inline base2 *rtrn_mptr_drvd2_up_cast2() { return new drvd2; } -inline int pass_base1(const base1 *b) { return b->id() + 21; } -inline int pass_base2(const base2 *b) { return b->id() + 22; } -inline int pass_drvd2(const drvd2 *d) { return d->id() + 23; } +inline int pass_cptr_base1(const base1 *b) { return b->id() + 21; } +inline int pass_cptr_base2(const base2 *b) { return b->id() + 22; } +inline int pass_cptr_drvd2(const drvd2 *d) { return d->id() + 23; } // clang-format on } // namespace classh_inheritance @@ -62,21 +62,26 @@ TEST_SUBMODULE(classh_inheritance, m) { py::classh(m, "base"); py::classh(m, "drvd"); - m.def("make_drvd", make_drvd, py::return_value_policy::take_ownership); - m.def("make_drvd_up_cast", make_drvd_up_cast, py::return_value_policy::take_ownership); - m.def("pass_base", pass_base); - m.def("pass_drvd", pass_drvd); + m.def("rtrn_mptr_drvd", rtrn_mptr_drvd, py::return_value_policy::take_ownership); + m.def( + "rtrn_mptr_drvd_up_cast", rtrn_mptr_drvd_up_cast, py::return_value_policy::take_ownership); + m.def("pass_cptr_base", pass_cptr_base); + m.def("pass_cptr_drvd", pass_cptr_drvd); py::classh(m, "base1").def(py::init<>()); // __init__ needed for Python inheritance. py::classh(m, "base2").def(py::init<>()); py::classh(m, "drvd2"); - m.def("make_drvd2", make_drvd2, py::return_value_policy::take_ownership); - m.def("make_drvd2_up_cast1", make_drvd2_up_cast1, py::return_value_policy::take_ownership); - m.def("make_drvd2_up_cast2", make_drvd2_up_cast2, py::return_value_policy::take_ownership); - m.def("pass_base1", pass_base1); - m.def("pass_base2", pass_base2); - m.def("pass_drvd2", pass_drvd2); + m.def("rtrn_mptr_drvd2", rtrn_mptr_drvd2, py::return_value_policy::take_ownership); + m.def("rtrn_mptr_drvd2_up_cast1", + rtrn_mptr_drvd2_up_cast1, + py::return_value_policy::take_ownership); + m.def("rtrn_mptr_drvd2_up_cast2", + rtrn_mptr_drvd2_up_cast2, + py::return_value_policy::take_ownership); + m.def("pass_cptr_base1", pass_cptr_base1); + m.def("pass_cptr_base2", pass_cptr_base2); + m.def("pass_cptr_drvd2", pass_cptr_drvd2); } } // namespace classh_inheritance diff --git a/tests/test_classh_inheritance.py b/tests/test_classh_inheritance.py index 9af0bc3ed..8421bc304 100644 --- a/tests/test_classh_inheritance.py +++ b/tests/test_classh_inheritance.py @@ -3,36 +3,36 @@ from pybind11_tests import classh_inheritance as m -def test_make_drvd_pass_base(): - d = m.make_drvd() - i = m.pass_base(d) # load_impl Case 2a +def test_rtrn_mptr_drvd_pass_cptr_base(): + d = m.rtrn_mptr_drvd() + i = m.pass_cptr_base(d) # load_impl Case 2a assert i == 2 * 100 + 11 -def test_make_drvd_up_cast_pass_drvd(): - b = m.make_drvd_up_cast() +def test_rtrn_mptr_drvd_up_cast_pass_cptr_drvd(): + b = m.rtrn_mptr_drvd_up_cast() # the base return is down-cast immediately. assert b.__class__.__name__ == "drvd" - i = m.pass_drvd(b) + i = m.pass_cptr_drvd(b) assert i == 2 * 100 + 12 -def test_make_drvd2_pass_bases(): - d = m.make_drvd2() - i1 = m.pass_base1(d) # load_impl Case 2c +def test_rtrn_mptr_drvd2_pass_cptr_bases(): + d = m.rtrn_mptr_drvd2() + i1 = m.pass_cptr_base1(d) # load_impl Case 2c assert i1 == 3 * 110 + 4 * 120 + 21 - i2 = m.pass_base2(d) + i2 = m.pass_cptr_base2(d) assert i2 == 3 * 110 + 4 * 120 + 22 -def test_make_drvd2_up_casts_pass_drvd2(): - b1 = m.make_drvd2_up_cast1() +def test_rtrn_mptr_drvd2_up_casts_pass_cptr_drvd2(): + b1 = m.rtrn_mptr_drvd2_up_cast1() assert b1.__class__.__name__ == "drvd2" - i1 = m.pass_drvd2(b1) + i1 = m.pass_cptr_drvd2(b1) assert i1 == 3 * 110 + 4 * 120 + 23 - b2 = m.make_drvd2_up_cast2() + b2 = m.rtrn_mptr_drvd2_up_cast2() assert b2.__class__.__name__ == "drvd2" - i2 = m.pass_drvd2(b2) + i2 = m.pass_cptr_drvd2(b2) assert i2 == 3 * 110 + 4 * 120 + 23 @@ -43,7 +43,7 @@ def test_python_drvd2(): m.base2.__init__(self) d = Drvd2() - i1 = m.pass_base1(d) # load_impl Case 2b + i1 = m.pass_cptr_base1(d) # load_impl Case 2b assert i1 == 110 + 21 - i2 = m.pass_base2(d) + i2 = m.pass_cptr_base2(d) assert i2 == 120 + 22