Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2024-11-26 07:02:11 +00:00
Code Issues Packages Projects Releases Wiki Activity
da803eb0a5
pybind11/tests/test_embed/CMakeLists.txt

41 lines
1.5 KiB
CMake
Raw Normal View History

Add Catch framework for testing embedding support and C++-side features At this point, there is only a single test for interpreter basics. Apart from embedding itself, having a C++ test framework will also benefit the C++-side features by allowing them to be tested directly.
2017-03-23 16:27:32 +00:00
if(${PYTHON_MODULE_EXTENSION} MATCHES "pypy")
format: apply cmake-format
2020-07-30 20:20:10 +00:00
add_custom_target(cpptest) # Dummy target on PyPy. Embedding is not supported.
Add Catch framework for testing embedding support and C++-side features At this point, there is only a single test for interpreter basics. Apart from embedding itself, having a C++ test framework will also benefit the C++-side features by allowing them to be tested directly.
2017-03-23 16:27:32 +00:00
set(_suppress_unused_variable_warning "${DOWNLOAD_CATCH}")
return()
endif()
chore: update Catch
2020-07-24 04:26:49 +00:00
find_package(Catch 2.13.0)
Miscellaneous travis-ci updates/fixes - For the debian/buster docker build (GCC 7/C++17) install and use the system `catch` package; this also renames "COMPILER_PACKAGES" to "EXTRA_PACKAGES" since it now contains a non-compiler package. - Add a status message indicating the catch version being used for compiling the embedded tests - Simplify some bash code by using VAR+=" foo" to append (rather than VAR="${VAR} foo" - Fix CMAKE_INCLUDE_PATH appending: it was prepending the ':' but not the existing $CMAKE_INCLUDE_PATH value and so would end up with ":/eigen-path" if CMAKE_INCLUDE_PATH was already set. (This wasn't bug that was actually noticed since currently nothing else sets it).
2017-10-22 15:25:18 +00:00
if(CATCH_FOUND)
message(STATUS "Building interpreter tests using Catch v${CATCH_VERSION}")
else()
Add Catch framework for testing embedding support and C++-side features At this point, there is only a single test for interpreter basics. Apart from embedding itself, having a C++ test framework will also benefit the C++-side features by allowing them to be tested directly.
2017-03-23 16:27:32 +00:00
message(STATUS "Catch not detected. Interpreter tests will be skipped. Install Catch headers"
ci: download EIGEN
2020-07-26 17:44:10 +00:00
" manually or use `cmake -DDOWNLOAD_CATCH=ON` to fetch them automatically.")
Add Catch framework for testing embedding support and C++-side features At this point, there is only a single test for interpreter basics. Apart from embedding itself, having a C++ test framework will also benefit the C++-side features by allowing them to be tested directly.
2017-03-23 16:27:32 +00:00
return()
endif()
format: apply cmake-format
2020-07-30 20:20:10 +00:00
add_executable(test_embed catch.cpp test_interpreter.cpp)
test: allow MSVC/Xcode to run the embed test
2020-07-22 14:23:16 +00:00
target_include_directories(test_embed PRIVATE "${CATCH_INCLUDE_DIR}")
Add Catch framework for testing embedding support and C++-side features At this point, there is only a single test for interpreter basics. Apart from embedding itself, having a C++ test framework will also benefit the C++-side features by allowing them to be tested directly.
2017-03-23 16:27:32 +00:00
pybind11_enable_warnings(test_embed)
feat: drop CMake 3.6 and below, modernize CMake fix: include PYTHON_IS_DEBUG
2020-07-28 04:43:12 +00:00
target_link_libraries(test_embed PRIVATE pybind11::embed)
Add Catch framework for testing embedding support and C++-side features At this point, there is only a single test for interpreter basics. Apart from embedding itself, having a C++ test framework will also benefit the C++-side features by allowing them to be tested directly.
2017-03-23 16:27:32 +00:00
Fix GIL release and acquire when embedding the interpreter Fixes a race condition when multiple threads try to acquire the GIL before `detail::internals` have been initialized. `gil_scoped_release` is now tasked with initializing `internals` (guaranteed single-threaded) to ensure the safety of subsequent `acquire` calls from multiple threads.
2017-06-20 21:50:51 +00:00
find_package(Threads REQUIRED)
feat: drop CMake 3.6 and below, modernize CMake fix: include PYTHON_IS_DEBUG
2020-07-28 04:43:12 +00:00
target_link_libraries(test_embed PUBLIC Threads::Threads)
Fix GIL release and acquire when embedding the interpreter Fixes a race condition when multiple threads try to acquire the GIL before `detail::internals` have been initialized. `gil_scoped_release` is now tasked with initializing `internals` (guaranteed single-threaded) to ensure the safety of subsequent `acquire` calls from multiple threads.
2017-06-20 21:50:51 +00:00
format: apply cmake-format
2020-07-30 20:20:10 +00:00
add_custom_target(
cpptest
COMMAND "$<TARGET_FILE:test_embed>"
WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}")
Fix segfault when reloading interpreter with external modules (#1092) * Fix segfault when reloading interpreter with external modules When embedding the interpreter and loading external modules in that embedded interpreter, the external module correctly shares its internals_ptr with the one in the embedded interpreter. When the interpreter is shut down, however, only the `internals_ptr` local to the embedded code is actually reset to nullptr: the external module remains set. The result is that loading an external pybind11 module, letting the interpreter go through a finalize/initialize, then attempting to use something in the external module fails because this external module is still trying to use the old (destroyed) internals. This causes undefined behaviour (typically a segfault). This commit fixes it by adding a level of indirection in the internals path, converting the local internals variable to `internals **` instead of `internals *`. With this change, we can detect a stale internals pointer and reload the internals pointer (either from a capsule or by creating a new internals instance). (No issue number: this was reported on gitter by @henryiii and @aoloe).
2018-01-11 23:46:10 +00:00
pybind11_add_module(external_module THIN_LTO external_module.cpp)
format: apply cmake-format
2020-07-30 20:20:10 +00:00
set_target_properties(external_module PROPERTIES LIBRARY_OUTPUT_DIRECTORY
"${CMAKE_CURRENT_SOURCE_DIR}")
test: allow MSVC/Xcode to run the embed test
2020-07-22 14:23:16 +00:00
foreach(config ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${config} config)
format: apply cmake-format
2020-07-30 20:20:10 +00:00
set_target_properties(external_module PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${config}
"${CMAKE_CURRENT_SOURCE_DIR}")
test: allow MSVC/Xcode to run the embed test
2020-07-22 14:23:16 +00:00
endforeach()
Fix segfault when reloading interpreter with external modules (#1092) * Fix segfault when reloading interpreter with external modules When embedding the interpreter and loading external modules in that embedded interpreter, the external module correctly shares its internals_ptr with the one in the embedded interpreter. When the interpreter is shut down, however, only the `internals_ptr` local to the embedded code is actually reset to nullptr: the external module remains set. The result is that loading an external pybind11 module, letting the interpreter go through a finalize/initialize, then attempting to use something in the external module fails because this external module is still trying to use the old (destroyed) internals. This causes undefined behaviour (typically a segfault). This commit fixes it by adding a level of indirection in the internals path, converting the local internals variable to `internals **` instead of `internals *`. With this change, we can detect a stale internals pointer and reload the internals pointer (either from a capsule or by creating a new internals instance). (No issue number: this was reported on gitter by @henryiii and @aoloe).
2018-01-11 23:46:10 +00:00
add_dependencies(cpptest external_module)
Add Catch framework for testing embedding support and C++-side features At this point, there is only a single test for interpreter basics. Apart from embedding itself, having a C++ test framework will also benefit the C++-side features by allowing them to be tested directly.
2017-03-23 16:27:32 +00:00
add_dependencies(check cpptest)
Reference in New Issue Copy Permalink