xcoll 0.5.11__py3-none-any.whl → 0.6.0__py3-none-any.whl

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

@@ -1,473 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import ConstructorStats, UserType
-from pybind11_tests import class_ as m
-
-
-def test_repr():
-    # In Python 3.3+, repr() accesses __qualname__
-    assert "pybind11_type" in repr(type(UserType))
-    assert "UserType" in repr(UserType)
-
-
-def test_instance(msg):
-    with pytest.raises(TypeError) as excinfo:
-        m.NoConstructor()
-    assert msg(excinfo.value) == "m.class_.NoConstructor: No constructor defined!"
-
-    instance = m.NoConstructor.new_instance()
-
-    cstats = ConstructorStats.get(m.NoConstructor)
-    assert cstats.alive() == 1
-    del instance
-    assert cstats.alive() == 0
-
-
-def test_instance_new(msg):
-    instance = m.NoConstructorNew()  # .__new__(m.NoConstructor.__class__)
-    cstats = ConstructorStats.get(m.NoConstructorNew)
-    assert cstats.alive() == 1
-    del instance
-    assert cstats.alive() == 0
-
-
-def test_type():
-    assert m.check_type(1) == m.DerivedClass1
-    with pytest.raises(RuntimeError) as execinfo:
-        m.check_type(0)
-
-    assert "pybind11::detail::get_type_info: unable to find type info" in str(
-        execinfo.value
-    )
-    assert "Invalid" in str(execinfo.value)
-
-    # Currently not supported
-    # See https://github.com/pybind/pybind11/issues/2486
-    # assert m.check_type(2) == int
-
-
-def test_type_of_py():
-    assert m.get_type_of(1) == int
-    assert m.get_type_of(m.DerivedClass1()) == m.DerivedClass1
-    assert m.get_type_of(int) == type
-
-
-def test_type_of_classic():
-    assert m.get_type_classic(1) == int
-    assert m.get_type_classic(m.DerivedClass1()) == m.DerivedClass1
-    assert m.get_type_classic(int) == type
-
-
-def test_type_of_py_nodelete():
-    # If the above test deleted the class, this will segfault
-    assert m.get_type_of(m.DerivedClass1()) == m.DerivedClass1
-
-
-def test_as_type_py():
-    assert m.as_type(int) == int
-
-    with pytest.raises(TypeError):
-        assert m.as_type(1) == int
-
-    with pytest.raises(TypeError):
-        assert m.as_type(m.DerivedClass1()) == m.DerivedClass1
-
-
-def test_docstrings(doc):
-    assert doc(UserType) == "A `py::class_` type for testing"
-    assert UserType.__name__ == "UserType"
-    assert UserType.__module__ == "pybind11_tests"
-    assert UserType.get_value.__name__ == "get_value"
-    assert UserType.get_value.__module__ == "pybind11_tests"
-
-    assert (
-        doc(UserType.get_value)
-        == """
-        get_value(self: m.UserType) -> int
-
-        Get value using a method
-    """
-    )
-    assert doc(UserType.value) == "Get/set value using a property"
-
-    assert (
-        doc(m.NoConstructor.new_instance)
-        == """
-        new_instance() -> m.class_.NoConstructor
-
-        Return an instance
-    """
-    )
-
-
-def test_qualname(doc):
-    """Tests that a properly qualified name is set in __qualname__ (even in pre-3.3, where we
-    backport the attribute) and that generated docstrings properly use it and the module name"""
-    assert m.NestBase.__qualname__ == "NestBase"
-    assert m.NestBase.Nested.__qualname__ == "NestBase.Nested"
-
-    assert (
-        doc(m.NestBase.__init__)
-        == """
-        __init__(self: m.class_.NestBase) -> None
-    """
-    )
-    assert (
-        doc(m.NestBase.g)
-        == """
-        g(self: m.class_.NestBase, arg0: m.class_.NestBase.Nested) -> None
-    """
-    )
-    assert (
-        doc(m.NestBase.Nested.__init__)
-        == """
-        __init__(self: m.class_.NestBase.Nested) -> None
-    """
-    )
-    assert (
-        doc(m.NestBase.Nested.fn)
-        == """
-        fn(self: m.class_.NestBase.Nested, arg0: int, arg1: m.class_.NestBase, arg2: m.class_.NestBase.Nested) -> None
-    """  # noqa: E501 line too long
-    )
-    assert (
-        doc(m.NestBase.Nested.fa)
-        == """
-        fa(self: m.class_.NestBase.Nested, a: int, b: m.class_.NestBase, c: m.class_.NestBase.Nested) -> None
-    """  # noqa: E501 line too long
-    )
-    assert m.NestBase.__module__ == "pybind11_tests.class_"
-    assert m.NestBase.Nested.__module__ == "pybind11_tests.class_"
-
-
-def test_inheritance(msg):
-    roger = m.Rabbit("Rabbit")
-    assert roger.name() + " is a " + roger.species() == "Rabbit is a parrot"
-    assert m.pet_name_species(roger) == "Rabbit is a parrot"
-
-    polly = m.Pet("Polly", "parrot")
-    assert polly.name() + " is a " + polly.species() == "Polly is a parrot"
-    assert m.pet_name_species(polly) == "Polly is a parrot"
-
-    molly = m.Dog("Molly")
-    assert molly.name() + " is a " + molly.species() == "Molly is a dog"
-    assert m.pet_name_species(molly) == "Molly is a dog"
-
-    fred = m.Hamster("Fred")
-    assert fred.name() + " is a " + fred.species() == "Fred is a rodent"
-
-    assert m.dog_bark(molly) == "Woof!"
-
-    with pytest.raises(TypeError) as excinfo:
-        m.dog_bark(polly)
-    assert (
-        msg(excinfo.value)
-        == """
-        dog_bark(): incompatible function arguments. The following argument types are supported:
-            1. (arg0: m.class_.Dog) -> str
-
-        Invoked with: <m.class_.Pet object at 0>
-    """
-    )
-
-    with pytest.raises(TypeError) as excinfo:
-        m.Chimera("lion", "goat")
-    assert "No constructor defined!" in str(excinfo.value)
-
-
-def test_inheritance_init(msg):
-
-    # Single base
-    class Python(m.Pet):
-        def __init__(self):
-            pass
-
-    with pytest.raises(TypeError) as exc_info:
-        Python()
-    expected = "m.class_.Pet.__init__() must be called when overriding __init__"
-    assert msg(exc_info.value) == expected
-
-    # Multiple bases
-    class RabbitHamster(m.Rabbit, m.Hamster):
-        def __init__(self):
-            m.Rabbit.__init__(self, "RabbitHamster")
-
-    with pytest.raises(TypeError) as exc_info:
-        RabbitHamster()
-    expected = "m.class_.Hamster.__init__() must be called when overriding __init__"
-    assert msg(exc_info.value) == expected
-
-
-def test_automatic_upcasting():
-    assert type(m.return_class_1()).__name__ == "DerivedClass1"
-    assert type(m.return_class_2()).__name__ == "DerivedClass2"
-    assert type(m.return_none()).__name__ == "NoneType"
-    # Repeat these a few times in a random order to ensure no invalid caching is applied
-    assert type(m.return_class_n(1)).__name__ == "DerivedClass1"
-    assert type(m.return_class_n(2)).__name__ == "DerivedClass2"
-    assert type(m.return_class_n(0)).__name__ == "BaseClass"
-    assert type(m.return_class_n(2)).__name__ == "DerivedClass2"
-    assert type(m.return_class_n(2)).__name__ == "DerivedClass2"
-    assert type(m.return_class_n(0)).__name__ == "BaseClass"
-    assert type(m.return_class_n(1)).__name__ == "DerivedClass1"
-
-
-def test_isinstance():
-    objects = [tuple(), dict(), m.Pet("Polly", "parrot")] + [m.Dog("Molly")] * 4
-    expected = (True, True, True, True, True, False, False)
-    assert m.check_instances(objects) == expected
-
-
-def test_mismatched_holder():
-    import re
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.mismatched_holder_1()
-    assert re.match(
-        'generic_type: type ".*MismatchDerived1" does not have a non-default '
-        'holder type while its base ".*MismatchBase1" does',
-        str(excinfo.value),
-    )
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.mismatched_holder_2()
-    assert re.match(
-        'generic_type: type ".*MismatchDerived2" has a non-default holder type '
-        'while its base ".*MismatchBase2" does not',
-        str(excinfo.value),
-    )
-
-
-def test_override_static():
-    """#511: problem with inheritance + overwritten def_static"""
-    b = m.MyBase.make()
-    d1 = m.MyDerived.make2()
-    d2 = m.MyDerived.make()
-
-    assert isinstance(b, m.MyBase)
-    assert isinstance(d1, m.MyDerived)
-    assert isinstance(d2, m.MyDerived)
-
-
-def test_implicit_conversion_life_support():
-    """Ensure the lifetime of temporary objects created for implicit conversions"""
-    assert m.implicitly_convert_argument(UserType(5)) == 5
-    assert m.implicitly_convert_variable(UserType(5)) == 5
-
-    assert "outside a bound function" in m.implicitly_convert_variable_fail(UserType(5))
-
-
-def test_operator_new_delete(capture):
-    """Tests that class-specific operator new/delete functions are invoked"""
-
-    class SubAliased(m.AliasedHasOpNewDelSize):
-        pass
-
-    with capture:
-        a = m.HasOpNewDel()
-        b = m.HasOpNewDelSize()
-        d = m.HasOpNewDelBoth()
-    assert (
-        capture
-        == """
-        A new 8
-        B new 4
-        D new 32
-    """
-    )
-    sz_alias = str(m.AliasedHasOpNewDelSize.size_alias)
-    sz_noalias = str(m.AliasedHasOpNewDelSize.size_noalias)
-    with capture:
-        c = m.AliasedHasOpNewDelSize()
-        c2 = SubAliased()
-    assert capture == ("C new " + sz_noalias + "\n" + "C new " + sz_alias + "\n")
-
-    with capture:
-        del a
-        pytest.gc_collect()
-        del b
-        pytest.gc_collect()
-        del d
-        pytest.gc_collect()
-    assert (
-        capture
-        == """
-        A delete
-        B delete 4
-        D delete
-    """
-    )
-
-    with capture:
-        del c
-        pytest.gc_collect()
-        del c2
-        pytest.gc_collect()
-    assert capture == ("C delete " + sz_noalias + "\n" + "C delete " + sz_alias + "\n")
-
-
-def test_bind_protected_functions():
-    """Expose protected member functions to Python using a helper class"""
-    a = m.ProtectedA()
-    assert a.foo() == 42
-
-    b = m.ProtectedB()
-    assert b.foo() == 42
-
-    class C(m.ProtectedB):
-        def __init__(self):
-            m.ProtectedB.__init__(self)
-
-        def foo(self):
-            return 0
-
-    c = C()
-    assert c.foo() == 0
-
-
-def test_brace_initialization():
-    """Tests that simple POD classes can be constructed using C++11 brace initialization"""
-    a = m.BraceInitialization(123, "test")
-    assert a.field1 == 123
-    assert a.field2 == "test"
-
-    # Tests that a non-simple class doesn't get brace initialization (if the
-    # class defines an initializer_list constructor, in particular, it would
-    # win over the expected constructor).
-    b = m.NoBraceInitialization([123, 456])
-    assert b.vec == [123, 456]
-
-
-@pytest.mark.xfail("env.PYPY")
-def test_class_refcount():
-    """Instances must correctly increase/decrease the reference count of their types (#1029)"""
-    from sys import getrefcount
-
-    class PyDog(m.Dog):
-        pass
-
-    for cls in m.Dog, PyDog:
-        refcount_1 = getrefcount(cls)
-        molly = [cls("Molly") for _ in range(10)]
-        refcount_2 = getrefcount(cls)
-
-        del molly
-        pytest.gc_collect()
-        refcount_3 = getrefcount(cls)
-
-        assert refcount_1 == refcount_3
-        assert refcount_2 > refcount_1
-
-
-def test_reentrant_implicit_conversion_failure(msg):
-    # ensure that there is no runaway reentrant implicit conversion (#1035)
-    with pytest.raises(TypeError) as excinfo:
-        m.BogusImplicitConversion(0)
-    assert (
-        msg(excinfo.value)
-        == """
-        __init__(): incompatible constructor arguments. The following argument types are supported:
-            1. m.class_.BogusImplicitConversion(arg0: m.class_.BogusImplicitConversion)
-
-        Invoked with: 0
-    """
-    )
-
-
-def test_error_after_conversions():
-    with pytest.raises(TypeError) as exc_info:
-        m.test_error_after_conversions("hello")
-    assert str(exc_info.value).startswith(
-        "Unable to convert function return value to a Python type!"
-    )
-
-
-def test_aligned():
-    if hasattr(m, "Aligned"):
-        p = m.Aligned().ptr()
-        assert p % 1024 == 0
-
-
-# https://foss.heptapod.net/pypy/pypy/-/issues/2742
-@pytest.mark.xfail("env.PYPY")
-def test_final():
-    with pytest.raises(TypeError) as exc_info:
-
-        class PyFinalChild(m.IsFinal):
-            pass
-
-    assert str(exc_info.value).endswith("is not an acceptable base type")
-
-
-# https://foss.heptapod.net/pypy/pypy/-/issues/2742
-@pytest.mark.xfail("env.PYPY")
-def test_non_final_final():
-    with pytest.raises(TypeError) as exc_info:
-
-        class PyNonFinalFinalChild(m.IsNonFinalFinal):
-            pass
-
-    assert str(exc_info.value).endswith("is not an acceptable base type")
-
-
-# https://github.com/pybind/pybind11/issues/1878
-def test_exception_rvalue_abort():
-    with pytest.raises(RuntimeError):
-        m.PyPrintDestructor().throw_something()
-
-
-# https://github.com/pybind/pybind11/issues/1568
-def test_multiple_instances_with_same_pointer(capture):
-    n = 100
-    instances = [m.SamePointer() for _ in range(n)]
-    for i in range(n):
-        # We need to reuse the same allocated memory for with a different type,
-        # to ensure the bug in `deregister_instance_impl` is detected. Otherwise
-        # `Py_TYPE(self) == Py_TYPE(it->second)` will still succeed, even though
-        # the `instance` is already deleted.
-        instances[i] = m.Empty()
-    # No assert: if this does not trigger the error
-    #   pybind11_fail("pybind11_object_dealloc(): Tried to deallocate unregistered instance!");
-    # and just completes without crashing, we're good.
-
-
-# https://github.com/pybind/pybind11/issues/1624
-def test_base_and_derived_nested_scope():
-    assert issubclass(m.DerivedWithNested, m.BaseWithNested)
-    assert m.BaseWithNested.Nested != m.DerivedWithNested.Nested
-    assert m.BaseWithNested.Nested.get_name() == "BaseWithNested::Nested"
-    assert m.DerivedWithNested.Nested.get_name() == "DerivedWithNested::Nested"
-
-
-def test_register_duplicate_class():
-    import types
-
-    module_scope = types.ModuleType("module_scope")
-    with pytest.raises(RuntimeError) as exc_info:
-        m.register_duplicate_class_name(module_scope)
-    expected = (
-        'generic_type: cannot initialize type "Duplicate": '
-        "an object with that name is already defined"
-    )
-    assert str(exc_info.value) == expected
-    with pytest.raises(RuntimeError) as exc_info:
-        m.register_duplicate_class_type(module_scope)
-    expected = 'generic_type: type "YetAnotherDuplicate" is already registered!'
-    assert str(exc_info.value) == expected
-
-    class ClassScope:
-        pass
-
-    with pytest.raises(RuntimeError) as exc_info:
-        m.register_duplicate_nested_class_name(ClassScope)
-    expected = (
-        'generic_type: cannot initialize type "DuplicateNested": '
-        "an object with that name is already defined"
-    )
-    assert str(exc_info.value) == expected
-    with pytest.raises(RuntimeError) as exc_info:
-        m.register_duplicate_nested_class_type(ClassScope)
-    expected = 'generic_type: type "YetAnotherDuplicateNested" is already registered!'
-    assert str(exc_info.value) == expected

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

