Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2024-11-29 08:32:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add no-op pybind11/smart_holder.h, 21 BAKEIN_BREAK in test_class_sh_basic.cpp, 26 BAKEIN_BREAK in test_class_sh_basic.py

Browse Source 
```
========================================================= short test summary info ==========================================================
SKIPPED [1] test_class_sh_basic.py:59: got empty parameter set ('pass_f', 'rtrn_f', 'expected'), function test_load_with_rtrn_f at /usr/local/google/home/rwgk/forked/pybind11/tests/test_class_sh_basic.py:58
SKIPPED [1] test_class_sh_basic.py:70: got empty parameter set ('pass_f', 'rtrn_f', 'regex_expected'), function test_deleter_roundtrip at /usr/local/google/home/rwgk/forked/pybind11/tests/test_class_sh_basic.py:69
SKIPPED [1] test_class_sh_basic.py:99: got empty parameter set ('pass_f', 'rtrn_f', 'expected'), function test_pass_unique_ptr_disowns at /usr/local/google/home/rwgk/forked/pybind11/tests/test_class_sh_basic.py:98
SKIPPED [1] test_class_sh_basic.py:120: got empty parameter set ('pass_f', 'rtrn_f'), function test_cannot_disown_use_count_ne_1 at /usr/local/google/home/rwgk/forked/pybind11/tests/test_class_sh_basic.py:119
SKIPPED [1] test_class_sh_basic.py:145: BAKEIN_BREAK: AttributeError unique_ptr_roundtrip
SKIPPED [1] test_class_sh_basic.py:157: unconditional skip
SKIPPED [1] test_class_sh_basic.py:169: got empty parameter set ('pass_f', 'rtrn_f', 'moved_out', 'moved_in'), function test_unique_ptr_consumer_roundtrip at /usr/local/google/home/rwgk/forked/pybind11/tests/test_class_sh_basic.py:168
SKIPPED [1] test_class_sh_basic.py:210: BAKEIN_BREAK: AttributeError args_unique_ptr
====================================================== 17 passed, 8 skipped in 0.04s =======================================================```
This commit is contained in:
Ralf W. Grosse-Kunstleve 2024-07-02 13:48:58 -07:00
parent b6171bc7ad
commit 12b01305de
3 changed files with 89 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
include/pybind11/smart_holder.h Normal file
View File

@ -0,0 +1,21 @@
// Copyright (c) 2024 The Pybind Development Team.
// All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#pragma once
#include "pybind11.h"
#define PYBIND11_SMART_HOLDER_TYPE_CASTERS(...)
#define PYBIND11_SH_AVL(...) // "Smart_Holder if AVaiLable"
#define PYBIND11_SH_DEF(...) // "Smart_Holder if DEFault"
PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
template <typename type_, typename... options>
class classh : public class_<type_, options...> {
public:
using class_<type_, options...>::class_;
};
PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

44
tests/test_class_sh_basic.cpp
View File

