Mirrors/fish-shell
2
0
Fork 0
mirror of https://github.com/fish-shell/fish-shell synced 2025-01-15 14:34:05 +00:00
Code Issues Projects Releases Packages Wiki Activity
fish-shell/cmake/Tests.cmake

126 lines
5.6 KiB
CMake
Raw Normal View History

Run each test fully independently in own environment
2021-03-15 17:42:53 +00:00
# This adds ctest support to the project
enable_testing()
Re-add dynamic CTEST_PARALLEL_LEVEL detection When it is not hard-coded in the environment variable of the same name.
2025-01-09 00:07:16 +00:00
# By default, ctest runs tests serially
Don't override CTEST_PARALLEL_LEVEL env variable I think the dynamic detection patch ends up overriding the environment variable set by CI (if present), because `if(NOT CTEST_PARALLEL_LEVEL)` would define to false even if an environment variable of that name existed then we end up explicitly assigning the environment variable by that name upon invocation with `env`.
2025-01-11 01:16:32 +00:00
# Support CTEST_PARALLEL_LEVEL as an environment variable in addition to a CMake variable
Re-add dynamic CTEST_PARALLEL_LEVEL detection When it is not hard-coded in the environment variable of the same name.
2025-01-09 00:07:16 +00:00
if(NOT CTEST_PARALLEL_LEVEL)
Don't override CTEST_PARALLEL_LEVEL env variable I think the dynamic detection patch ends up overriding the environment variable set by CI (if present), because `if(NOT CTEST_PARALLEL_LEVEL)` would define to false even if an environment variable of that name existed then we end up explicitly assigning the environment variable by that name upon invocation with `env`.
2025-01-11 01:16:32 +00:00
set(CTEST_PARALLEL_LEVEL $ENV{CTEST_PARALLEL_LEVEL})
if(NOT CTEST_PARALLEL_LEVEL)
include(ProcessorCount)
ProcessorCount(CORES)
set(CTEST_PARALLEL_LEVEL ${CORES})
endif()
Re-add dynamic CTEST_PARALLEL_LEVEL detection When it is not hard-coded in the environment variable of the same name.
2025-01-09 00:07:16 +00:00
endif()
cmake: Group test targets into tests folder in IDEs This simplifies fish project as shown in IDEs. No change to command line build systems.
2021-09-20 19:51:24 +00:00
# Put in a tests folder to reduce the top level targets in IDEs.
set(CMAKE_FOLDER tests)
Add support for bubbling up skipped tests to cmake This prevents tests that were skipped (e.g. because of a missing REQUIRES) from being reported as successes in the CTest overall run results list.
2021-03-28 18:59:14 +00:00
# We will use 125 as a reserved exit code to indicate that a test has been skipped, i.e. it did not
# pass but it should not be considered a failed test run, either.
set(SKIP_RETURN_CODE 125)
Make `test` a custom target again and add top-level test targets Even though we are using CMake's ctest for testing, we still define our own `make test` target rather than use its default for many reasons: * CMake doesn't run tests in-proc or even add each tests as an individual node in the ninja dependency tree, instead it just bundles all tests into a target called `test` that always just shells out to `ctest`, so there are no build-related benefits to not doing that ourselves. * CMake devs insist that it is appropriate for `make test` to never depend on `make all`, i.e. running `make test` does not require any of the binaries to be built before testing. * The only way to have a test depend on a binary is to add a fake test with a name like "build_fish" that executes CMake recursively to build the `fish` target. * It is not possible to set top-level CTest options/settings such as CTEST_PARALLEL_LEVEL from within the CMake configuration file. * Circling back to the point about individual tests not being actual Makefile targets, CMake does not offer any way to execute a named test via the `make`/`ninja`/whatever interface; the only way to manually invoke test `foo` is to to manually run `ctest` and specify a regex matching `foo` as an argument, e.g. `ctest -R ^foo$`... which is really crazy. With this patch, it is now possible to execute any single test by name, by invoking the build directly, e.g. to run the `universal.fish` check: `cmake --build build --target universal.fish` or `ninja -C build universal.fish`. Unfortunately, this is not integrated into the Makefile wrapper, so `make universal.fish` won't work (although this can potentially be hacked around).
2021-08-08 23:31:50 +00:00
# Even though we are using CMake's ctest for testing, we still define our own `make test` target
# rather than use its default for many reasons:
# * CMake doesn't run tests in-proc or even add each tests as an individual node in the ninja
# dependency tree, instead it just bundles all tests into a target called `test` that always just
# shells out to `ctest`, so there are no build-related benefits to not doing that ourselves.
# * CMake devs insist that it is appropriate for `make test` to never depend on `make all`, i.e.
# running `make test` does not require any of the binaries to be built before testing.
Re-add dynamic CTEST_PARALLEL_LEVEL detection When it is not hard-coded in the environment variable of the same name.
2025-01-09 00:07:16 +00:00
# * It is not possible to set top-level CTest options/settings such as CTEST_PARALLEL_LEVEL from
# within the CMake configuration file.
Make `test` a custom target again and add top-level test targets Even though we are using CMake's ctest for testing, we still define our own `make test` target rather than use its default for many reasons: * CMake doesn't run tests in-proc or even add each tests as an individual node in the ninja dependency tree, instead it just bundles all tests into a target called `test` that always just shells out to `ctest`, so there are no build-related benefits to not doing that ourselves. * CMake devs insist that it is appropriate for `make test` to never depend on `make all`, i.e. running `make test` does not require any of the binaries to be built before testing. * The only way to have a test depend on a binary is to add a fake test with a name like "build_fish" that executes CMake recursively to build the `fish` target. * It is not possible to set top-level CTest options/settings such as CTEST_PARALLEL_LEVEL from within the CMake configuration file. * Circling back to the point about individual tests not being actual Makefile targets, CMake does not offer any way to execute a named test via the `make`/`ninja`/whatever interface; the only way to manually invoke test `foo` is to to manually run `ctest` and specify a regex matching `foo` as an argument, e.g. `ctest -R ^foo$`... which is really crazy. With this patch, it is now possible to execute any single test by name, by invoking the build directly, e.g. to run the `universal.fish` check: `cmake --build build --target universal.fish` or `ninja -C build universal.fish`. Unfortunately, this is not integrated into the Makefile wrapper, so `make universal.fish` won't work (although this can potentially be hacked around).
2021-08-08 23:31:50 +00:00
# * The only way to have a test depend on a binary is to add a fake test with a name like
# "build_fish" that executes CMake recursively to build the `fish` target.
# * Circling back to the point about individual tests not being actual Makefile targets, CMake does
# not offer any way to execute a named test via the `make`/`ninja`/whatever interface; the only
# way to manually invoke test `foo` is to to manually run `ctest` and specify a regex matching
# `foo` as an argument, e.g. `ctest -R ^foo$`... which is really crazy.
Rename the top-level test target to fish_run_tests This keeps 'test' as an alias target. The reason is for compatibility with CMake 3.10 and earlier, where one cannot make a target named 'test'.
2021-11-26 21:07:40 +00:00
# The top-level test target is "fish_run_tests".
add_custom_target(fish_run_tests
Re-add dynamic CTEST_PARALLEL_LEVEL detection When it is not hard-coded in the environment variable of the same name.
2025-01-09 00:07:16 +00:00
COMMAND env CTEST_PARALLEL_LEVEL=${CTEST_PARALLEL_LEVEL} FISH_FORCE_COLOR=1
cmake: Pass the source directory to the tests Our tests typically run in their own environment, which is great for normal tests. However for the coming translation test, we don't want to copy the .po files into the test environment, so it's nice to have a way out.
2021-10-18 15:00:19 +00:00
FISH_SOURCE_DIR=${CMAKE_SOURCE_DIR}
Split test_driver.sh into test_env.sh + test_driver.sh This lets us run non-fish targets (such as `fish_tests`) under a clean test environment without running into the fish-specific payload configuration now carried out by `test_driver.sh` which expects a `.fish` payload that it will run under a deterministically configured instance of fish, running in an environment initialized by `test_env.sh`. This should fix the problem with in-tree builds leaving detritus behind after a `make test` when `fish_tests` would be executed without `test_driver.sh` - it is now executed under `test_env.sh` instead.
2021-09-07 16:33:56 +00:00
${CMAKE_CTEST_COMMAND} --force-new-ctest-process # --verbose
cmake: Use progress output for tests This means instead of printing at least two lines per successful test, we overwrite one line again and again with the current status, and for *failed* (i.e interesting) tests we print the output. Makes test failures much more visible.
2021-08-29 21:03:23 +00:00
--output-on-failure --progress
cmake: Explicitly have tests depend on indent and key_reader
2025-01-12 17:05:50 +00:00
DEPENDS fish fish_indent fish_key_reader fish_test_helper
Make `test` a custom target again and add top-level test targets Even though we are using CMake's ctest for testing, we still define our own `make test` target rather than use its default for many reasons: * CMake doesn't run tests in-proc or even add each tests as an individual node in the ninja dependency tree, instead it just bundles all tests into a target called `test` that always just shells out to `ctest`, so there are no build-related benefits to not doing that ourselves. * CMake devs insist that it is appropriate for `make test` to never depend on `make all`, i.e. running `make test` does not require any of the binaries to be built before testing. * The only way to have a test depend on a binary is to add a fake test with a name like "build_fish" that executes CMake recursively to build the `fish` target. * It is not possible to set top-level CTest options/settings such as CTEST_PARALLEL_LEVEL from within the CMake configuration file. * Circling back to the point about individual tests not being actual Makefile targets, CMake does not offer any way to execute a named test via the `make`/`ninja`/whatever interface; the only way to manually invoke test `foo` is to to manually run `ctest` and specify a regex matching `foo` as an argument, e.g. `ctest -R ^foo$`... which is really crazy. With this patch, it is now possible to execute any single test by name, by invoking the build directly, e.g. to run the `universal.fish` check: `cmake --build build --target universal.fish` or `ninja -C build universal.fish`. Unfortunately, this is not integrated into the Makefile wrapper, so `make universal.fish` won't work (although this can potentially be hacked around).
2021-08-08 23:31:50 +00:00
USES_TERMINAL
)
Rename the top-level test target to fish_run_tests This keeps 'test' as an alias target. The reason is for compatibility with CMake 3.10 and earlier, where one cannot make a target named 'test'.
2021-11-26 21:07:40 +00:00
# If CMP0037 is available, also make an alias "test" target.
# Note that this policy may not be available, in which case definining such a target silently fails.
cmake_policy(PUSH)
if(POLICY CMP0037)
cmake_policy(SET CMP0037 OLD)
add_custom_target(test DEPENDS fish_run_tests)
endif()
Make `test` a custom target again and add top-level test targets Even though we are using CMake's ctest for testing, we still define our own `make test` target rather than use its default for many reasons: * CMake doesn't run tests in-proc or even add each tests as an individual node in the ninja dependency tree, instead it just bundles all tests into a target called `test` that always just shells out to `ctest`, so there are no build-related benefits to not doing that ourselves. * CMake devs insist that it is appropriate for `make test` to never depend on `make all`, i.e. running `make test` does not require any of the binaries to be built before testing. * The only way to have a test depend on a binary is to add a fake test with a name like "build_fish" that executes CMake recursively to build the `fish` target. * It is not possible to set top-level CTest options/settings such as CTEST_PARALLEL_LEVEL from within the CMake configuration file. * Circling back to the point about individual tests not being actual Makefile targets, CMake does not offer any way to execute a named test via the `make`/`ninja`/whatever interface; the only way to manually invoke test `foo` is to to manually run `ctest` and specify a regex matching `foo` as an argument, e.g. `ctest -R ^foo$`... which is really crazy. With this patch, it is now possible to execute any single test by name, by invoking the build directly, e.g. to run the `universal.fish` check: `cmake --build build --target universal.fish` or `ninja -C build universal.fish`. Unfortunately, this is not integrated into the Makefile wrapper, so `make universal.fish` won't work (although this can potentially be hacked around).
2021-08-08 23:31:50 +00:00
cmake_policy(POP)
# CMake being CMake, you can't just add a DEPENDS argument to add_test to make it depend on any of
# your binaries actually being built before `make test` is executed (requiring `make all` first),
Remove fish_tests The remaining tests are all obsolete or already ported.
2024-01-07 11:00:19 +00:00
# and the only dependency a test can have is on another test. So we make building fish
# prerequisites to our entire top-level `test` target.
Prefix all ninja/cmake test target names with test_ `test:foo` is not allowed by CMake ("reserved name") and `test/foo` won't work since CMake doesn't allow targets to have a directory separator in their name.
2021-07-31 00:07:17 +00:00
function(add_test_target NAME)
Let's make src/ easier to grok, move builins to src/builtins + No functional change here, just renames and #include changes. + CMake can't have slashes in the target names. I'm suspciious of that weird machinery for test, but I made it work. + A couple of builtins did not include their own headers, that is no longer the case.
2021-11-10 01:07:15 +00:00
string(REPLACE "/" "-" NAME ${NAME})
add_custom_target("test_${NAME}" COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -R "^${NAME}$$"
cmake: Explicitly have tests depend on indent and key_reader
2025-01-12 17:05:50 +00:00
DEPENDS fish fish_indent fish_key_reader fish_test_helper USES_TERMINAL)
Prefix all ninja/cmake test target names with test_ `test:foo` is not allowed by CMake ("reserved name") and `test/foo` won't work since CMake doesn't allow targets to have a directory separator in their name.
2021-07-31 00:07:17 +00:00
endfunction()
Compile fish_test_helper in CMake again That means we don't have to recompile it for every test
2025-01-12 16:40:46 +00:00
add_executable(fish_test_helper tests/fish_test_helper.c)
Run each test fully independently in own environment
2021-03-15 17:42:53 +00:00
FILE(GLOB FISH_CHECKS CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/tests/checks/*.fish)
foreach(CHECK ${FISH_CHECKS})
get_filename_component(CHECK_NAME ${CHECK} NAME)
get_filename_component(CHECK ${CHECK} NAME_WE)
add_test(NAME ${CHECK_NAME}
cmake: Stop setting up temporary test directory We already set up a temporary directory for each test in the test_driver, so let's stop doing that here. It took a weirdly long time anyway.
2025-01-12 16:44:31 +00:00
COMMAND ${CMAKE_SOURCE_DIR}/tests/test_driver.py --cachedir=${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}
Rewrite test driver in python (#11028) This replaces the test_driver.sh/test.fish/interactive.fish system with a test driver written in python that calls into littlecheck directly and runs pexpect in a subprocess. This means we reduce the reliance on the fish that we're testing, and we remove a posix sh script that is a weird stumbling block (see my recent quest to make it work on directories with spaces). To run specific tests, e.g. all the tmux tests and bind.py: tests/test_driver.py target/release/ tests/checks/tmux*.fish tests/pexpects/bind.py
2025-01-11 20:13:19 +00:00
checks/${CHECK}.fish
cmake: Stop setting up temporary test directory We already set up a temporary directory for each test in the test_driver, so let's stop doing that here. It took a weirdly long time anyway.
2025-01-12 16:44:31 +00:00
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests
Run each test fully independently in own environment
2021-03-15 17:42:53 +00:00
)
Add support for bubbling up skipped tests to cmake This prevents tests that were skipped (e.g. because of a missing REQUIRES) from being reported as successes in the CTest overall run results list.
2021-03-28 18:59:14 +00:00
set_tests_properties(${CHECK_NAME} PROPERTIES SKIP_RETURN_CODE ${SKIP_RETURN_CODE})
Mark FISH_FORCE_COLOR in individual test targets This allows running individual tests to produce colorized output. No need to relnote this.
2022-04-10 20:40:51 +00:00
set_tests_properties(${CHECK_NAME} PROPERTIES ENVIRONMENT FISH_FORCE_COLOR=1)
Make `test` a custom target again and add top-level test targets Even though we are using CMake's ctest for testing, we still define our own `make test` target rather than use its default for many reasons: * CMake doesn't run tests in-proc or even add each tests as an individual node in the ninja dependency tree, instead it just bundles all tests into a target called `test` that always just shells out to `ctest`, so there are no build-related benefits to not doing that ourselves. * CMake devs insist that it is appropriate for `make test` to never depend on `make all`, i.e. running `make test` does not require any of the binaries to be built before testing. * The only way to have a test depend on a binary is to add a fake test with a name like "build_fish" that executes CMake recursively to build the `fish` target. * It is not possible to set top-level CTest options/settings such as CTEST_PARALLEL_LEVEL from within the CMake configuration file. * Circling back to the point about individual tests not being actual Makefile targets, CMake does not offer any way to execute a named test via the `make`/`ninja`/whatever interface; the only way to manually invoke test `foo` is to to manually run `ctest` and specify a regex matching `foo` as an argument, e.g. `ctest -R ^foo$`... which is really crazy. With this patch, it is now possible to execute any single test by name, by invoking the build directly, e.g. to run the `universal.fish` check: `cmake --build build --target universal.fish` or `ninja -C build universal.fish`. Unfortunately, this is not integrated into the Makefile wrapper, so `make universal.fish` won't work (although this can potentially be hacked around).
2021-08-08 23:31:50 +00:00
add_test_target("${CHECK_NAME}")
Run each test fully independently in own environment
2021-03-15 17:42:53 +00:00
endforeach(CHECK)
Add pexpect tests to new test driver
2021-03-18 18:23:31 +00:00
FILE(GLOB PEXPECTS CONFIGURE_DEPENDS ${CMAKE_SOURCE_DIR}/tests/pexpects/*.py)
foreach(PEXPECT ${PEXPECTS})
get_filename_component(PEXPECT ${PEXPECT} NAME)
add_test(NAME ${PEXPECT}
cmake: Stop setting up temporary test directory We already set up a temporary directory for each test in the test_driver, so let's stop doing that here. It took a weirdly long time anyway.
2025-01-12 16:44:31 +00:00
COMMAND ${CMAKE_SOURCE_DIR}/tests/test_driver.py --cachedir=${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}
Rewrite test driver in python (#11028) This replaces the test_driver.sh/test.fish/interactive.fish system with a test driver written in python that calls into littlecheck directly and runs pexpect in a subprocess. This means we reduce the reliance on the fish that we're testing, and we remove a posix sh script that is a weird stumbling block (see my recent quest to make it work on directories with spaces). To run specific tests, e.g. all the tmux tests and bind.py: tests/test_driver.py target/release/ tests/checks/tmux*.fish tests/pexpects/bind.py
2025-01-11 20:13:19 +00:00
pexpects/${PEXPECT}
cmake: Stop setting up temporary test directory We already set up a temporary directory for each test in the test_driver, so let's stop doing that here. It took a weirdly long time anyway.
2025-01-12 16:44:31 +00:00
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/tests
Add pexpect tests to new test driver
2021-03-18 18:23:31 +00:00
)
Add support for bubbling up skipped tests to cmake This prevents tests that were skipped (e.g. because of a missing REQUIRES) from being reported as successes in the CTest overall run results list.
2021-03-28 18:59:14 +00:00
set_tests_properties(${PEXPECT} PROPERTIES SKIP_RETURN_CODE ${SKIP_RETURN_CODE})
Mark FISH_FORCE_COLOR in individual test targets This allows running individual tests to produce colorized output. No need to relnote this.
2022-04-10 20:40:51 +00:00
set_tests_properties(${PEXPECT} PROPERTIES ENVIRONMENT FISH_FORCE_COLOR=1)
Add pexpect tests to new test driver
2021-03-18 18:23:31 +00:00
add_test_target("${PEXPECT}")
endforeach(PEXPECT)
Initial Rust commit
2023-01-14 22:56:24 +00:00
Enable doctests They are probably not terribly useful for us but let's see what happens. Unfortunately cargo does not properly forward the combination of "RUSTFLAGS" and "--target" that is currently required to build with ASan [1]. Hence doctests will fail to link on ASan builds. Let's disable doctests when ASan is active. [1]: https://github.com/rust-lang/cargo/issues/10666 et al
2024-01-13 00:26:28 +00:00
set(cargo_test_flags)
Initial Rust commit
2023-01-14 22:56:24 +00:00
# Rust stuff.
Enable rust address sanitizer for asan ci job (#9643) Rust has multiple sanitizers available (with llvm integration). -Zsanitizer=address catches the most likely culprits but we may want to set up a separate job w/ -Zsanitizer=memory to catch uninitialized reads. It might be necessary to execute `cargo build` as `cargo build -Zbuild-std` to get full coverage. When we're linking against the hybrid C++ codebase, the sanitizer library is injected into the binary by also include `-fsanitize=address` in CXXFLAGS - we do *not* want to manually opt-into `-lasan`. We also need to manually specify the desired target triple as a CMake variable and then explicitly pass it to all `cargo` invocations if building with ASAN. Corrosion has been patched to make sure it follows these rules. The `cargo-test` target is failing to link under ASAN. For some reason it has autocxx/ffi dependencies even though only rust-native, ffi-free code should be tested (and one would think the situation wouldn't change depending on the presence of the sanitizer flag). It's been disabled under ASAN for now.
2023-03-07 00:15:36 +00:00
if(DEFINED ASAN)
# Rust w/ -Zsanitizer=address requires explicitly specifying the --target triple or else linker
# errors pertaining to asan symbols will ensue.
if(NOT DEFINED Rust_CARGO_TARGET)
message(FATAL_ERROR "ASAN requires defining the CMake variable Rust_CARGO_TARGET to the
intended target triple")
endif()
Always pass `--target` to `cargo test` when CMake Rust_CARGO_TARGET is set The CMake `cargo test` integration was broken if Rust_CARGO_TARGET were used with `CARGO_FLAGS` set to `-Zbuild-std` (e.g. to target i586 under i686 without the i586 toolchain installed).
2024-06-21 16:56:50 +00:00
endif()
Update docker files and cirrus config - Ubuntu focal is the lowest LTS release that we can support with only distro packages (e.g. no rustup). - Remove tsan from Cirrus (it's not working currently, and also not really important). - Remove Centos (it passes tests but I'm not sure it's worth adding; there isn't even an official docker image for CentOS Stream).
2024-08-04 08:18:06 +00:00
if(DEFINED TSAN)
if(NOT DEFINED Rust_CARGO_TARGET)
message(FATAL_ERROR "TSAN requires defining the CMake variable Rust_CARGO_TARGET to the
intended target triple")
endif()
endif()
Always pass `--target` to `cargo test` when CMake Rust_CARGO_TARGET is set The CMake `cargo test` integration was broken if Rust_CARGO_TARGET were used with `CARGO_FLAGS` set to `-Zbuild-std` (e.g. to target i586 under i686 without the i586 toolchain installed).
2024-06-21 16:56:50 +00:00
if(DEFINED Rust_CARGO_TARGET)
Enable doctests They are probably not terribly useful for us but let's see what happens. Unfortunately cargo does not properly forward the combination of "RUSTFLAGS" and "--target" that is currently required to build with ASan [1]. Hence doctests will fail to link on ASan builds. Let's disable doctests when ASan is active. [1]: https://github.com/rust-lang/cargo/issues/10666 et al
2024-01-13 00:26:28 +00:00
list(APPEND cargo_test_flags "--target" ${Rust_CARGO_TARGET})
list(APPEND cargo_test_flags "--lib")
Enable rust address sanitizer for asan ci job (#9643) Rust has multiple sanitizers available (with llvm integration). -Zsanitizer=address catches the most likely culprits but we may want to set up a separate job w/ -Zsanitizer=memory to catch uninitialized reads. It might be necessary to execute `cargo build` as `cargo build -Zbuild-std` to get full coverage. When we're linking against the hybrid C++ codebase, the sanitizer library is injected into the binary by also include `-fsanitize=address` in CXXFLAGS - we do *not* want to manually opt-into `-lasan`. We also need to manually specify the desired target triple as a CMake variable and then explicitly pass it to all `cargo` invocations if building with ASAN. Corrosion has been patched to make sure it follows these rules. The `cargo-test` target is failing to link under ASAN. For some reason it has autocxx/ffi dependencies even though only rust-native, ffi-free code should be tested (and one would think the situation wouldn't change depending on the presence of the sanitizer flag). It's been disabled under ASAN for now.
2023-03-07 00:15:36 +00:00
endif()
CMake: re-enable cargo-test under ASAN With autocxx/cxx gone, this seems to work fine now.
2024-01-07 20:38:49 +00:00
add_test(
NAME "cargo-test"
Disable default features for `cargo test` Unfortunately it does not appear like #[cfg(test)] works for build.rs? Investigating a better solution, but this is a good idea anyway (or `make test` would generate man pages via build.rs!)
2024-12-11 16:04:44 +00:00
COMMAND env ${VARS_FOR_CARGO} cargo test --no-default-features ${CARGO_FLAGS} --workspace --target-dir ${rust_target_dir} ${cargo_test_flags}
CMake: re-enable cargo-test under ASAN With autocxx/cxx gone, this seems to work fine now.
2024-01-07 20:38:49 +00:00
WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}"
)
set_tests_properties("cargo-test" PROPERTIES SKIP_RETURN_CODE ${SKIP_RETURN_CODE})
add_test_target("cargo-test")
Reference in a new issue Copy permalink