mirrors/cmake
2
0
Fork 0
mirror of https://gitlab.kitware.com/cmake/cmake.git synced 2026-09-25 04:09:36 +03:00
Code Activity
Files
26e6188e047a9a5b42891873f0440f078710e504
cmake/Tests/RunCMake/CMakeLists.txt
T
Tyler Yankee 26e6188e04 Tests/Instrumentation: Split make cases out to separate suite 
These tests experience frequent timeouts in CI, which are either actual
timeouts due to low resource runners, or a platform-specific bug
causing an indefinite hang. Either way, it's beneficial to locate these
in their own test suite to reduce noise and ensure the rest of the
tests pass regularly.
2026-07-30 11:14:48 -04:00

1657 lines
64 KiB
CMake
Raw Blame History

# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file LICENSE.rst or https://cmake.org/licensing for details.
# See adjacent README.rst for documentation of this test infrastructure.
# Note that the _isMultiConfig variable is set in the parent directory's
# CMakeLists.txt (slightly complex logic to support CMake versions before 3.9)
macro(add_RunCMake_test test)
set(TEST_ARGS ${ARGN})
if ("${ARGV1}" STREQUAL "TEST_DIR")
if ("${ARGV2}" STREQUAL "")
message(FATAL_ERROR "Invalid args")
endif()
set(Test_Dir ${ARGV2})
list(REMOVE_AT TEST_ARGS 0)
list(REMOVE_AT TEST_ARGS 0)
else()
set(Test_Dir ${test})
endif()
if(CMAKE_C_COMPILER_ID STREQUAL "LCC")
list(APPEND TEST_ARGS -DRunCMake_TEST_LCC=1)
endif()
if(DEFINED CMake_TEST_E2K_BROKEN_LIBC)
list(APPEND TEST_ARGS -DRunCMake_TEST_E2K_BROKEN_LIBC=${CMake_TEST_E2K_BROKEN_LIBC})
endif()
add_test(NAME RunCMake.${test} COMMAND ${CMAKE_CMAKE_COMMAND}
-DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}
-DRunCMake_GENERATOR_IS_MULTI_CONFIG=${_isMultiConfig}
-DRunCMake_GENERATOR=${CMAKE_GENERATOR}
-DRunCMake_GENERATOR_INSTANCE=${CMAKE_GENERATOR_INSTANCE}
-DRunCMake_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
-DRunCMake_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
-DRunCMake_MAKE_PROGRAM=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
-DRunCMake_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${Test_Dir}
-DRunCMake_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/${test}
${${test}_ARGS}
${TEST_ARGS}
-P "${CMAKE_CURRENT_SOURCE_DIR}/${Test_Dir}/RunCMakeTest.cmake"
)
endmacro()
function(add_RunCMake_test_group test types)
# create directory for common content
set(TEST_CONFIG_DIR "${CMAKE_CURRENT_BINARY_DIR}/${test}/conf")
file(REMOVE_RECURSE "${TEST_CONFIG_DIR}")
file(MAKE_DIRECTORY "${TEST_CONFIG_DIR}")
set(TEST_ARGS "")
if(CMAKE_C_COMPILER_ID STREQUAL "LCC")
list(APPEND TEST_ARGS -DRunCMake_TEST_LCC=1)
endif()
foreach(type IN LISTS types)
# generate prerequirements config file in cmake as ctest doesn't have as
# much system information so it is easier to set programs and environment
# values here
unset(${test}_${type}_FOUND_PREREQUIREMENTS)
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test}/${type}/Prerequirements.cmake")
include("${CMAKE_CURRENT_SOURCE_DIR}/${test}/${type}/Prerequirements.cmake")
else()
string(REGEX MATCH "^[^.]*" main_type "${type}")
include("${CMAKE_CURRENT_SOURCE_DIR}/${test}/${main_type}/Prerequirements.cmake")
endif()
get_test_prerequirements("${test}_${type}_FOUND_PREREQUIREMENTS"
"${TEST_CONFIG_DIR}/${type}_config.cmake")
# only add the test if prerequirements are met
if(${test}_${type}_FOUND_PREREQUIREMENTS)
add_test(NAME RunCMake.${test}_${type} COMMAND ${CMAKE_CMAKE_COMMAND}
-DTEST_TYPE=${type}
-DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}
-DRunCMake_GENERATOR_IS_MULTI_CONFIG=${_isMultiConfig}
-DRunCMake_GENERATOR=${CMAKE_GENERATOR}
-DRunCMake_GENERATOR_INSTANCE=${CMAKE_GENERATOR_INSTANCE}
-DRunCMake_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
-DRunCMake_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
-DRunCMake_MAKE_PROGRAM=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
-DRunCMake_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${test}
-DRunCMake_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/${type}/${test}
${TEST_ARGS}
-Dconfig_file=${TEST_CONFIG_DIR}/${type}_config.cmake
-P "${CMAKE_CURRENT_SOURCE_DIR}/${test}/RunCMakeTest.cmake"
)
endif()
endforeach()
endfunction()
# Some tests use python for extra checks.
find_package(Python QUIET)
# Test MSVC for older host CMake versions, and test
# WIN32/CMAKE_C_COMPILER_ID to fix check on Intel for Windows.
if(MSVC OR (WIN32 AND CMAKE_C_COMPILER_ID MATCHES "MSVC|Intel")
OR (WIN32 AND CMAKE_C_COMPILER_ID MATCHES "Clang" AND CMAKE_C_SIMULATE_ID MATCHES "MSVC"))
set(LINKER_SUPPORTS_PDB 1)
else()
set(LINKER_SUPPORTS_PDB 0)
endif()
add_RunCMake_test(CMP0019)
add_RunCMake_test(CMP0022)
add_RunCMake_test(CMP0026)
add_RunCMake_test(CMP0027)
add_RunCMake_test(CMP0037)
add_RunCMake_test(CMP0038)
add_RunCMake_test(CMP0039)
add_RunCMake_test(CMP0040)
add_RunCMake_test(CMP0041)
if(CMAKE_SYSTEM_NAME MATCHES Darwin AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
add_RunCMake_test(CMP0042)
endif()
add_RunCMake_test(CMP0045)
add_RunCMake_test(CMP0046)
add_RunCMake_test(CMP0049)
add_RunCMake_test(CMP0051)
add_RunCMake_test(CMP0053)
add_RunCMake_test(CMP0054)
add_RunCMake_test(CMP0055)
add_RunCMake_test(CMP0057)
add_RunCMake_test(CMP0059)
add_RunCMake_test(CMP0060)
add_RunCMake_test(CMP0064)
if(CMAKE_SYSTEM_NAME MATCHES Darwin AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
add_RunCMake_test(CMP0068)
endif()
add_RunCMake_test(CMP0069)
add_RunCMake_test(CMP0081)
add_RunCMake_test(CMP0102)
if(CMake_TEST_CUDA)
add_RunCMake_test(CMP0104)
set_property(TEST RunCMake.CMP0104 APPEND
PROPERTY LABELS "CUDA")
endif()
add_RunCMake_test(CMP0106)
add_RunCMake_test(CMP0111)
add_RunCMake_test(CMP0115)
if(CMAKE_GENERATOR MATCHES "Ninja")
add_RunCMake_test(CMP0116)
endif()
add_RunCMake_test(CMP0118)
add_RunCMake_test(CMP0119 -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION})
add_RunCMake_test(CMP0121)
if (CMAKE_SYSTEM_NAME MATCHES "(Linux|Darwin)")
add_RunCMake_test(CMP0125 -DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
-DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX})
endif()
add_RunCMake_test(CMP0126)
if("${CMAKE_C_COMPILER_ID}" STREQUAL "LCC" OR
"${CMAKE_CXX_COMPILER_ID}" STREQUAL "LCC" OR
"${CMAKE_Fortran_COMPILER_ID}" STREQUAL "LCC")
if(CMAKE_Fortran_COMPILER)
list(APPEND CMP0129_ARGS -DCMake_TEST_Fortran=1)
endif()
add_RunCMake_test("CMP0129")
set_property(TEST RunCMake.CMP0129 APPEND PROPERTY LABELS "Fortran")
endif()
add_RunCMake_test(CMP0132)
add_RunCMake_test(CMP0135)
add_RunCMake_test(CMP0139)
if(GIT_EXECUTABLE)
add_RunCMake_test(CMP0150)
endif()
if(NOT WIN32 OR CYGWIN)
add_RunCMake_test(CMP0152)
endif()
add_RunCMake_test(CMP0153)
add_RunCMake_test(CMP0156 -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION})
add_RunCMake_test(CMP0160)
add_RunCMake_test(CMP0163)
add_RunCMake_test(CMP0165)
add_RunCMake_test(CMP0169)
add_RunCMake_test(CMP0170)
add_RunCMake_test(CMP0171)
add_RunCMake_test(CMP0173)
add_RunCMake_test(CMP0187)
if(WIN32)
add_RunCMake_test(CMP0212)
endif()
add_RunCMake_test(CMP0217)
add_RunCMake_test(CMP0219)
if(CMAKE_C_COMPILER_ID STREQUAL "MSVC")
add_RunCMake_test(CMP0194 -DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION})
endif()
add_RunCMake_test(CMP0218)
# The test for Policy 65 requires the use of the
# CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS variable, which both the VS and Xcode
# generators ignore. The policy will have no effect on those generators.
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio|Xcode")
add_RunCMake_test(CMP0065 -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
endif()
add_executable(detect_jobserver detect_jobserver.c)
if(CMAKE_GENERATOR MATCHES "Make")
add_RunCMake_test(Make -DMAKE_IS_GNU=${MAKE_IS_GNU} -DDETECT_JOBSERVER=$<TARGET_FILE:detect_jobserver>)
endif()
unset(ninja_test_with_qt_version)
unset(ninja_qt_args)
if(CMake_TEST_Qt6)
find_package(Qt6Widgets QUIET NO_MODULE)
if(Qt6Widgets_FOUND)
set(ninja_test_with_qt_version 6)
# Work around Qt6 not finding sibling dependencies without CMAKE_PREFIX_PATH
cmake_path(GET Qt6_DIR PARENT_PATH base_dir) # <base>/lib/cmake
cmake_path(GET base_dir PARENT_PATH base_dir) # <base>/lib
cmake_path(GET base_dir PARENT_PATH base_dir) # <base>
set(ninja_qt_args -DCMAKE_PREFIX_PATH=${base_dir})
endif()
elseif(CMake_TEST_Qt5)
find_package(Qt5Widgets QUIET NO_MODULE)
if(Qt5Widgets_FOUND)
set(ninja_test_with_qt_version 5)
endif()
endif()
if(CMAKE_GENERATOR MATCHES "FASTBuild")
add_RunCMake_test(FASTBuild)
endif()
if(CMAKE_GENERATOR MATCHES "Ninja")
set(Ninja_ARGS
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_OUTPUT_EXTENSION=${CMAKE_C_OUTPUT_EXTENSION}
-DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
-DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX})
if(CMAKE_Fortran_COMPILER)
list(APPEND Ninja_ARGS
-DCMake_TEST_Fortran=1
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
)
endif()
if(ninja_test_with_qt_version)
list(APPEND Ninja_ARGS
-DCMake_TEST_Qt_version=${ninja_test_with_qt_version}
-DQt${ninja_test_with_qt_version}_DIR=${Qt${ninja_test_with_qt_version}_DIR}
-DQt${ninja_test_with_qt_version}Core_DIR=${Qt${ninja_test_with_qt_version}Core_DIR}
-DCMake_TEST_Qt${ninja_test_with_qt_version}Core_Version=${Qt${ninja_test_with_qt_version}Core_VERSION}
-DQt${ninja_test_with_qt_version}Widgets_DIR=${Qt${ninja_test_with_qt_version}Widgets_DIR}
${ninja_qt_args}
)
endif()
if(WIN32)
add_executable(showIncludes showIncludes.c)
list(APPEND Ninja_ARGS -DshowIncludes=$<TARGET_FILE:showIncludes>)
if(CMake_TEST_NO_CODEPAGE_9xx)
list(APPEND Ninja_ARGS -DCMake_TEST_NO_CODEPAGE_9xx=1)
endif()
endif()
add_RunCMake_test(Ninja)
set_property(TEST RunCMake.Ninja APPEND PROPERTY LABELS "Fortran")
set(NinjaMultiConfig_ARGS
-DCYGWIN=${CYGWIN} -DMSYS=${MSYS}
-DCMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX}
)
if(ninja_test_with_qt_version)
list(APPEND NinjaMultiConfig_ARGS
-DCMake_TEST_Qt_version=${ninja_test_with_qt_version}
-DQt${ninja_test_with_qt_version}Core_DIR=${Qt${ninja_test_with_qt_version}Core_DIR}
-DCMake_TEST_Qt${ninja_test_with_qt_version}Core_Version=${Qt${ninja_test_with_qt_version}Core_VERSION}
${ninja_qt_args}
)
endif()
if(DEFINED CMake_TEST_CUDA)
list(APPEND NinjaMultiConfig_ARGS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
endif()
add_RunCMake_test(NinjaMultiConfig)
set_property(TEST RunCMake.NinjaMultiConfig APPEND
PROPERTY LABELS "CUDA")
add_RunCMake_test(NinjaPrivateDeps
-DCMAKE_C_OUTPUT_EXTENSION=${CMAKE_C_OUTPUT_EXTENSION}
-DRunCMake_GENERATOR_IS_MULTI_CONFIG=${_isMultiConfig})
endif()
add_RunCMake_test(InstallParallel)
add_RunCMake_test(CTest)
add_RunCMake_test(CTestLaunch)
if(NOT CMake_TEST_EXTERNAL_CMAKE)
add_RunCMake_test(ctest_memcheck
-DPSEUDO_BC=$<TARGET_FILE:pseudo_BC>
-DPSEUDO_PURIFY=$<TARGET_FILE:pseudo_purify>
-DPSEUDO_VALGRIND=$<TARGET_FILE:pseudo_valgrind>
-DPSEUDO_CUDA_SANITIZER=$<TARGET_FILE:pseudo_cuda-memcheck>
-DPSEUDO_BC_NOLOG=$<TARGET_FILE:pseudonl_BC>
-DPSEUDO_PURIFY_NOLOG=$<TARGET_FILE:pseudonl_purify>
-DPSEUDO_VALGRIND_NOLOG=$<TARGET_FILE:pseudonl_valgrind>
-DMEMCHECK_FAIL=$<TARGET_FILE:memcheck_fail>
)
endif()
add_RunCMake_test(ABI -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
set_property(TEST RunCMake.ABI APPEND
PROPERTY LABELS "CUDA")
add_RunCMake_test(AndroidTestUtilities)
if(CMake_TEST_APPLE_SILICON)
add_RunCMake_test(AppleSilicon)
endif()
set(want_NoQt_test TRUE)
set(autogen_test_number 1 2 3 4 5 6 7)
if(CMake_TEST_Qt6 AND Qt6Widgets_FOUND)
# Work around Qt6 not finding sibling dependencies without CMAKE_PREFIX_PATH
cmake_path(GET Qt6_DIR PARENT_PATH base_dir) # <base>/lib/cmake
cmake_path(GET base_dir PARENT_PATH base_dir) # <base>/lib
cmake_path(GET base_dir PARENT_PATH base_dir) # <base>
# Note: Since RunCMake.Autogen tests cause time out on some CI,
# we split the tests.
foreach(val IN ITEMS ${autogen_test_number})
add_RunCMake_test("Autogen_Qt6_${val}" TEST_DIR "Autogen_${val}"
-Dwith_qt_version=6
-DQtCore_VERSION=${Qt6Core_VERSION}
"-DQt6_DIR:PATH=${Qt6_DIR}"
"-DCMAKE_PREFIX_PATH:STRING=${base_dir}"
-DPSEUDO_TIDY=$<TARGET_FILE:pseudo_tidy>
-DPSEUDO_IWYU=$<TARGET_FILE:pseudo_iwyu>
-DPSEUDO_PVS=$<TARGET_FILE:pseudo_pvs>
-DPSEUDO_CPPLINT=$<TARGET_FILE:pseudo_cpplint>
-DPSEUDO_CPPCHECK=$<TARGET_FILE:pseudo_cppcheck>
)
endforeach()
set(want_NoQt_test FALSE)
endif ()
if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND)
foreach(val IN ITEMS ${autogen_test_number})
add_RunCMake_test("Autogen_Qt5_${val}" TEST_DIR "Autogen_${val}"
-Dwith_qt_version=5
-DQtCore_VERSION=${Qt5Core_VERSION}
"-DQt5_DIR:PATH=${Qt5_DIR}"
)
endforeach()
set(want_NoQt_test FALSE)
endif ()
if(want_NoQt_test)
add_RunCMake_test(AutogenNoQt TEST_DIR Autogen_1)
endif()
if(NOT DEFINED CMake_TEST_BuildDepends_GNU_AS
AND (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "LCC")
AND CMAKE_GENERATOR MATCHES "^Ninja"
)
execute_process(COMMAND "${CMAKE_C_COMPILER}" -print-prog-name=as
RESULT_VARIABLE _gnu_res
OUTPUT_VARIABLE _gnu_as OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
if(_gnu_res EQUAL 0 AND _gnu_as)
set(CMake_TEST_BuildDepends_GNU_AS "${_gnu_as}")
endif()
endif()
if(CMAKE_Fortran_COMPILER)
list(APPEND BuildDepends_ARGS
-DCMake_TEST_Fortran=1
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
)
endif()
add_RunCMake_test(BuildDepends
-DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
-DMSVC_VERSION=${MSVC_VERSION}
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_LINK_DEPENDS_USE_COMPILER=${CMAKE_C_LINK_DEPENDS_USE_COMPILER}
-DCMake_TEST_BuildDepends_GNU_AS=${CMake_TEST_BuildDepends_GNU_AS}
)
set_property(TEST RunCMake.BuildDepends APPEND PROPERTY LABELS "Fortran")
add_RunCMake_test(BuiltinTargets)
if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja|FASTBuild")
add_RunCMake_test(Byproducts)
endif()
add_RunCMake_test(CMakeDependentOption)
if(APPLE # Remove these conditions when the test has non-Apple cases
AND CMAKE_C_COMPILER_ID STREQUAL "AppleClang")
add_RunCMake_test(CMakePackage
-DCMake_TEST_XCODE_VERSION=${CMake_TEST_XCODE_VERSION}
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
)
endif()
add_RunCMake_test(CMakeRoleGlobalProperty)
add_RunCMake_test(CMakeRelease -DCMake_TEST_JQ=${CMake_TEST_JQ})
if(CMAKE_GENERATOR MATCHES "Make|Ninja")
add_RunCMake_test(Color)
endif()
if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja|FASTBuild")
add_RunCMake_test(CompilerChange)
endif()
add_RunCMake_test(CompilerNotFound)
if(DEFINED CMake_TEST_OBJC)
list(APPEND CMake_TEST_LANG_VARS -DCMake_TEST_OBJC=${CMake_TEST_OBJC})
endif()
if(CMAKE_Fortran_COMPILER)
# lfortran < 1.24 cannot handle long file names. Fortran is not
# enabled here, so check the C compiler version instead.
if(CMAKE_C_COMPILER_ID STREQUAL "LCC" AND CMAKE_C_COMPILER_VERSION VERSION_LESS "1.24")
string(LENGTH "${CMAKE_CURRENT_BINARY_DIR}" _CCBD_LEN)
if(_CCBD_LEN LESS 35)
list(APPEND CMake_TEST_LANG_VARS -DCMake_TEST_Fortran=1)
endif()
unset(_CCBD_LEN)
else()
list(APPEND CMake_TEST_LANG_VARS -DCMake_TEST_Fortran=1)
endif()
endif()
foreach(lang IN ITEMS CUDA HIP ISPC)
if(CMake_TEST_${lang})
list(APPEND CMake_TEST_LANG_VARS -DCMake_TEST_${lang}=1)
endif()
endforeach()
add_RunCMake_test(CompilerId ${CMake_TEST_LANG_VARS})
set_property(TEST RunCMake.CompilerId APPEND PROPERTY LABELS "CUDA" "HIP" "ISPC" "Fortran")
add_RunCMake_test(CompilerTest ${CMake_TEST_LANG_VARS})
set_property(TEST RunCMake.CompilerTest APPEND PROPERTY LABELS "CUDA" "HIP" "ISPC" "Fortran")
add_RunCMake_test(Configure -DMSVC_IDE=${MSVC_IDE})
add_RunCMake_test(CpsExportImportBuild)
add_RunCMake_test(CpsExportImportInstall)
add_RunCMake_test(CpsMapConfig)
add_RunCMake_test(create_test_sourcelist)
add_RunCMake_test(DisallowedCommands)
add_RunCMake_test(discover_tests)
if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja|FASTBuild")
add_RunCMake_test(ExportCompileCommands)
endif()
add_RunCMake_test(ExcludeFromAll)
add_RunCMake_test(ExportImport)
add_RunCMake_test(ExternalData)
if(CMAKE_GENERATOR MATCHES "^(Unix Makefiles|Ninja)$"
AND NOT "${CMAKE_CURRENT_BINARY_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
add_RunCMake_test(ExtraGenerators)
endif()
add_RunCMake_test(FeatureSummary)
add_RunCMake_test(FPHSA)
if(CMAKE_USE_SYSTEM_JSONCPP)
list(APPEND FileAPI_ARGS -DJsonCpp_VERSION=${JsonCpp_VERSION})
endif()
add_RunCMake_test(FileAPI -DPython_EXECUTABLE=${Python_EXECUTABLE}
-DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID}
-DCMAKE_CXX_SIMULATE_ID=${CMAKE_CXX_SIMULATE_ID}
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
-DCMake_TEST_MODULE_COMPILATION=${CMake_TEST_MODULE_COMPILATION}
-DCMake_TEST_MODULE_COMPILATION_RULES=${CMake_TEST_MODULE_COMPILATION_RULES}
-DCMake_TEST_CXX_STDLIB_MODULES_JSON=${CMake_TEST_CXX_STDLIB_MODULES_JSON})
if(CMAKE_GENERATOR MATCHES "Make|Ninja|FASTBuild")
function(add_RunCMake_Instrumentation_test variant)
add_RunCMake_test(Instrumentation${variant}
TEST_DIR Instrumentation
-DPython_EXECUTABLE=${Python_EXECUTABLE}
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER=${CMAKE_C_COMPILER}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
-DCMAKE_EXECUTABLE_SUFFIX=${CMAKE_EXECUTABLE_SUFFIX}
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
-DCMake_TEST_INSTRUMENTATION_VARIANT=${variant}
)
set_property(TEST RunCMake.Instrumentation${variant} APPEND PROPERTY
LABELS "Instrumentation"
)
endfunction()
add_RunCMake_Instrumentation_test("")
add_RunCMake_Instrumentation_test(MakeProgram)
# The real-signal/console-event interrupt case runs in its own suite so it
# can be excluded from MemCheck (the interrupted cmake is killed by a real
# signal).
add_RunCMake_Instrumentation_test(InterruptReal)
endif()
add_RunCMake_test(ConfigDir)
if(CMake_TEST_FindPython2)
add_RunCMake_test(FindPython2.CPython TEST_DIR FindPython
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
"-DRunCMake_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-DCMake_TEST_FindPython2_CPython=TRUE
-DCMake_TEST_FindPython2=TRUE)
set_property(TEST RunCMake.FindPython2.CPython PROPERTY LABELS Python2)
endif()
if(CMake_TEST_FindPython3)
add_RunCMake_test(FindPython3.CPython TEST_DIR FindPython
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
"-DRunCMake_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
-DCMake_TEST_FindPython3_CPython=TRUE
-DCMake_TEST_FindPython3=TRUE)
set_property(TEST RunCMake.FindPython3.CPython PROPERTY LABELS Python3)
endif()
if(CMake_TEST_FindPython2_IronPython)
add_RunCMake_test(FindPython2.IronPython TEST_DIR FindPython
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
"-DRunCMake_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-DCMake_TEST_FindPython2=${CMake_TEST_FindPython2}
-DCMake_TEST_FindPython2_IronPython=${CMake_TEST_FindPython2_IronPython})
set_property(TEST RunCMake.FindPython2.IronPython PROPERTY LABELS Python2)
endif()
if(CMake_TEST_FindPython3_IronPython)
add_RunCMake_test(FindPython3.IronPython TEST_DIR FindPython
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
"-DRunCMake_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-DCMake_TEST_FindPython3=${CMake_TEST_FindPython3}
-DCMake_TEST_FindPython3_IronPython=${CMake_TEST_FindPython3_IronPython})
set_property(TEST RunCMake.FindPython3.IronPython PROPERTY LABELS Python3)
endif()
if(CMake_TEST_FindPython2_PyPy)
add_RunCMake_test(FindPython2.PyPy TEST_DIR FindPython
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
"-DRunCMake_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-DCMake_TEST_FindPython2_PyPy=${CMake_TEST_FindPython2_PyPy})
set_property(TEST RunCMake.FindPython2.PyPy PROPERTY LABELS Python2)
endif()
if(CMake_TEST_FindPython3_PyPy)
add_RunCMake_test(FindPython3.PyPy TEST_DIR FindPython
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
"-DRunCMake_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-DCMake_TEST_FindPython3_PyPy=${CMake_TEST_FindPython3_PyPy})
set_property(TEST RunCMake.FindPython3.PyPy PROPERTY LABELS Python3)
endif()
if(CMake_TEST_FindPython2 OR CMake_TEST_FindPython2_SABIModule OR CMake_TEST_FindPython2_NumPy
OR CMake_TEST_FindPython3 OR CMake_TEST_FindPython3_SABIModule OR CMake_TEST_FindPython3_NumPy
OR CMake_TEST_FindPython3_Conda)
add_RunCMake_test(FindPython.Various TEST_DIR FindPython
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
"-DRunCMake_BUILD_TYPE=${CMAKE_BUILD_TYPE}"
-DCMake_TEST_FindPython_Various=TRUE
-DCMake_TEST_FindPython2=${CMake_TEST_FindPython2}
-DCMake_TEST_FindPython2_SABIModule=${CMake_TEST_FindPython2_SABIModule}
-DCMake_TEST_FindPython2_NumPy=${CMake_TEST_FindPython2_NumPy}
-DCMake_TEST_FindPython3=${CMake_TEST_FindPython3}
-DCMake_TEST_FindPython3_SABIModule=${CMake_TEST_FindPython3_SABIModule}
-DCMake_TEST_FindPython3_NumPy=${CMake_TEST_FindPython3_NumPy}
-DCMake_TEST_FindPython3_Conda=${CMake_TEST_FindPython3_Conda})
set_property(TEST RunCMake.FindPython.Various PROPERTY LABELS Python2 Python3)
endif()
add_RunCMake_test(FindBoost)
add_RunCMake_test(FindLua)
if(CMake_TEST_FindRuby)
add_RunCMake_test(FindRuby
-DCMake_TEST_FindRuby_RBENV=${CMake_TEST_FindRuby_RBENV}
-DCMake_TEST_FindRuby_RVM=${CMake_TEST_FindRuby_RVM}
)
endif()
add_RunCMake_test(FindOpenGL)
add_RunCMake_test(InitialFlags)
if(CMake_TEST_FindOpenSSL)
add_RunCMake_test(FindOpenSSL)
endif()
if(CMake_TEST_UseSWIG)
add_RunCMake_test(FindSWIG)
add_RunCMake_test(UseSWIG -DCMake_TEST_FindPython2=${CMake_TEST_FindPython2}
-DCMake_TEST_FindPython3=${CMake_TEST_FindPython3})
endif()
if(NOT CMAKE_C_COMPILER_ID MATCHES "Watcom")
add_RunCMake_test(GenerateExportHeader)
endif()
add_RunCMake_test(GenEx-COMPILE_LANGUAGE)
add_RunCMake_test(GenEx-COMPILE_LANG_AND_ID)
add_RunCMake_test(GenEx-LINK_LANGUAGE)
add_RunCMake_test(GenEx-LINK_LANG_AND_ID)
add_RunCMake_test(GenEx-HOST_LINK)
add_RunCMake_test(GenEx-DEVICE_LINK)
add_RunCMake_test(GenEx-LINK_LIBRARY)
add_RunCMake_test(GenEx-LINK_GROUP)
add_RunCMake_test(GenEx-TARGET_FILE -DLINKER_SUPPORTS_PDB=${LINKER_SUPPORTS_PDB})
add_RunCMake_test(GenEx-TARGET_IMPORT_FILE)
add_RunCMake_test(GenEx-GENEX_EVAL)
add_RunCMake_test(GenEx-SOURCE_EXISTS)
add_RunCMake_test(GenEx-SOURCE_PROPERTY)
add_RunCMake_test(GenEx-FILE_SET_EXISTS)
add_RunCMake_test(GenEx-FILE_SET_PROPERTY)
add_RunCMake_test(GenEx-TARGET_PROPERTY)
add_RunCMake_test(GenEx-TARGET_RUNTIME_DLLS)
list(LENGTH CMAKE_OSX_ARCHITECTURES _num_archs)
if(NOT (XCODE AND _num_archs GREATER 1))
add_RunCMake_test(GenEx-TARGET_OBJECTS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
set_property(TEST RunCMake.GenEx-TARGET_OBJECTS APPEND PROPERTY LABELS "CUDA")
endif()
add_RunCMake_test(GenEx-STRING)
add_RunCMake_test(GenEx-PATH)
add_RunCMake_test(GenEx-PATH_EQUAL)
add_RunCMake_test(GenEx-LIST)
add_RunCMake_test(GeneratorExpression
-DCMake_TEST_OBJC=${CMake_TEST_OBJC}
-DCMake_TEST_Fortran=${CMake_TEST_Fortran}
-DCMake_TEST_CUDA=${CMake_TEST_CUDA}
-DCMake_TEST_HIP=${CMake_TEST_HIP}
-DCMAKE_C_OUTPUT_EXTENSION=${CMAKE_C_OUTPUT_EXTENSION}
)
add_RunCMake_test(GeneratorExpressionShortCircuit)
add_RunCMake_test(GeneratorInstance)
add_RunCMake_test(GeneratorPlatform)
if(XCODE_VERSION)
set(GeneratorToolset_ARGS -DXCODE_VERSION=${XCODE_VERSION})
endif()
add_RunCMake_test(GeneratorToolset)
add_RunCMake_test(GetPrerequisites -DSAMPLE_EXE=$<TARGET_FILE:exit_code>)
add_RunCMake_test(GNUInstallDirs -DSYSTEM_NAME=${CMAKE_SYSTEM_NAME})
add_RunCMake_test(GoogleTest # Note: does not actually depend on Google Test
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
-DCMAKE_VS_PLATFORM_NAME=${CMAKE_VS_PLATFORM_NAME}
)
add_RunCMake_test(Graphviz)
add_RunCMake_test(Languages)
add_RunCMake_test(LanguageStandards
-DCMake_NO_C_STANDARD=${CMake_NO_C_STANDARD}
-DCMake_NO_CXX_STANDARD=${CMake_NO_CXX_STANDARD}
-DCMake_TEST_CUDA=${CMake_TEST_CUDA}
-DCMake_TEST_HIP=${CMake_TEST_HIP}
-DCMake_TEST_OBJC=${CMake_TEST_OBJC}
)
set_property(TEST RunCMake.LanguageStandards APPEND PROPERTY LABELS "CUDA" "HIP")
add_RunCMake_test(LinkItemValidation)
add_RunCMake_test(LinkStatic)
add_RunCMake_test(ARCHIVER-prefix -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
if(CMAKE_CXX_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang|IBMClang|Fujitsu|FujitsuClang)$")
add_RunCMake_test(MetaCompileFeatures)
endif()
if(MSVC)
add_RunCMake_test(MSVCDefaultFlags)
add_RunCMake_test(MSVCRuntimeChecks)
add_RunCMake_test(MSVCRuntimeLibrary)
add_RunCMake_test(MSVCRuntimeTypeInfo)
add_RunCMake_test(MSVCDebugInformationFormat)
endif()
if(XCODE_VERSION)
set(ObjectLibrary_ARGS -DXCODE_VERSION=${XCODE_VERSION})
endif()
add_RunCMake_test(ObjectLibrary)
add_RunCMake_test(INSTALL_OBJECT_NAME)
add_RunCMake_test(OBJECT_NAME)
add_RunCMake_test(ParseImplicitIncludeInfo)
add_RunCMake_test(ParseImplicitLinkInfo)
if(UNIX AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
add_RunCMake_test(RuntimePath
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCMAKE_EXECUTABLE_FORMAT=${CMAKE_EXECUTABLE_FORMAT}
)
endif()
if(CMake_TEST_Rust)
add_RunCMake_test(Rust)
endif()
add_RunCMake_test(ScriptMode)
add_RunCMake_test(StandardLinkDirectories)
add_RunCMake_test(Swift -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCMake_TEST_Swift=${CMake_TEST_Swift}
-DCMAKE_Swift_COMPILER_VERSION=${CMAKE_Swift_COMPILER_VERSION}
-DXCODE_VERSION=${XCODE_VERSION})
add_RunCMake_test(TargetArtifacts -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
add_RunCMake_test(TargetObjects)
add_RunCMake_test(TargetProperties)
add_RunCMake_test(FileSetProperties)
add_RunCMake_test(FileSet-SOURCES -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_OUTPUT_EXTENSION=${CMAKE_C_OUTPUT_EXTENSION}
-DMSVC_VERSION=${MSVC_VERSION})
add_RunCMake_test(ToolchainFile)
add_RunCMake_test(ToolchainSkipsChecks
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID}
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
)
if(NOT CMake_TEST_EXTERNAL_CMAKE)
set(Tutorial_ARGS TEST_DIR Tutorial -DTutorial_SOURCE_DIR=${CMake_SOURCE_DIR}/Help/guide/tutorial)
add_RunCMake_test(Tutorial ${Tutorial_ARGS})
endif()
add_RunCMake_test(find_dependency)
add_RunCMake_test(CompileDefinitions)
add_RunCMake_test(CompileWarningAsError
-DCMake_TEST_CUDA=${CMake_TEST_CUDA}
-DCMake_TEST_Swift=${CMake_TEST_Swift}
-DCMAKE_Swift_COMPILER_VERSION=${CMAKE_Swift_COMPILER_VERSION}
)
set_property(TEST RunCMake.CompileWarningAsError APPEND PROPERTY LABELS
"CUDA" "Swift")
if((CMAKE_C_COMPILER_ID MATCHES "AppleClang|MSVC"
OR (CMAKE_SYSTEM_NAME MATCHES "Linux|Windows" AND CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
OR (CMAKE_SYSTEM_NAME STREQUAL "SunOS" AND CMAKE_C_COMPILER_ID STREQUAL "SunPro")
OR (CMAKE_SYSTEM_NAME STREQUAL "AIX" AND CMAKE_C_COMPILER_ID STREQUAL "XL"))
AND CMAKE_C_COMPILER_LINKER_ID)
add_RunCMake_test(LinkWarningAsError)
endif()
add_RunCMake_test(CompileFeatures -DCMake_NO_C_STANDARD=${CMake_NO_C_STANDARD} -DCMake_NO_CXX_STANDARD=${CMake_NO_CXX_STANDARD})
add_RunCMake_test(Policy)
add_RunCMake_test(PolicyScope)
add_RunCMake_test(Diagnostics)
add_RunCMake_test(DiagnosticScope)
add_RunCMake_test(WriteBasicConfigVersionFile)
add_RunCMake_test(WriteCompilerDetectionHeader)
add_RunCMake_test(SourceProperties)
if(NOT WIN32)
add_RunCMake_test(PositionIndependentCode -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID})
endif()
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio")
add_RunCMake_test(VisibilityPreset)
endif()
if (Qt4_FOUND)
set(CompatibleInterface_ARGS -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE})
endif()
add_RunCMake_test(CompatibleInterface)
add_RunCMake_test(Syntax)
add_RunCMake_test(WorkingDirectory)
add_RunCMake_test(MaxRecursionDepth)
add_RunCMake_test(add_custom_command)
add_RunCMake_test(add_custom_target)
add_RunCMake_test(add_dependencies)
add_RunCMake_test(add_executable)
add_RunCMake_test(add_library)
add_RunCMake_test(add_subdirectory -DCMAKE_Fortran_COMPILER=${CMAKE_Fortran_COMPILER})
set_property(TEST RunCMake.add_subdirectory APPEND PROPERTY LABELS "Fortran")
add_RunCMake_test(add_test -DPSEUDO_EMULATOR=$<TARGET_FILE:pseudo_emulator>)
add_RunCMake_test(build_command)
add_executable(exit_code exit_code.c)
if(NOT CMAKE_C_COMPILER_ID MATCHES "OrangeC|Watcom"
AND NOT CMAKE_C_FLAGS MATCHES "-fsanitize=")
add_executable(exit_crash exit_crash.c)
set(EXIT_CRASH_EXE $<TARGET_FILE:exit_crash>)
endif()
set(execute_process_ARGS
-DEXIT_CODE_EXE=$<TARGET_FILE:exit_code>
-DEXIT_CRASH_EXE=${EXIT_CRASH_EXE}
-DPRINT_STDIN_EXE=$<TARGET_FILE:print_stdin>
-DCYGWIN=${CYGWIN}
)
if(NOT CMake_TEST_EXTERNAL_CMAKE)
list(APPEND execute_process_ARGS -DTEST_ENCODING_EXE=$<TARGET_FILE:testEncoding>)
endif()
if(WIN32)
add_executable(testStartupInfo testStartupInfo.c)
list(APPEND execute_process_ARGS -DTEST_STARTUPINFO_EXE=$<TARGET_FILE:testStartupInfo>)
endif()
add_RunCMake_test(execute_process)
add_RunCMake_test(export)
if(DEFINED CMake_TEST_LOCALE_CHARSET)
list(APPEND cmake_host_system_information_ARGS -DCMake_TEST_LOCALE_CHARSET=${CMake_TEST_LOCALE_CHARSET})
endif()
if(DEFINED CMake_TEST_LOCALE_C_UTF8)
list(APPEND cmake_host_system_information_ARGS -DCMake_TEST_LOCALE_C_UTF8=${CMake_TEST_LOCALE_C_UTF8})
endif()
if(CMake_TEST_MSYSTEM_PREFIX)
list(APPEND cmake_host_system_information_ARGS -DCMake_TEST_MSYSTEM_PREFIX=${CMake_TEST_MSYSTEM_PREFIX})
endif()
add_RunCMake_test(cmake_host_system_information)
add_RunCMake_test(cmake_language)
add_RunCMake_test(cmake_minimum_required)
add_RunCMake_test(cmake_parse_arguments)
add_RunCMake_test(cmake_path -DMSYS=${MSYS})
add_RunCMake_test(cmake_pkg_config)
add_RunCMake_test(continue)
add_executable(color_warning color_warning.c)
add_executable(fake_build_command fake_build_command.c)
add_RunCMake_test(ctest_build
-DCOLOR_WARNING=$<TARGET_FILE:color_warning>
-DFAKE_BUILD_COMMAND_EXE=$<TARGET_FILE:fake_build_command>
)
add_RunCMake_test(ctest_cmake_error)
add_RunCMake_test(ctest_configure)
if(COVERAGE_COMMAND)
add_RunCMake_test(ctest_coverage -DCOVERAGE_COMMAND=${COVERAGE_COMMAND})
endif()
add_RunCMake_test(ctest_start)
add_RunCMake_test(ctest_submit)
add_RunCMake_test(ctest_test
-DIMAGE_DIR=${CMAKE_SOURCE_DIR}/Utilities/Sphinx/static
)
add_RunCMake_test(ctest_disabled_test)
add_RunCMake_test(ctest_skipped_test)
add_RunCMake_test(ctest_update)
add_RunCMake_test(ctest_upload)
add_RunCMake_test(ctest_environment)
add_RunCMake_test(ctest_empty_binary_directory)
add_RunCMake_test(ctest_exit)
add_RunCMake_test(ctest_fixtures)
if(CMAKE_GENERATOR MATCHES "Make|Ninja")
add_RunCMake_test(ctest_instrumentation)
endif()
add_RunCMake_test(define_property)
add_RunCMake_test(file -DCYGWIN=${CYGWIN} -DMSYS=${MSYS})
add_RunCMake_test(file-CHMOD -DMSYS=${MSYS})
foreach(var
CMake_TEST_NO_NETWORK
CMake_TEST_TLS_VERIFY_URL
CMake_TEST_TLS_VERIFY_URL_BAD
CMake_TEST_TLS_VERSION
CMake_TEST_TLS_VERSION_URL_BAD
)
if(DEFINED ${var})
list(APPEND file-DOWNLOAD_ARGS -D${var}=${${var}})
endif()
endforeach()
add_RunCMake_test(file-CREATE_LINK)
add_RunCMake_test(file-DOWNLOAD)
add_RunCMake_test(file-MAKE_DIRECTORY)
add_RunCMake_test(file-RPATH
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCMake_TEST_ELF_LARGE=${CMake_TEST_ELF_LARGE}
)
add_RunCMake_test(file-STRINGS)
add_RunCMake_test(find_file -DMINGW=${MINGW})
add_RunCMake_test(find_library -DMINGW=${MINGW} -DCYGWIN=${CYGWIN} -DMSYS=${MSYS} -DMSVC=${MSVC})
add_RunCMake_test(find_package -DMINGW=${MINGW} -DMSYS=${MSYS}
-DCMake_TEST_FILESYSTEM_CASE=${CMake_TEST_FILESYSTEM_CASE})
add_RunCMake_test(find_package-CPS)
add_RunCMake_test(find_path -DMINGW=${MINGW})
add_RunCMake_test(find_program -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
add_RunCMake_test(foreach)
add_RunCMake_test(function)
add_RunCMake_test(block)
add_RunCMake_test(get_filename_component)
add_RunCMake_test(get_property)
if(DEFINED CMake_TEST_NO_WRITE_ONLY_DIR)
list(APPEND if_ARGS -DCMake_TEST_NO_WRITE_ONLY_DIR=${CMake_TEST_NO_WRITE_ONLY_DIR})
endif()
add_RunCMake_test(INSTALL_OBJECT_NAME_STRATEGY)
add_RunCMake_test(INSTALL_OBJECT_ONLY_USE_DESTINATION)
add_RunCMake_test(if -DMSYS=${MSYS})
add_RunCMake_test(include -DCMake_TEST_FILESYSTEM_CASE=${CMake_TEST_FILESYSTEM_CASE})
add_RunCMake_test(include_directories)
add_RunCMake_test(include_guard)
add_RunCMake_test(list)
add_RunCMake_test(load_cache)
if(DEFINED CMake_TEST_MATH_OVERFLOW)
list(APPEND math_ARGS -DCMake_TEST_MATH_OVERFLOW=${CMake_TEST_MATH_OVERFLOW})
endif()
add_RunCMake_test(math)
add_RunCMake_test(message)
add_RunCMake_test(option)
add_RunCMake_test(PrintHelpers)
add_RunCMake_test(project -DCMake_TEST_RESOURCES=${CMake_TEST_RESOURCES})
add_RunCMake_test(project_injected)
add_RunCMake_test(property_init)
add_RunCMake_test(DependencyProviders)
add_RunCMake_test(return)
add_RunCMake_test(SarifOutput)
add_RunCMake_test(separate_arguments)
add_RunCMake_test(set_property)
add_RunCMake_test(string
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}
-DCMake_TEST_NO_64BIT_TIME=${CMake_TEST_NO_64BIT_TIME}
)
add_RunCMake_test(test_include_dirs)
add_RunCMake_test(BundleUtilities)
if(APPLE)
add_RunCMake_test(INSTALL_NAME_DIR)
add_RunCMake_test(MacOSVersions)
add_RunCMake_test(AppleSDK)
add_RunCMake_test(AppleTextStubs)
endif()
function(add_RunCMake_test_try_compile)
foreach(
var
IN ITEMS
CMAKE_C_COMPILER_ID
CMAKE_SYSTEM_NAME
CMake_TEST_CUDA
CMake_TEST_ISPC
CMake_TEST_HIP
CMake_TEST_OBJC
CMake_TEST_FILESYSTEM_1S
)
if(DEFINED ${var})
list(APPEND try_compile_ARGS -D${var}=${${var}})
endif()
endforeach()
add_RunCMake_test(try_compile)
set_property(TEST RunCMake.try_compile APPEND
PROPERTY LABELS "CUDA;ISPC")
endfunction()
add_RunCMake_test_try_compile()
if(CMAKE_Fortran_COMPILER)
list(APPEND try_run_ARGS -DCMake_TEST_Fortran=1)
endif()
add_RunCMake_test(try_run)
set_property(TEST RunCMake.try_run APPEND PROPERTY LABELS "Fortran")
add_RunCMake_test(set)
add_RunCMake_test(variable_watch)
add_RunCMake_test(while)
add_RunCMake_test(CMP0004)
add_RunCMake_test(TargetPolicies)
add_RunCMake_test(alias_targets)
add_RunCMake_test(InterfaceLibrary)
add_RunCMake_test(IntermediateDirStrategy)
add_RunCMake_test(no_install_prefix)
add_RunCMake_test(SourceGroup)
add_RunCMake_test(configure_file)
if(CTestTestTimeout_TIME)
set(CTestTimeout_ARGS -DTIMEOUT=${CTestTestTimeout_TIME})
endif()
add_RunCMake_test(CTestTimeout)
add_RunCMake_test(CTestTimeoutAfterMatch)
if(CMake_TEST_CUDA)
add_RunCMake_test(CUDA_architectures)
set_property(TEST RunCMake.CUDA_architectures APPEND PROPERTY LABELS "CUDA")
endif()
if(CMAKE_Fortran_COMPILER)
list(APPEND DependencyGraph_ARGS
-DCMake_TEST_Fortran=1
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
)
endif()
add_RunCMake_test(DependencyGraph)
set_property(TEST RunCMake.DependencyGraph APPEND PROPERTY LABELS "Fortran")
# Add C++ Module tests.
add_RunCMake_test(CXXModules
-DCMake_TEST_CXX_STDLIB_MODULES_JSON=${CMake_TEST_CXX_STDLIB_MODULES_JSON}
)
set_property(TEST RunCMake.CXXModules APPEND
PROPERTY LABELS "CXXModules")
function (add_RunCMake_CXXModulesCompile_test variant)
add_RunCMake_test(CXXModulesCompile${variant}
TEST_DIR CXXModulesCompile
-DCMake_TEST_MODULE_VARIANT=${variant}
-DCMake_TEST_MODULE_COMPILATION=${CMake_TEST_MODULE_COMPILATION}
-DCMake_TEST_MODULE_COMPILATION_RULES=${CMake_TEST_MODULE_COMPILATION_RULES}
-DCMake_TEST_CXX_STDLIB_MODULES_JSON=${CMake_TEST_CXX_STDLIB_MODULES_JSON}
)
set_property(TEST RunCMake.CXXModulesCompile${variant} APPEND
PROPERTY LABELS "CXXModules")
endfunction ()
add_RunCMake_CXXModulesCompile_test(BuildBehavior)
add_RunCMake_CXXModulesCompile_test(BuildImportExport)
add_RunCMake_CXXModulesCompile_test(Install)
# ctresalloc links against CMakeLib and CTestLib, which means it can't be built
# if CMake_TEST_EXTERNAL_CMAKE is activated (the compiler might be different.)
# So, it has to be provided in the original build tree.
if(CMake_TEST_EXTERNAL_CMAKE)
set(no_package_root_path)
if(NOT CMAKE_VERSION VERSION_LESS 3.12)
set(no_package_root_path NO_PACKAGE_ROOT_PATH)
endif()
find_program(ctresalloc ctresalloc PATHS ${CMake_TEST_EXTERNAL_CMAKE}
NO_DEFAULT_PATH
${no_package_root_path}
NO_CMAKE_PATH
NO_CMAKE_ENVIRONMENT_PATH
NO_SYSTEM_ENVIRONMENT_PATH
NO_CMAKE_SYSTEM_PATH
NO_CMAKE_FIND_ROOT_PATH
)
if(ctresalloc)
add_executable(ctresalloc IMPORTED)
set_property(TARGET ctresalloc PROPERTY IMPORTED_LOCATION ${ctresalloc})
endif()
else()
add_executable(ctresalloc CTestResourceAllocation/ctresalloc.cxx)
target_link_libraries(ctresalloc CTestLib)
target_include_directories(ctresalloc PRIVATE
${CMake_BINARY_DIR}/Source
${CMake_SOURCE_DIR}/Source
${CMake_SOURCE_DIR}/Source/CTest
)
set_property(TARGET ctresalloc PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMake_BIN_DIR})
endif()
if(TARGET ctresalloc)
add_RunCMake_test(CTestResourceAllocation -DCTRESALLOC_COMMAND=$<TARGET_FILE:ctresalloc>)
else()
message(STATUS "Could not find ctresalloc")
endif()
get_filename_component(real_binary_dir "${CMake_BINARY_DIR}" REALPATH)
if(NOT WIN32
AND NOT MSYS # FIXME: This works on CYGWIN but not on MSYS
AND real_binary_dir STREQUAL CMake_BINARY_DIR
)
add_RunCMake_test(SymlinkTrees)
endif ()
if(CMake_TEST_Qt4)
find_package(Qt4 QUIET)
endif()
if(CMake_TEST_Qt5)
find_package(Qt5Core QUIET)
endif()
if (CMake_TEST_Qt4 AND CMake_TEST_Qt5 AND Qt4_FOUND AND Qt5Core_FOUND AND NOT Qt5Core_VERSION VERSION_LESS 5.1.0)
add_RunCMake_test(IncompatibleQt)
endif()
if (CMake_TEST_Qt4 AND Qt4_FOUND)
add_RunCMake_test(ObsoleteQtMacros -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE})
endif()
find_package(PkgConfig QUIET)
if(PkgConfig_FOUND)
add_RunCMake_test(FindPkgConfig)
endif()
if(CMake_TEST_FindGTK2)
add_RunCMake_test(FindGTK2)
endif()
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
add_RunCMake_test(CMAKE_MSVCIDE_RUN_PATH)
add_RunCMake_test(include_external_msproject -DVS_PLATFORM_NAME=${CMAKE_VS_PLATFORM_NAME})
add_RunCMake_test(VSSolution)
add_RunCMake_test(VS10Project
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
)
add_RunCMake_test(VS10ProjectUseDebugLibraries)
endif()
if(CMAKE_GENERATOR MATCHES "^Visual Studio (1[6-9]|[2-9][0-9])"
AND NOT CMAKE_GENERATOR_TOOLSET MATCHES "^(v80|v90|v100|v110|v120)$")
add_RunCMake_test(VsDotnetSdk)
add_RunCMake_test(VsNugetPackageRestore)
endif()
if(XCODE_VERSION)
add_RunCMake_test(XcodeProject -DXCODE_VERSION=${XCODE_VERSION}
-DCMAKE_HOST_SYSTEM_PROCESSOR=${CMAKE_HOST_SYSTEM_PROCESSOR}
-DCMake_TEST_Swift=${CMake_TEST_Swift})
add_RunCMake_test(XcodeProject-Device -DXCODE_VERSION=${XCODE_VERSION})
add_RunCMake_test(XcodeProject-Embed -DXCODE_VERSION=${XCODE_VERSION})
# This test can take a very long time due to lots of combinations.
# Use a long default timeout and provide an option to customize it.
if(NOT DEFINED CMake_TEST_XcodeProject_TIMEOUT)
set(CMake_TEST_XcodeProject_TIMEOUT 2000)
endif()
set_property(TEST RunCMake.XcodeProject PROPERTY TIMEOUT ${CMake_TEST_XcodeProject_TIMEOUT})
endif()
if((CMAKE_C_COMPILER_ID STREQUAL "AppleClang"
AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 6.0)
OR (APPLE AND CMAKE_C_COMPILER_ID STREQUAL "GNU" AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 5.0))
add_RunCMake_test(Framework -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
if(CMAKE_C_COMPILER_ID STREQUAL "AppleClang" AND NOT DEFINED CMake_TEST_XcFramework)
set(CMake_TEST_XcFramework ON)
endif()
if(CMake_TEST_XcFramework AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 11.0)
set(XcFramework_ARGS -DCMake_TEST_XCODE_VERSION=${CMake_TEST_XCODE_VERSION})
add_RunCMake_test(XcFramework)
# This test can take a very long time due to lots of combinations.
# Use a long default timeout and provide an option to customize it.
if(NOT DEFINED CMake_TEST_XcFramework_TIMEOUT)
set(CMake_TEST_XcFramework_TIMEOUT 3000)
endif()
set_tests_properties(RunCMake.XcFramework PROPERTIES
TIMEOUT "${CMake_TEST_XcFramework_TIMEOUT}"
RUN_SERIAL TRUE
)
endif()
endif()
if (CMAKE_SYSTEM_NAME MATCHES "(Linux|Darwin|Windows|OpenBSD|FreeBSD|NetBSD|MirBSD)"
AND CMAKE_C_COMPILER_ID MATCHES "^(AppleClang|Clang|GNU|MSVC|NVIDIA)$"
AND NOT CMAKE_GENERATOR STREQUAL "Green Hills MULTI")
add_RunCMake_test(LinkerSelection -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
-DCMake_TEST_Swift=${CMake_TEST_Swift}
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION})
endif()
add_RunCMake_test(LinkLibrariesProcessing)
add_RunCMake_test(LinkLibrariesStrategy)
add_RunCMake_test(LinkFlags -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
if(DEFINED CMake_TEST_LOCALE_CHARSET)
list(APPEND File_Archive_ARGS -DCMake_TEST_LOCALE_CHARSET=${CMake_TEST_LOCALE_CHARSET})
endif()
list(APPEND File_Archive_ARGS -DPython_EXECUTABLE=${Python_EXECUTABLE})
add_RunCMake_test(File_Archive)
add_RunCMake_test(File_Configure)
add_RunCMake_test(File_Generate)
add_RunCMake_test(ExportWithoutLanguage)
add_RunCMake_test(target_link_directories)
add_RunCMake_test(target_link_libraries)
add_RunCMake_test(target_link_libraries-ALIAS)
add_RunCMake_test(target_link_libraries-LINK_LANGUAGE)
add_RunCMake_test(target_link_libraries-LINK_LANG_AND_ID)
add_RunCMake_test(target_link_libraries-LINK_LIBRARY -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DMINGW=${MINGW}
-DMSYS=${MSYS}
-DCYGWIN=${CYGWIN}
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
-DMSVC_VERSION=${MSVC_VERSION}
-DXCODE=${XCODE}
-DXCODE_VERSION=${XCODE_VERSION}
-DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
-DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX}
-DCMAKE_IMPORT_LIBRARY_PREFIX=${CMAKE_IMPORT_LIBRARY_PREFIX}
-DCMAKE_IMPORT_LIBRARY_SUFFIX=${CMAKE_IMPORT_LIBRARY_SUFFIX}
-DCMAKE_LINK_LIBRARY_FLAG=${CMAKE_LINK_LIBRARY_FLAG})
add_RunCMake_test(target_link_libraries-LINK_GROUP -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DMINGW=${MINGW}
-DMSYS=${MSYS}
-DCYGWIN=${CYGWIN}
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
-DMSVC_VERSION=${MSVC_VERSION}
-DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
-DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX}
-DCMAKE_IMPORT_LIBRARY_PREFIX=${CMAKE_IMPORT_LIBRARY_PREFIX}
-DCMAKE_IMPORT_LIBRARY_SUFFIX=${CMAKE_IMPORT_LIBRARY_SUFFIX}
-DCMAKE_LINK_LIBRARY_FLAG=${CMAKE_LINK_LIBRARY_FLAG})
add_RunCMake_test(target_link_libraries-LINKER-prefix -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCMAKE_EXECUTABLE_FORMAT=${CMAKE_EXECUTABLE_FORMAT}
-DCMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN=${CMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN}
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_COMPILER_FRONTEND_VARIANT=${CMAKE_C_COMPILER_FRONTEND_VARIANT})
add_RunCMake_test(add_link_options -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
add_RunCMake_test(target_link_options -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMake_TEST_CUDA=${CMake_TEST_CUDA})
set_property(TEST RunCMake.target_link_options APPEND
PROPERTY LABELS "CUDA")
add_RunCMake_test(add_compile_definitions)
add_RunCMake_test(target_compile_definitions)
add_RunCMake_test(target_compile_features)
add_RunCMake_test(target_compile_options
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_SIMULATE_ID=${CMAKE_C_SIMULATE_ID}
)
add_RunCMake_test(target_include_directories)
add_RunCMake_test(target_sources)
add_RunCMake_test(CheckCompilerFlag -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
-DCMake_TEST_ISPC=${CMake_TEST_ISPC}
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
-DCMake_TEST_HIP=${CMake_TEST_HIP}
-DCMake_TEST_Swift=${CMake_TEST_Swift})
add_RunCMake_test(CheckSourceCompiles -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
-DCMake_TEST_ISPC=${CMake_TEST_ISPC}
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
-DCMake_TEST_HIP=${CMake_TEST_HIP}
-DCMake_TEST_Swift=${CMake_TEST_Swift})
add_RunCMake_test(CheckSourceRuns -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
-DCMake_TEST_HIP=${CMake_TEST_HIP})
set_property(TEST RunCMake.CheckCompilerFlag
RunCMake.CheckSourceCompiles
RunCMake.CheckSourceRuns
APPEND PROPERTY LABELS "CUDA" "HIP" "Fortran")
set_property(TEST RunCMake.CheckSourceCompiles
RunCMake.CheckCompilerFlag
APPEND PROPERTY LABELS "ISPC")
add_RunCMake_test(CheckModules)
add_RunCMake_test(CheckIPOSupported)
if (CMAKE_SYSTEM_NAME MATCHES "(Linux|Darwin)"
AND (CMAKE_C_COMPILER_ID MATCHES "Clang|GNU|LCC" OR CMAKE_Fortran_COMPILER_ID MATCHES "GNU|LCC"))
add_RunCMake_test(CheckLinkerFlag -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
-DCMake_TEST_CUDA=${CMake_TEST_CUDA}
-DCMake_TEST_HIP=${CMake_TEST_HIP})
set_property(TEST RunCMake.CheckLinkerFlag APPEND PROPERTY LABELS "CUDA" "HIP" "Fortran")
endif()
add_executable(pseudo_llvm-rc pseudo_llvm-rc.c)
add_RunCMake_test(CommandLine -DLLVM_RC=$<TARGET_FILE:pseudo_llvm-rc> -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCYGWIN=${CYGWIN} -DMSYS=${MSYS} -DPython_EXECUTABLE=${Python_EXECUTABLE}
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
-DEXIT_CODE_EXE=$<TARGET_FILE:exit_code>
-DPRINT_STDIN_EXE=$<TARGET_FILE:print_stdin>)
if(NOT DEFINED CMake_TEST_LibLZMA_ARM64_BCJ)
if(NOT CMake_TEST_EXTERNAL_CMAKE AND NOT CMAKE_USE_SYSTEM_LIBARCHIVE AND NOT CMAKE_USE_SYSTEM_LIBLZMA)
set(CMake_TEST_LibLZMA_ARM64_BCJ 1)
endif()
endif()
if(CMake_TEST_LibArchive_VERSION)
list(APPEND CommandLineTar_ARGS -DCMake_TEST_LibArchive_VERSION=${CMake_TEST_LibArchive_VERSION})
endif()
if(DEFINED CMake_TEST_LOCALE_CHARSET)
list(APPEND CommandLineTar_ARGS -DCMake_TEST_LOCALE_CHARSET=${CMake_TEST_LOCALE_CHARSET})
endif()
if(DEFINED CMake_TEST_LibLZMA_ARM64_BCJ)
list(APPEND CommandLineTar_ARGS -DCMake_TEST_LibLZMA_ARM64_BCJ=${CMake_TEST_LibLZMA_ARM64_BCJ})
endif()
list(APPEND CommandLineTar_ARGS -DPython_EXECUTABLE=${Python_EXECUTABLE})
add_RunCMake_test(CommandLineTar)
if(CMAKE_PLATFORM_NO_VERSIONED_SONAME OR (NOT CMAKE_SHARED_LIBRARY_SONAME_FLAG AND NOT CMAKE_SHARED_LIBRARY_SONAME_C_FLAG))
set(NO_NAMELINK 1)
else()
set(NO_NAMELINK 0)
endif()
function (add_RunCMake_install_test variant)
add_RunCMake_test(install-${variant}
TEST_DIR install
-DNO_NAMELINK=${NO_NAMELINK}
-DCYGWIN=${CYGWIN}
-DMSYS=${MSYS}
-DCMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN=${CMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN}
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}
-DCMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG=${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG}
-DCMAKE_EXECUTABLE_FORMAT=${CMAKE_EXECUTABLE_FORMAT}
-DCMake_TEST_ISPC=${CMake_TEST_ISPC}
-DCMake_TEST_install_VARIANT=${variant}
)
set_property(TEST RunCMake.install-${variant} APPEND
PROPERTY LABELS "ISPC")
endfunction ()
add_RunCMake_install_test(Files)
add_RunCMake_install_test(Targets)
add_RunCMake_install_test(Exports)
if(DEFINED CMake_COMPILER_FORCES_NEW_DTAGS)
list(APPEND file-GET_RUNTIME_DEPENDENCIES_ARGS
-DCMake_COMPILER_FORCES_NEW_DTAGS=${CMake_COMPILER_FORCES_NEW_DTAGS})
endif()
add_RunCMake_test(file-GET_RUNTIME_DEPENDENCIES
-DCMake_INSTALL_NAME_TOOL_BUG=${CMake_INSTALL_NAME_TOOL_BUG}
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
)
add_RunCMake_test(CPackCommandLine)
add_RunCMake_test(CPackConfig)
add_RunCMake_test(CPackInstallProperties)
if(XCODE_VERSION)
set(ExternalProject_ARGS -DXCODE_VERSION=${XCODE_VERSION})
endif()
if(CMake_TEST_RunCMake_ExternalProject_DOWNLOAD_SERVER_TIMEOUT)
list(APPEND ExternalProject_ARGS -DDOWNLOAD_SERVER_TIMEOUT=${CMake_TEST_RunCMake_ExternalProject_DOWNLOAD_SERVER_TIMEOUT})
endif()
add_RunCMake_test(ExternalProject -DDETECT_JOBSERVER=$<TARGET_FILE:detect_jobserver>)
if(CMake_TEST_RunCMake_ExternalProject_RUN_SERIAL)
set_property(TEST RunCMake.ExternalProject PROPERTY RUN_SERIAL TRUE)
endif()
add_RunCMake_test(FetchContent)
add_RunCMake_test(FetchContent_find_package)
if(CMake_TEST_CLANG_COVERAGE)
add_RunCMake_test(CTestCoverage -DCMake_TEST_CLANG_COVERAGE=${CMake_TEST_CLANG_COVERAGE})
endif()
set(CTestCommandLine_ARGS
-DPython_EXECUTABLE=${Python_EXECUTABLE}
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
)
if(NOT CMake_TEST_EXTERNAL_CMAKE)
list(APPEND CTestCommandLine_ARGS -DTEST_AFFINITY=$<TARGET_FILE:testAffinity>)
endif()
add_executable(print_stdin print_stdin.c)
add_RunCMake_test(CTestCommandLine -DTEST_PRINT_STDIN=$<TARGET_FILE:print_stdin>)
add_RunCMake_test(CacheNewline)
add_RunCMake_test(CacheVarHelpFallback)
add_RunCMake_test(CacheVarHelpCoverage
-DCMake_SOURCE_DIR=${CMake_SOURCE_DIR})
# Only run this test on unix platforms that support
# symbolic links
if(UNIX)
add_RunCMake_test(CPackSymlinks)
endif()
set(IfacePaths_INCDIRS_ARGS -DTEST_PROP=INCLUDE_DIRECTORIES)
add_RunCMake_test(IfacePaths_INCDIRS TEST_DIR IfacePaths)
set(IfacePaths_SOURCES_ARGS -DTEST_PROP=SOURCES)
add_RunCMake_test(IfacePaths_SOURCES TEST_DIR IfacePaths)
# Matlab module related tests
if(CMake_TEST_FindMatlab OR CMake_TEST_FindMatlab_MCR OR (NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL ""))
set(FindMatlab_additional_test_options )
if(CMake_TEST_FindMatlab_MCR OR NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL "")
set(FindMatlab_additional_test_options -DIS_MCR=TRUE)
endif()
if(NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL "")
set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMCR_ROOT:FILEPATH=${CMake_TEST_FindMatlab_MCR_ROOT_DIR}")
endif()
add_RunCMake_test(FindMatlab ${FindMatlab_additional_test_options})
set_property(TEST RunCMake.FindMatlab APPEND PROPERTY LABELS "Matlab")
endif()
add_executable(pseudo_emulator pseudo_emulator.c)
add_executable(pseudo_emulator_custom_command pseudo_emulator_custom_command.c)
add_executable(pseudo_emulator_custom_command_arg pseudo_emulator_custom_command_arg.c)
add_RunCMake_test(CrosscompilingEmulator
-DPSEUDO_EMULATOR=$<TARGET_FILE:pseudo_emulator>
-DPSEUDO_EMULATOR_CUSTOM_COMMAND=$<TARGET_FILE:pseudo_emulator_custom_command>
-DPSEUDO_EMULATOR_CUSTOM_COMMAND_ARG=$<TARGET_FILE:pseudo_emulator_custom_command_arg>)
add_executable(pseudo_tidy pseudo_tidy.c)
add_executable(pseudo_iwyu pseudo_iwyu.c)
add_executable(pseudo_cpplint pseudo_cpplint.c)
add_executable(pseudo_cppcheck pseudo_cppcheck.c)
add_executable(pseudo_pvs pseudo_pvs.c)
add_executable(pseudo_plog_converter pseudo_plog_converter.c)
if (WIN32)
set_target_properties(pseudo_plog_converter PROPERTIES OUTPUT_NAME HtmlGenerator)
else()
set_target_properties(pseudo_plog_converter PROPERTIES OUTPUT_NAME plog-converter)
endif()
if("${CMAKE_GENERATOR}" MATCHES "Make|Ninja|FASTBuild")
if(UNIX AND NOT CYGWIN)
execute_process(COMMAND ldd --help
OUTPUT_VARIABLE LDD_HELP
ERROR_VARIABLE LDD_ERR
RESULT_VARIABLE LDD_RESULT)
if(LDD_RESULT EQUAL 0 AND "${LDD_HELP}" MATCHES
"(-r, --function-relocs.*process data and function relocations.*-u, --unused.*print unused direct dependencies)")
add_RunCMake_test(LinkWhatYouUse)
endif()
endif()
add_RunCMake_test(ClangTidy -DPSEUDO_TIDY=$<TARGET_FILE:pseudo_tidy>)
add_RunCMake_test(IncludeWhatYouUse -DPSEUDO_IWYU=$<TARGET_FILE:pseudo_iwyu>)
add_RunCMake_test(PVSStudio -DPSEUDO_PVS=$<TARGET_FILE:pseudo_pvs>)
add_RunCMake_test(Cpplint -DPSEUDO_CPPLINT=$<TARGET_FILE:pseudo_cpplint>)
add_RunCMake_test(Cppcheck -DPSEUDO_CPPCHECK=$<TARGET_FILE:pseudo_cppcheck>)
add_RunCMake_test(MultiLint
-DPSEUDO_TIDY=$<TARGET_FILE:pseudo_tidy>
-DPSEUDO_IWYU=$<TARGET_FILE:pseudo_iwyu>
-DPSEUDO_PVS=$<TARGET_FILE:pseudo_pvs>
-DPSEUDO_CPPLINT=$<TARGET_FILE:pseudo_cpplint>
-DPSEUDO_CPPCHECK=$<TARGET_FILE:pseudo_cppcheck>
)
if(DEFINED CMake_TEST_CUDA)
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
endif()
if(DEFINED CMake_TEST_HIP)
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_HIP=${CMake_TEST_HIP})
endif()
if(DEFINED CMake_TEST_ISPC)
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_ISPC=${CMake_TEST_ISPC})
endif()
if(DEFINED CMake_TEST_OBJC)
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_OBJC=${CMake_TEST_OBJC})
list(APPEND LinkerLauncher_ARGS -DCMake_TEST_OBJC=${CMake_TEST_OBJC})
endif()
if(CMAKE_Fortran_COMPILER)
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_Fortran=1)
endif()
add_RunCMake_test(CompilerLauncher)
set_property(TEST RunCMake.CompilerLauncher APPEND
PROPERTY LABELS "CUDA" "HIP" "ISPC" "Fortran")
add_RunCMake_test(ctest_labels_for_subprojects)
add_RunCMake_test(CompilerArgs)
add_RunCMake_test(LinkerLauncher)
endif()
set(cpack_tests
DEB.AUTO_SUFFIXES
DEB.CUSTOM_NAMES
DEB.DEBUGINFO
DEB.DEFAULT_PERMISSIONS
DEB.DEPENDENCIES
DEB.EMPTY_DIR
DEB.VERSION
DEB.EXTRA
DEB.GENERATE_SHLIBS
DEB.GENERATE_SHLIBS_LDCONFIG
DEB.LONG_FILENAMES
DEB.MINIMAL
DEB.PER_COMPONENT_FIELDS
DEB.TIMESTAMPS
DEB.MD5SUMS
DEB.DEB_PACKAGE_VERSION_BACK_COMPATIBILITY
DEB.DEB_DESCRIPTION
DEB.PROJECT_META
DEB.COMPONENT_WITH_SPECIAL_CHARS
DEB.MULTIARCH
RPM.AUTO_SUFFIXES
RPM.CUSTOM_BINARY_SPEC_FILE
RPM.CUSTOM_NAMES
RPM.DEBUGINFO
RPM.DEFAULT_PERMISSIONS
RPM.DEPENDENCIES
RPM.DIST
RPM.EMPTY_DIR
RPM.VERSION
RPM.INSTALL_SCRIPTS
RPM.MAIN_COMPONENT
RPM.MINIMAL
RPM.PARTIALLY_RELOCATABLE_WARNING
RPM.PER_COMPONENT_FIELDS
RPM.SINGLE_DEBUGINFO
RPM.EXTRA_SLASH_IN_PATH
RPM.SOURCE_PACKAGE
RPM.SUGGESTS
RPM.ENHANCES
RPM.RECOMMENDS
RPM.SUPPLEMENTS
RPM.SYMLINKS
RPM.USER_FILELIST
RPM.PROJECT_META
RPM.COMPONENT_WITH_SPECIAL_CHARS
7Z
7Z_STORE
7Z_DEFLATE
7Z_BZ2
7Z_LZMA
7Z_LZMA2
7Z_ZSTD
7Z_PPMD
TAR
TBZ2
TGZ
TXZ
TZ
TZST
ZIP
ZIP_STORE
ZIP_DEFLATE
ZIP_BZ2
ZIP_LZMA
ZIP_LZMA2
ZIP_ZSTD
STGZ
External
)
if(APPLE)
list(APPEND cpack_tests DragNDrop)
endif()
if(CMAKE_SYSTEM_PROCESSOR STREQUAL "e2k" AND NOT DEFINED CMake_TEST_E2K_BROKEN_LIBC)
# Exclude tests that fail due to a broken libc version on Elbrus.
find_program(DPKG_QUERY "dpkg-query" )
execute_process(COMMAND "${DPKG_QUERY}" "-f" "\${Version}" "-W" "glibc"
OUTPUT_VARIABLE LIBC_VERSION
RESULT_VARIABLE _result_libc)
if(LIBC_VERSION MATCHES "2.29-25.*")
list(REMOVE_ITEM cpack_tests
DEB.DEFAULT_PERMISSIONS
DEB.DEBUGINFO
DEB.MINIMAL
DEB.PER_COMPONENT_FIELDS
DEB.AUTO_SUFFIXES
DEB.CUSTOM_NAMES
DEB.DEB_PACKAGE_VERSION_BACK_COMPATIBILITY
DEB.PROJECT_META DEB.DEPENDENCIES
DEB.EXTRA
DEB.GENERATE_SHLIBS_LDCONFIG
DEB.LONG_FILENAMES
DEB.MD5SUMS
DEB.EMPTY_DIR
DEB.DEFAULT_PERMISSIONS
DEB.VERSION
DEB.TIMESTAMPS
RPM.PARTIALLY_RELOCATABLE_WARNING
RPM.PER_COMPONENT_FIELDS
RPM.USER_FILELIST
RPM.DIST
RPM.AUTO_SUFFIXES
7Z
7Z_STORE
7Z_DEFLATE
7Z_BZ2
7Z_LZMA
7Z_LZMA2
7Z_ZSTD
7Z_PPMD
TXZ
TZST
TBZ2
TGZ
ZIP
ZIP_STORE
ZIP_DEFLATE
ZIP_BZ2
ZIP_LZMA
ZIP_LZMA2
ZIP_ZSTD
STGZ
External
)
set(CMake_TEST_E2K_BROKEN_LIBC 1)
endif()
endif()
if(CMake_TEST_LibArchive_VERSION AND CMake_TEST_LibArchive_VERSION VERSION_LESS 3.8.0)
# Exclude tests, that require libarchive >= 3.8.0
# if the version of libarchive is less than required
list(REMOVE_ITEM cpack_tests
7Z_ZSTD
ZIP_BZ2
ZIP_LZMA
ZIP_LZMA2
ZIP_ZSTD
)
endif()
add_RunCMake_test_group(CPack "${cpack_tests}")
if(CMake_TEST_CPACK_APPIMAGE)
add_RunCMake_test(CPack_AppImage
-DCMake_TEST_CPACK_APPIMAGE_RUNTIME_FILE=${CMake_TEST_CPACK_APPIMAGE_RUNTIME_FILE}
)
endif()
if(CMake_TEST_CPACK_DEB)
add_RunCMake_test(CPack_DEB)
endif()
if(CMake_TEST_CPACK_RPM)
add_RunCMake_test(CPack_RPM)
endif()
if(CMake_TEST_CPACK_WIX3 OR CMake_TEST_CPACK_WIX4)
add_RunCMake_test(CPack_WIX
-DCMake_TEST_CPACK_WIX3=${CMake_TEST_CPACK_WIX3}
-DCMake_TEST_CPACK_WIX4=${CMake_TEST_CPACK_WIX4}
)
endif()
if(CMake_TEST_CPACK_NUGET)
add_RunCMake_test(CPack_NuGet)
endif()
# add a test to make sure symbols are exported from a shared library
# for MSVC compilers CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS property is used
add_RunCMake_test(AutoExportDll
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
-DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID}
)
add_RunCMake_test(AndroidMK)
add_RunCMake_test(ExportPackageInfo)
add_RunCMake_test(ExportSbom)
add_RunCMake_test(EnvSbom)
add_RunCMake_test(InstallPackageInfo)
add_RunCMake_test(InstallExportsAsPackageInfo)
add_RunCMake_test(InstallSbom)
if(CMake_TEST_ANDROID_NDK OR CMake_TEST_ANDROID_STANDALONE_TOOLCHAIN)
if(NOT "${CMAKE_GENERATOR}" MATCHES "Make|Ninja|Visual Studio 1[456]")
message(FATAL_ERROR "Android tests supported only by Makefile, Ninja, and Visual Studio >= 14 generators")
endif()
foreach(v IN ITEMS TEST_ANDROID_NDK TEST_ANDROID_STANDALONE_TOOLCHAIN)
if(CMake_${v})
string(REPLACE ";" "|" ${v} "${CMake_${v}}")
list(APPEND Android_ARGS "-D${v}=${${v}}")
endif()
endforeach()
add_RunCMake_test(Android)
# This test can take a very long time due to lots of combinations.
# Use a long default timeout and provide an option to customize it.
if(NOT DEFINED CMake_TEST_ANDROID_TIMEOUT)
set(CMake_TEST_ANDROID_TIMEOUT 3000)
endif()
set_property(TEST RunCMake.Android PROPERTY TIMEOUT ${CMake_TEST_ANDROID_TIMEOUT})
endif()
if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
add_RunCMake_test(CSharpCustomCommand)
if(NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
add_RunCMake_test(CSharpReferenceImport)
endif()
endif()
add_RunCMake_test("CTestCommandExpandLists")
add_RunCMake_test(PrecompileHeaders -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
-DCMAKE_C_SIMULATE_ID=${CMAKE_C_SIMULATE_ID}
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION})
add_RunCMake_test(PrecompileHeaders-Reuse -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
# This test can take a long time due to the number of test cases.
# Provide an option to customize it.
if(DEFINED CMake_TEST_PrecompileHeaders_TIMEOUT)
set_property(TEST RunCMake.PrecompileHeaders PROPERTY TIMEOUT ${CMake_TEST_PrecompileHeaders_TIMEOUT})
endif()
add_RunCMake_test(UnityBuild -DCMake_TEST_OBJC=${CMake_TEST_OBJC} -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
set_property(TEST RunCMake.UnityBuild APPEND
PROPERTY LABELS "CUDA")
add_RunCMake_test(CMakePresets
-DPython_EXECUTABLE=${Python_EXECUTABLE}
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
)
if(NOT CMake_TEST_E2K_BROKEN_LIBC)
add_RunCMake_test(CMakePresetsBuild
-DPython_EXECUTABLE=${Python_EXECUTABLE}
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
)
add_RunCMake_test(CMakePresetsTest
-DPython_EXECUTABLE=${Python_EXECUTABLE}
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
)
add_RunCMake_test(CMakePresetsPackage
-DPython_EXECUTABLE=${Python_EXECUTABLE}
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
)
endif()
add_RunCMake_test(CMakePresetsWorkflow
-DPython_EXECUTABLE=${Python_EXECUTABLE}
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
)
add_RunCMake_test(VerifyHeaderSets -DCMake_TEST_OBJC=${CMake_TEST_OBJC})
add_RunCMake_test(set_tests_properties)
add_RunCMake_test(CMakeListFileName)
if(CMAKE_GENERATOR MATCHES "Make|Ninja")
add_RunCMake_test(Codegen)
add_RunCMake_test(TransformDepfile)
endif()
if(WIN32)
add_RunCMake_test(Win32GenEx)
endif()
if(CMake_TEST_IAR_TOOLCHAINS)
add_executable(pseudo_icstat pseudo_icstat.c)
add_RunCMake_test(IAR
-DCMake_TEST_IAR_TOOLCHAINS=${CMake_TEST_IAR_TOOLCHAINS}
-DPSEUDO_ICSTAT=$<TARGET_FILE:pseudo_icstat>
)
set_property(TEST RunCMake.IAR APPEND PROPERTY LABELS "IAR")
endif()
if(CMake_TEST_TICLANG_TOOLCHAINS)
# This is necessary to preserve the LIST variable contents given by user.
string(REPLACE ";" "$<SEMICOLON>" TOOLCHAINS "${CMake_TEST_TICLANG_TOOLCHAINS}")
add_RunCMake_test(TIClang "-DCMake_TEST_TICLANG_TOOLCHAINS=${TOOLCHAINS}")
set_property(TEST RunCMake.TIClang APPEND PROPERTY LABELS "TIClang")
endif()
if(CMake_TEST_Diab_TOOLCHAINS)
add_RunCMake_test(Diab -DCMake_TEST_Diab_TOOLCHAINS=${CMake_TEST_Diab_TOOLCHAINS})
set_property(TEST RunCMake.Diab APPEND PROPERTY LABELS "Diab")
endif()
if (CMake_TEST_Renesas_TOOLCHAINS)
add_RunCMake_test(Renesas -DCMake_TEST_Renesas_TOOLCHAINS=${CMake_TEST_Renesas_TOOLCHAINS})
set_property(TEST RunCMake.Renesas APPEND PROPERTY LABELS "Renesas")
endif()
if(CMake_TEST_Emscripten_TOOLCHAINS)
add_RunCMake_test(Emscripten -DCMake_TEST_Emscripten_TOOLCHAINS=${CMake_TEST_Emscripten_TOOLCHAINS}
-DCMake_TEST_Emscripten_NODE=${CMake_TEST_Emscripten_NODE})
set_property(TEST RunCMake.Emscripten APPEND PROPERTY LABELS "Emscripten")
endif()
add_RunCMake_test(SharedLibraryDefines
-DCMake_TEST_CUDA=${CMake_TEST_CUDA}
)
set_property(TEST RunCMake.SharedLibraryDefines APPEND PROPERTY LABELS "CUDA")
add_RunCMake_test(MsvcCharsetDefines
-DCMake_TEST_CUDA=${CMake_TEST_CUDA}
)
set_property(TEST RunCMake.MsvcCharsetDefines APPEND PROPERTY LABELS "CUDA")
add_RunCMake_test(cmake-E-bin2c -DCMake_TEST_BIN2C_LARGE_FILE=${CMake_TEST_BIN2C_LARGE_FILE})
if(CMake_TEST_BIN2C_LARGE_FILE)
set_property(TEST RunCMake.cmake-E-bin2c PROPERTY TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
endif()
View Git Blame Copy Permalink