Systematically removing _atyp from function names, to make the test code simpler.

tests/test_class_sh_basic.cpp

@@ -18,40 +18,40 @@ struct atyp { // Short for "any type".
 
 
 // clang-format off
 // clang-format off
 
 
-atyp        rtrn_valu_atyp() { atyp obj{"rtrn_valu"}; return obj; }
-atyp&&      rtrn_rref_atyp() { static atyp obj; obj.mtxt = "rtrn_rref"; return std::move(obj); }
-atyp const& rtrn_cref_atyp() { static atyp obj; obj.mtxt = "rtrn_cref"; return obj; }
-atyp&       rtrn_mref_atyp() { static atyp obj; obj.mtxt = "rtrn_mref"; return obj; }
-atyp const* rtrn_cptr_atyp() { return new atyp{"rtrn_cptr"}; }
-atyp*       rtrn_mptr_atyp() { return new atyp{"rtrn_mptr"}; }
+atyp        rtrn_valu() { atyp obj{"rtrn_valu"}; return obj; }
+atyp&&      rtrn_rref() { static atyp obj; obj.mtxt = "rtrn_rref"; return std::move(obj); }
+atyp const& rtrn_cref() { static atyp obj; obj.mtxt = "rtrn_cref"; return obj; }
+atyp&       rtrn_mref() { static atyp obj; obj.mtxt = "rtrn_mref"; return obj; }
+atyp const* rtrn_cptr() { return new atyp{"rtrn_cptr"}; }
+atyp*       rtrn_mptr() { return new atyp{"rtrn_mptr"}; }
 
 
-std::string pass_valu_atyp(atyp obj)        { return "pass_valu:" + obj.mtxt; }
-std::string pass_rref_atyp(atyp&& obj)      { return "pass_rref:" + obj.mtxt; }
-std::string pass_cref_atyp(atyp const& obj) { return "pass_cref:" + obj.mtxt; }
-std::string pass_mref_atyp(atyp& obj)       { return "pass_mref:" + obj.mtxt; }
-std::string pass_cptr_atyp(atyp const* obj) { return "pass_cptr:" + obj->mtxt; }
-std::string pass_mptr_atyp(atyp* obj)       { return "pass_mptr:" + obj->mtxt; }
+std::string pass_valu(atyp obj)        { return "pass_valu:" + obj.mtxt; }
+std::string pass_rref(atyp&& obj)      { return "pass_rref:" + obj.mtxt; }
+std::string pass_cref(atyp const& obj) { return "pass_cref:" + obj.mtxt; }
+std::string pass_mref(atyp& obj)       { return "pass_mref:" + obj.mtxt; }
+std::string pass_cptr(atyp const* obj) { return "pass_cptr:" + obj->mtxt; }
+std::string pass_mptr(atyp* obj)       { return "pass_mptr:" + obj->mtxt; }
 
 
-std::shared_ptr<atyp>       rtrn_shmp_atyp() { return std::shared_ptr<atyp      >(new atyp{"rtrn_shmp"}); }
-std::shared_ptr<atyp const> rtrn_shcp_atyp() { return std::shared_ptr<atyp const>(new atyp{"rtrn_shcp"}); }
+std::shared_ptr<atyp>       rtrn_shmp() { return std::shared_ptr<atyp      >(new atyp{"rtrn_shmp"}); }
+std::shared_ptr<atyp const> rtrn_shcp() { return std::shared_ptr<atyp const>(new atyp{"rtrn_shcp"}); }
 
 
-std::string pass_shmp_atyp(std::shared_ptr<atyp>       obj) { return "pass_shmp:" + obj->mtxt; }
-std::string pass_shcp_atyp(std::shared_ptr<atyp const> obj) { return "pass_shcp:" + obj->mtxt; }
+std::string pass_shmp(std::shared_ptr<atyp>       obj) { return "pass_shmp:" + obj->mtxt; }
+std::string pass_shcp(std::shared_ptr<atyp const> obj) { return "pass_shcp:" + obj->mtxt; }
 
 
-std::unique_ptr<atyp>       rtrn_uqmp_atyp() { return std::unique_ptr<atyp      >(new atyp{"rtrn_uqmp"}); }
-std::unique_ptr<atyp const> rtrn_uqcp_atyp() { return std::unique_ptr<atyp const>(new atyp{"rtrn_uqcp"}); }
+std::unique_ptr<atyp>       rtrn_uqmp() { return std::unique_ptr<atyp      >(new atyp{"rtrn_uqmp"}); }
+std::unique_ptr<atyp const> rtrn_uqcp() { return std::unique_ptr<atyp const>(new atyp{"rtrn_uqcp"}); }
 
 
-std::string pass_uqmp_atyp(std::unique_ptr<atyp      > obj) { return "pass_uqmp:" + obj->mtxt; }
-std::string pass_uqcp_atyp(std::unique_ptr<atyp const> obj) { return "pass_uqcp:" + obj->mtxt; }
+std::string pass_uqmp(std::unique_ptr<atyp      > obj) { return "pass_uqmp:" + obj->mtxt; }
+std::string pass_uqcp(std::unique_ptr<atyp const> obj) { return "pass_uqcp:" + obj->mtxt; }
 
 
 struct sddm : std::default_delete<atyp      > {};
 struct sddm : std::default_delete<atyp      > {};
 struct sddc : std::default_delete<atyp const> {};
 struct sddc : std::default_delete<atyp const> {};
 
 
-std::unique_ptr<atyp,       sddm> rtrn_udmp_atyp() { return std::unique_ptr<atyp,       sddm>(new atyp{"rtrn_udmp"}); }
-std::unique_ptr<atyp const, sddc> rtrn_udcp_atyp() { return std::unique_ptr<atyp const, sddc>(new atyp{"rtrn_udcp"}); }
+std::unique_ptr<atyp,       sddm> rtrn_udmp() { return std::unique_ptr<atyp,       sddm>(new atyp{"rtrn_udmp"}); }
+std::unique_ptr<atyp const, sddc> rtrn_udcp() { return std::unique_ptr<atyp const, sddc>(new atyp{"rtrn_udcp"}); }
 
 
-std::string pass_udmp_atyp(std::unique_ptr<atyp,       sddm> obj) { return "pass_udmp:" + obj->mtxt; }
-std::string pass_udcp_atyp(std::unique_ptr<atyp const, sddc> obj) { return "pass_udcp:" + obj->mtxt; }
+std::string pass_udmp(std::unique_ptr<atyp,       sddm> obj) { return "pass_udmp:" + obj->mtxt; }
+std::string pass_udcp(std::unique_ptr<atyp const, sddc> obj) { return "pass_udcp:" + obj->mtxt; }
 
 
 // clang-format on
 // clang-format on
 
 
@@ -76,42 +76,42 @@ TEST_SUBMODULE(class_sh_basic, m) {
         return obj;
         return obj;
     }));
     }));
 
 
