545 lines
26 KiB
C++
545 lines
26 KiB
C++
/*
|
|
tests/test_copy_move_policies.cpp -- 'copy' and 'move' return value policies
|
|
and related tests
|
|
|
|
Copyright (c) 2016 Ben North <ben@redfrontdoor.org>
|
|
|
|
All rights reserved. Use of this source code is governed by a
|
|
BSD-style license that can be found in the LICENSE file.
|
|
*/
|
|
|
|
#include <pybind11/stl.h>
|
|
|
|
#include "constructor_stats.h"
|
|
#include "pybind11_tests.h"
|
|
|
|
#include <type_traits>
|
|
|
|
template <typename derived>
|
|
struct empty {
|
|
static const derived &get_one() { return instance_; }
|
|
static derived instance_;
|
|
};
|
|
|
|
struct lacking_copy_ctor : public empty<lacking_copy_ctor> {
|
|
lacking_copy_ctor() = default;
|
|
lacking_copy_ctor(const lacking_copy_ctor &other) = delete;
|
|
};
|
|
|
|
template <>
|
|
lacking_copy_ctor empty<lacking_copy_ctor>::instance_ = {};
|
|
|
|
struct lacking_move_ctor : public empty<lacking_move_ctor> {
|
|
lacking_move_ctor() = default;
|
|
lacking_move_ctor(const lacking_move_ctor &other) = delete;
|
|
lacking_move_ctor(lacking_move_ctor &&other) = delete;
|
|
};
|
|
|
|
template <>
|
|
lacking_move_ctor empty<lacking_move_ctor>::instance_ = {};
|
|
|
|
/* Custom type caster move/copy test classes */
|
|
class MoveOnlyInt {
|
|
public:
|
|
MoveOnlyInt() { print_default_created(this); }
|
|
explicit MoveOnlyInt(int v) : value{v} { print_created(this, value); }
|
|
MoveOnlyInt(MoveOnlyInt &&m) noexcept {
|
|
print_move_created(this, m.value);
|
|
std::swap(value, m.value);
|
|
}
|
|
MoveOnlyInt &operator=(MoveOnlyInt &&m) noexcept {
|
|
print_move_assigned(this, m.value);
|
|
std::swap(value, m.value);
|
|
return *this;
|
|
}
|
|
MoveOnlyInt(const MoveOnlyInt &) = delete;
|
|
MoveOnlyInt &operator=(const MoveOnlyInt &) = delete;
|
|
~MoveOnlyInt() { print_destroyed(this); }
|
|
|
|
int value;
|
|
};
|
|
class MoveOrCopyInt {
|
|
public:
|
|
MoveOrCopyInt() { print_default_created(this); }
|
|
explicit MoveOrCopyInt(int v) : value{v} { print_created(this, value); }
|
|
MoveOrCopyInt(MoveOrCopyInt &&m) noexcept {
|
|
print_move_created(this, m.value);
|
|
std::swap(value, m.value);
|
|
}
|
|
MoveOrCopyInt &operator=(MoveOrCopyInt &&m) noexcept {
|
|
print_move_assigned(this, m.value);
|
|
std::swap(value, m.value);
|
|
return *this;
|
|
}
|
|
MoveOrCopyInt(const MoveOrCopyInt &c) {
|
|
print_copy_created(this, c.value);
|
|
// NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
|
|
value = c.value;
|
|
}
|
|
MoveOrCopyInt &operator=(const MoveOrCopyInt &c) {
|
|
print_copy_assigned(this, c.value);
|
|
value = c.value;
|
|
return *this;
|
|
}
|
|
~MoveOrCopyInt() { print_destroyed(this); }
|
|
|
|
int value;
|
|
};
|
|
class CopyOnlyInt {
|
|
public:
|
|
CopyOnlyInt() { print_default_created(this); }
|
|
explicit CopyOnlyInt(int v) : value{v} { print_created(this, value); }
|
|
CopyOnlyInt(const CopyOnlyInt &c) {
|
|
print_copy_created(this, c.value);
|
|
// NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
|
|
value = c.value;
|
|
}
|
|
CopyOnlyInt &operator=(const CopyOnlyInt &c) {
|
|
print_copy_assigned(this, c.value);
|
|
value = c.value;
|
|
return *this;
|
|
}
|
|
~CopyOnlyInt() { print_destroyed(this); }
|
|
|
|
int value;
|
|
};
|
|
PYBIND11_NAMESPACE_BEGIN(pybind11)
|
|
PYBIND11_NAMESPACE_BEGIN(detail)
|
|
template <>
|
|
struct type_caster<MoveOnlyInt> {
|
|
PYBIND11_TYPE_CASTER(MoveOnlyInt, const_name("MoveOnlyInt"));
|
|
bool load(handle src, bool) {
|
|
value = MoveOnlyInt(src.cast<int>());
|
|
return true;
|
|
}
|
|
static handle cast(const MoveOnlyInt &m, return_value_policy r, handle p) {
|
|
return pybind11::cast(m.value, r, p);
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct type_caster<MoveOrCopyInt> {
|
|
PYBIND11_TYPE_CASTER(MoveOrCopyInt, const_name("MoveOrCopyInt"));
|
|
bool load(handle src, bool) {
|
|
value = MoveOrCopyInt(src.cast<int>());
|
|
return true;
|
|
}
|
|
static handle cast(const MoveOrCopyInt &m, return_value_policy r, handle p) {
|
|
return pybind11::cast(m.value, r, p);
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct type_caster<CopyOnlyInt> {
|
|
protected:
|
|
CopyOnlyInt value;
|
|
|
|
public:
|
|
static constexpr auto name = const_name("CopyOnlyInt");
|
|
bool load(handle src, bool) {
|
|
value = CopyOnlyInt(src.cast<int>());
|
|
return true;
|
|
}
|
|
static handle cast(const CopyOnlyInt &m, return_value_policy r, handle p) {
|
|
return pybind11::cast(m.value, r, p);
|
|
}
|
|
static handle cast(const CopyOnlyInt *src, return_value_policy policy, handle parent) {
|
|
if (!src) {
|
|
return none().release();
|
|
}
|
|
return cast(*src, policy, parent);
|
|
}
|
|
explicit operator CopyOnlyInt *() { return &value; }
|
|
explicit operator CopyOnlyInt &() { return value; }
|
|
template <typename T>
|
|
using cast_op_type = pybind11::detail::cast_op_type<T>;
|
|
};
|
|
PYBIND11_NAMESPACE_END(detail)
|
|
PYBIND11_NAMESPACE_END(pybind11)
|
|
|
|
namespace {
|
|
|
|
py::object CastUnusualOpRefConstRef(const UnusualOpRef &cref) { return py::cast(cref); }
|
|
py::object CastUnusualOpRefMovable(UnusualOpRef &&mvbl) { return py::cast(std::move(mvbl)); }
|
|
|
|
} // namespace
|
|
|
|
TEST_SUBMODULE(copy_move_policies, m) {
|
|
// test_lacking_copy_ctor
|
|
py::class_<lacking_copy_ctor>(m, "lacking_copy_ctor")
|
|
.def_static("get_one", &lacking_copy_ctor::get_one, py::return_value_policy::copy);
|
|
// test_lacking_move_ctor
|
|
py::class_<lacking_move_ctor>(m, "lacking_move_ctor")
|
|
.def_static("get_one", &lacking_move_ctor::get_one, py::return_value_policy::move);
|
|
|
|
// test_move_and_copy_casts
|
|
// NOLINTNEXTLINE(performance-unnecessary-value-param)
|
|
m.def("move_and_copy_casts", [](const py::object &o) {
|
|
int r = 0;
|
|
r += py::cast<MoveOrCopyInt>(o).value; /* moves */
|
|
r += py::cast<MoveOnlyInt>(o).value; /* moves */
|
|
r += py::cast<CopyOnlyInt>(o).value; /* copies */
|
|
auto m1(py::cast<MoveOrCopyInt>(o)); /* moves */
|
|
auto m2(py::cast<MoveOnlyInt>(o)); /* moves */
|
|
auto m3(py::cast<CopyOnlyInt>(o)); /* copies */
|
|
r += m1.value + m2.value + m3.value;
|
|
|
|
return r;
|
|
});
|
|
|
|
// test_move_and_copy_loads
|
|
m.def("move_only", [](MoveOnlyInt m) { return m.value; });
|
|
// Changing this breaks the existing test: needs careful review.
|
|
// NOLINTNEXTLINE(performance-unnecessary-value-param)
|
|
m.def("move_or_copy", [](MoveOrCopyInt m) { return m.value; });
|
|
// Changing this breaks the existing test: needs careful review.
|
|
// NOLINTNEXTLINE(performance-unnecessary-value-param)
|
|
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; });
|
|
m.def("move_tuple", [](std::tuple<MoveOnlyInt, MoveOrCopyInt, MoveOnlyInt> t) {
|
|
return std::get<0>(t).value + std::get<1>(t).value + std::get<2>(t).value;
|
|
});
|
|
m.def("copy_tuple", [](std::tuple<CopyOnlyInt, CopyOnlyInt> t) {
|
|
return std::get<0>(t).value + std::get<1>(t).value;
|
|
});
|
|
m.def("move_copy_nested",
|
|
[](std::pair<MoveOnlyInt,
|
|
std::pair<std::tuple<MoveOrCopyInt, CopyOnlyInt, std::tuple<MoveOnlyInt>>,
|
|
MoveOrCopyInt>> x) {
|
|
return x.first.value + std::get<0>(x.second.first).value
|
|
+ std::get<1>(x.second.first).value
|
|
+ std::get<0>(std::get<2>(x.second.first)).value + x.second.second.value;
|
|
});
|
|
m.def("move_and_copy_cstats", []() {
|
|
ConstructorStats::gc();
|
|
// Reset counts to 0 so that previous tests don't affect later ones:
|
|
auto &mc = ConstructorStats::get<MoveOrCopyInt>();
|
|
mc.move_assignments = mc.move_constructions = mc.copy_assignments = mc.copy_constructions
|
|
= 0;
|
|
auto &mo = ConstructorStats::get<MoveOnlyInt>();
|
|
mo.move_assignments = mo.move_constructions = mo.copy_assignments = mo.copy_constructions
|
|
= 0;
|
|
auto &co = ConstructorStats::get<CopyOnlyInt>();
|
|
co.move_assignments = co.move_constructions = co.copy_assignments = co.copy_constructions
|
|
= 0;
|
|
py::dict d;
|
|
d["MoveOrCopyInt"] = py::cast(mc, py::return_value_policy::reference);
|
|
d["MoveOnlyInt"] = py::cast(mo, py::return_value_policy::reference);
|
|
d["CopyOnlyInt"] = py::cast(co, py::return_value_policy::reference);
|
|
return d;
|
|
});
|
|
#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_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;
|
|
});
|
|
#else
|
|
m.attr("has_optional") = false;
|
|
#endif
|
|
|
|
// #70 compilation issue if operator new is not public - simple body added
|
|
// but not needed on most compilers; MSVC and nvcc don't like a local
|
|
// struct not having a method defined when declared, since it can not be
|
|
// added later.
|
|
struct PrivateOpNew {
|
|
int value = 1;
|
|
|
|
private:
|
|
void *operator new(size_t bytes) {
|
|
void *ptr = std::malloc(bytes);
|
|
if (ptr) {
|
|
return ptr;
|
|
}
|
|
throw std::bad_alloc{};
|
|
}
|
|
};
|
|
py::class_<PrivateOpNew>(m, "PrivateOpNew").def_readonly("value", &PrivateOpNew::value);
|
|
m.def("private_op_new_value", []() { return PrivateOpNew(); });
|
|
m.def(
|
|
"private_op_new_reference",
|
|
[]() -> const PrivateOpNew & {
|
|
static PrivateOpNew x{};
|
|
return x;
|
|
},
|
|
py::return_value_policy::reference);
|
|
|
|
// test_move_fallback
|
|
// #389: rvp::move should fall-through to copy on non-movable objects
|
|
struct MoveIssue1 {
|
|
int v;
|
|
explicit MoveIssue1(int v) : v{v} {}
|
|
MoveIssue1(const MoveIssue1 &c) = default;
|
|
MoveIssue1(MoveIssue1 &&) = delete;
|
|
};
|
|
py::class_<MoveIssue1>(m, "MoveIssue1")
|
|
.def(py::init<int>())
|
|
.def_readwrite("value", &MoveIssue1::v);
|
|
|
|
struct MoveIssue2 {
|
|
int v;
|
|
explicit MoveIssue2(int v) : v{v} {}
|
|
MoveIssue2(MoveIssue2 &&) = default;
|
|
};
|
|
py::class_<MoveIssue2>(m, "MoveIssue2")
|
|
.def(py::init<int>())
|
|
.def_readwrite("value", &MoveIssue2::v);
|
|
|
|
// #2742: Don't expect ownership of raw pointer to `new`ed object to be transferred with
|
|
// `py::return_value_policy::move`
|
|
m.def(
|
|
"get_moveissue1",
|
|
[](int i) { return std::unique_ptr<MoveIssue1>(new MoveIssue1(i)); },
|
|
py::return_value_policy::move);
|
|
m.def("get_moveissue2", [](int i) { return MoveIssue2(i); }, py::return_value_policy::move);
|
|
|
|
// Make sure that cast from pytype rvalue to other pytype works
|
|
m.def("get_pytype_rvalue_castissue", [](double i) { return py::float_(i).cast<py::int_>(); });
|
|
|
|
py::class_<UnusualOpRef>(m, "UnusualOpRef");
|
|
m.def("CallCastUnusualOpRefConstRef",
|
|
[]() { return CastUnusualOpRefConstRef(UnusualOpRef()); });
|
|
m.def("CallCastUnusualOpRefMovable", []() { return CastUnusualOpRefMovable(UnusualOpRef()); });
|
|
}
|
|
|
|
/*
|
|
* Rest of the file:
|
|
* static_assert based tests for pybind11 adaptations of
|
|
* std::is_move_constructible, std::is_copy_constructible and
|
|
* std::is_copy_assignable (no adaptation of std::is_move_assignable).
|
|
* Difference between pybind11 and std traits: pybind11 traits will also check
|
|
* the contained value_types.
|
|
*/
|
|
|
|
struct NotMovable {
|
|
NotMovable() = default;
|
|
NotMovable(NotMovable const &) = default;
|
|
NotMovable(NotMovable &&) = delete;
|
|
NotMovable &operator=(NotMovable const &) = default;
|
|
NotMovable &operator=(NotMovable &&) = delete;
|
|
};
|
|
static_assert(!std::is_move_constructible<NotMovable>::value,
|
|
"!std::is_move_constructible<NotMovable>::value");
|
|
static_assert(std::is_copy_constructible<NotMovable>::value,
|
|
"std::is_copy_constructible<NotMovable>::value");
|
|
static_assert(!pybind11::detail::is_move_constructible<NotMovable>::value,
|
|
"!pybind11::detail::is_move_constructible<NotMovable>::value");
|
|
static_assert(pybind11::detail::is_copy_constructible<NotMovable>::value,
|
|
"pybind11::detail::is_copy_constructible<NotMovable>::value");
|
|
static_assert(!std::is_move_assignable<NotMovable>::value,
|
|
"!std::is_move_assignable<NotMovable>::value");
|
|
static_assert(std::is_copy_assignable<NotMovable>::value,
|
|
"std::is_copy_assignable<NotMovable>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<NotMovable>::value,
|
|
// "!pybind11::detail::is_move_assignable<NotMovable>::value");
|
|
static_assert(pybind11::detail::is_copy_assignable<NotMovable>::value,
|
|
"pybind11::detail::is_copy_assignable<NotMovable>::value");
|
|
|
|
struct NotCopyable {
|
|
NotCopyable() = default;
|
|
NotCopyable(NotCopyable const &) = delete;
|
|
NotCopyable(NotCopyable &&) = default;
|
|
NotCopyable &operator=(NotCopyable const &) = delete;
|
|
NotCopyable &operator=(NotCopyable &&) = default;
|
|
};
|
|
static_assert(std::is_move_constructible<NotCopyable>::value,
|
|
"std::is_move_constructible<NotCopyable>::value");
|
|
static_assert(!std::is_copy_constructible<NotCopyable>::value,
|
|
"!std::is_copy_constructible<NotCopyable>::value");
|
|
static_assert(pybind11::detail::is_move_constructible<NotCopyable>::value,
|
|
"pybind11::detail::is_move_constructible<NotCopyable>::value");
|
|
static_assert(!pybind11::detail::is_copy_constructible<NotCopyable>::value,
|
|
"!pybind11::detail::is_copy_constructible<NotCopyable>::value");
|
|
static_assert(std::is_move_assignable<NotCopyable>::value,
|
|
"std::is_move_assignable<NotCopyable>::value");
|
|
static_assert(!std::is_copy_assignable<NotCopyable>::value,
|
|
"!std::is_copy_assignable<NotCopyable>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<NotCopyable>::value,
|
|
// "!pybind11::detail::is_move_assignable<NotCopyable>::value");
|
|
static_assert(!pybind11::detail::is_copy_assignable<NotCopyable>::value,
|
|
"!pybind11::detail::is_copy_assignable<NotCopyable>::value");
|
|
|
|
struct NotCopyableNotMovable {
|
|
NotCopyableNotMovable() = default;
|
|
NotCopyableNotMovable(NotCopyableNotMovable const &) = delete;
|
|
NotCopyableNotMovable(NotCopyableNotMovable &&) = delete;
|
|
NotCopyableNotMovable &operator=(NotCopyableNotMovable const &) = delete;
|
|
NotCopyableNotMovable &operator=(NotCopyableNotMovable &&) = delete;
|
|
};
|
|
static_assert(!std::is_move_constructible<NotCopyableNotMovable>::value,
|
|
"!std::is_move_constructible<NotCopyableNotMovable>::value");
|
|
static_assert(!std::is_copy_constructible<NotCopyableNotMovable>::value,
|
|
"!std::is_copy_constructible<NotCopyableNotMovable>::value");
|
|
static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovable>::value,
|
|
"!pybind11::detail::is_move_constructible<NotCopyableNotMovable>::value");
|
|
static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovable>::value,
|
|
"!pybind11::detail::is_copy_constructible<NotCopyableNotMovable>::value");
|
|
static_assert(!std::is_move_assignable<NotCopyableNotMovable>::value,
|
|
"!std::is_move_assignable<NotCopyableNotMovable>::value");
|
|
static_assert(!std::is_copy_assignable<NotCopyableNotMovable>::value,
|
|
"!std::is_copy_assignable<NotCopyableNotMovable>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovable>::value,
|
|
// "!pybind11::detail::is_move_assignable<NotCopyableNotMovable>::value");
|
|
static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovable>::value,
|
|
"!pybind11::detail::is_copy_assignable<NotCopyableNotMovable>::value");
|
|
|
|
struct NotMovableVector : std::vector<NotMovable> {};
|
|
static_assert(std::is_move_constructible<NotMovableVector>::value,
|
|
"std::is_move_constructible<NotMovableVector>::value");
|
|
static_assert(std::is_copy_constructible<NotMovableVector>::value,
|
|
"std::is_copy_constructible<NotMovableVector>::value");
|
|
static_assert(!pybind11::detail::is_move_constructible<NotMovableVector>::value,
|
|
"!pybind11::detail::is_move_constructible<NotMovableVector>::value");
|
|
static_assert(pybind11::detail::is_copy_constructible<NotMovableVector>::value,
|
|
"pybind11::detail::is_copy_constructible<NotMovableVector>::value");
|
|
static_assert(std::is_move_assignable<NotMovableVector>::value,
|
|
"std::is_move_assignable<NotMovableVector>::value");
|
|
static_assert(std::is_copy_assignable<NotMovableVector>::value,
|
|
"std::is_copy_assignable<NotMovableVector>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<NotMovableVector>::value,
|
|
// "!pybind11::detail::is_move_assignable<NotMovableVector>::value");
|
|
static_assert(pybind11::detail::is_copy_assignable<NotMovableVector>::value,
|
|
"pybind11::detail::is_copy_assignable<NotMovableVector>::value");
|
|
|
|
struct NotCopyableVector : std::vector<NotCopyable> {};
|
|
static_assert(std::is_move_constructible<NotCopyableVector>::value,
|
|
"std::is_move_constructible<NotCopyableVector>::value");
|
|
static_assert(std::is_copy_constructible<NotCopyableVector>::value,
|
|
"std::is_copy_constructible<NotCopyableVector>::value");
|
|
static_assert(pybind11::detail::is_move_constructible<NotCopyableVector>::value,
|
|
"pybind11::detail::is_move_constructible<NotCopyableVector>::value");
|
|
static_assert(!pybind11::detail::is_copy_constructible<NotCopyableVector>::value,
|
|
"!pybind11::detail::is_copy_constructible<NotCopyableVector>::value");
|
|
static_assert(std::is_move_assignable<NotCopyableVector>::value,
|
|
"std::is_move_assignable<NotCopyableVector>::value");
|
|
static_assert(std::is_copy_assignable<NotCopyableVector>::value,
|
|
"std::is_copy_assignable<NotCopyableVector>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<NotCopyableVector>::value,
|
|
// "!pybind11::detail::is_move_assignable<NotCopyableVector>::value");
|
|
static_assert(!pybind11::detail::is_copy_assignable<NotCopyableVector>::value,
|
|
"!pybind11::detail::is_copy_assignable<NotCopyableVector>::value");
|
|
|
|
struct NotCopyableNotMovableVector : std::vector<NotCopyableNotMovable> {};
|
|
static_assert(std::is_move_constructible<NotCopyableNotMovableVector>::value,
|
|
"std::is_move_constructible<NotCopyableNotMovableVector>::value");
|
|
static_assert(std::is_copy_constructible<NotCopyableNotMovableVector>::value,
|
|
"std::is_copy_constructible<NotCopyableNotMovableVector>::value");
|
|
static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovableVector>::value,
|
|
"!pybind11::detail::is_move_constructible<NotCopyableNotMovableVector>::value");
|
|
static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovableVector>::value,
|
|
"!pybind11::detail::is_copy_constructible<NotCopyableNotMovableVector>::value");
|
|
static_assert(std::is_move_assignable<NotCopyableNotMovableVector>::value,
|
|
"std::is_move_assignable<NotCopyableNotMovableVector>::value");
|
|
static_assert(std::is_copy_assignable<NotCopyableNotMovableVector>::value,
|
|
"std::is_copy_assignable<NotCopyableNotMovableVector>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovableVector>::value,
|
|
// "!pybind11::detail::is_move_assignable<NotCopyableNotMovableVector>::value");
|
|
static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovableVector>::value,
|
|
"!pybind11::detail::is_copy_assignable<NotCopyableNotMovableVector>::value");
|
|
|
|
struct NotMovableMap : std::map<int, NotMovable> {};
|
|
static_assert(std::is_move_constructible<NotMovableMap>::value,
|
|
"std::is_move_constructible<NotMovableMap>::value");
|
|
static_assert(std::is_copy_constructible<NotMovableMap>::value,
|
|
"std::is_copy_constructible<NotMovableMap>::value");
|
|
static_assert(!pybind11::detail::is_move_constructible<NotMovableMap>::value,
|
|
"!pybind11::detail::is_move_constructible<NotMovableMap>::value");
|
|
static_assert(pybind11::detail::is_copy_constructible<NotMovableMap>::value,
|
|
"pybind11::detail::is_copy_constructible<NotMovableMap>::value");
|
|
static_assert(std::is_move_assignable<NotMovableMap>::value,
|
|
"std::is_move_assignable<NotMovableMap>::value");
|
|
static_assert(std::is_copy_assignable<NotMovableMap>::value,
|
|
"std::is_copy_assignable<NotMovableMap>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<NotMovableMap>::value,
|
|
// "!pybind11::detail::is_move_assignable<NotMovableMap>::value");
|
|
static_assert(pybind11::detail::is_copy_assignable<NotMovableMap>::value,
|
|
"pybind11::detail::is_copy_assignable<NotMovableMap>::value");
|
|
|
|
struct NotCopyableMap : std::map<int, NotCopyable> {};
|
|
static_assert(std::is_move_constructible<NotCopyableMap>::value,
|
|
"std::is_move_constructible<NotCopyableMap>::value");
|
|
static_assert(std::is_copy_constructible<NotCopyableMap>::value,
|
|
"std::is_copy_constructible<NotCopyableMap>::value");
|
|
static_assert(pybind11::detail::is_move_constructible<NotCopyableMap>::value,
|
|
"pybind11::detail::is_move_constructible<NotCopyableMap>::value");
|
|
static_assert(!pybind11::detail::is_copy_constructible<NotCopyableMap>::value,
|
|
"!pybind11::detail::is_copy_constructible<NotCopyableMap>::value");
|
|
static_assert(std::is_move_assignable<NotCopyableMap>::value,
|
|
"std::is_move_assignable<NotCopyableMap>::value");
|
|
static_assert(std::is_copy_assignable<NotCopyableMap>::value,
|
|
"std::is_copy_assignable<NotCopyableMap>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<NotCopyableMap>::value,
|
|
// "!pybind11::detail::is_move_assignable<NotCopyableMap>::value");
|
|
static_assert(!pybind11::detail::is_copy_assignable<NotCopyableMap>::value,
|
|
"!pybind11::detail::is_copy_assignable<NotCopyableMap>::value");
|
|
|
|
struct NotCopyableNotMovableMap : std::map<int, NotCopyableNotMovable> {};
|
|
static_assert(std::is_move_constructible<NotCopyableNotMovableMap>::value,
|
|
"std::is_move_constructible<NotCopyableNotMovableMap>::value");
|
|
static_assert(std::is_copy_constructible<NotCopyableNotMovableMap>::value,
|
|
"std::is_copy_constructible<NotCopyableNotMovableMap>::value");
|
|
static_assert(!pybind11::detail::is_move_constructible<NotCopyableNotMovableMap>::value,
|
|
"!pybind11::detail::is_move_constructible<NotCopyableNotMovableMap>::value");
|
|
static_assert(!pybind11::detail::is_copy_constructible<NotCopyableNotMovableMap>::value,
|
|
"!pybind11::detail::is_copy_constructible<NotCopyableNotMovableMap>::value");
|
|
static_assert(std::is_move_assignable<NotCopyableNotMovableMap>::value,
|
|
"std::is_move_assignable<NotCopyableNotMovableMap>::value");
|
|
static_assert(std::is_copy_assignable<NotCopyableNotMovableMap>::value,
|
|
"std::is_copy_assignable<NotCopyableNotMovableMap>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<NotCopyableNotMovableMap>::value,
|
|
// "!pybind11::detail::is_move_assignable<NotCopyableNotMovableMap>::value");
|
|
static_assert(!pybind11::detail::is_copy_assignable<NotCopyableNotMovableMap>::value,
|
|
"!pybind11::detail::is_copy_assignable<NotCopyableNotMovableMap>::value");
|
|
|
|
struct RecursiveVector : std::vector<RecursiveVector> {};
|
|
static_assert(std::is_move_constructible<RecursiveVector>::value,
|
|
"std::is_move_constructible<RecursiveVector>::value");
|
|
static_assert(std::is_copy_constructible<RecursiveVector>::value,
|
|
"std::is_copy_constructible<RecursiveVector>::value");
|
|
static_assert(pybind11::detail::is_move_constructible<RecursiveVector>::value,
|
|
"pybind11::detail::is_move_constructible<RecursiveVector>::value");
|
|
static_assert(pybind11::detail::is_copy_constructible<RecursiveVector>::value,
|
|
"pybind11::detail::is_copy_constructible<RecursiveVector>::value");
|
|
static_assert(std::is_move_assignable<RecursiveVector>::value,
|
|
"std::is_move_assignable<RecursiveVector>::value");
|
|
static_assert(std::is_copy_assignable<RecursiveVector>::value,
|
|
"std::is_copy_assignable<RecursiveVector>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<RecursiveVector>::value,
|
|
// "!pybind11::detail::is_move_assignable<RecursiveVector>::value");
|
|
static_assert(pybind11::detail::is_copy_assignable<RecursiveVector>::value,
|
|
"pybind11::detail::is_copy_assignable<RecursiveVector>::value");
|
|
|
|
struct RecursiveMap : std::map<int, RecursiveMap> {};
|
|
static_assert(std::is_move_constructible<RecursiveMap>::value,
|
|
"std::is_move_constructible<RecursiveMap>::value");
|
|
static_assert(std::is_copy_constructible<RecursiveMap>::value,
|
|
"std::is_copy_constructible<RecursiveMap>::value");
|
|
static_assert(pybind11::detail::is_move_constructible<RecursiveMap>::value,
|
|
"pybind11::detail::is_move_constructible<RecursiveMap>::value");
|
|
static_assert(pybind11::detail::is_copy_constructible<RecursiveMap>::value,
|
|
"pybind11::detail::is_copy_constructible<RecursiveMap>::value");
|
|
static_assert(std::is_move_assignable<RecursiveMap>::value,
|
|
"std::is_move_assignable<RecursiveMap>::value");
|
|
static_assert(std::is_copy_assignable<RecursiveMap>::value,
|
|
"std::is_copy_assignable<RecursiveMap>::value");
|
|
// pybind11 does not have this
|
|
// static_assert(!pybind11::detail::is_move_assignable<RecursiveMap>::value,
|
|
// "!pybind11::detail::is_move_assignable<RecursiveMap>::value");
|
|
static_assert(pybind11::detail::is_copy_assignable<RecursiveMap>::value,
|
|
"pybind11::detail::is_copy_assignable<RecursiveMap>::value");
|