@ -173,45 +173,46 @@ TEST_SUBMODULE(class_sh_basic, m) {
m.def("pass_shcp", pass_shcp); m.def("pass_shcp", pass_shcp);
m.def("rtrn_uqmp", rtrn_uqmp); m.def("rtrn_uqmp", rtrn_uqmp);
m.def("rtrn_uqcp", rtrn_uqcp); // BAKEIN_BREAK m.def("rtrn_uqcp", rtrn_uqcp);
m.def("pass_uqmp", pass_uqmp); // BAKEIN_BREAK m.def("pass_uqmp", pass_uqmp);
m.def("pass_uqcp", pass_uqcp); // BAKEIN_BREAK m.def("pass_uqcp", pass_uqcp);
m.def("rtrn_udmp", rtrn_udmp); m.def("rtrn_udmp", rtrn_udmp);
m.def("rtrn_udcp", rtrn_udcp); // BAKEIN_BREAK m.def("rtrn_udcp", rtrn_udcp);
m.def("pass_udmp", pass_udmp); // BAKEIN_BREAK m.def("pass_udmp", pass_udmp);
m.def("pass_udcp", pass_udcp); // BAKEIN_BREAK m.def("pass_udcp", pass_udcp);
m.def("rtrn_udmp_del", rtrn_udmp_del); m.def("rtrn_udmp_del", rtrn_udmp_del);
m.def("rtrn_udcp_del", rtrn_udcp_del); // BAKEIN_BREAK m.def("rtrn_udcp_del", rtrn_udcp_del);
m.def("pass_udmp_del", pass_udmp_del); // BAKEIN_BREAK m.def("pass_udmp_del", pass_udmp_del);
m.def("pass_udcp_del", pass_udcp_del); // BAKEIN_BREAK m.def("pass_udcp_del", pass_udcp_del);
m.def("rtrn_udmp_del_nd", rtrn_udmp_del_nd); m.def("rtrn_udmp_del_nd", rtrn_udmp_del_nd);
m.def("rtrn_udcp_del_nd", rtrn_udcp_del_nd); // BAKEIN_BREAK m.def("rtrn_udcp_del_nd", rtrn_udcp_del_nd);
m.def("pass_udmp_del_nd", pass_udmp_del_nd); // BAKEIN_BREAK m.def("pass_udmp_del_nd", pass_udmp_del_nd);
m.def("pass_udcp_del_nd", pass_udcp_del_nd); // BAKEIN_BREAK m.def("pass_udcp_del_nd", pass_udcp_del_nd);
py::classh<uconsumer>(m, "uconsumer") py::classh<uconsumer>(m, "uconsumer")
.def(py::init<>()) .def(py::init<>())
.def("valid", &uconsumer::valid) .def("valid", &uconsumer::valid)
.def("pass_valu", &uconsumer::pass_valu) // BAKEIN_BREAK .def("pass_valu", &uconsumer::pass_valu)
.def("pass_rref", &uconsumer::pass_rref) // BAKEIN_BREAK .def("pass_rref", &uconsumer::pass_rref)
.def("rtrn_valu", &uconsumer::rtrn_valu) .def("rtrn_valu", &uconsumer::rtrn_valu)
.def("rtrn_lref", &uconsumer::rtrn_lref) // BAKEIN_BREAK .def("rtrn_lref", &uconsumer::rtrn_lref)
.def("rtrn_cref", &uconsumer::rtrn_cref); // BAKEIN_BREAK .def("rtrn_cref", &uconsumer::rtrn_cref)
;
// 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 m.def("get_mtxt", get_mtxt); // pass_cref
m.def("get_ptr", get_ptr); // pass_cref m.def("get_ptr", get_ptr); // pass_cref
m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_uqmp, rtrn_uqmp // BAKEIN_BREAK m.def("unique_ptr_roundtrip", unique_ptr_roundtrip); // pass_uqmp, rtrn_uqmp
m.def("unique_ptr_cref_roundtrip", unique_ptr_cref_roundtrip); // BAKEIN_BREAK m.def("unique_ptr_cref_roundtrip", unique_ptr_cref_roundtrip);
py::classh<SharedPtrStash>(m, "SharedPtrStash") py::classh<SharedPtrStash>(m, "SharedPtrStash")
.def(py::init<>()) .def(py::init<>())
@ -224,8 +225,11 @@ TEST_SUBMODULE(class_sh_basic, m) {
// Checks for type names used as arguments // Checks for type names used as arguments
m.def("args_shared_ptr", [](std::shared_ptr<atyp> p) { return p; }); m.def("args_shared_ptr", [](std::shared_ptr<atyp> p) { return p; });
m.def("args_shared_ptr_const", [](std::shared_ptr<atyp const> p) { return p; }); m.def("args_shared_ptr_const", [](std::shared_ptr<atyp const> p) { return p; });
m.def("args_unique_ptr", [](std::unique_ptr<atyp> p) { return p; }); // BAKEIN_TEMP clang-format off
m.def("args_unique_ptr_const", [](std::unique_ptr<atyp const> p) { return p; }); // clang-format off
// BAKEIN_BREAK m.def("args_unique_ptr", [](std::unique_ptr<atyp> p) { return p; });
// BAKEIN_BREAK m.def("args_unique_ptr_const", [](std::unique_ptr<atyp const> p) { return p; });
// clang-format on
// Make sure unique_ptr type caster accept automatic_reference return value policy. // Make sure unique_ptr type caster accept automatic_reference return value policy.
m.def( m.def(

86
tests/test_class_sh_basic.py
View File

@ -26,12 +26,12 @@ def test_atyp_constructors():
(m.rtrn_mref, "rtrn_mref(_MvCtor)*_CpCtor"), (m.rtrn_mref, "rtrn_mref(_MvCtor)*_CpCtor"),
(m.rtrn_cptr, "rtrn_cptr"), (m.rtrn_cptr, "rtrn_cptr"),
(m.rtrn_mptr, "rtrn_mptr"), (m.rtrn_mptr, "rtrn_mptr"),
(m.rtrn_shmp, "rtrn_shmp"), # BAKEIN_BREAK (m.rtrn_shmp, "rtrn_shmp"),
(m.rtrn_shcp, "rtrn_shcp"), # BAKEIN_BREAK (m.rtrn_shcp, "rtrn_shcp"),
(m.rtrn_uqmp, "rtrn_uqmp"), (m.rtrn_uqmp, "rtrn_uqmp"),
(m.rtrn_uqcp, "rtrn_uqcp"), # BAKEIN_BREAK (m.rtrn_uqcp, "rtrn_uqcp"),
(m.rtrn_udmp, "rtrn_udmp"), (m.rtrn_udmp, "rtrn_udmp"),
(m.rtrn_udcp, "rtrn_udcp"), # BAKEIN_BREAK (m.rtrn_udcp, "rtrn_udcp"),
], ],
) )
def test_cast(rtrn_f, expected): def test_cast(rtrn_f, expected):
@ -46,10 +46,10 @@ def test_cast(rtrn_f, expected):
(m.pass_mref, "Mref", "pass_mref:Mref(_MvCtor)*_MvCtor"), (m.pass_mref, "Mref", "pass_mref:Mref(_MvCtor)*_MvCtor"),
(m.pass_cptr, "Cptr", "pass_cptr:Cptr(_MvCtor)*_MvCtor"), (m.pass_cptr, "Cptr", "pass_cptr:Cptr(_MvCtor)*_MvCtor"),
(m.pass_mptr, "Mptr", "pass_mptr:Mptr(_MvCtor)*_MvCtor"), (m.pass_mptr, "Mptr", "pass_mptr:Mptr(_MvCtor)*_MvCtor"),
(m.pass_shmp, "Shmp", "pass_shmp:Shmp(_MvCtor)*_MvCtor"), # BAKEIN_BREAK (m.pass_shmp, "Shmp", "pass_shmp:Shmp(_MvCtor)*_MvCtor"),
(m.pass_shcp, "Shcp", "pass_shcp:Shcp(_MvCtor)*_MvCtor"), # BAKEIN_BREAK (m.pass_shcp, "Shcp", "pass_shcp:Shcp(_MvCtor)*_MvCtor"),
(m.pass_uqmp, "Uqmp", "pass_uqmp:Uqmp(_MvCtor)*_MvCtor"), # BAKEIN_BREAK (m.pass_uqmp, "Uqmp", "pass_uqmp:Uqmp(_MvCtor)*_MvCtor"),
(m.pass_uqcp, "Uqcp", "pass_uqcp:Uqcp(_MvCtor)*_MvCtor"), # BAKEIN_BREAK (m.pass_uqcp, "Uqcp", "pass_uqcp:Uqcp(_MvCtor)*_MvCtor"),
], ],
) )
def test_load_with_mtxt(pass_f, mtxt, expected): def test_load_with_mtxt(pass_f, mtxt, expected):
@ -59,8 +59,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, m.rtrn_udmp, "pass_udmp:rtrn_udmp"), # (m.pass_udmp, m.rtrn_udmp, "pass_udmp:rtrn_udmp"),
(m.pass_udcp, m.rtrn_udcp, "pass_udcp:rtrn_udcp"), # (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):
@ -70,26 +70,26 @@ def test_load_with_rtrn_f(pass_f, rtrn_f, expected):
@pytest.mark.parametrize( @pytest.mark.parametrize(
("pass_f", "rtrn_f", "regex_expected"), ("pass_f", "rtrn_f", "regex_expected"),
[ [
( # BAKEIN_BREAK (
m.pass_udmp_del, # m.pass_udmp_del,
m.rtrn_udmp_del, # m.rtrn_udmp_del,
"pass_udmp_del:rtrn_udmp_del,udmp_deleter(_MvCtorTo)*_MvCtorTo", # "pass_udmp_del:rtrn_udmp_del,udmp_deleter(_MvCtorTo)*_MvCtorTo",
), # ),
( # BAKEIN_BREAK (
m.pass_udcp_del, # m.pass_udcp_del,
m.rtrn_udcp_del, # m.rtrn_udcp_del,
"pass_udcp_del:rtrn_udcp_del,udcp_deleter(_MvCtorTo)*_MvCtorTo", # "pass_udcp_del:rtrn_udcp_del,udcp_deleter(_MvCtorTo)*_MvCtorTo",
), # ),
( # BAKEIN_BREAK (
m.pass_udmp_del_nd, # m.pass_udmp_del_nd,
m.rtrn_udmp_del_nd, # m.rtrn_udmp_del_nd,
"pass_udmp_del_nd:rtrn_udmp_del_nd,udmp_deleter_nd(_MvCtorTo)*_MvCtorTo", # "pass_udmp_del_nd:rtrn_udmp_del_nd,udmp_deleter_nd(_MvCtorTo)*_MvCtorTo",
), # ),
( # BAKEIN_BREAK (
m.pass_udcp_del_nd, # m.pass_udcp_del_nd,
m.rtrn_udcp_del_nd, # m.rtrn_udcp_del_nd,
"pass_udcp_del_nd:rtrn_udcp_del_nd,udcp_deleter_nd(_MvCtorTo)*_MvCtorTo", # "pass_udcp_del_nd:rtrn_udcp_del_nd,udcp_deleter_nd(_MvCtorTo)*_MvCtorTo",
), # ),
], ],
) )
def test_deleter_roundtrip(pass_f, rtrn_f, regex_expected): def test_deleter_roundtrip(pass_f, rtrn_f, regex_expected):
@ -99,10 +99,10 @@ def test_deleter_roundtrip(pass_f, rtrn_f, regex_expected):
@pytest.mark.parametrize( @pytest.mark.parametrize(
("pass_f", "rtrn_f", "expected"), ("pass_f", "rtrn_f", "expected"),
[ [
(m.pass_uqmp, m.rtrn_uqmp, "pass_uqmp:rtrn_uqmp"), # BAKEIN_BREAK (m.pass_uqmp, m.rtrn_uqmp, "pass_uqmp:rtrn_uqmp"),
(m.pass_uqcp, m.rtrn_uqcp, "pass_uqcp:rtrn_uqcp"), # BAKEIN_BREAK (m.pass_uqcp, m.rtrn_uqcp, "pass_uqcp:rtrn_uqcp"),
(m.pass_udmp, m.rtrn_udmp, "pass_udmp:rtrn_udmp"), # BAKEIN_BREAK (m.pass_udmp, m.rtrn_udmp, "pass_udmp:rtrn_udmp"),
(m.pass_udcp, m.rtrn_udcp, "pass_udcp:rtrn_udcp"), # BAKEIN_BREAK (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):
@ -120,10 +120,10 @@ def test_pass_unique_ptr_disowns(pass_f, rtrn_f, expected):
@pytest.mark.parametrize( @pytest.mark.parametrize(
("pass_f", "rtrn_f"), ("pass_f", "rtrn_f"),
[ [
(m.pass_uqmp, m.rtrn_uqmp), # BAKEIN_BREAK (m.pass_uqmp, m.rtrn_uqmp),
(m.pass_uqcp, m.rtrn_uqcp), # BAKEIN_BREAK (m.pass_uqcp, m.rtrn_uqcp),
(m.pass_udmp, m.rtrn_udmp), # BAKEIN_BREAK (m.pass_udmp, m.rtrn_udmp),
(m.pass_udcp, m.rtrn_udcp), # BAKEIN_BREAK (m.pass_udcp, m.rtrn_udcp),
], ],
) )
def test_cannot_disown_use_count_ne_1(pass_f, rtrn_f): def test_cannot_disown_use_count_ne_1(pass_f, rtrn_f):
@ -142,6 +142,7 @@ def test_unique_ptr_roundtrip(num_round_trips=1000):
recycled = m.atyp("passenger") recycled = m.atyp("passenger")
for _ in range(num_round_trips): for _ in range(num_round_trips):
id_orig = id(recycled) id_orig = id(recycled)
pytest.skip("BAKEIN_BREAK: AttributeError unique_ptr_roundtrip")
recycled = m.unique_ptr_roundtrip(recycled) recycled = m.unique_ptr_roundtrip(recycled)
assert re.match("passenger(_MvCtor)*_MvCtor", m.get_mtxt(recycled)) assert re.match("passenger(_MvCtor)*_MvCtor", m.get_mtxt(recycled))
id_rtrn = id(recycled) id_rtrn = id(recycled)
@ -168,10 +169,10 @@ def test_unique_ptr_cref_roundtrip():
@pytest.mark.parametrize( @pytest.mark.parametrize(
("pass_f", "rtrn_f", "moved_out", "moved_in"), ("pass_f", "rtrn_f", "moved_out", "moved_in"),
[ [
(m.uconsumer.pass_valu, m.uconsumer.rtrn_valu, True, True), # BAKEIN_BREAK (m.uconsumer.pass_valu, m.uconsumer.rtrn_valu, True, True),
(m.uconsumer.pass_rref, m.uconsumer.rtrn_valu, True, True), # BAKEIN_BREAK (m.uconsumer.pass_rref, m.uconsumer.rtrn_valu, True, True),
(m.uconsumer.pass_valu, m.uconsumer.rtrn_lref, True, False), # BAKEIN_BREAK (m.uconsumer.pass_valu, m.uconsumer.rtrn_lref, True, False),
(m.uconsumer.pass_valu, m.uconsumer.rtrn_cref, True, False), # BAKEIN_BREAK (m.uconsumer.pass_valu, m.uconsumer.rtrn_cref, True, False),
], ],
) )
def test_unique_ptr_consumer_roundtrip(pass_f, rtrn_f, moved_out, moved_in): def test_unique_ptr_consumer_roundtrip(pass_f, rtrn_f, moved_out, moved_in):
@ -206,6 +207,7 @@ def test_function_signatures(doc):
doc(m.args_shared_ptr_const) doc(m.args_shared_ptr_const)
== "args_shared_ptr_const(arg0: m.class_sh_basic.atyp) -> m.class_sh_basic.atyp" == "args_shared_ptr_const(arg0: m.class_sh_basic.atyp) -> m.class_sh_basic.atyp"
) )
pytest.skip("BAKEIN_BREAK: AttributeError args_unique_ptr")
assert ( assert (
doc(m.args_unique_ptr) doc(m.args_unique_ptr)
== "args_unique_ptr(arg0: m.class_sh_basic.atyp) -> m.class_sh_basic.atyp" == "args_unique_ptr(arg0: m.class_sh_basic.atyp) -> m.class_sh_basic.atyp"