xcoll 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_cmake_build/subdirectory_embed/CMakeLists.txt

@@ -1,41 +0,0 @@
-cmake_minimum_required(VERSION 3.4)
-
-# The `cmake_minimum_required(VERSION 3.4...3.18)` syntax does not work with
-# some versions of VS that have a patched CMake 3.11. This forces us to emulate
-# the behavior using the following workaround:
-if(${CMAKE_VERSION} VERSION_LESS 3.18)
-  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-else()
-  cmake_policy(VERSION 3.18)
-endif()
-
-project(test_subdirectory_embed CXX)
-
-set(PYBIND11_INSTALL
-    ON
-    CACHE BOOL "")
-set(PYBIND11_EXPORT_NAME test_export)
-
-add_subdirectory("${pybind11_SOURCE_DIR}" pybind11)
-
-# Test basic target functionality
-add_executable(test_subdirectory_embed ../embed.cpp)
-target_link_libraries(test_subdirectory_embed PRIVATE pybind11::embed)
-set_target_properties(test_subdirectory_embed PROPERTIES OUTPUT_NAME test_cmake_build)
-
-add_custom_target(
-  check_subdirectory_embed
-  $<TARGET_FILE:test_subdirectory_embed> "${PROJECT_SOURCE_DIR}/../test.py"
-  DEPENDS test_subdirectory_embed)
-
-# Test custom export group -- PYBIND11_EXPORT_NAME
-add_library(test_embed_lib ../embed.cpp)
-target_link_libraries(test_embed_lib PRIVATE pybind11::embed)
-
-install(
-  TARGETS test_embed_lib
-  EXPORT test_export
-  ARCHIVE DESTINATION bin
-  LIBRARY DESTINATION lib
-  RUNTIME DESTINATION lib)
-install(EXPORT test_export DESTINATION lib/cmake/test_export/test_export-Targets.cmake)

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_cmake_build/subdirectory_function/CMakeLists.txt

@@ -1,35 +0,0 @@
-cmake_minimum_required(VERSION 3.4)
-
-# The `cmake_minimum_required(VERSION 3.4...3.18)` syntax does not work with
-# some versions of VS that have a patched CMake 3.11. This forces us to emulate
-# the behavior using the following workaround:
-if(${CMAKE_VERSION} VERSION_LESS 3.18)
-  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-else()
-  cmake_policy(VERSION 3.18)
-endif()
-
-project(test_subdirectory_function CXX)
-
-add_subdirectory("${pybind11_SOURCE_DIR}" pybind11)
-pybind11_add_module(test_subdirectory_function ../main.cpp)
-set_target_properties(test_subdirectory_function PROPERTIES OUTPUT_NAME test_cmake_build)
-
-if(DEFINED Python_EXECUTABLE)
-  set(_Python_EXECUTABLE "${Python_EXECUTABLE}")
-elseif(DEFINED PYTHON_EXECUTABLE)
-  set(_Python_EXECUTABLE "${PYTHON_EXECUTABLE}")
-else()
-  message(FATAL_ERROR "No Python executable defined (should not be possible at this stage)")
-endif()
-
-add_custom_target(
-  check_subdirectory_function
-  ${CMAKE_COMMAND}
-  -E
-  env
-  PYTHONPATH=$<TARGET_FILE_DIR:test_subdirectory_function>
-  ${_Python_EXECUTABLE}
-  ${PROJECT_SOURCE_DIR}/../test.py
-  ${PROJECT_NAME}
-  DEPENDS test_subdirectory_function)

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_cmake_build/subdirectory_target/CMakeLists.txt

@@ -1,41 +0,0 @@
-cmake_minimum_required(VERSION 3.4)
-
-# The `cmake_minimum_required(VERSION 3.4...3.18)` syntax does not work with
-# some versions of VS that have a patched CMake 3.11. This forces us to emulate
-# the behavior using the following workaround:
-if(${CMAKE_VERSION} VERSION_LESS 3.18)
-  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
-else()
-  cmake_policy(VERSION 3.18)
-endif()
-
-project(test_subdirectory_target CXX)
-
-add_subdirectory("${pybind11_SOURCE_DIR}" pybind11)
-
-add_library(test_subdirectory_target MODULE ../main.cpp)
-set_target_properties(test_subdirectory_target PROPERTIES OUTPUT_NAME test_cmake_build)
-
-target_link_libraries(test_subdirectory_target PRIVATE pybind11::module)
-
-# Make sure result is, for example, test_installed_target.so, not libtest_installed_target.dylib
-pybind11_extension(test_subdirectory_target)
-
-if(DEFINED Python_EXECUTABLE)
-  set(_Python_EXECUTABLE "${Python_EXECUTABLE}")
-elseif(DEFINED PYTHON_EXECUTABLE)
-  set(_Python_EXECUTABLE "${PYTHON_EXECUTABLE}")
-else()
-  message(FATAL_ERROR "No Python executable defined (should not be possible at this stage)")
-endif()
-
-add_custom_target(
-  check_subdirectory_target
-  ${CMAKE_COMMAND}
-  -E
-  env
-  PYTHONPATH=$<TARGET_FILE_DIR:test_subdirectory_target>
-  ${_Python_EXECUTABLE}
-  ${PROJECT_SOURCE_DIR}/../test.py
-  ${PROJECT_NAME}
-  DEPENDS test_subdirectory_target)

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_cmake_build/test.py

