Zengtudor/pybind11
1
0
Fork 0
mirror of https://github.com/pybind/pybind11.git synced 2024-11-22 13:15:12 +00:00
Code Issues Packages Projects Releases Wiki Activity
fe1392d089
pybind11/tests/CMakeLists.txt

262 lines
9.4 KiB
CMake
Raw Normal View History

Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
# CMakeLists.txt -- Build system for the pybind11 test suite
#
# Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
#
# All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.
cmake_minimum_required(VERSION 2.8.12)
option(PYBIND11_WERROR "Report all warnings as errors" OFF)
cmake: Expose `PYBIND11_TEST_OVERRIDE` (#2218) Primarily for the ccmake curses GUI
2020-05-31 05:00:55 +00:00
set(PYBIND11_TEST_OVERRIDE "" CACHE STRING "Tests from ;-separated list of *.cpp files will be built instead of all tests")
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
# We're being loaded directly, i.e. not via add_subdirectory, so make this
# work as its own project and load the pybind11Config to get the tools we need
Specify CXX as project language for CMake >= 3.4 (#1027)
2017-08-30 12:17:54 +00:00
project(pybind11_tests CXX)
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
find_package(pybind11 REQUIRED CONFIG)
endif()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
message(STATUS "Setting tests build type to MinSizeRel as none was specified")
set possible build types in cmake build system
2016-09-17 10:58:18 +00:00
set(CMAKE_BUILD_TYPE MinSizeRel CACHE STRING "Choose the type of build." FORCE)
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
"MinSizeRel" "RelWithDebInfo")
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
endif()
Add cmake option to override tests (#489) When working on some particular feature, it's nice to be able to disable all the tests except for the one I'm working on; this is currently possible by editing tests/CMakeLists.txt, and commenting out the tests you don't want. This commit goes a step further by letting you give a list of tests you do want when invoking cmake, e.g.: cmake -DPYBIND11_TEST_OVERRIDE="test_issues.cpp;test_pickling.cpp" .. changes the build to build just those two tests (and changes the `pytest` target to invoke just the two associated tests). This persists in the build directory until you disable it again by running cmake with `-DPYBIND11_TEST_OVERRIDE=`. It also adds a message after the pytest output to remind you that it is in effect: Note: not all tests run: -DPYBIND11_TEST_OVERRIDE is in effect
2016-11-13 00:10:53 +00:00
# Full set of test files (you can override these; see below)
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
set(PYBIND11_TEST_FILES
Add support for __await__, __aiter__, and __anext__ protocols (#1842)
2019-07-18 07:02:35 +00:00
test_async.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_buffers.cpp
Split test_python_types.cpp into builtin_casters, stl and pytypes
2017-06-08 22:44:49 +00:00
test_builtin_casters.cpp
Add a scope guard call policy ```c++ m.def("foo", foo, py::call_guard<T>()); ``` is equivalent to: ```c++ m.def("foo", [](args...) { T scope_guard; return foo(args...); // forwarded arguments }); ```
2017-03-16 10:22:26 +00:00
test_call_policies.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_callbacks.cpp
Refactor the chrono cast functions into chrono.h. Add unit tests and documentation for the chrono cast.
2016-08-25 13:08:04 +00:00
test_chrono.cpp
Split test_python_types.cpp into builtin_casters, stl and pytypes
2017-06-08 22:44:49 +00:00
test_class.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_constants_and_functions.cpp
Add movable cast support to type casters This commit allows type_casters to allow their local values to be moved away, rather than copied, when the type caster instance itself is an rvalue. This only applies (automatically) to type casters using PYBIND11_TYPE_CASTER; the generic type type casters don't own their own pointer, and various value casters (e.g. std::string, std::pair, arithmetic types) already cast to an rvalue (i.e. they return by value). This updates various calling code to attempt to get a movable value whenever the value is itself coming from a type caster about to be destroyed: for example, when constructing an std::pair or various stl.h containers. For types that don't support value moving, the cast_op falls back to an lvalue cast. There wasn't an obvious place to add the tests, so I added them to test_copy_move_policies, but also renamed it to drop the _policies as it now tests more than just policies.
2017-05-14 19:57:26 +00:00
test_copy_move.cpp
Refactor: Extract Custom Type Casts related tests
2020-06-21 11:53:53 +00:00
test_custom_type_casters.cpp
Provide more control over automatic generation of docstrings (#486) Added the docstring_options class, which gives global control over the generation of docstrings and function signatures.
2016-11-15 11:38:05 +00:00
test_docstring_options.cpp
Make test initialization self-registering Adding or removing tests is a little bit cumbersome currently: the test needs to be added to CMakeLists.txt, the init function needs to be predeclared in pybind11_tests.cpp, then called in the plugin initialization. While this isn't a big deal for tests that are being committed, it's more of a hassle when working on some new feature or test code for which I temporarily only care about building and linking the test being worked on rather than the entire test suite. This commit changes tests to self-register their initialization by having each test initialize a local object (which stores the initialization function in a static variable). This makes changing the set of tests being build easy: one only needs to add or comment out test names in tests/CMakeLists.txt. A couple other minor changes that go along with this: - test_eigen.cpp is now included in the test list, then removed if eigen isn't available. This lets you disable the eigen tests by commenting it out, just like all the other tests, but keeps the build working without eigen eigen isn't available. (Also, if it's commented out, we don't even bother looking for and reporting the building with/without eigen status message). - pytest is now invoked with all the built test names (with .cpp changed to .py) so that it doesn't try to run tests that weren't built.
2016-09-03 18:54:22 +00:00
test_eigen.cpp
Move enum tests into a new file There are more enum tests than 'constants and functions'.
2016-08-12 22:57:24 +00:00
test_enum.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_eval.cpp
test_exceptions.cpp
Allow binding factory functions as constructors This allows you to use: cls.def(py::init(&factory_function)); where `factory_function` returns a pointer, holder, or value of the class type (or a derived type). Various compile-time checks (static_asserts) are performed to ensure the function is valid, and various run-time type checks where necessary. Some other details of this feature: - The `py::init` name doesn't conflict with the templated no-argument `py::init<...>()`, but keeps the naming consistent: the existing templated, no-argument one wraps constructors, the no-template, function-argument one wraps factory functions. - If returning a CppClass (whether by value or pointer) when an CppAlias is required (i.e. python-side inheritance and a declared alias), a dynamic_cast to the alias is attempted (for the pointer version); if it fails, or if returned by value, an Alias(Class &&) constructor is invoked. If this constructor doesn't exist, a runtime error occurs. - for holder returns when an alias is required, we try a dynamic_cast of the wrapped pointer to the alias to see if it is already an alias instance; if it isn't, we raise an error. - `py::init(class_factory, alias_factory)` is also available that takes two factories: the first is called when an alias is not needed, the second when it is. - Reimplement factory instance clearing. The previous implementation failed under python-side multiple inheritance: *each* inherited type's factory init would clear the instance instead of only setting its own type value. The new implementation here clears just the relevant value pointer. - dealloc is updated to explicitly set the leftover value pointer to nullptr and the `holder_constructed` flag to false so that it can be used to clear preallocated value without needing to rebuild the instance internals data. - Added various tests to test out new allocation/deallocation code. - With preallocation now done lazily, init factory holders can completely avoid the extra overhead of needing an extra allocation/deallocation. - Updated documentation to make factory constructors the default advanced constructor style. - If an `__init__` is called a second time, we have two choices: we can throw away the first instance, replacing it with the second; or we can ignore the second call. The latter is slightly easier, so do that.
2017-06-13 01:52:48 +00:00
test_factory_constructors.cpp
Use `PyGILState_GetThisThreadState` when using gil_scoped_acquire. (#1211) This avoids GIL deadlocking when pybind11 tries to acquire the GIL in a thread that already acquired it using standard Python API (e.g. when running from a Python thread).
2018-12-01 13:47:40 +00:00
test_gil_scoped.cpp
Utility for redirecting C++ streams to Python (#1009)
2017-08-25 00:12:43 +00:00
test_iostream.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_kwargs_and_defaults.cpp
Add py::module_local() attribute for module-local type bindings This commit adds a `py::module_local` attribute that lets you confine a registered type to the module (more technically, the shared object) in which it is defined, by registering it with: py::class_<C>(m, "C", py::module_local()) This will allow the same C++ class `C` to be registered in different modules with independent sets of class definitions. On the Python side, two such types will be completely distinct; on the C++ side, the C++ type resolves to a different Python type in each module. This applies `py::module_local` automatically to `stl_bind.h` bindings when the container value type looks like something global: i.e. when it is a converting type (for example, when binding a `std::vector<int>`), or when it is a registered type itself bound with `py::module_local`. This should help resolve potential future conflicts (e.g. if two completely unrelated modules both try to bind a `std::vector<int>`. Users can override the automatic selection by adding a `py::module_local()` or `py::module_local(false)`. Note that this does mildly break backwards compatibility: bound stl containers of basic types like `std::vector<int>` cannot be bound in one module and returned in a different module. (This can be re-enabled with `py::module_local(false)` as described above, but with the potential for eventual load conflicts).
2017-07-29 02:03:44 +00:00
test_local_bindings.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_methods_and_attributes.cpp
test_modules.cpp
Fix missing smart_ptr test
2016-09-20 09:52:25 +00:00
test_multiple_inheritance.cpp
Expose some dtype/array attributes via NumPy C API
2016-08-29 01:41:05 +00:00
test_numpy_array.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_numpy_dtypes.cpp
test_numpy_vectorize.cpp
test_opaque_types.cpp
test_operator_overloading.cpp
test_pickling.cpp
Split test_python_types.cpp into builtin_casters, stl and pytypes
2017-06-08 22:44:49 +00:00
test_pytypes.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_sequences_and_iterators.cpp
Fix missing smart_ptr test
2016-09-20 09:52:25 +00:00
test_smart_ptr.cpp
Split test_python_types.cpp into builtin_casters, stl and pytypes
2017-06-08 22:44:49 +00:00
test_stl.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_stl_binders.cpp
Add basic support for tag-based static polymorphism (#1326) * Add basic support for tag-based static polymorphism Sometimes it is possible to look at a C++ object and know what its dynamic type is, even if it doesn't use C++ polymorphism, because instances of the object and its subclasses conform to some other mechanism for being self-describing; for example, perhaps there's an enumerated "tag" or "kind" member in the base class that's always set to an indication of the correct type. This might be done for performance reasons, or to permit most-derived types to be trivially copyable. One of the most widely-known examples is in LLVM: https://llvm.org/docs/HowToSetUpLLVMStyleRTTI.html This PR permits pybind11 to be informed of such conventions via a new specializable detail::polymorphic_type_hook<> template, which generalizes the previous logic for determining the runtime type of an object based on C++ RTTI. Implementors provide a way to map from a base class object to a const std::type_info* for the dynamic type; pybind11 then uses this to ensure that casting a Base* to Python creates a Python object that knows it's wrapping the appropriate sort of Derived. There are a number of restrictions with this tag-based static polymorphism support compared to pybind11's existing support for built-in C++ polymorphism: - there is no support for this-pointer adjustment, so only single inheritance is permitted - there is no way to make C++ code call new Python-provided subclasses - when binding C++ classes that redefine a method in a subclass, the .def() must be repeated in the binding for Python to know about the update But these are not much of an issue in practice in many cases, the impact on the complexity of pybind11's innards is minimal and localized, and the support for automatic downcasting improves usability a great deal.
2018-04-14 00:13:10 +00:00
test_tagbased_polymorphic.cpp
Fix assertion failure for unions (#1685) (#1709) In def_readonly and def_readwrite, there is an assertion that the member comes from the class or a base class: static_assert(std::is_base_of<C, type>::value, "..."); However, if C and type are the same type, is_base_of will still only be true if they are the same _non-union_ type. This means we can't define accessors for the members of a union type because of this assertion. Update the assertion to test std::is_same<C, type>::value || std::is_base_of<C, type>::value which will allow union types, or members of base classes. Also add a basic unit test for accessing unions.
2019-06-11 20:25:12 +00:00
test_union.cpp
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
test_virtual_functions.cpp
)
Add cmake option to override tests (#489) When working on some particular feature, it's nice to be able to disable all the tests except for the one I'm working on; this is currently possible by editing tests/CMakeLists.txt, and commenting out the tests you don't want. This commit goes a step further by letting you give a list of tests you do want when invoking cmake, e.g.: cmake -DPYBIND11_TEST_OVERRIDE="test_issues.cpp;test_pickling.cpp" .. changes the build to build just those two tests (and changes the `pytest` target to invoke just the two associated tests). This persists in the build directory until you disable it again by running cmake with `-DPYBIND11_TEST_OVERRIDE=`. It also adds a message after the pytest output to remind you that it is in effect: Note: not all tests run: -DPYBIND11_TEST_OVERRIDE is in effect
2016-11-13 00:10:53 +00:00
# Invoking cmake with something like:
Move tests from test_issues.cpp/py into appropriate files
2017-06-07 14:52:50 +00:00
# cmake -DPYBIND11_TEST_OVERRIDE="test_callbacks.cpp;test_picking.cpp" ..
Add cmake option to override tests (#489) When working on some particular feature, it's nice to be able to disable all the tests except for the one I'm working on; this is currently possible by editing tests/CMakeLists.txt, and commenting out the tests you don't want. This commit goes a step further by letting you give a list of tests you do want when invoking cmake, e.g.: cmake -DPYBIND11_TEST_OVERRIDE="test_issues.cpp;test_pickling.cpp" .. changes the build to build just those two tests (and changes the `pytest` target to invoke just the two associated tests). This persists in the build directory until you disable it again by running cmake with `-DPYBIND11_TEST_OVERRIDE=`. It also adds a message after the pytest output to remind you that it is in effect: Note: not all tests run: -DPYBIND11_TEST_OVERRIDE is in effect
2016-11-13 00:10:53 +00:00
# lets you override the tests that get compiled and run. You can restore to all tests with:
# cmake -DPYBIND11_TEST_OVERRIDE= ..
if (PYBIND11_TEST_OVERRIDE)
set(PYBIND11_TEST_FILES ${PYBIND11_TEST_OVERRIDE})
endif()
Add support for __await__, __aiter__, and __anext__ protocols (#1842)
2019-07-18 07:02:35 +00:00
# Skip test_async for Python < 3.5
list(FIND PYBIND11_TEST_FILES test_async.cpp PYBIND11_TEST_FILES_ASYNC_I)
if((PYBIND11_TEST_FILES_ASYNC_I GREATER -1) AND ("${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR}" VERSION_LESS 3.5))
message(STATUS "Skipping test_async because Python version ${PYTHON_VERSION_MAJOR}.${PYTHON_VERSION_MINOR} < 3.5")
list(REMOVE_AT PYBIND11_TEST_FILES ${PYBIND11_TEST_FILES_ASYNC_I})
endif()
Make test initialization self-registering Adding or removing tests is a little bit cumbersome currently: the test needs to be added to CMakeLists.txt, the init function needs to be predeclared in pybind11_tests.cpp, then called in the plugin initialization. While this isn't a big deal for tests that are being committed, it's more of a hassle when working on some new feature or test code for which I temporarily only care about building and linking the test being worked on rather than the entire test suite. This commit changes tests to self-register their initialization by having each test initialize a local object (which stores the initialization function in a static variable). This makes changing the set of tests being build easy: one only needs to add or comment out test names in tests/CMakeLists.txt. A couple other minor changes that go along with this: - test_eigen.cpp is now included in the test list, then removed if eigen isn't available. This lets you disable the eigen tests by commenting it out, just like all the other tests, but keeps the build working without eigen eigen isn't available. (Also, if it's commented out, we don't even bother looking for and reporting the building with/without eigen status message). - pytest is now invoked with all the built test names (with .cpp changed to .py) so that it doesn't try to run tests that weren't built.
2016-09-03 18:54:22 +00:00
string(REPLACE ".cpp" ".py" PYBIND11_PYTEST_FILES "${PYBIND11_TEST_FILES}")
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
# Contains the set of test files that require pybind11_cross_module_tests to be
# built; if none of these are built (i.e. because TEST_OVERRIDE is used and
# doesn't include them) the second module doesn't get built.
set(PYBIND11_CROSS_MODULE_TESTS
Fix builtin exception handlers to work across modules The builtin exception handler currently doesn't work across modules under clang/libc++ for builtin pybind exceptions like `pybind11::error_already_set` or `pybind11::stop_iteration`: under RTLD_LOCAL module loading clang considers each module's exception classes distinct types. This then means that the base exception translator fails to catch the exceptions and the fall through to the generic `std::exception` handler, which completely breaks things like `stop_iteration`: only the `stop_iteration` of the first module loaded actually works properly; later modules raise a RuntimeError with no message when trying to invoke their iterators. For example, two modules defined like this exhibit the behaviour under clang++/libc++: z1.cpp: #include <pybind11/pybind11.h> #include <pybind11/stl_bind.h> namespace py = pybind11; PYBIND11_MODULE(z1, m) { py::bind_vector<std::vector<long>>(m, "IntVector"); } z2.cpp: #include <pybind11/pybind11.h> #include <pybind11/stl_bind.h> namespace py = pybind11; PYBIND11_MODULE(z2, m) { py::bind_vector<std::vector<double>>(m, "FloatVector"); } Python: import z1, z2 for i in z2.FloatVector(): pass results in: Traceback (most recent call last): File "zs.py", line 2, in <module> for i in z2.FloatVector(): RuntimeError This commit fixes the issue by adding a new exception translator each time the internals pointer is initialized from python builtins: this generally means the internals data was initialized by some other module. (The extra translator(s) are skipped under libstdc++).
2017-07-29 01:38:23 +00:00
test_exceptions.py
Add py::module_local() attribute for module-local type bindings This commit adds a `py::module_local` attribute that lets you confine a registered type to the module (more technically, the shared object) in which it is defined, by registering it with: py::class_<C>(m, "C", py::module_local()) This will allow the same C++ class `C` to be registered in different modules with independent sets of class definitions. On the Python side, two such types will be completely distinct; on the C++ side, the C++ type resolves to a different Python type in each module. This applies `py::module_local` automatically to `stl_bind.h` bindings when the container value type looks like something global: i.e. when it is a converting type (for example, when binding a `std::vector<int>`), or when it is a registered type itself bound with `py::module_local`. This should help resolve potential future conflicts (e.g. if two completely unrelated modules both try to bind a `std::vector<int>`. Users can override the automatic selection by adding a `py::module_local()` or `py::module_local(false)`. Note that this does mildly break backwards compatibility: bound stl containers of basic types like `std::vector<int>` cannot be bound in one module and returned in a different module. (This can be re-enabled with `py::module_local(false)` as described above, but with the potential for eventual load conflicts).
2017-07-29 02:03:44 +00:00
test_local_bindings.py
Make TypeErrors more informative when an optional header is missing E.g. trying to convert a `list` to a `std::vector<int>` without including <pybind11/stl.h> will now raise an error with a note that suggests checking the headers. The note is only appended if `std::` is found in the function signature. This should only be the case when a header is missing. E.g. when stl.h is included, the signature would contain `List[int]` instead of `std::vector<int>` while using stl_bind.h would produce something like `MyVector`. Similarly for `std::map`/`Dict`, `complex`, `std::function`/`Callable`, etc. There's a possibility for false positives, but it's pretty low.
2017-09-09 18:21:34 +00:00
test_stl.py
Fix STL casters for containers with proxies (regression) To avoid an ODR violation in the test suite while testing both `stl.h` and `std_bind.h` with `std::vector<bool>`, the `py::bind_vector<std::vector<bool>>` test is moved to the secondary module (which does not include `stl.h`).
2017-09-01 19:42:20 +00:00
test_stl_binders.py
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
)
Make sure `detail::get_internals` acquires the GIL before making Python calls. (#1836) This is only necessary if `get_internals` is called for the first time in a given module when the running thread is in a GIL-released state. Fixes #1364
2019-07-15 14:47:02 +00:00
set(PYBIND11_CROSS_MODULE_GIL_TESTS
test_gil_scoped.py
)
Make test initialization self-registering Adding or removing tests is a little bit cumbersome currently: the test needs to be added to CMakeLists.txt, the init function needs to be predeclared in pybind11_tests.cpp, then called in the plugin initialization. While this isn't a big deal for tests that are being committed, it's more of a hassle when working on some new feature or test code for which I temporarily only care about building and linking the test being worked on rather than the entire test suite. This commit changes tests to self-register their initialization by having each test initialize a local object (which stores the initialization function in a static variable). This makes changing the set of tests being build easy: one only needs to add or comment out test names in tests/CMakeLists.txt. A couple other minor changes that go along with this: - test_eigen.cpp is now included in the test list, then removed if eigen isn't available. This lets you disable the eigen tests by commenting it out, just like all the other tests, but keeps the build working without eigen eigen isn't available. (Also, if it's commented out, we don't even bother looking for and reporting the building with/without eigen status message). - pytest is now invoked with all the built test names (with .cpp changed to .py) so that it doesn't try to run tests that weren't built.
2016-09-03 18:54:22 +00:00
# Check if Eigen is available; if not, remove from PYBIND11_TEST_FILES (but
# keep it in PYBIND11_PYTEST_FILES, so that we get the "eigen is not installed"
# skip message).
list(FIND PYBIND11_TEST_FILES test_eigen.cpp PYBIND11_TEST_FILES_EIGEN_I)
if(PYBIND11_TEST_FILES_EIGEN_I GREATER -1)
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
# Try loading via newer Eigen's Eigen3Config first (bypassing tools/FindEigen3.cmake).
# Eigen 3.3.1+ exports a cmake 3.0+ target for handling dependency requirements, but also
# produces a fatal error if loaded from a pre-3.0 cmake.
if (NOT CMAKE_VERSION VERSION_LESS 3.0)
Specify minimum needed cmake version in test suite Fixes #1117
2017-09-28 11:04:34 +00:00
find_package(Eigen3 3.2.7 QUIET CONFIG)
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
if (EIGEN3_FOUND)
if (EIGEN3_VERSION_STRING AND NOT EIGEN3_VERSION_STRING VERSION_LESS 3.3.1)
set(PYBIND11_EIGEN_VIA_TARGET 1)
endif()
endif()
endif()
if (NOT EIGEN3_FOUND)
# Couldn't load via target, so fall back to allowing module mode finding, which will pick up
# tools/FindEigen3.cmake
Specify minimum needed cmake version in test suite Fixes #1117
2017-09-28 11:04:34 +00:00
find_package(Eigen3 3.2.7 QUIET)
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
endif()
Make test initialization self-registering Adding or removing tests is a little bit cumbersome currently: the test needs to be added to CMakeLists.txt, the init function needs to be predeclared in pybind11_tests.cpp, then called in the plugin initialization. While this isn't a big deal for tests that are being committed, it's more of a hassle when working on some new feature or test code for which I temporarily only care about building and linking the test being worked on rather than the entire test suite. This commit changes tests to self-register their initialization by having each test initialize a local object (which stores the initialization function in a static variable). This makes changing the set of tests being build easy: one only needs to add or comment out test names in tests/CMakeLists.txt. A couple other minor changes that go along with this: - test_eigen.cpp is now included in the test list, then removed if eigen isn't available. This lets you disable the eigen tests by commenting it out, just like all the other tests, but keeps the build working without eigen eigen isn't available. (Also, if it's commented out, we don't even bother looking for and reporting the building with/without eigen status message). - pytest is now invoked with all the built test names (with .cpp changed to .py) so that it doesn't try to run tests that weren't built.
2016-09-03 18:54:22 +00:00
if(EIGEN3_FOUND)
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
# Eigen 3.3.1+ cmake sets EIGEN3_VERSION_STRING (and hard codes the version when installed
# rather than looking it up in the cmake script); older versions, and the
# tools/FindEigen3.cmake, set EIGEN3_VERSION instead.
if(NOT EIGEN3_VERSION AND EIGEN3_VERSION_STRING)
set(EIGEN3_VERSION ${EIGEN3_VERSION_STRING})
endif()
Make test initialization self-registering Adding or removing tests is a little bit cumbersome currently: the test needs to be added to CMakeLists.txt, the init function needs to be predeclared in pybind11_tests.cpp, then called in the plugin initialization. While this isn't a big deal for tests that are being committed, it's more of a hassle when working on some new feature or test code for which I temporarily only care about building and linking the test being worked on rather than the entire test suite. This commit changes tests to self-register their initialization by having each test initialize a local object (which stores the initialization function in a static variable). This makes changing the set of tests being build easy: one only needs to add or comment out test names in tests/CMakeLists.txt. A couple other minor changes that go along with this: - test_eigen.cpp is now included in the test list, then removed if eigen isn't available. This lets you disable the eigen tests by commenting it out, just like all the other tests, but keeps the build working without eigen eigen isn't available. (Also, if it's commented out, we don't even bother looking for and reporting the building with/without eigen status message). - pytest is now invoked with all the built test names (with .cpp changed to .py) so that it doesn't try to run tests that weren't built.
2016-09-03 18:54:22 +00:00
message(STATUS "Building tests with Eigen v${EIGEN3_VERSION}")
else()
list(REMOVE_AT PYBIND11_TEST_FILES ${PYBIND11_TEST_FILES_EIGEN_I})
message(STATUS "Building tests WITHOUT Eigen")
endif()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
endif()
Skip boost::variant tests on unsupported compilers and versions of Boost
2017-08-25 19:11:36 +00:00
# Optional dependency for some tests (boost::variant is only supported with version >= 1.56)
find_package(Boost 1.56)
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
# Compile with compiler warnings turned on
function(pybind11_enable_warnings target_name)
if(MSVC)
target_compile_options(${target_name} PRIVATE /W4)
Make compiler flags for -Werror specific to GNU, Clang, or Intel
2019-06-11 20:42:30 +00:00
elseif(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Intel|Clang)")
Add -Wdeprecated to test suite and fix associated warnings (#1191) This commit turns on `-Wdeprecated` in the test suite and fixes several associated deprecation warnings that show up as a result: - in C++17 `static constexpr` members are implicitly inline; our redeclaration (needed for C++11/14) is deprecated in C++17. - various test suite classes have destructors and rely on implicit copy constructors, but implicit copy constructor definitions when a user-declared destructor is present was deprecated in C++11. - Eigen also has various implicit copy constructors, so just disable `-Wdeprecated` in `eigen.h`.
2017-11-20 13:19:53 +00:00
target_compile_options(${target_name} PRIVATE -Wall -Wextra -Wconversion -Wcast-qual -Wdeprecated)
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
endif()
if(PYBIND11_WERROR)
if(MSVC)
target_compile_options(${target_name} PRIVATE /WX)
Make compiler flags for -Werror specific to GNU, Clang, or Intel
2019-06-11 20:42:30 +00:00
elseif(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Intel|Clang)")
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
target_compile_options(${target_name} PRIVATE -Werror)
endif()
endif()
endfunction()
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
set(test_targets pybind11_tests)
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
# Build pybind11_cross_module_tests if any test_whatever.py are being built that require it
foreach(t ${PYBIND11_CROSS_MODULE_TESTS})
list(FIND PYBIND11_PYTEST_FILES ${t} i)
if (i GREATER -1)
list(APPEND test_targets pybind11_cross_module_tests)
break()
endif()
endforeach()
Make header files viewable in IDEs (fixes #424)
2016-09-29 19:30:00 +00:00
Make sure `detail::get_internals` acquires the GIL before making Python calls. (#1836) This is only necessary if `get_internals` is called for the first time in a given module when the running thread is in a GIL-released state. Fixes #1364
2019-07-15 14:47:02 +00:00
foreach(t ${PYBIND11_CROSS_MODULE_GIL_TESTS})
list(FIND PYBIND11_PYTEST_FILES ${t} i)
if (i GREATER -1)
list(APPEND test_targets cross_module_gil_utils)
break()
endif()
endforeach()
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
set(testdir ${CMAKE_CURRENT_SOURCE_DIR})
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
foreach(target ${test_targets})
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
set(test_files ${PYBIND11_TEST_FILES})
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
if(NOT target STREQUAL "pybind11_tests")
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
set(test_files "")
endif()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
# Create the binding library
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
pybind11_add_module(${target} THIN_LTO ${target}.cpp ${test_files} ${PYBIND11_HEADERS})
pybind11_enable_warnings(${target})
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
if(MSVC)
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
target_compile_options(${target} PRIVATE /utf-8)
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
endif()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
if(EIGEN3_FOUND)
if (PYBIND11_EIGEN_VIA_TARGET)
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
target_link_libraries(${target} PRIVATE Eigen3::Eigen)
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
else()
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
target_include_directories(${target} PRIVATE ${EIGEN3_INCLUDE_DIR})
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
endif()
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
target_compile_definitions(${target} PRIVATE -DPYBIND11_TEST_EIGEN)
endif()
if(Boost_FOUND)
target_include_directories(${target} PRIVATE ${Boost_INCLUDE_DIRS})
target_compile_definitions(${target} PRIVATE -DPYBIND11_TEST_BOOST)
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
endif()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
# Always write the output file directly into the 'tests' directory (even on MSVC)
if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
set_target_properties(${target} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${testdir})
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
foreach(config ${CMAKE_CONFIGURATION_TYPES})
string(TOUPPER ${config} config)
Add support for boost::variant in C++11 mode In C++11 mode, `boost::apply_visitor` requires an explicit `result_type`. This also adds optional tests for `boost::variant` in C++11/14, if boost is available. In C++17 mode, `std::variant` is tested instead.
2017-08-08 14:02:31 +00:00
set_target_properties(${target} PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${config} ${testdir})
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
endforeach()
endif()
endforeach()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
Don't install pytest from cmake, just fail instead Installing something outside the project directory from a cmake invocation is overly intrusive; this changes tests/CMakeLists.txt to just fail with an informative message instead, and changes the travis-ci builds to install pytest via pip or apt-get.
2016-08-26 21:11:40 +00:00
# Make sure pytest is found or produce a fatal error
Automatically install pytest from CMake Pytest is a development dependency but we can make it painless by automating the install using CMake.
2016-08-13 00:44:56 +00:00
if(NOT PYBIND11_PYTEST_FOUND)
Minor pytest maintenance (#702) * Add `pytest.ini` config file and set default options there instead of in `CMakeLists.txt` (command line arguments). * Change all output capture from `capfd` (filedescriptors) to `capsys` (Python's `sys.stdout` and `sys.stderr`). This avoids capturing low-level C errors, e.g. from the debug build of Python. * Set pytest minimum version to 3.0 to make it easier to use new features. Removed conditional use of `excinfo.match()`. * Clean up some leftover function-level `@pytest.requires_numpy`.
2017-03-10 14:42:42 +00:00
execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import pytest; print(pytest.__version__)"
RESULT_VARIABLE pytest_not_found OUTPUT_VARIABLE pytest_version ERROR_QUIET)
if(pytest_not_found)
message(FATAL_ERROR "Running the tests requires pytest. Please install it manually"
" (try: ${PYTHON_EXECUTABLE} -m pip install pytest)")
elseif(pytest_version VERSION_LESS 3.0)
message(FATAL_ERROR "Running the tests requires pytest >= 3.0. Found: ${pytest_version}"
"Please update it (try: ${PYTHON_EXECUTABLE} -m pip install -U pytest)")
Automatically install pytest from CMake Pytest is a development dependency but we can make it painless by automating the install using CMake.
2016-08-13 00:44:56 +00:00
endif()
fixed typo in cmake file
2016-10-09 11:51:05 +00:00
set(PYBIND11_PYTEST_FOUND TRUE CACHE INTERNAL "")
Automatically install pytest from CMake Pytest is a development dependency but we can make it painless by automating the install using CMake.
2016-08-13 00:44:56 +00:00
endif()
pytest target: add USE_TERMINAL flag The added flag enables non-buffered console output when using Ninja
2017-04-28 20:43:14 +00:00
if(CMAKE_VERSION VERSION_LESS 3.2)
set(PYBIND11_USES_TERMINAL "")
else()
set(PYBIND11_USES_TERMINAL "USES_TERMINAL")
endif()
Port tests to pytest Use simple asserts and pytest's powerful introspection to make testing simpler. This merges the old .py/.ref file pairs into simple .py files where the expected values are right next to the code being tested. This commit does not touch the C++ part of the code and replicates the Python tests exactly like the old .ref-file-based approach.
2016-08-12 11:50:00 +00:00
# A single command to compile and run the tests
Minor pytest maintenance (#702) * Add `pytest.ini` config file and set default options there instead of in `CMakeLists.txt` (command line arguments). * Change all output capture from `capfd` (filedescriptors) to `capsys` (Python's `sys.stdout` and `sys.stderr`). This avoids capturing low-level C errors, e.g. from the debug build of Python. * Set pytest minimum version to 3.0 to make it easier to use new features. Removed conditional use of `excinfo.match()`. * Clean up some leftover function-level `@pytest.requires_numpy`.
2017-03-10 14:42:42 +00:00
add_custom_target(pytest COMMAND ${PYTHON_EXECUTABLE} -m pytest ${PYBIND11_PYTEST_FILES}
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
DEPENDS ${test_targets} WORKING_DIRECTORY ${testdir} ${PYBIND11_USES_TERMINAL})
Add debugging info about .so size to build output (#477) * Add debugging info about so size to build output This adds a small python script to tools that captures before-and-after .so sizes between builds and outputs this in the build output via a string such as: ------ pybind11_tests.cpython-35m-x86_64-linux-gnu.so file size: 924696 (decrease of 73680 bytes = 7.38%) ------ pybind11_tests.cpython-35m-x86_64-linux-gnu.so file size: 998376 (increase of 73680 bytes = 7.97%) ------ pybind11_tests.cpython-35m-x86_64-linux-gnu.so file size: 998376 (no change) Or, if there was no .so during the build, just the .so size by itself: ------ pybind11_tests.cpython-35m-x86_64-linux-gnu.so file size: 998376 This allows you to, for example, build, checkout a different branch, rebuild, and easily see exactly the change in the pybind11_tests.so size. It also allows looking at the travis and appveyor build logs to get an idea of .so/.dll sizes across different build systems. * Minor libsize.py script changes - Use RAII open - Remove unused libsize=-1 - Report change as [+-]xyz bytes = [+-]a.bc%
2016-11-04 13:47:41 +00:00
Add cmake option to override tests (#489) When working on some particular feature, it's nice to be able to disable all the tests except for the one I'm working on; this is currently possible by editing tests/CMakeLists.txt, and commenting out the tests you don't want. This commit goes a step further by letting you give a list of tests you do want when invoking cmake, e.g.: cmake -DPYBIND11_TEST_OVERRIDE="test_issues.cpp;test_pickling.cpp" .. changes the build to build just those two tests (and changes the `pytest` target to invoke just the two associated tests). This persists in the build directory until you disable it again by running cmake with `-DPYBIND11_TEST_OVERRIDE=`. It also adds a message after the pytest output to remind you that it is in effect: Note: not all tests run: -DPYBIND11_TEST_OVERRIDE is in effect
2016-11-13 00:10:53 +00:00
if(PYBIND11_TEST_OVERRIDE)
add_custom_command(TARGET pytest POST_BUILD
COMMAND ${CMAKE_COMMAND} -E echo "Note: not all tests run: -DPYBIND11_TEST_OVERRIDE is in effect")
endif()
Independent tests (#665) * Make tests buildable independently This makes "tests" buildable as a separate project that uses find_package(pybind11 CONFIG) when invoked independently. This also moves the WERROR option into tests/CMakeLists.txt, as that's the only place it is used. * Use Eigen 3.3.1's cmake target, if available This changes the eigen finding code to attempt to use Eigen's system-installed Eigen3Config first. In Eigen 3.3.1, it exports a cmake Eigen3::Eigen target to get dependencies from (rather than setting the include path directly). If it fails, we fall back to the trying to load allowing modules (i.e. allowing our tools/FindEigen3.cmake). If we either fallback, or the eigen version is older than 3.3.1 (or , we still set the include directory manually; otherwise, for CONFIG + new Eigen, we get it via the target. This is also needed to allow 'tests' to be built independently, when the find_package(Eigen3) is going to find via the system-installed Eigen3Config.cmake. * Add a install-then-build test, using clang on linux This tests that `make install` to the actual system, followed by a build of the tests (without the main pybind11 repository available) works as expected. To also expand the testing variety a bit, it also builds using clang-3.9 instead of gcc. * Don't try loading Eigen3Config in cmake < 3.0 It could FATAL_ERROR as the newer cmake includes a cmake 3.0 required line. If doing an independent, out-of-tree "tests" build, the regular find_package(Eigen3) is likely to fail with the same error, but I think we can just let that be: if you want a recent Eigen with proper cmake loading support *and* want to do an independent tests build, you'll need at least cmake 3.0.
2017-02-24 22:07:53 +00:00
# Add a check target to run all the tests, starting with pytest (we add dependencies to this below)
add_custom_target(check DEPENDS pytest)
# The remaining tests only apply when being built as part of the pybind11 project, but not if the
# tests are being built independently.
if (NOT PROJECT_NAME STREQUAL "pybind11")
return()
endif()
Add cross-module test plugin This adds the infrastructure for a separate test plugin for cross-module tests. (This commit contains no tests that actually use it, but the following commits do; this is separated simply to provide a cleaner commit history).
2017-07-29 00:57:57 +00:00
# Add a post-build comment to show the primary test suite .so size and, if a previous size, compare it:
Make sure add_subdirectory and find_package behave identically Add a BUILD_INTERFACE and a pybind11::pybind11 alias for the interface library to match the installed target. Add new cmake tests for add_subdirectory and consolidates the .cpp and .py files needed for the cmake build tests: Before: tests |-- test_installed_module | |-- CMakeLists.txt | |-- main.cpp | \-- test.py \-- test_installed_target |-- CMakeLists.txt |-- main.cpp \-- test.py After: tests \-- test_cmake_build |-- installed_module/CMakeLists.txt |-- installed_target/CMakeLists.txt |-- subdirectory_module/CMakeLists.txt |-- subdirectory_target/CMakeLists.txt |-- main.cpp \-- test.py
2016-12-14 00:43:39 +00:00
add_custom_command(TARGET pybind11_tests POST_BUILD
Fix path to libsize.py (#658) Use PROJECT_SOURCE_DIR instead of CMAKE_SOURCE_DIR as the base of the path to libsize.py. This fixes an error if pybind11 is being built directly within another project.
2017-02-08 22:43:23 +00:00
COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/tools/libsize.py
Make sure add_subdirectory and find_package behave identically Add a BUILD_INTERFACE and a pybind11::pybind11 alias for the interface library to match the installed target. Add new cmake tests for add_subdirectory and consolidates the .cpp and .py files needed for the cmake build tests: Before: tests |-- test_installed_module | |-- CMakeLists.txt | |-- main.cpp | \-- test.py \-- test_installed_target |-- CMakeLists.txt |-- main.cpp \-- test.py After: tests \-- test_cmake_build |-- installed_module/CMakeLists.txt |-- installed_target/CMakeLists.txt |-- subdirectory_module/CMakeLists.txt |-- subdirectory_target/CMakeLists.txt |-- main.cpp \-- test.py
2016-12-14 00:43:39 +00:00
$<TARGET_FILE:pybind11_tests> ${CMAKE_CURRENT_BINARY_DIR}/sosize-$<TARGET_FILE_NAME:pybind11_tests>.txt)
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
# Test embedding the interpreter. Provides the `cpptest` target.
add_subdirectory(test_embed)
Make sure add_subdirectory and find_package behave identically Add a BUILD_INTERFACE and a pybind11::pybind11 alias for the interface library to match the installed target. Add new cmake tests for add_subdirectory and consolidates the .cpp and .py files needed for the cmake build tests: Before: tests |-- test_installed_module | |-- CMakeLists.txt | |-- main.cpp | \-- test.py \-- test_installed_target |-- CMakeLists.txt |-- main.cpp \-- test.py After: tests \-- test_cmake_build |-- installed_module/CMakeLists.txt |-- installed_target/CMakeLists.txt |-- subdirectory_module/CMakeLists.txt |-- subdirectory_target/CMakeLists.txt |-- main.cpp \-- test.py
2016-12-14 00:43:39 +00:00
# Test CMake build using functions and targets from subdirectory or installed location
Move test_cmake_build target code into its subdirectory
2017-06-25 13:16:34 +00:00
add_subdirectory(test_cmake_build)
Reference in New Issue Copy Permalink