Cleaning up test_classh_mock.cpp.

Author: rwgk

tests/test_classh_mock.cpp

@@ -30,41 +30,42 @@ PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
 // BOILERPLATE END
 
 namespace {
-struct Foo0 {};
-struct Foo1 {};
-struct Foo2 {};
-struct Foo3 {};
-struct Foo4 {};
+struct FooUc {};
+struct FooUp {};
+struct FooSa {};
+struct FooSc {};
+struct FooSp {};
 } // namespace
 
-PYBIND11_TYPE_CASTER_BASE_HOLDER(Foo1, std::shared_ptr<Foo1>)
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(Foo2)
-PYBIND11_SMART_HOLDER_TYPE_CASTERS(Foo4)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(FooUp)
+PYBIND11_SMART_HOLDER_TYPE_CASTERS(FooSp)
+
+PYBIND11_TYPE_CASTER_BASE_HOLDER(FooSa, std::shared_ptr<FooSa>)
 
 TEST_SUBMODULE(classh_mock, m) {
     // Please see README_smart_holder.rst, in particular section
     // Classic / Conservative / Progressive cross-module compatibility
 
-    // Uses std::unique_ptr<Foo0> as holder in Conservative mode, py::smart_holder in Progressive
-    // mode (if available).
-    py::class_<Foo0>(m, "Foo0").def(py::init<>());
-
-    // Always uses std::shared_ptr<Foo1> as holder.
-    py::class_<Foo1, std::shared_ptr<Foo1>>(m, "Foo1").def(py::init<>());
+    // Uses std::unique_ptr<FooUc> as holder in Classic or Conservative mode, py::smart_holder in
+    // Progressive mode.
+    py::class_<FooUc>(m, "FooUc").def(py::init<>());
 
-    // Uses std::shared_ptr<Foo2> as holder in Classic mode, py::smart_holder in Conservative or
+    // Uses std::unique_ptr<FooUp> as holder in Classic mode, py::smart_holder in Conservative or
     // Progressive mode.
-    py::class_<Foo2, PYBIND11_SH_AVL(Foo2)>(m, "Foo2").def(py::init<>());
-    // ------------- std::shared_ptr<Foo2> -- same length by design, to not disturb the indentation
-    // of existing code.
+    py::classh<FooUp>(m, "FooUp").def(py::init<>());
 
-    // Uses std::shared_ptr<Foo3> as holder in Classic or Conservative mode, py::smart_holder in
+    // Always uses std::shared_ptr<FooSa> as holder.
+    py::class_<FooSa, std::shared_ptr<FooSa>>(m, "FooSa").def(py::init<>());
+
+    // Uses std::shared_ptr<FooSc> as holder in Classic or Conservative mode, py::smart_holder in
     // Progressive mode.
-    py::class_<Foo3, PYBIND11_SH_DEF(Foo3)>(m, "Foo3").def(py::init<>());
-    // ------------- std::shared_ptr<Foo3> -- same length by design, to not disturb the indentation
-    // of existing code.
+    py::class_<FooSc, PYBIND11_SH_DEF(FooSc)>(m, "FooSc").def(py::init<>());
+    // -------------- std::shared_ptr<FooSc> -- same length by design, to not disturb the
+    // indentation of existing code.
 
-    // Uses py::smart_holder if available, or std::unique_ptr<Foo3> if only pybind11 Classic is
-    // available.
-    py::classh<Foo4>(m, "Foo4").def(py::init<>());
+    // Uses std::shared_ptr<FooSp> as holder in Classic mode, py::smart_holder in Conservative or
+    // Progressive mode.
+    py::class_<FooSp, PYBIND11_SH_AVL(FooSp)>(m, "FooSp").def(py::init<>());
+    // -------------- std::shared_ptr<FooSp> -- same length by design, to not disturb the
+    // indentation of existing code.
 }

tests/test_classh_mock.py

@@ -6,8 +6,8 @@
 def test_foobar():
     # Not really testing anything in particular. The main purpose of this test is to ensure the
     # suggested BOILERPLATE code block in test_classh_mock.cpp is correct.
-    assert m.Foo0()
-    assert m.Foo1()
-    assert m.Foo2()
-    assert m.Foo3()
-    assert m.Foo4()
+    assert m.FooUc()
+    assert m.FooUp()
+    assert m.FooSa()
+    assert m.FooSc()
+    assert m.FooSp()