-    m.def("rtrn_valu_atyp", rtrn_valu_atyp);
-    m.def("rtrn_rref_atyp", rtrn_rref_atyp);
-    m.def("rtrn_cref_atyp", rtrn_cref_atyp);
-    m.def("rtrn_mref_atyp", rtrn_mref_atyp);
-    m.def("rtrn_cptr_atyp", rtrn_cptr_atyp);
-    m.def("rtrn_mptr_atyp", rtrn_mptr_atyp);
+    m.def("rtrn_valu", rtrn_valu);
+    m.def("rtrn_rref", rtrn_rref);
+    m.def("rtrn_cref", rtrn_cref);
+    m.def("rtrn_mref", rtrn_mref);
+    m.def("rtrn_cptr", rtrn_cptr);
+    m.def("rtrn_mptr", rtrn_mptr);
 
 
-    m.def("pass_valu_atyp", pass_valu_atyp);
-    m.def("pass_rref_atyp", pass_rref_atyp);
-    m.def("pass_cref_atyp", pass_cref_atyp);
-    m.def("pass_mref_atyp", pass_mref_atyp);
-    m.def("pass_cptr_atyp", pass_cptr_atyp);
-    m.def("pass_mptr_atyp", pass_mptr_atyp);
+    m.def("pass_valu", pass_valu);
+    m.def("pass_rref", pass_rref);
+    m.def("pass_cref", pass_cref);
+    m.def("pass_mref", pass_mref);
+    m.def("pass_cptr", pass_cptr);
+    m.def("pass_mptr", pass_mptr);
 
 
-    m.def("rtrn_shmp_atyp", rtrn_shmp_atyp);
-    m.def("rtrn_shcp_atyp", rtrn_shcp_atyp);
+    m.def("rtrn_shmp", rtrn_shmp);
+    m.def("rtrn_shcp", rtrn_shcp);
 
 
-    m.def("pass_shmp_atyp", pass_shmp_atyp);
-    m.def("pass_shcp_atyp", pass_shcp_atyp);
+    m.def("pass_shmp", pass_shmp);
+    m.def("pass_shcp", pass_shcp);
 
 
-    m.def("rtrn_uqmp_atyp", rtrn_uqmp_atyp);
-    m.def("rtrn_uqcp_atyp", rtrn_uqcp_atyp);
+    m.def("rtrn_uqmp", rtrn_uqmp);
+    m.def("rtrn_uqcp", rtrn_uqcp);
 
 
-    m.def("pass_uqmp_atyp", pass_uqmp_atyp);
-    m.def("pass_uqcp_atyp", pass_uqcp_atyp);
+    m.def("pass_uqmp", pass_uqmp);
+    m.def("pass_uqcp", pass_uqcp);
 
 
-    m.def("rtrn_udmp_atyp", rtrn_udmp_atyp);
-    m.def("rtrn_udcp_atyp", rtrn_udcp_atyp);
+    m.def("rtrn_udmp", rtrn_udmp);
+    m.def("rtrn_udcp", rtrn_udcp);
 
 
-    m.def("pass_udmp_atyp", pass_udmp_atyp);
-    m.def("pass_udcp_atyp", pass_udcp_atyp);
+    m.def("pass_udmp", pass_udmp);
+    m.def("pass_udcp", pass_udcp);
 
 
     // Helpers for testing.
     // Helpers for testing.
     // These require selected functions above to work first, as indicated:
     // These require selected functions above to work first, as indicated:
