/*
    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");