@@ -1,10 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-
-import test_cmake_build
-
-if str is not bytes:  # If not Python2
-    assert isinstance(__file__, str)  # Test this is properly set
-
-assert test_cmake_build.add(1, 2) == 3
-print("{} imports, runs, and adds: 1 + 2 = 3".format(sys.argv[1]))

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_constants_and_functions.cpp

@@ -1,165 +0,0 @@
-/*
-    tests/test_constants_and_functions.cpp -- global constants and functions, enumerations, raw
-    byte strings
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    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_tests.h"
-
-enum MyEnum { EFirstEntry = 1, ESecondEntry };
-
-std::string test_function1() {
-    return "test_function()";
-}
-
-std::string test_function2(MyEnum k) {
-    return "test_function(enum=" + std::to_string(k) + ")";
-}
-
-std::string test_function3(int i) {
-    return "test_function(" + std::to_string(i) + ")";
-}
-
-py::str test_function4()           { return "test_function()"; }
-py::str test_function4(char *)     { return "test_function(char *)"; }
-py::str test_function4(int, float) { return "test_function(int, float)"; }
-py::str test_function4(float, int) { return "test_function(float, int)"; }
-
-py::bytes return_bytes() {
-    const char *data = "\x01\x00\x02\x00";
-    return std::string(data, 4);
-}
-
-std::string print_bytes(const py::bytes &bytes) {
-    std::string ret = "bytes[";
-    const auto value = static_cast<std::string>(bytes);
-    for (size_t i = 0; i < value.length(); ++i) {
-        ret += std::to_string(static_cast<int>(value[i])) + " ";
-    }
-    ret.back() = ']';
-    return ret;
-}
-
-// Test that we properly handle C++17 exception specifiers (which are part of the function signature
-// in C++17).  These should all still work before C++17, but don't affect the function signature.
-namespace test_exc_sp {
-// [workaround(intel)] Unable to use noexcept instead of noexcept(true)
-// Make the f1 test basically the same as the f2 test in C++17 mode for the Intel compiler as
-// it fails to compile with a plain noexcept (tested with icc (ICC) 2021.1 Beta 20200827).
-#if defined(__INTEL_COMPILER) && defined(PYBIND11_CPP17)
-int f1(int x) noexcept(true) { return x+1; }
-#else
-int f1(int x) noexcept { return x+1; }
-#endif
-int f2(int x) noexcept(true) { return x+2; }
-int f3(int x) noexcept(false) { return x+3; }
-#if defined(__GNUG__) && !defined(__INTEL_COMPILER)
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wdeprecated"
-#endif
-// NOLINTNEXTLINE(modernize-use-noexcept)
-int f4(int x) throw() { return x+4; } // Deprecated equivalent to noexcept(true)
-#if defined(__GNUG__) && !defined(__INTEL_COMPILER)
-#  pragma GCC diagnostic pop
-#endif
-struct C {
-    int m1(int x) noexcept { return x-1; }
-    int m2(int x) const noexcept { return x-2; }
-    int m3(int x) noexcept(true) { return x-3; }
-    int m4(int x) const noexcept(true) { return x-4; }
-    int m5(int x) noexcept(false) { return x-5; }
-    int m6(int x) const noexcept(false) { return x-6; }
-#if defined(__GNUG__) && !defined(__INTEL_COMPILER)
-#  pragma GCC diagnostic push
-#  pragma GCC diagnostic ignored "-Wdeprecated"
-#endif
-    // NOLINTNEXTLINE(modernize-use-noexcept)
-    int m7(int x) throw() { return x - 7; }
-    // NOLINTNEXTLINE(modernize-use-noexcept)
-    int m8(int x) const throw() { return x - 8; }
-#if defined(__GNUG__) && !defined(__INTEL_COMPILER)
-#  pragma GCC diagnostic pop
-#endif
-};
-} // namespace test_exc_sp
-
-
-TEST_SUBMODULE(constants_and_functions, m) {
-    // test_constants
-    m.attr("some_constant") = py::int_(14);
-
-    // test_function_overloading
-    m.def("test_function", &test_function1);
-    m.def("test_function", &test_function2);
-    m.def("test_function", &test_function3);
-
-#if defined(PYBIND11_OVERLOAD_CAST)
-    m.def("test_function", py::overload_cast<>(&test_function4));
-    m.def("test_function", py::overload_cast<char *>(&test_function4));
-    m.def("test_function", py::overload_cast<int, float>(&test_function4));
-    m.def("test_function", py::overload_cast<float, int>(&test_function4));
-#else
-    m.def("test_function", static_cast<py::str (*)()>(&test_function4));
-    m.def("test_function", static_cast<py::str (*)(char *)>(&test_function4));
-    m.def("test_function", static_cast<py::str (*)(int, float)>(&test_function4));
-    m.def("test_function", static_cast<py::str (*)(float, int)>(&test_function4));
-#endif
-
-    py::enum_<MyEnum>(m, "MyEnum")
-        .value("EFirstEntry", EFirstEntry)
-        .value("ESecondEntry", ESecondEntry)
-        .export_values();
-
-    // test_bytes
-    m.def("return_bytes", &return_bytes);
-    m.def("print_bytes", &print_bytes);
-
-    // test_exception_specifiers
-    using namespace test_exc_sp;
-    py::class_<C>(m, "C")
-        .def(py::init<>())
-        .def("m1", &C::m1)
-        .def("m2", &C::m2)
-        .def("m3", &C::m3)
-        .def("m4", &C::m4)
-        .def("m5", &C::m5)
-        .def("m6", &C::m6)
-        .def("m7", &C::m7)
-        .def("m8", &C::m8)
-        ;
-    m.def("f1", f1);
-    m.def("f2", f2);
-#if defined(__INTEL_COMPILER)
-#    pragma warning push
-#    pragma warning disable 878 // incompatible exception specifications
-#endif
-    m.def("f3", f3);
-#if defined(__INTEL_COMPILER)
-#    pragma warning pop
-#endif
-    m.def("f4", f4);
-
-    // test_function_record_leaks
-    struct LargeCapture {
-        // This should always be enough to trigger the alternative branch
-        // where `sizeof(capture) > sizeof(rec->data)`
-        uint64_t zeros[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
-    };
-    m.def("register_large_capture_with_invalid_arguments", [](py::module_ m) {
-        LargeCapture capture;  // VS 2015's MSVC is acting up if we create the array here
-        m.def("should_raise", [capture](int) { return capture.zeros[9] + 33; }, py::kw_only(), py::arg());
-    });
-    m.def("register_with_raising_repr", [](py::module_ m, const py::object &default_value) {
-        m.def(
-            "should_raise",
-            [](int, int, const py::object &) { return 42; },
-            "some docstring",
-            py::arg_v("x", 42),
-            py::arg_v("y", 42, "<the answer>"),
-            py::arg_v("z", default_value));
-    });
-}

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_constants_and_functions.py

@@ -1,53 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-m = pytest.importorskip("pybind11_tests.constants_and_functions")
-
-
-def test_constants():
-    assert m.some_constant == 14
-
-
-def test_function_overloading():
-    assert m.test_function() == "test_function()"
-    assert m.test_function(7) == "test_function(7)"
-    assert m.test_function(m.MyEnum.EFirstEntry) == "test_function(enum=1)"
-    assert m.test_function(m.MyEnum.ESecondEntry) == "test_function(enum=2)"
-
-    assert m.test_function() == "test_function()"
-    assert m.test_function("abcd") == "test_function(char *)"
-    assert m.test_function(1, 1.0) == "test_function(int, float)"
-    assert m.test_function(1, 1.0) == "test_function(int, float)"
-    assert m.test_function(2.0, 2) == "test_function(float, int)"
-
-
-def test_bytes():
-    assert m.print_bytes(m.return_bytes()) == "bytes[1 0 2 0]"
-
-
-def test_exception_specifiers():
-    c = m.C()
-    assert c.m1(2) == 1
-    assert c.m2(3) == 1
-    assert c.m3(5) == 2
-    assert c.m4(7) == 3
-    assert c.m5(10) == 5
-    assert c.m6(14) == 8
-    assert c.m7(20) == 13
-    assert c.m8(29) == 21
-
-    assert m.f1(33) == 34
-    assert m.f2(53) == 55
-    assert m.f3(86) == 89
-    assert m.f4(140) == 144
-
-
-def test_function_record_leaks():
-    class RaisingRepr:
-        def __repr__(self):
-            raise RuntimeError("Surprise!")
-
-    with pytest.raises(RuntimeError):
-        m.register_large_capture_with_invalid_arguments(m)
-    with pytest.raises(RuntimeError):
-        m.register_with_raising_repr(m, RaisingRepr())

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_copy_move.cpp

@@ -1,238 +0,0 @@
-/*
-    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_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/stl.h>
-
-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); 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); 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, _("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, _("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 = _("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)
-
-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);
-}