-    m.def("get_mtxt", get_mtxt);                         // pass_cref_atyp
-    m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_uqmp_atyp, rtrn_uqmp_atyp
+    m.def("get_mtxt", get_mtxt);                         // pass_cref
+    m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_uqmp, rtrn_uqmp
 
 
     m.def("py_type_handle_of_atyp", []() {
     m.def("py_type_handle_of_atyp", []() {
         return py::type::handle_of<atyp>(); // Exercises static_cast in this function.
         return py::type::handle_of<atyp>(); // Exercises static_cast in this function.

tests/test_class_sh_basic.py

@@ -16,18 +16,18 @@ def test_atyp_constructors():
 @pytest.mark.parametrize(
 @pytest.mark.parametrize(
     "rtrn_f, expected",
     "rtrn_f, expected",
     [
     [
-        (m.rtrn_valu_atyp, "rtrn_valu.MvCtor"),
-        (m.rtrn_rref_atyp, "rtrn_rref.MvCtor"),
-        (m.rtrn_cref_atyp, "rtrn_cref.CpCtor"),
-        (m.rtrn_mref_atyp, "rtrn_mref.CpCtor"),
-        (m.rtrn_cptr_atyp, "rtrn_cptr"),
-        (m.rtrn_mptr_atyp, "rtrn_mptr"),
-        (m.rtrn_shmp_atyp, "rtrn_shmp"),
-        (m.rtrn_shcp_atyp, "rtrn_shcp"),
-        (m.rtrn_uqmp_atyp, "rtrn_uqmp"),
-        (m.rtrn_uqcp_atyp, "rtrn_uqcp"),
-        (m.rtrn_udmp_atyp, "rtrn_udmp"),
-        (m.rtrn_udcp_atyp, "rtrn_udcp"),
+        (m.rtrn_valu, "rtrn_valu.MvCtor"),
+        (m.rtrn_rref, "rtrn_rref.MvCtor"),
+        (m.rtrn_cref, "rtrn_cref.CpCtor"),
+        (m.rtrn_mref, "rtrn_mref.CpCtor"),
+        (m.rtrn_cptr, "rtrn_cptr"),
+        (m.rtrn_mptr, "rtrn_mptr"),
+        (m.rtrn_shmp, "rtrn_shmp"),
+        (m.rtrn_shcp, "rtrn_shcp"),
+        (m.rtrn_uqmp, "rtrn_uqmp"),
+        (m.rtrn_uqcp, "rtrn_uqcp"),
+        (m.rtrn_udmp, "rtrn_udmp"),
+        (m.rtrn_udcp, "rtrn_udcp"),
     ],
     ],
 )
 )
 def test_cast(rtrn_f, expected):
 def test_cast(rtrn_f, expected):
@@ -37,16 +37,16 @@ def test_cast(rtrn_f, expected):
 @pytest.mark.parametrize(
 @pytest.mark.parametrize(
     "pass_f, mtxt, expected",
     "pass_f, mtxt, expected",
     [
     [
-        (m.pass_valu_atyp, "Valu", "pass_valu:Valu.MvCtor.CpCtor"),
-        (m.pass_rref_atyp, "Rref", "pass_rref:Rref.MvCtor.CpCtor"),
-        (m.pass_cref_atyp, "Cref", "pass_cref:Cref.MvCtor"),
-        (m.pass_mref_atyp, "Mref", "pass_mref:Mref.MvCtor"),
-        (m.pass_cptr_atyp, "Cptr", "pass_cptr:Cptr.MvCtor"),
-        (m.pass_mptr_atyp, "Mptr", "pass_mptr:Mptr.MvCtor"),
-        (m.pass_shmp_atyp, "Shmp", "pass_shmp:Shmp.MvCtor"),
-        (m.pass_shcp_atyp, "Shcp", "pass_shcp:Shcp.MvCtor"),
-        (m.pass_uqmp_atyp, "Uqmp", "pass_uqmp:Uqmp.MvCtor"),
-        (m.pass_uqcp_atyp, "Uqcp", "pass_uqcp:Uqcp.MvCtor"),
+        (m.pass_valu, "Valu", "pass_valu:Valu.MvCtor.CpCtor"),
+        (m.pass_rref, "Rref", "pass_rref:Rref.MvCtor.CpCtor"),
+        (m.pass_cref, "Cref", "pass_cref:Cref.MvCtor"),
+        (m.pass_mref, "Mref", "pass_mref:Mref.MvCtor"),
+        (m.pass_cptr, "Cptr", "pass_cptr:Cptr.MvCtor"),
+        (m.pass_mptr, "Mptr", "pass_mptr:Mptr.MvCtor"),
+        (m.pass_shmp, "Shmp", "pass_shmp:Shmp.MvCtor"),
+        (m.pass_shcp, "Shcp", "pass_shcp:Shcp.MvCtor"),
+        (m.pass_uqmp, "Uqmp", "pass_uqmp:Uqmp.MvCtor"),
+        (m.pass_uqcp, "Uqcp", "pass_uqcp:Uqcp.MvCtor"),
     ],
     ],
 )
 )
 def test_load_with_mtxt(pass_f, mtxt, expected):
 def test_load_with_mtxt(pass_f, mtxt, expected):
@@ -56,8 +56,8 @@ def test_load_with_mtxt(pass_f, mtxt, expected):
 @pytest.mark.parametrize(
 @pytest.mark.parametrize(
     "pass_f, rtrn_f, expected",
     "pass_f, rtrn_f, expected",
     [
     [
-        (m.pass_udmp_atyp, m.rtrn_udmp_atyp, "pass_udmp:rtrn_udmp"),
-        (m.pass_udcp_atyp, m.rtrn_udcp_atyp, "pass_udcp:rtrn_udcp"),
+        (m.pass_udmp, m.rtrn_udmp, "pass_udmp:rtrn_udmp"),
+        (m.pass_udcp, m.rtrn_udcp, "pass_udcp:rtrn_udcp"),
     ],
     ],
 )
 )
 def test_load_with_rtrn_f(pass_f, rtrn_f, expected):
 def test_load_with_rtrn_f(pass_f, rtrn_f, expected):
@@ -67,10 +67,10 @@ def test_load_with_rtrn_f(pass_f, rtrn_f, expected):
 @pytest.mark.parametrize(
 @pytest.mark.parametrize(
     "pass_f, rtrn_f, expected",
     "pass_f, rtrn_f, expected",
     [
     [
-        (m.pass_uqmp_atyp, m.rtrn_uqmp_atyp, "pass_uqmp:rtrn_uqmp"),
-        (m.pass_uqcp_atyp, m.rtrn_uqcp_atyp, "pass_uqcp:rtrn_uqcp"),
-        (m.pass_udmp_atyp, m.rtrn_udmp_atyp, "pass_udmp:rtrn_udmp"),
-        (m.pass_udcp_atyp, m.rtrn_udcp_atyp, "pass_udcp:rtrn_udcp"),
+        (m.pass_uqmp, m.rtrn_uqmp, "pass_uqmp:rtrn_uqmp"),
+        (m.pass_uqcp, m.rtrn_uqcp, "pass_uqcp:rtrn_uqcp"),
+        (m.pass_udmp, m.rtrn_udmp, "pass_udmp:rtrn_udmp"),
+        (m.pass_udcp, m.rtrn_udcp, "pass_udcp:rtrn_udcp"),
     ],
     ],
 )
 )
 def test_pass_unique_ptr_disowns(pass_f, rtrn_f, expected):
 def test_pass_unique_ptr_disowns(pass_f, rtrn_f, expected):