@@ -1,84 +0,0 @@
-# Built-in in CMake 3.5+
-include(CMakeParseArguments)
-
-add_custom_target(test_cmake_build)
-
-function(pybind11_add_build_test name)
-  cmake_parse_arguments(ARG "INSTALL" "" "" ${ARGN})
-
-  set(build_options "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}")
-
-  if(PYBIND11_FINDPYTHON)
-    list(APPEND build_options "-DPYBIND11_FINDPYTHON=${PYBIND11_FINDPYTHON}")
-
-    if(DEFINED Python_ROOT_DIR)
-      list(APPEND build_options "-DPython_ROOT_DIR=${Python_ROOT_DIR}")
-    endif()
-
-    list(APPEND build_options "-DPython_EXECUTABLE=${Python_EXECUTABLE}")
-  else()
-    list(APPEND build_options "-DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}")
-  endif()
-
-  if(DEFINED CMAKE_CXX_STANDARD)
-    list(APPEND build_options "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}")
-  endif()
-
-  if(NOT ARG_INSTALL)
-    list(APPEND build_options "-Dpybind11_SOURCE_DIR=${pybind11_SOURCE_DIR}")
-  else()
-    list(APPEND build_options "-DCMAKE_PREFIX_PATH=${pybind11_BINARY_DIR}/mock_install")
-  endif()
-
-  add_custom_target(
-    test_build_${name}
-    ${CMAKE_CTEST_COMMAND}
-    --build-and-test
-    "${CMAKE_CURRENT_SOURCE_DIR}/${name}"
-    "${CMAKE_CURRENT_BINARY_DIR}/${name}"
-    --build-config
-    Release
-    --build-noclean
-    --build-generator
-    ${CMAKE_GENERATOR}
-    $<$<BOOL:${CMAKE_GENERATOR_PLATFORM}>:--build-generator-platform>
-    ${CMAKE_GENERATOR_PLATFORM}
-    --build-makeprogram
-    ${CMAKE_MAKE_PROGRAM}
-    --build-target
-    check_${name}
-    --build-options
-    ${build_options})
-  if(ARG_INSTALL)
-    add_dependencies(test_build_${name} mock_install)
-  endif()
-  add_dependencies(test_cmake_build test_build_${name})
-endfunction()
-
-possibly_uninitialized(PYTHON_MODULE_EXTENSION Python_INTERPRETER_ID)
-
-pybind11_add_build_test(subdirectory_function)
-pybind11_add_build_test(subdirectory_target)
-if("${PYTHON_MODULE_EXTENSION}" MATCHES "pypy" OR "${Python_INTERPRETER_ID}" STREQUAL "PyPy")
-  message(STATUS "Skipping embed test on PyPy")
-else()
-  pybind11_add_build_test(subdirectory_embed)
-endif()
-
-if(PYBIND11_INSTALL)
-  add_custom_target(
-    mock_install ${CMAKE_COMMAND} "-DCMAKE_INSTALL_PREFIX=${pybind11_BINARY_DIR}/mock_install" -P
-                 "${pybind11_BINARY_DIR}/cmake_install.cmake")
-
-  pybind11_add_build_test(installed_function INSTALL)
-  pybind11_add_build_test(installed_target INSTALL)
-  if(NOT ("${PYTHON_MODULE_EXTENSION}" MATCHES "pypy" OR "${Python_INTERPRETER_ID}" STREQUAL "PyPy"
-         ))
-    pybind11_add_build_test(installed_embed INSTALL)
-  endif()
-endif()
-
-add_dependencies(check test_cmake_build)
-
-add_subdirectory(subdirectory_target EXCLUDE_FROM_ALL)
-add_subdirectory(subdirectory_embed EXCLUDE_FROM_ALL)

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_cmake_build/embed.cpp

