github.com/kaydxh/golang@v0.0.131/pkg/gocv/cgo/third_path/pybind11/tests/test_copy_move.py (about)

     1  import pytest
     2  
     3  from pybind11_tests import copy_move_policies as m
     4  
     5  
     6  def test_lacking_copy_ctor():
     7      with pytest.raises(RuntimeError) as excinfo:
     8          m.lacking_copy_ctor.get_one()
     9      assert "is non-copyable!" in str(excinfo.value)
    10  
    11  
    12  def test_lacking_move_ctor():
    13      with pytest.raises(RuntimeError) as excinfo:
    14          m.lacking_move_ctor.get_one()
    15      assert "is neither movable nor copyable!" in str(excinfo.value)
    16  
    17  
    18  def test_move_and_copy_casts():
    19      """Cast some values in C++ via custom type casters and count the number of moves/copies."""
    20  
    21      cstats = m.move_and_copy_cstats()
    22      c_m, c_mc, c_c = (
    23          cstats["MoveOnlyInt"],
    24          cstats["MoveOrCopyInt"],
    25          cstats["CopyOnlyInt"],
    26      )
    27  
    28      # The type move constructions/assignments below each get incremented: the move assignment comes
    29      # from the type_caster load; the move construction happens when extracting that via a cast or
    30      # loading into an argument.
    31      assert m.move_and_copy_casts(3) == 18
    32      assert c_m.copy_assignments + c_m.copy_constructions == 0
    33      assert c_m.move_assignments == 2
    34      assert c_m.move_constructions >= 2
    35      assert c_mc.alive() == 0
    36      assert c_mc.copy_assignments + c_mc.copy_constructions == 0
    37      assert c_mc.move_assignments == 2
    38      assert c_mc.move_constructions >= 2
    39      assert c_c.alive() == 0
    40      assert c_c.copy_assignments == 2
    41      assert c_c.copy_constructions >= 2
    42      assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
    43  
    44  
    45  def test_move_and_copy_loads():
    46      """Call some functions that load arguments via custom type casters and count the number of
    47      moves/copies."""
    48  
    49      cstats = m.move_and_copy_cstats()
    50      c_m, c_mc, c_c = (
    51          cstats["MoveOnlyInt"],
    52          cstats["MoveOrCopyInt"],
    53          cstats["CopyOnlyInt"],
    54      )
    55  
    56      assert m.move_only(10) == 10  # 1 move, c_m
    57      assert m.move_or_copy(11) == 11  # 1 move, c_mc
    58      assert m.copy_only(12) == 12  # 1 copy, c_c
    59      assert m.move_pair((13, 14)) == 27  # 1 c_m move, 1 c_mc move
    60      assert m.move_tuple((15, 16, 17)) == 48  # 2 c_m moves, 1 c_mc move
    61      assert m.copy_tuple((18, 19)) == 37  # 2 c_c copies
    62      # Direct constructions: 2 c_m moves, 2 c_mc moves, 1 c_c copy
    63      # Extra moves/copies when moving pairs/tuples: 3 c_m, 3 c_mc, 2 c_c
    64      assert m.move_copy_nested((1, ((2, 3, (4,)), 5))) == 15
    65  
    66      assert c_m.copy_assignments + c_m.copy_constructions == 0
    67      assert c_m.move_assignments == 6
    68      assert c_m.move_constructions == 9
    69      assert c_mc.copy_assignments + c_mc.copy_constructions == 0
    70      assert c_mc.move_assignments == 5
    71      assert c_mc.move_constructions == 8
    72      assert c_c.copy_assignments == 4
    73      assert c_c.copy_constructions == 6
    74      assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
    75  
    76  
    77  @pytest.mark.skipif(not m.has_optional, reason="no <optional>")
    78  def test_move_and_copy_load_optional():
    79      """Tests move/copy loads of std::optional arguments"""
    80  
    81      cstats = m.move_and_copy_cstats()
    82      c_m, c_mc, c_c = (
    83          cstats["MoveOnlyInt"],
    84          cstats["MoveOrCopyInt"],
    85          cstats["CopyOnlyInt"],
    86      )
    87  
    88      # The extra move/copy constructions below come from the std::optional move (which has to move
    89      # its arguments):
    90      assert m.move_optional(10) == 10  # c_m: 1 move assign, 2 move construct
    91      assert m.move_or_copy_optional(11) == 11  # c_mc: 1 move assign, 2 move construct
    92      assert m.copy_optional(12) == 12  # c_c: 1 copy assign, 2 copy construct
    93      # 1 move assign + move construct moves each of c_m, c_mc, 1 c_c copy
    94      # +1 move/copy construct each from moving the tuple
    95      # +1 move/copy construct each from moving the optional (which moves the tuple again)
    96      assert m.move_optional_tuple((3, 4, 5)) == 12
    97  
    98      assert c_m.copy_assignments + c_m.copy_constructions == 0
    99      assert c_m.move_assignments == 2
   100      assert c_m.move_constructions == 5
   101      assert c_mc.copy_assignments + c_mc.copy_constructions == 0
   102      assert c_mc.move_assignments == 2
   103      assert c_mc.move_constructions == 5
   104      assert c_c.copy_assignments == 2
   105      assert c_c.copy_constructions == 5
   106      assert c_m.alive() + c_mc.alive() + c_c.alive() == 0
   107  
   108  
   109  def test_private_op_new():
   110      """An object with a private `operator new` cannot be returned by value"""
   111  
   112      with pytest.raises(RuntimeError) as excinfo:
   113          m.private_op_new_value()
   114      assert "is neither movable nor copyable" in str(excinfo.value)
   115  
   116      assert m.private_op_new_reference().value == 1
   117  
   118  
   119  def test_move_fallback():
   120      """#389: rvp::move should fall-through to copy on non-movable objects"""
   121  
   122      m1 = m.get_moveissue1(1)
   123      assert m1.value == 1
   124      m2 = m.get_moveissue2(2)
   125      assert m2.value == 2
   126  
   127  
   128  def test_pytype_rvalue_cast():
   129      """Make sure that cast from pytype rvalue to other pytype works"""
   130  
   131      value = m.get_pytype_rvalue_castissue(1.0)
   132      assert value == 1