maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/libcxx/test/CMakeLists.txt

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

182 lines
6.4 KiB
CMake
Raw Normal View History

Add CMake build and fix major Linux blockers. llvm-svn: 121510
2010-12-11 03:47:54 +08:00
macro(pythonize_bool var)
if (${var})
set(${var} True)
else()
set(${var} False)
endif()
endmacro()
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
set(LIBCXX_LIT_VARIANT "libcxx" CACHE STRING
"Configuration variant to use for LIT.")
Allow passing additional compiler/linker flags for the tests Summary: These flags can be specified using the CMake variables LIBCXX_TEST_LINKER_FLAGS and LIBCXX_TEST_COMPILER_FLAGS. When building the tests for CHERI I need to pass additional flags (such as -mabi=n64 or -mabi=purecap) to the compiler for our test configurations Reviewers: EricWF Reviewed By: EricWF Subscribers: christof, mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D42139 llvm-svn: 325914
2018-02-23 23:19:48 +08:00
set(LIBCXX_TEST_LINKER_FLAGS "" CACHE STRING
"Additonal linker flags to pass when compiling the tests")
set(LIBCXX_TEST_COMPILER_FLAGS "" CACHE STRING
"Additonal linker flags to pass when compiling the tests")
Fix linker script generation for in-tree builds llvm-svn: 283700
2016-10-10 05:34:03 +08:00
# The tests shouldn't link to any ABI library when it has been linked into
# libc++ statically or via a linker script.
if (LIBCXX_ENABLE_STATIC_ABI_LIBRARY OR LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
set(LIBCXX_CXX_ABI_LIBNAME "none")
endif()
# The tests shouldn't link to libunwind if we have a linker script which
# already does so.
if (LIBCXX_ENABLE_ABI_LINKER_SCRIPT)
set(LIBCXXABI_USE_LLVM_UNWINDER OFF)
endif()
[libc++] Switch a few CI jobs to the minimal Lit configuration Eventually, this should become the default way of running the tests. For now, only move a few CI nodes to it, and keep a node that runs the legacy configuration. Differential Revision: https://reviews.llvm.org/D97565
2021-02-27 02:18:21 +08:00
# TODO: Clients using those options should switch to from-scratch Lit configuration files.
[libcxx] Allow tests to link with static libc++abi/libc++ even if the shared version is present Summary: This is essentially D71894, but for libc++. This is needed for running libc++ tests over SSH. Reviewers: EricWF, ldionne, phosek, mehdi_amini, mclow.lists, jroelofs, bcraig, #libc Reviewed By: ldionne, phosek, #libc Subscribers: mgorny, christof, dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D72687
2020-03-25 20:27:05 +08:00
option(LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXXABI
"Whether the libc++ tests should link with the shared libc++abi library"
${LIBCXXABI_ENABLE_SHARED})
option(LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXX
"Whether the libc++ tests should link with the shared libc++ library"
${LIBCXX_ENABLE_SHARED})
if(DEFINED LIBCXXABI_ENABLE_SHARED
AND LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXXABI
AND NOT LIBCXXABI_ENABLE_SHARED)
message(FATAL_ERROR "LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXXABI being ON requires LIBCXXABI_ENABLE_SHARED to be ON")
endif()
if(DEFINED LIBCXXABI_ENABLE_STATIC
AND NOT LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXXABI
AND NOT LIBCXXABI_ENABLE_STATIC)
message(FATAL_ERROR "LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXXABI being OFF requires LIBCXXABI_ENABLE_STATIC to be ON")
endif()
[libc++] Fix CMake configuration breakage when libc++ is built neither static nor dynamic Introduced by https://reviews.llvm.org/D72687. This condition can happen when the tests are not being run at all, and we're only trying to generate the libc++ headers.
2020-03-26 04:50:19 +08:00
if(LIBCXX_INCLUDE_TESTS AND LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXX AND NOT LIBCXX_ENABLE_SHARED)
[libcxx] Allow tests to link with static libc++abi/libc++ even if the shared version is present Summary: This is essentially D71894, but for libc++. This is needed for running libc++ tests over SSH. Reviewers: EricWF, ldionne, phosek, mehdi_amini, mclow.lists, jroelofs, bcraig, #libc Reviewed By: ldionne, phosek, #libc Subscribers: mgorny, christof, dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D72687
2020-03-25 20:27:05 +08:00
message(FATAL_ERROR "LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXX being ON requires LIBCXX_ENABLE_SHARED to be ON")
endif()
[libc++] Fix CMake configuration breakage when libc++ is built neither static nor dynamic Introduced by https://reviews.llvm.org/D72687. This condition can happen when the tests are not being run at all, and we're only trying to generate the libc++ headers.
2020-03-26 04:50:19 +08:00
if(LIBCXX_INCLUDE_TESTS AND NOT LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXX AND NOT LIBCXX_ENABLE_STATIC)
[libcxx] Allow tests to link with static libc++abi/libc++ even if the shared version is present Summary: This is essentially D71894, but for libc++. This is needed for running libc++ tests over SSH. Reviewers: EricWF, ldionne, phosek, mehdi_amini, mclow.lists, jroelofs, bcraig, #libc Reviewed By: ldionne, phosek, #libc Subscribers: mgorny, christof, dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D72687
2020-03-25 20:27:05 +08:00
message(FATAL_ERROR "LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXX being OFF requires LIBCXX_ENABLE_STATIC to be ON")
endif()
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
pythonize_bool(LIBCXX_ENABLE_SHARED)
[libcxx] Allow tests to link with static libc++abi/libc++ even if the shared version is present Summary: This is essentially D71894, but for libc++. This is needed for running libc++ tests over SSH. Reviewers: EricWF, ldionne, phosek, mehdi_amini, mclow.lists, jroelofs, bcraig, #libc Reviewed By: ldionne, phosek, #libc Subscribers: mgorny, christof, dexonsmith, libcxx-commits Tags: #libc Differential Revision: https://reviews.llvm.org/D72687
2020-03-25 20:27:05 +08:00
pythonize_bool(LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXX)
pythonize_bool(LIBCXX_LINK_TESTS_WITH_SHARED_LIBCXXABI)
Allow disabling of filesystem library. Summary: Filesystem doesn't work on Windows, so we need a mechanism to turn it off for the time being. Reviewers: ldionne, serge-sans-paille, EricWF Reviewed By: EricWF Subscribers: mstorsjo, mgorny, christof, jdoerfert, libcxx-commits Differential Revision: https://reviews.llvm.org/D59619 llvm-svn: 356633
2019-03-21 08:04:31 +08:00
pythonize_bool(LIBCXX_ENABLE_FILESYSTEM)
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
pythonize_bool(LIBCXX_BUILD_32_BITS)
pythonize_bool(LIBCXX_GENERATE_COVERAGE)
Framework to allow testing of static libc++abi These changes make linking against static libraries more explicit. Instead of using -lc++ and -lc++abi in the tests, an absolute path to the library is provided instead. The choices of shared vs. static, and the choices of library paths for both libcxx and libcxxabi needed to be exchanged for this to work. In other words, libcxx tests need to know the library path of libcxxabi, and whether libcxxabi is a static or shared library. Some Mac specific logic for testing against libc++abi had to be moved from libcxxabi's config.py, as it was overriding choices made in libcxx's config.py. That logic is now in libcxx's target_info.py. Testing a static libcxx on Linux will now automatically link in librt most of the time. Previously, lots of pthread tests would fail because of an unresolved clock_gettime. http://reviews.llvm.org/D16544 llvm-svn: 266730
2016-04-19 20:49:05 +08:00
pythonize_bool(LIBCXXABI_ENABLE_SHARED)
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
pythonize_bool(LIBCXXABI_USE_LLVM_UNWINDER)
[libcxx] Support the use of compiler-rt in lit tests Don't link tests against libgcc when compiler-rt is being used. Differential Revision: https://reviews.llvm.org/D40513 llvm-svn: 322044
2018-01-09 07:36:53 +08:00
pythonize_bool(LIBCXX_USE_COMPILER_RT)
Re-commit "Introduce a cmake module to figure out whether we need to link with libatomic." This re-applies commit r260235. However, this time we add -gcc-toolchain to the compiler's flags when the user has specified the LIBCXX_GCC_TOOLCHAIN variable. llvm-svn: 260515
2016-02-11 20:43:04 +08:00
pythonize_bool(LIBCXX_HAS_ATOMIC_LIB)
Rework libatomic handling in CMake and LIT. This patch updates the way libc++ handles checking for libatomic, in part to prepare for https://reviews.llvm.org/D22073. Changes: * 'LIBCXX_HAS_ATOMIC_LIB' is now set whenever libatomic is available even libc++ doesn't need to manually link it. * 'LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB' is now used to detect when libatomic needs to be manually linked. * 'LIBCXX_HAS_ATOMIC_LIB' now adds 'libatomic' as a available feature in the test suite. llvm-svn: 275759
2016-07-18 14:01:50 +08:00
pythonize_bool(LIBCXX_HAVE_CXX_ATOMICS_WITH_LIB)
[libc++] Cleanup and document <__threading_support> Summary: This patch attempts to clean up the macro configuration mess in `<__threading_support>`, specifically the mess involving external threading variants. Additionally this patch adds design documentation for `<__threading_support>` and the configuration macros it uses. The primary change in this patch is separating the idea of an "external API" provided by `<__external_threading>` and the idea of having an external threading library. Now `_LIBCPP_HAS_THREAD_API_EXTERNAL` means that libc++ should use `<__external_threading>` and that the header is expected to exist. Additionally the new macro `_LIBCPP_HAS_THREAD_LIBRARY_EXTERNAL` is now used to configure for using an "external library" with the default threading API. Reviewers: compnerd, rmaprath Subscribers: smeenai, cfe-commits, mgorny Differential Revision: https://reviews.llvm.org/D28316 llvm-svn: 291275
2017-01-07 04:05:40 +08:00
pythonize_bool(LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY)
[libc++][CMake] Use debug MSVC runtimes when libc++ is built in debug mode Summary: This patch allows libc++ to be built against the debug MSVC runtimes instead of just the release ones. Reviewers: rnk, majnemer, compnerd, smeenai Subscribers: mgorny, cfe-commits Differential Revision: https://reviews.llvm.org/D28725 llvm-svn: 292006
2017-01-14 15:54:39 +08:00
pythonize_bool(LIBCXX_DEBUG_BUILD)
[libc++] Take 2: Integrate the PSTL into libc++ Summary: This commit allows specifying LIBCXX_ENABLE_PARALLEL_ALGORITHMS when configuring libc++ in CMake. When that option is enabled, libc++ will assume that the PSTL can be found somewhere on the CMake module path, and it will provide the C++17 parallel algorithms based on the PSTL (that is assumed to be available). The commit also adds support for running the PSTL tests as part of the libc++ test suite. The first attempt to commit this failed because it exposed a bug in the tests for modules. Now that this has been fixed, it should be safe to commit this. Reviewers: EricWF Subscribers: mgorny, christof, jkorous, dexonsmith, libcxx-commits, mclow.lists, EricWF Tags: #libc Differential Revision: https://reviews.llvm.org/D60480 llvm-svn: 367903
2019-08-06 02:29:14 +08:00
pythonize_bool(LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
Framework to allow testing of static libc++abi These changes make linking against static libraries more explicit. Instead of using -lc++ and -lc++abi in the tests, an absolute path to the library is provided instead. The choices of shared vs. static, and the choices of library paths for both libcxx and libcxxabi needed to be exchanged for this to work. In other words, libcxx tests need to know the library path of libcxxabi, and whether libcxxabi is a static or shared library. Some Mac specific logic for testing against libc++abi had to be moved from libcxxabi's config.py, as it was overriding choices made in libcxx's config.py. That logic is now in libcxx's target_info.py. Testing a static libcxx on Linux will now automatically link in librt most of the time. Previously, lots of pthread tests would fail because of an unresolved clock_gettime. http://reviews.llvm.org/D16544 llvm-svn: 266730
2016-04-19 20:49:05 +08:00
# By default, for non-standalone builds, libcxx and libcxxabi share a library
# directory.
if (NOT LIBCXX_CXX_ABI_LIBRARY_PATH)
set(LIBCXX_CXX_ABI_LIBRARY_PATH "${LIBCXX_LIBRARY_DIR}" CACHE PATH
Revert "[libcxx] Force-cache LIBCXX_CXX_ABI_LIBRARY_PATH" This reverts commit 41f4dfd63ea0fe995ddfba1838aa5ed972cc1377. It broke standalone libc++ builds, which now try to use libc++abi from the wrong directory, instead of system instance. (cherry picked from commit 3573526c0286c9461f0459be1a4592b2214594e7)
2020-01-31 19:35:43 +08:00
"The path to libc++abi library.")
Framework to allow testing of static libc++abi These changes make linking against static libraries more explicit. Instead of using -lc++ and -lc++abi in the tests, an absolute path to the library is provided instead. The choices of shared vs. static, and the choices of library paths for both libcxx and libcxxabi needed to be exchanged for this to work. In other words, libcxx tests need to know the library path of libcxxabi, and whether libcxxabi is a static or shared library. Some Mac specific logic for testing against libc++abi had to be moved from libcxxabi's config.py, as it was overriding choices made in libcxx's config.py. That logic is now in libcxx's target_info.py. Testing a static libcxx on Linux will now automatically link in librt most of the time. Previously, lots of pthread tests would fail because of an unresolved clock_gettime. http://reviews.llvm.org/D16544 llvm-svn: 266730
2016-04-19 20:49:05 +08:00
endif()
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
set(LIBCXX_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
"TargetInfo to use when setting up test environment.")
[libcxx] [test] Quote the path to the python interpreter This should allow running tests with the interpreter in some of the default paths where Python for Windows might be installed. Differential Revision: https://reviews.llvm.org/D97369
2021-02-24 18:18:48 +08:00
set(LIBCXX_EXECUTOR "\\\"${Python3_EXECUTABLE}\\\" ${CMAKE_CURRENT_LIST_DIR}/../utils/run.py" CACHE STRING
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
"Executor to use when running tests.")
set(AUTO_GEN_COMMENT "## Autogenerated by libcxx configuration.\n# Do not edit!")
[libc++] Serialize Lit parameters to make them available to from-scratch configs Before this patch, Lit parameters that were set as a result of CMake options were not made available to from-scratch configs. This patch serializes those parameters into the generated lit config file so that they are available to all configs. Differential Revision: https://reviews.llvm.org/D105047
2021-06-02 05:16:11 +08:00
set(SERIALIZED_LIT_PARAMS "# Lit parameters serialized here for llvm-lit to pick them up\n")
macro(serialize_lit_param param value)
string(APPEND SERIALIZED_LIT_PARAMS "config.${param} = ${value}\n")
endmacro()
if (NOT LIBCXX_ENABLE_EXCEPTIONS)
serialize_lit_param(enable_exceptions False)
endif()
if (NOT LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY)
serialize_lit_param(enable_experimental False)
endif()
if (NOT LIBCXX_ENABLE_RTTI)
serialize_lit_param(enable_rtti False)
endif()
if (NOT LIBCXX_ENABLE_DEBUG_MODE_SUPPORT)
serialize_lit_param(enable_debug_tests False)
endif()
[runtimes] Simplify how we set the target triple Instead of using TARGET_TRIPLE, which is always set to LLVM_DEFAULT_TARGET_TRIPLE, use that variable directly to populate the various XXXX_TARGET_TRIPLE variables in the runtimes. This re-applies 77396bbc98 and 5099e01568, which were reverted in 850b57c5fbe because they broke the build. Differential Revision: https://reviews.llvm.org/D106009
2021-07-15 03:54:13 +08:00
if (LIBCXX_TARGET_TRIPLE)
serialize_lit_param(target_triple "\"${LIBCXX_TARGET_TRIPLE}\"")
[libc++] Serialize Lit parameters to make them available to from-scratch configs Before this patch, Lit parameters that were set as a result of CMake options were not made available to from-scratch configs. This patch serializes those parameters into the generated lit config file so that they are available to all configs. Differential Revision: https://reviews.llvm.org/D105047
2021-06-02 05:16:11 +08:00
endif()
if (LLVM_USE_SANITIZER)
serialize_lit_param(use_sanitizer "\"${LLVM_USE_SANITIZER}\"")
endif()
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
[runtimes] Move enable_32bit to the DSL This is necessary for from-scratch configurations to support the 32-bit mode of the test suite. Differential Revision: https://reviews.llvm.org/D105435
2021-07-06 00:27:14 +08:00
if (LIBCXX_BUILD_32_BITS)
serialize_lit_param(enable_32bit True)
endif()
[runtimes] Serialize all Lit params instead of passing them to add_lit_testsuite add_lit_testsuite() takes Lit parameters passed to it and adds them to the parameters used globally when running all test suites. That means that a target like `check-all`, which ends up calling Lit on the whole monorepo, will see the test parameters for all the individual project's test suites. So, for example, it would see `--param std=c++03` (from libc++abi), and `--param std=c++03` (from libc++), and `--param whatever` (from another project being tested at the same time). While always unclean, that works when the parameters all agree. However, if the parameters share the same name but have different values, only one of those two values will be used and it will be incredibly confusing to understand why one of the test suites is being run with the incorrect parameter value. For that reason, this commit moves away from using add_lit_testsuite()'s PARAM functionality, and serializes the parameter values for the runtimes in the generated config.py file instead, which is local to the specific test suite. Differential Revision: https://reviews.llvm.org/D105991
2021-07-14 23:36:22 +08:00
foreach(param IN LISTS LIBCXX_TEST_PARAMS)
string(REGEX REPLACE "(.+)=(.+)" "\\1" name "${param}")
string(REGEX REPLACE "(.+)=(.+)" "\\2" value "${param}")
serialize_lit_param("${name}" "\"${value}\"")
endforeach()
Rename cxx-benchmark-unittests target and convert to LIT. This patch renames the cxx-benchmark-unittests to check-cxx-benchmarks and converts the target to use LIT in order to make the tests run faster and provide better output. In particular this runs each benchmark in a suite one by one, allowing more parallelism while ensuring output isn't garbage with multiple threads. Additionally, it adds the CMake flag '-DLIBCXX_BENCHMARK_TEST_ARGS=<list>' to specify what options are passed when running the benchmarks. llvm-svn: 346888
2018-11-15 04:38:46 +08:00
if (NOT DEFINED LIBCXX_TEST_DEPS)
message(FATAL_ERROR "Expected LIBCXX_TEST_DEPS to be defined")
[libcxx] Introduce an externally-threaded libc++ variant. This patch further decouples libc++ from pthread, allowing libc++ to be built against other threading systems. There are two main use cases: - Building libc++ against a thread library other than pthreads. - Building libc++ with an "external" thread API, allowing a separate library to provide the implementation of that API. The two use cases are quite similar, the second one being sligtly more de-coupled than the first. The cmake option LIBCXX_HAS_EXTERNAL_THREAD_API enables both kinds of builds. One needs to place an <__external_threading> header file containing an implementation of the "libc++ thread API" declared in the <__threading_support> header. For the second use case, the implementation of the libc++ thread API can delegate to a custom "external" thread API where the implementation of this external API is provided in a seperate library. This mechanism allows toolchain vendors to distribute a build of libc++ with a custom thread-porting-layer API (which is the "external" API above), platform vendors (recipients of the toolchain/libc++) are then required to provide their implementation of this API to be linked with (end-user) C++ programs. Note that the second use case still requires establishing the basic types that get passed between the external thread library and the libc++ library (e.g. __libcpp_mutex_t). These cannot be opaque pointer types (libc++ sources won't compile otherwise). It should also be noted that the second use case can have a slight performance penalty; as all the thread constructs need to cross a library boundary through an additional function call. When the header <__external_threading> is omitted, libc++ is built with the "libc++ thread API" (declared in <__threading_support>) as the "external" thread API (basic types are pthread based). An implementation (pthread based) of this API is provided in test/support/external_threads.cpp, which is built into a separate DSO and linked in when running the libc++ test suite. A test run therefore demonstrates the second use case (less the intermediate custom API). Differential revision: https://reviews.llvm.org/D21968 Reviewers: bcraig, compnerd, EricWF, mclow.lists llvm-svn: 281179
2016-09-12 05:46:40 +08:00
endif()
Generate the test configuration even when LIBCXX_INCLUDE_TESTS=OFF. This patch changes the CMake configuration so that it always generates the test/lit.site.cfg file, even when testing is disabled. This allows users to test libc++ without requiring them to have a full LLVM checkout on their machine. llvm-svn: 296685
2017-03-02 05:53:30 +08:00
if (LIBCXX_INCLUDE_TESTS)
[libc++] NFC: Fix incorrect comments in CMake
2021-07-07 21:45:26 +08:00
include(AddLLVM) # for configure_lit_site_cfg and add_lit_testsuite
Include AddLLVM needed for tests in the right context AddLLVM is needed for several functions that are used in tests and as such needs to be included from the right context which previously wasn't the case. Differential Revision: https://reviews.llvm.org/D40280 llvm-svn: 319515
2017-12-01 11:16:50 +08:00
configure_lit_site_cfg(
[libc++] Allow specifying custom Lit config files Before this patch, the libc++ test suite first loads lit.site.cfg (generated by CMake), and then lit.cfg. It's also possible to load lit.cfg before lit.site.cfg and to point to a custom lit.site.cfg file using '--param=libcxx_site_config'. However, in that case, lit.cfg still relies on the site configuration filling up the 'config' object like the default lit.site.cfg file does, which isn't flexible enough. This commit simplifies the setup by having just a single Lit site config file per CMake configuration, and always loading exactly that config file. However, the config file to use can be selected when setting up CMake via the LIBCXX_TEST_CONFIG setting. Furthermore, the site configs are entirely standalone, which means that a new site config can be added that doesn't need to conform what's expected by config.py. Differential Revision: https://reviews.llvm.org/D81846
2020-06-13 03:19:55 +08:00
"${LIBCXX_TEST_CONFIG}"
${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg
MAIN_CONFIG "${CMAKE_CURRENT_SOURCE_DIR}/lit.cfg.py")
Include AddLLVM needed for tests in the right context AddLLVM is needed for several functions that are used in tests and as such needs to be included from the right context which previously wasn't the case. Differential Revision: https://reviews.llvm.org/D40280 llvm-svn: 319515
2017-12-01 11:16:50 +08:00
[libc++] Rename check-cxx-deps to cxx-test-depends for consistency Several subprojects have targets that do the same thing, and they all follow the same naming convention: llvm-test-depends, clang-test-depends, lld-test-depends, etc. This makes libc++ consistent with other LLVM projects. Thanks to Duncan Exon Smith for noticing and suggesting the change. Differential Revision: https://reviews.llvm.org/D94499
2021-01-12 23:56:57 +08:00
add_custom_target(cxx-test-depends
[libc++] Add a new target check-cxx-deps to build dependencies of the test suite When running the tests through `lit` directly instead of through `check-cxx`, it is required to manually build the `cxx` (and often `cxx_experimental`) targets. Instead of having to do that manually, this commit adds a new target `check-cxx-deps` that does that for you.
2020-04-16 03:05:14 +08:00
DEPENDS cxx ${LIBCXX_TEST_DEPS}
COMMENT "Builds dependencies required to run the test suite.")
[libc++] Use add_lit_testsuite to register the libc++ test suite The Runtimes build uses variables set by add_lit_testsuite to discover tests suites to run. Differential Revision: https://reviews.llvm.org/D97913
2021-03-25 04:45:55 +08:00
add_lit_testsuite(check-cxx
Generate the test configuration even when LIBCXX_INCLUDE_TESTS=OFF. This patch changes the CMake configuration so that it always generates the test/lit.site.cfg file, even when testing is disabled. This allows users to test libc++ without requiring them to have a full LLVM checkout on their machine. llvm-svn: 296685
2017-03-02 05:53:30 +08:00
"Running libcxx tests"
${CMAKE_CURRENT_BINARY_DIR}
[runtimes] Serialize all Lit params instead of passing them to add_lit_testsuite add_lit_testsuite() takes Lit parameters passed to it and adds them to the parameters used globally when running all test suites. That means that a target like `check-all`, which ends up calling Lit on the whole monorepo, will see the test parameters for all the individual project's test suites. So, for example, it would see `--param std=c++03` (from libc++abi), and `--param std=c++03` (from libc++), and `--param whatever` (from another project being tested at the same time). While always unclean, that works when the parameters all agree. However, if the parameters share the same name but have different values, only one of those two values will be used and it will be incredibly confusing to understand why one of the test suites is being run with the incorrect parameter value. For that reason, this commit moves away from using add_lit_testsuite()'s PARAM functionality, and serializes the parameter values for the runtimes in the generated config.py file instead, which is local to the specific test suite. Differential Revision: https://reviews.llvm.org/D105991
2021-07-14 23:36:22 +08:00
DEPENDS cxx-test-depends)
Generate the test configuration even when LIBCXX_INCLUDE_TESTS=OFF. This patch changes the CMake configuration so that it always generates the test/lit.site.cfg file, even when testing is disabled. This allows users to test libc++ without requiring them to have a full LLVM checkout on their machine. llvm-svn: 296685
2017-03-02 05:53:30 +08:00
endif()
[CMake] Be more consistent about naming targets and components Summary: The point of this patch is to have a consistent convention for naming build, check and install targets so that the targets can be constructed from the project name. This change renames a bunch of CMake components and targets from libcxx to cxx. For each renamed target I've added a convenience target that matches the old target name and depends on the new target. This will preserve function of the old targets so that the change doesn't break the world. We can evaluate if it is worth removing the extra targets later. Reviewers: EricWF Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D23699 llvm-svn: 279675
2016-08-25 06:17:06 +08:00
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
if (LIBCXX_GENERATE_COVERAGE)
include(CodeCoverage)
set(output_dir "${CMAKE_CURRENT_BINARY_DIR}/coverage")
fix test coverage capture dirs llvm-svn: 297555
2017-03-11 13:28:09 +08:00
set(capture_dirs
"${LIBCXX_LIB_CMAKEFILES_DIR}/cxx_objects.dir/"
"${LIBCXX_LIB_CMAKEFILES_DIR}/cxx.dir/"
"${LIBCXX_LIB_CMAKEFILES_DIR}/cxx_experimental.dir/"
"${CMAKE_CURRENT_BINARY_DIR}")
Reapply working parts of CMake cleanup. This patch adds the working parts of r243503. The difference with this patch is that it doesn't include the HandleLLVMOptions.cmake file. llvm-svn: 243698
2015-07-31 06:30:34 +08:00
set(extract_dirs "${LIBCXX_SOURCE_DIR}/include;${LIBCXX_SOURCE_DIR}/src")
setup_lcov_test_target_coverage("cxx" "${output_dir}" "${capture_dirs}" "${extract_dirs}")
Add CMake build and fix major Linux blockers. llvm-svn: 121510
2010-12-11 03:47:54 +08:00
endif()
Add dummy CMake target for *.pass.cpp tests when LIBCXX_CONFIGURE_IDE=ON. In order for IDE's like CLion to correctly parse and highlight the tests it needs to know roughly how to build them. This patch adds a dummy CMake target for each/all of the .pass.cpp tests in the test suite to solve this problem. The target is only created when LIBCXX_CONFIGURE_IDE=ON, so it shouldn't affect most users. Originally I wasn't sure that this change deserved to live upstream, but it's quite frustrating to edit libc++ tests using CLion or Visual Studio without it, in particular the filesystem tests which rely heavily on macros. Even though the change should have no effect on non-IDE users/configurations I decided to commit it upstream with the hopes it will benefit somebody other than me. llvm-svn: 307118
2017-07-05 11:50:03 +08:00
if (LIBCXX_CONFIGURE_IDE)
# Create dummy targets for each of the tests in the test suite, this allows
# IDE's such as CLion to correctly highlight the tests because it knows
# roughly what include paths/compile flags/macro definitions are needed.
include_directories(support)
file(GLOB_RECURSE LIBCXX_TESTS ${CMAKE_CURRENT_SOURCE_DIR}/*.pass.cpp)
file(GLOB LIBCXX_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/support/*)
file(GLOB_RECURSE LIBCXX_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/*)
add_executable(libcxx_test_objects EXCLUDE_FROM_ALL
${LIBCXX_TESTS} ${LIBCXX_TEST_HEADERS} ${LIBCXX_HEADERS})
add_dependencies(libcxx_test_objects cxx)
split_list(LIBCXX_COMPILE_FLAGS)
split_list(LIBCXX_LINK_FLAGS)
set_target_properties(libcxx_test_objects
PROPERTIES
COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS}"
LINK_FLAGS "${LIBCXX_LINK_FLAGS}"
EXCLUDE_FROM_ALL ON
)
endif()