@@ -1,21 +0,0 @@
-#include <pybind11/embed.h>
-namespace py = pybind11;
-
-PYBIND11_EMBEDDED_MODULE(test_cmake_build, m) {
-    m.def("add", [](int i, int j) { return i + j; });
-}
-
-int main(int argc, char *argv[]) {
-    if (argc != 2)
-        throw std::runtime_error("Expected test.py file as the first argument");
-    auto test_py_file = argv[1];
-
-    py::scoped_interpreter guard{};
-
-    auto m = py::module_::import("test_cmake_build");
-    if (m.attr("add")(1, 2).cast<int>() != 3)
-        throw std::runtime_error("embed.cpp failed");
-
-    py::module_::import("sys").attr("argv") = py::make_tuple("test.py", "embed.cpp");
-    py::eval_file(test_py_file, py::globals());
-}

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

@@ -1,28 +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_installed_embed CXX)
-
-find_package(pybind11 CONFIG REQUIRED)
-message(STATUS "Found pybind11 v${pybind11_VERSION}: ${pybind11_INCLUDE_DIRS}")
-
-add_executable(test_installed_embed ../embed.cpp)
-target_link_libraries(test_installed_embed PRIVATE pybind11::embed)
-set_target_properties(test_installed_embed PROPERTIES OUTPUT_NAME test_cmake_build)
-
-# Do not treat includes from IMPORTED target as SYSTEM (Python headers in pybind11::embed).
-# This may be needed to resolve header conflicts, e.g. between Python release and debug headers.
-set_target_properties(test_installed_embed PROPERTIES NO_SYSTEM_FROM_IMPORTED ON)
-
-add_custom_target(
-  check_installed_embed
-  $<TARGET_FILE:test_installed_embed> ${PROJECT_SOURCE_DIR}/../test.py
-  DEPENDS test_installed_embed)

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

