Adapt ConstructorStats of unittests

As we prefer copying over moving now (if not explicitly asked for otherwise),
the constructor stats shift from moving towards copying.

Author: rhaschke

tests/test_copy_move.cpp

@@ -111,10 +111,10 @@ TEST_SUBMODULE(copy_move_policies, m) {
     // test_move_and_copy_casts
     m.def("move_and_copy_casts", [](py::object o) {
         int r = 0;
-        r += py::cast<MoveOrCopyInt>(o).value; /* moves */
+        r += py::cast<MoveOrCopyInt>(o).value; /* copies */
         r += py::cast<MoveOnlyInt>(o).value; /* moves */
         r += py::cast<CopyOnlyInt>(o).value; /* copies */
-        auto m1(py::cast<MoveOrCopyInt>(o)); /* moves */
+        auto m1(py::cast<MoveOrCopyInt>(o)); /* copies */
         auto m2(py::cast<MoveOnlyInt>(o)); /* moves */
         auto m3(py::cast<CopyOnlyInt>(o)); /* copies */
         r += m1.value + m2.value + m3.value;
@@ -124,7 +124,8 @@ TEST_SUBMODULE(copy_move_policies, m) {
 
     // test_move_and_copy_loads
     m.def("move_only", [](MoveOnlyInt m) { return m.value; });
-    m.def("move_or_copy", [](MoveOrCopyInt m) { return m.value; });
+    m.def("move", [](MoveOrCopyInt&& m) { return m.value; });
+    m.def("copy", [](MoveOrCopyInt m) { return m.value; });
     m.def("copy_only", [](CopyOnlyInt m) { return m.value; });
     m.def("move_pair", [](std::pair<MoveOnlyInt, MoveOrCopyInt> p) {
         return p.first.value + p.second.value;
@@ -184,15 +185,10 @@ TEST_SUBMODULE(copy_move_policies, m) {
 #ifdef PYBIND11_HAS_OPTIONAL
     // test_move_and_copy_load_optional
     m.attr("has_optional") = true;
-    m.def("move_optional", [](std::optional<MoveOnlyInt> o) {
-        return o->value;
-    });
-    m.def("move_or_copy_optional", [](std::optional<MoveOrCopyInt> o) {
-        return o->value;
-    });
-    m.def("copy_optional", [](std::optional<CopyOnlyInt> o) {
-        return o->value;
-    });
+    m.def("move_optional", [](std::optional<MoveOnlyInt> o) { return o->value; });
+    m.def("mc_move_optional", [](std::optional<MoveOrCopyInt>&& o) { return o->value; });
+    m.def("mc_copy_optional", [](std::optional<MoveOrCopyInt> o) { return o->value; });
+    m.def("copy_optional", [](std::optional<CopyOnlyInt> o) { return o->value; });
     m.def("move_optional_tuple", [](std::optional<std::tuple<MoveOrCopyInt, MoveOnlyInt, CopyOnlyInt>> x) {
         return std::get<0>(*x).value + std::get<1>(*x).value + std::get<2>(*x).value;
     });

tests/test_copy_move.py

@@ -26,14 +26,15 @@ def test_move_and_copy_casts():
     # The type move constructions/assignments below each get incremented: the move assignment comes
     # from the type_caster load; the move construction happens when extracting that via a cast or
     # loading into an argument.
-    assert m.move_and_copy_casts(3) == 18
+    assert m.move_and_copy_casts(3) == 6 * 3
     assert c_m.copy_assignments + c_m.copy_constructions == 0
     assert c_m.move_assignments == 2
     assert c_m.move_constructions >= 2
     assert c_mc.alive() == 0
-    assert c_mc.copy_assignments + c_mc.copy_constructions == 0
+    assert c_mc.copy_assignments == 0
+    assert c_mc.copy_constructions == 2
     assert c_mc.move_assignments == 2
-    assert c_mc.move_constructions >= 2
+    assert c_mc.move_constructions == 0
     assert c_c.alive() == 0
     assert c_c.copy_assignments == 2
     assert c_c.copy_constructions >= 2
@@ -50,21 +51,23 @@ def test_move_and_copy_loads():
     )
 
     assert m.move_only(10) == 10  # 1 move, c_m
-    assert m.move_or_copy(11) == 11  # 1 move, c_mc
+    assert m.move(10) == 10  # 0 move (just ref), c_mc
+    assert m.copy(11) == 11  # 1 copy, c_mc
     assert m.copy_only(12) == 12  # 1 copy, c_c
-    assert m.move_pair((13, 14)) == 27  # 1 c_m move, 1 c_mc move
-    assert m.move_tuple((15, 16, 17)) == 48  # 2 c_m moves, 1 c_mc move
+    assert m.move_pair((13, 14)) == 27  # 1 c_m move, 1 c_mc copy
+    assert m.move_tuple((15, 16, 17)) == 48  # 2 c_m moves, 1 c_mc copy
     assert m.copy_tuple((18, 19)) == 37  # 2 c_c copies
-    # Direct constructions: 2 c_m moves, 2 c_mc moves, 1 c_c copy
+    # Direct constructions: 2 c_m moves, 2 c_mc copies, 1 c_c copy
     # Extra moves/copies when moving pairs/tuples: 3 c_m, 3 c_mc, 2 c_c
     assert m.move_copy_nested((1, ((2, 3, (4,)), 5))) == 15
 
     assert c_m.copy_assignments + c_m.copy_constructions == 0
     assert c_m.move_assignments == 6
     assert c_m.move_constructions == 9
-    assert c_mc.copy_assignments + c_mc.copy_constructions == 0
-    assert c_mc.move_assignments == 5
-    assert c_mc.move_constructions == 8
+    assert c_mc.copy_assignments == 0
+    assert c_mc.copy_constructions == 5
+    assert c_mc.move_assignments == 6
+    assert c_mc.move_constructions == 3
     assert c_c.copy_assignments == 4
     assert c_c.copy_constructions == 6
     assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
@@ -111,8 +114,9 @@ def test_move_and_copy_load_optional():
 
     # The extra move/copy constructions below come from the std::optional move (which has to move
     # its arguments):
-    assert m.move_optional(10) == 10  # c_m: 1 move assign, 2 move construct
-    assert m.move_or_copy_optional(11) == 11  # c_mc: 1 move assign, 2 move construct
+    assert m.move_optional(10) == 10  # c_m: 1 move assign, +1 move construct
+    assert m.mc_move_optional(10) == 10  # c_mc: 1 move assign, +0 move construct
+    assert m.mc_copy_optional(11) == 11  # c_mc: 1 move assign, 1 copy construct
     assert m.copy_optional(12) == 12  # c_c: 1 copy assign, 2 copy construct
     # 1 move assign + move construct moves each of c_m, c_mc, 1 c_c copy
     # +1 move/copy construct each from moving the tuple
@@ -122,9 +126,10 @@ def test_move_and_copy_load_optional():
     assert c_m.copy_assignments + c_m.copy_constructions == 0
     assert c_m.move_assignments == 2
     assert c_m.move_constructions == 5
-    assert c_mc.copy_assignments + c_mc.copy_constructions == 0
-    assert c_mc.move_assignments == 2
-    assert c_mc.move_constructions == 5
+    assert c_mc.copy_assignments == 0
+    assert c_mc.copy_constructions == 2
+    assert c_mc.move_assignments == 3
+    assert c_mc.move_constructions == 4
     assert c_c.copy_assignments == 2
     assert c_c.copy_constructions == 5
     assert c_m.alive() + c_mc.alive() + c_c.alive() == 0

tests/test_kwargs_and_defaults.py

@@ -244,7 +244,7 @@ def test_args_refcount():
     myval = 54321
     expected = refcount(myval)
     assert m.arg_refcount_h(myval) == expected
-    assert m.arg_refcount_o(myval) == expected + 1
+    assert m.arg_refcount_o(myval) == expected + 2
     assert m.arg_refcount_h(myval) == expected
     assert refcount(myval) == expected
 
@@ -280,6 +280,6 @@ def test_args_refcount():
     # for the `py::args`; in the previous case, we could simply inc_ref and pass on Python's input
     # tuple without having to inc_ref the individual elements, but here we can't, hence the extra
     # refs.
-    assert m.mixed_args_refcount(myval, myval, myval) == (exp3 + 3, exp3 + 3, exp3 + 3)
+    assert m.mixed_args_refcount(myval, myval, myval) == (exp3 + 4, exp3 + 4, exp3 + 4)
 
     assert m.class_default_argument() == "<class 'decimal.Decimal'>"