@@ -1,39 +0,0 @@
-cmake_minimum_required(VERSION 3.4)
-project(test_installed_module CXX)
-
-# 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_installed_function CXX)
-
-find_package(pybind11 CONFIG REQUIRED)
-message(
-  STATUS "Found pybind11 v${pybind11_VERSION} ${pybind11_VERSION_TYPE}: ${pybind11_INCLUDE_DIRS}")
-
-pybind11_add_module(test_installed_function SHARED NO_EXTRAS ../main.cpp)
-set_target_properties(test_installed_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_installed_function
-  ${CMAKE_COMMAND}
-  -E
-  env
-  PYTHONPATH=$<TARGET_FILE_DIR:test_installed_function>
-  ${_Python_EXECUTABLE}
-  ${PROJECT_SOURCE_DIR}/../test.py
-  ${PROJECT_NAME}
-  DEPENDS test_installed_function)

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

@@ -1,46 +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_installed_target CXX)
-
-find_package(pybind11 CONFIG REQUIRED)
-message(STATUS "Found pybind11 v${pybind11_VERSION}: ${pybind11_INCLUDE_DIRS}")
-
-add_library(test_installed_target MODULE ../main.cpp)
-
-target_link_libraries(test_installed_target PRIVATE pybind11::module)
-set_target_properties(test_installed_target PROPERTIES OUTPUT_NAME test_cmake_build)
-
-# Make sure result is, for example, test_installed_target.so, not libtest_installed_target.dylib
-pybind11_extension(test_installed_target)
-
-# Do not treat includes from IMPORTED target as SYSTEM (Python headers in pybind11::module).
-# This may be needed to resolve header conflicts, e.g. between Python release and debug headers.
-set_target_properties(test_installed_target PROPERTIES NO_SYSTEM_FROM_IMPORTED ON)
-
-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_installed_target
-  ${CMAKE_COMMAND}
-  -E
-  env
-  PYTHONPATH=$<TARGET_FILE_DIR:test_installed_target>
-  ${_Python_EXECUTABLE}
-  ${PROJECT_SOURCE_DIR}/../test.py
-  ${PROJECT_NAME}
-  DEPENDS test_installed_target)

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_cmake_build/main.cpp

@@ -1,6 +0,0 @@
-#include <pybind11/pybind11.h>
-namespace py = pybind11;
-
-PYBIND11_MODULE(test_cmake_build, m) {
-    m.def("add", [](int i, int j) { return i + j; });
-}