Tests/RunCMake/CMakeLists.txt

   1 # See adjacent README.rst for documentation of this test infrastructure.
   2
   3 # Note that the _isMultiConfig variable is set in the parent directory's
   4 # CMakeLists.txt (slightly complex logic to support CMake versions before 3.9)
   5
   6 macro(add_RunCMake_test test)
   7   set(TEST_ARGS ${ARGN})
   8   if ("${ARGV1}" STREQUAL "TEST_DIR")
   9     if ("${ARGV2}" STREQUAL "")
  10       message(FATAL_ERROR "Invalid args")
  11     endif()
  12     set(Test_Dir ${ARGV2})
  13     list(REMOVE_AT TEST_ARGS 0)
  14     list(REMOVE_AT TEST_ARGS 0)
  15   else()
  16     set(Test_Dir ${test})
  17   endif()
  18   add_test(NAME RunCMake.${test} COMMAND ${CMAKE_CMAKE_COMMAND}
  19     -DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}
  20     -DRunCMake_GENERATOR_IS_MULTI_CONFIG=${_isMultiConfig}
  21     -DRunCMake_GENERATOR=${CMAKE_GENERATOR}
  22     -DRunCMake_GENERATOR_INSTANCE=${CMAKE_GENERATOR_INSTANCE}
  23     -DRunCMake_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
  24     -DRunCMake_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
  25     -DRunCMake_MAKE_PROGRAM=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
  26     -DRunCMake_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${Test_Dir}
  27     -DRunCMake_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/${test}
  28     ${${test}_ARGS}
  29     ${TEST_ARGS}
  30     -P "${CMAKE_CURRENT_SOURCE_DIR}/${Test_Dir}/RunCMakeTest.cmake"
  31     )
  32   set_tests_properties("RunCMake.${test}" PROPERTIES LABELS "CMake;run")
  33   if(${test} MATCHES ^CMP)
  34     set_property(TEST "RunCMake.${test}" APPEND PROPERTY LABELS "policy")
  35   endif()
  36 endmacro()
  37
  38 function(add_RunCMake_test_group test types)
  39   # create directory for common content
  40   set(TEST_CONFIG_DIR "${CMAKE_CURRENT_BINARY_DIR}/${test}/conf")
  41   file(REMOVE_RECURSE "${TEST_CONFIG_DIR}")
  42   file(MAKE_DIRECTORY "${TEST_CONFIG_DIR}")
  43
  44   foreach(type IN LISTS types)
  45     # generate prerequirements config file in cmake as ctest doesn't have as
  46     # much system information so it is easier to set programs and environment
  47     # values here
  48     unset(${test}_${type}_FOUND_PREREQUIREMENTS)
  49     if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test}/${type}/Prerequirements.cmake")
  50       include("${CMAKE_CURRENT_SOURCE_DIR}/${test}/${type}/Prerequirements.cmake")
  51     else()
  52       string(REGEX MATCH "^[^.]*" main_type "${type}")
  53       include("${CMAKE_CURRENT_SOURCE_DIR}/${test}/${main_type}/Prerequirements.cmake")
  54     endif()
  55     get_test_prerequirements("${test}_${type}_FOUND_PREREQUIREMENTS"
  56         "${TEST_CONFIG_DIR}/${type}_config.cmake")
  57
  58     # only add the test if prerequirements are met
  59     if(${test}_${type}_FOUND_PREREQUIREMENTS)
  60       add_test(NAME RunCMake.${test}_${type} COMMAND ${CMAKE_CMAKE_COMMAND}
  61         -DTEST_TYPE=${type}
  62         -DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}
  63         -DRunCMake_GENERATOR_IS_MULTI_CONFIG=${_isMultiConfig}
  64         -DRunCMake_GENERATOR=${CMAKE_GENERATOR}
  65         -DRunCMake_GENERATOR_INSTANCE=${CMAKE_GENERATOR_INSTANCE}
  66         -DRunCMake_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
  67         -DRunCMake_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
  68         -DRunCMake_MAKE_PROGRAM=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
  69         -DRunCMake_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${test}
  70         -DRunCMake_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/${type}/${test}
  71         -Dconfig_file=${TEST_CONFIG_DIR}/${type}_config.cmake
  72         -P "${CMAKE_CURRENT_SOURCE_DIR}/${test}/RunCMakeTest.cmake"
  73         )
  74     endif()
  75   endforeach()
  76 endfunction()
  77
  78 # Some tests use python for extra checks.
  79 find_package(Python QUIET)
  80
  81 if(XCODE_VERSION AND "${XCODE_VERSION}" VERSION_LESS 6.1)
  82   set(Swift_ARGS -DXCODE_BELOW_6_1=1)
  83 endif()
  84
  85 # Test MSVC for older host CMake versions, and test
  86 # WIN32/CMAKE_C_COMPILER_ID to fix check on Intel for Windows.
  87 if(MSVC OR (WIN32 AND CMAKE_C_COMPILER_ID MATCHES "MSVC|Intel")
  88    OR (WIN32 AND CMAKE_C_COMPILER_ID MATCHES "Clang" AND CMAKE_C_SIMULATE_ID MATCHES "MSVC"))
  89   set(LINKER_SUPPORTS_PDB 1)
  90 else()
  91   set(LINKER_SUPPORTS_PDB 0)
  92 endif()
  93
  94 add_RunCMake_test(CMP0019)
  95 add_RunCMake_test(CMP0022)
  96 add_RunCMake_test(CMP0026)
  97 add_RunCMake_test(CMP0027)
  98 add_RunCMake_test(CMP0037)
  99 add_RunCMake_test(CMP0038)
 100 add_RunCMake_test(CMP0039)
 101 add_RunCMake_test(CMP0040)
 102 add_RunCMake_test(CMP0041)
 103 if(CMAKE_SYSTEM_NAME MATCHES Darwin AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
 104   add_RunCMake_test(CMP0042)
 105 endif()
 106 add_RunCMake_test(CMP0043)
 107 add_RunCMake_test(CMP0045)
 108 add_RunCMake_test(CMP0046)
 109 add_RunCMake_test(CMP0049)
 110 add_RunCMake_test(CMP0050)
 111 add_RunCMake_test(CMP0051)
 112 add_RunCMake_test(CMP0053)
 113 add_RunCMake_test(CMP0054)
 114 add_RunCMake_test(CMP0055)
 115 add_RunCMake_test(CMP0057)
 116 add_RunCMake_test(CMP0059)
 117 add_RunCMake_test(CMP0060)
 118 add_RunCMake_test(CMP0064)
 119 if(CMAKE_SYSTEM_NAME MATCHES Darwin AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
 120   add_RunCMake_test(CMP0068)
 121 endif()
 122 add_RunCMake_test(CMP0069)
 123 add_RunCMake_test(CMP0081)
 124 add_RunCMake_test(CMP0102)
 125 if(CMake_TEST_CUDA)
 126   add_RunCMake_test(CMP0104)
 127   set_property(TEST RunCMake.CMP0104 APPEND
 128     PROPERTY LABELS "CUDA")
 129 endif()
 130 add_RunCMake_test(CMP0106)
 131 add_RunCMake_test(CMP0111)
 132 add_RunCMake_test(CMP0115)
 133 if(CMAKE_GENERATOR MATCHES "Ninja")
 134   add_RunCMake_test(CMP0116)
 135 endif()
 136 add_RunCMake_test(CMP0118)
 137 add_RunCMake_test(CMP0119 -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
 138 add_RunCMake_test(CMP0121)
 139 if (CMAKE_SYSTEM_NAME MATCHES "(Linux|Darwin)")
 140   add_RunCMake_test(CMP0125 -DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
 141                             -DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX})
 142 endif()
 143 add_RunCMake_test(CMP0126)
 144
 145 if("${CMAKE_C_COMPILER_ID}" STREQUAL "LCC" OR
 146    "${CMAKE_CXX_COMPILER_ID}" STREQUAL "LCC" OR
 147    "${CMAKE_Fortran_COMPILER_ID}" STREQUAL "LCC")
 148   add_RunCMake_test("CMP0129")
 149 endif()
 150
 151 add_RunCMake_test(CMP0132)
 152 add_RunCMake_test(CMP0135)
 153 add_RunCMake_test(CMP0139)
 154
 155 # The test for Policy 65 requires the use of the
 156 # CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS variable, which both the VS and Xcode
 157 # generators ignore.  The policy will have no effect on those generators.
 158 if(NOT CMAKE_GENERATOR MATCHES "Visual Studio|Xcode")
 159   add_RunCMake_test(CMP0065 -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
 160 endif()
 161 if(CMAKE_GENERATOR MATCHES "Make")
 162   add_RunCMake_test(Make -DMAKE_IS_GNU=${MAKE_IS_GNU})
 163 endif()
 164 unset(ninja_test_with_qt_version)
 165 unset(ninja_qt_args)
 166 if(CMake_TEST_Qt6)
 167   find_package(Qt6Widgets QUIET NO_MODULE)
 168   if(Qt6Widgets_FOUND)
 169     set(ninja_test_with_qt_version 6)
 170     # Work around Qt6 not finding sibling dependencies without CMAKE_PREFIX_PATH
 171     cmake_path(GET Qt6_DIR  PARENT_PATH base_dir)  # <base>/lib/cmake
 172     cmake_path(GET base_dir PARENT_PATH base_dir)  # <base>/lib
 173     cmake_path(GET base_dir PARENT_PATH base_dir)  # <base>
 174     set(ninja_qt_args -DCMAKE_PREFIX_PATH=${base_dir})
 175   endif()
 176 elseif(CMake_TEST_Qt5)
 177   find_package(Qt5Widgets QUIET NO_MODULE)
 178   if(Qt5Widgets_FOUND)
 179     set(ninja_test_with_qt_version 5)
 180   endif()
 181 endif()
 182 if(CMAKE_GENERATOR MATCHES "Ninja")
 183   set(Ninja_ARGS
 184     -DCMAKE_C_OUTPUT_EXTENSION=${CMAKE_C_OUTPUT_EXTENSION}
 185     -DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
 186     -DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX})
 187   if(CMAKE_Fortran_COMPILER)
 188     list(APPEND Ninja_ARGS -DTEST_Fortran=1)
 189   endif()
 190   if(ninja_test_with_qt_version)
 191     list(APPEND Ninja_ARGS
 192       -DCMake_TEST_Qt_version=${ninja_test_with_qt_version}
 193       -DQt${ninja_test_with_qt_version}_DIR=${Qt${ninja_test_with_qt_version}_DIR}
 194       -DQt${ninja_test_with_qt_version}Core_DIR=${Qt${ninja_test_with_qt_version}Core_DIR}
 195       -DCMake_TEST_Qt${ninja_test_with_qt_version}Core_Version=${Qt${ninja_test_with_qt_version}Core_VERSION}
 196       -DQt${ninja_test_with_qt_version}Widgets_DIR=${Qt${ninja_test_with_qt_version}Widgets_DIR}
 197       ${ninja_qt_args}
 198     )
 199   endif()
 200   if(WIN32)
 201     add_executable(showIncludes showIncludes.c)
 202     list(APPEND Ninja_ARGS -DshowIncludes=$<TARGET_FILE:showIncludes>)
 203   endif()
 204   add_RunCMake_test(Ninja)
 205   set(NinjaMultiConfig_ARGS
 206     -DCYGWIN=${CYGWIN} -DMSYS=${MSYS}
 207     )
 208   if(ninja_test_with_qt_version)
 209     list(APPEND NinjaMultiConfig_ARGS
 210       -DCMake_TEST_Qt_version=${ninja_test_with_qt_version}
 211       -DQt${ninja_test_with_qt_version}Core_DIR=${Qt${ninja_test_with_qt_version}Core_DIR}
 212       -DCMake_TEST_Qt${ninja_test_with_qt_version}Core_Version=${Qt${ninja_test_with_qt_version}Core_VERSION}
 213       ${ninja_qt_args}
 214     )
 215   endif()
 216   if(DEFINED CMake_TEST_CUDA)
 217     list(APPEND NinjaMultiConfig_ARGS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
 218   endif()
 219   add_RunCMake_test(NinjaMultiConfig)
 220   set_property(TEST RunCMake.NinjaMultiConfig APPEND
 221     PROPERTY LABELS "CUDA")
 222 endif()
 223 add_RunCMake_test(CTest)
 224
 225 if(NOT CMake_TEST_EXTERNAL_CMAKE)
 226   add_RunCMake_test(ctest_memcheck
 227     -DPSEUDO_BC=$<TARGET_FILE:pseudo_BC>
 228     -DPSEUDO_PURIFY=$<TARGET_FILE:pseudo_purify>
 229     -DPSEUDO_VALGRIND=$<TARGET_FILE:pseudo_valgrind>
 230     -DPSEUDO_CUDA_SANITIZER=$<TARGET_FILE:pseudo_cuda-memcheck>
 231     -DPSEUDO_BC_NOLOG=$<TARGET_FILE:pseudonl_BC>
 232     -DPSEUDO_PURIFY_NOLOG=$<TARGET_FILE:pseudonl_purify>
 233     -DPSEUDO_VALGRIND_NOLOG=$<TARGET_FILE:pseudonl_valgrind>
 234     -DMEMCHECK_FAIL=$<TARGET_FILE:memcheck_fail>
 235     )
 236 endif()
 237
 238 add_RunCMake_test(ABI -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
 239 set_property(TEST RunCMake.ABI APPEND
 240   PROPERTY LABELS "CUDA")
 241
 242 add_RunCMake_test(AndroidTestUtilities)
 243 if(CMake_TEST_APPLE_SILICON)
 244   add_RunCMake_test(AppleSilicon)
 245 endif()
 246 set(want_NoQt_test TRUE)
 247 if(CMake_TEST_Qt6 AND Qt6Widgets_FOUND)
 248   # Work around Qt6 not finding sibling dependencies without CMAKE_PREFIX_PATH
 249   cmake_path(GET Qt6_DIR  PARENT_PATH base_dir)  # <base>/lib/cmake
 250   cmake_path(GET base_dir PARENT_PATH base_dir)  # <base>/lib
 251   cmake_path(GET base_dir PARENT_PATH base_dir)  # <base>
 252   add_RunCMake_test(AutogenQt6 TEST_DIR Autogen
 253     -Dwith_qt_version=6
 254     "-DQt6_DIR:PATH=${Qt6_DIR}"
 255     "-DCMAKE_PREFIX_PATH:STRING=${base_dir}"
 256   )
 257   set(want_NoQt_test FALSE)
 258 endif ()
 259 if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND)
 260   add_RunCMake_test(AutogenQt5 TEST_DIR Autogen
 261     -Dwith_qt_version=5
 262     "-DQt5_DIR:PATH=${Qt5_DIR}"
 263   )
 264   set(want_NoQt_test FALSE)
 265 endif ()
 266 if(want_NoQt_test)
 267   add_RunCMake_test(AutogenNoQt TEST_DIR Autogen)
 268 endif()
 269
 270 add_RunCMake_test(ArtifactOutputDirs)
 271
 272 if(NOT DEFINED CMake_TEST_BuildDepends_GNU_AS
 273     AND (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "LCC")
 274     AND CMAKE_GENERATOR MATCHES "^Ninja"
 275     )
 276   execute_process(COMMAND "${CMAKE_C_COMPILER}" -print-prog-name=as
 277     RESULT_VARIABLE _gnu_res
 278     OUTPUT_VARIABLE _gnu_as OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
 279   if(_gnu_res EQUAL 0 AND _gnu_as)
 280     set(CMake_TEST_BuildDepends_GNU_AS "${_gnu_as}")
 281   endif()
 282 endif()
 283
 284 add_RunCMake_test(BuildDepends
 285   -DMSVC_VERSION=${MSVC_VERSION}
 286   -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 287   -DCMake_TEST_BuildDepends_GNU_AS=${CMake_TEST_BuildDepends_GNU_AS}
 288   )
 289 if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
 290   add_RunCMake_test(Byproducts)
 291 endif()
 292 add_RunCMake_test(CMakeDependentOption)
 293 add_RunCMake_test(CMakeRoleGlobalProperty)
 294 add_RunCMake_test(CMakeRelease -DCMake_TEST_JQ=${CMake_TEST_JQ})
 295 if(CMAKE_GENERATOR MATCHES "Make|Ninja")
 296   add_RunCMake_test(Color)
 297 endif()
 298 if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
 299   add_RunCMake_test(CompilerChange)
 300 endif()
 301 add_RunCMake_test(CompilerNotFound)
 302 if (APPLE AND CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
 303   list(APPEND CompilerTest_ARGS -DCMake_TEST_OBJC=1)
 304 endif()
 305 if(CMAKE_Fortran_COMPILER)
 306   list(APPEND CompilerTest_ARGS -DCMake_TEST_Fortran=1)
 307 endif()
 308 foreach(lang IN ITEMS CUDA HIP ISPC)
 309   if(CMake_TEST_${lang})
 310     list(APPEND CompilerTest_ARGS -DCMake_TEST_${lang}=1)
 311   endif()
 312 endforeach()
 313 add_RunCMake_test(CompilerTest)
 314 set_property(TEST RunCMake.CompilerTest APPEND PROPERTY LABELS "CUDA" "HIP" "ISPC")
 315 add_RunCMake_test(Configure -DMSVC_IDE=${MSVC_IDE})
 316 add_RunCMake_test(DisallowedCommands)
 317 if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
 318   add_RunCMake_test(ExportCompileCommands)
 319 endif()
 320 add_RunCMake_test(ExcludeFromAll)
 321 add_RunCMake_test(ExportImport)
 322 add_RunCMake_test(ExternalData)
 323 add_RunCMake_test(FeatureSummary)
 324 add_RunCMake_test(FPHSA)
 325 if(CMAKE_USE_SYSTEM_JSONCPP)
 326   list(APPEND FileAPI_ARGS -DJsonCpp_VERSION_STRING=${JsonCpp_VERSION_STRING})
 327 endif()
 328 add_RunCMake_test(FileAPI -DPython_EXECUTABLE=${Python_EXECUTABLE}
 329                           -DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID})
 330 add_RunCMake_test(FindBoost)
 331 add_RunCMake_test(FindLua)
 332 add_RunCMake_test(FindOpenGL)
 333 add_RunCMake_test(InitialFlags)
 334 if(CMake_TEST_FindOpenSSL)
 335   add_RunCMake_test(FindOpenSSL)
 336 endif()
 337 if(CMake_TEST_UseSWIG)
 338   add_RunCMake_test(FindSWIG)
 339   add_RunCMake_test(UseSWIG -DCMake_TEST_FindPython=${CMake_TEST_FindPython})
 340 endif()
 341 if(NOT CMAKE_C_COMPILER_ID MATCHES "Watcom")
 342   add_RunCMake_test(GenerateExportHeader)
 343 endif()
 344 add_RunCMake_test(GenEx-COMPILE_LANGUAGE)
 345 add_RunCMake_test(GenEx-COMPILE_LANG_AND_ID)
 346 add_RunCMake_test(GenEx-LINK_LANGUAGE)
 347 add_RunCMake_test(GenEx-LINK_LANG_AND_ID)
 348 add_RunCMake_test(GenEx-HOST_LINK)
 349 add_RunCMake_test(GenEx-DEVICE_LINK)
 350 add_RunCMake_test(GenEx-LINK_LIBRARY)
 351 add_RunCMake_test(GenEx-LINK_GROUP)
 352 add_RunCMake_test(GenEx-TARGET_FILE -DLINKER_SUPPORTS_PDB=${LINKER_SUPPORTS_PDB})
 353 add_RunCMake_test(GenEx-GENEX_EVAL)
 354 add_RunCMake_test(GenEx-TARGET_RUNTIME_DLLS)
 355 add_RunCMake_test(GenEx-PATH)
 356 add_RunCMake_test(GenEx-PATH_EQUAL)
 357 add_RunCMake_test(GeneratorExpression)
 358 add_RunCMake_test(GeneratorInstance)
 359 add_RunCMake_test(GeneratorPlatform)
 360 if(XCODE_VERSION)
 361   set(GeneratorToolset_ARGS -DXCODE_VERSION=${XCODE_VERSION})
 362 endif()
 363 add_RunCMake_test(GeneratorToolset)
 364 add_RunCMake_test(GetPrerequisites)
 365 add_RunCMake_test(GNUInstallDirs -DSYSTEM_NAME=${CMAKE_SYSTEM_NAME})
 366 add_RunCMake_test(GoogleTest) # Note: does not actually depend on Google Test
 367 add_RunCMake_test(Graphviz)
 368 add_RunCMake_test(TargetPropertyGeneratorExpressions)
 369 add_RunCMake_test(Languages)
 370 add_RunCMake_test(LinkItemValidation)
 371 add_RunCMake_test(LinkStatic)
 372 if(CMAKE_CXX_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang|IBMClang|Fujitsu|FujitsuClang)$")
 373   add_RunCMake_test(MetaCompileFeatures)
 374 endif()
 375 if(MSVC)
 376   add_RunCMake_test(MSVCRuntimeLibrary)
 377   add_RunCMake_test(MSVCRuntimeTypeInfo)
 378   add_RunCMake_test(MSVCWarningFlags)
 379   add_RunCMake_test(MSVCDebugInformationFormat)
 380 endif()
 381 if(XCODE_VERSION)
 382   set(ObjectLibrary_ARGS -DXCODE_VERSION=${XCODE_VERSION})
 383 endif()
 384 add_RunCMake_test(ObjectLibrary)
 385 add_RunCMake_test(ParseImplicitIncludeInfo)
 386 add_RunCMake_test(ParseImplicitLinkInfo)
 387 if(UNIX AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG AND CMAKE_EXECUTABLE_FORMAT STREQUAL "ELF")
 388   add_RunCMake_test(RuntimePath)
 389 endif()
 390 add_RunCMake_test(ScriptMode)
 391 add_RunCMake_test(Swift -DCMAKE_Swift_COMPILER=${CMAKE_Swift_COMPILER} -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
 392 add_RunCMake_test(TargetObjects)
 393 add_RunCMake_test(TargetProperties)
 394 add_RunCMake_test(ToolchainFile)
 395 add_RunCMake_test(find_dependency)
 396 add_RunCMake_test(CompileDefinitions)
 397 add_RunCMake_test(CompileWarningAsError -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
 398 set_property(TEST RunCMake.CompileWarningAsError APPEND PROPERTY LABELS "CUDA")
 399 add_RunCMake_test(CompileFeatures -DCMake_NO_C_STANDARD=${CMake_NO_C_STANDARD} -DCMake_NO_CXX_STANDARD=${CMake_NO_CXX_STANDARD})
 400 add_RunCMake_test(Policy)
 401 add_RunCMake_test(PolicyScope)
 402 add_RunCMake_test(WriteBasicConfigVersionFile)
 403 add_RunCMake_test(WriteCompilerDetectionHeader)
 404 add_RunCMake_test(SourceProperties)
 405 if(NOT WIN32)
 406   add_RunCMake_test(PositionIndependentCode -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 407                                             -DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID})
 408 endif()
 409 if(NOT CMAKE_GENERATOR MATCHES "Visual Studio")
 410   add_RunCMake_test(VisibilityPreset)
 411 endif()
 412 if (QT4_FOUND)
 413   set(CompatibleInterface_ARGS -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE})
 414 endif()
 415 add_RunCMake_test(CompatibleInterface)
 416 add_RunCMake_test(Syntax)
 417 add_RunCMake_test(WorkingDirectory)
 418 add_RunCMake_test(MaxRecursionDepth)
 419
 420 add_RunCMake_test(add_custom_command)
 421 add_RunCMake_test(add_custom_target)
 422 add_RunCMake_test(add_dependencies)
 423 add_RunCMake_test(add_executable)
 424 add_RunCMake_test(add_library)
 425 add_RunCMake_test(add_subdirectory)
 426 add_RunCMake_test(add_test)
 427 add_RunCMake_test(build_command)
 428 add_executable(exit_code exit_code.c)
 429 set(execute_process_ARGS
 430   -DEXIT_CODE_EXE=$<TARGET_FILE:exit_code>
 431   -DPython_EXECUTABLE=${Python_EXECUTABLE}
 432   )
 433 if(NOT CMake_TEST_EXTERNAL_CMAKE)
 434   list(APPEND execute_process_ARGS -DTEST_ENCODING_EXE=$<TARGET_FILE:testEncoding>)
 435 endif()
 436 add_RunCMake_test(execute_process)
 437 add_RunCMake_test(export)
 438 add_RunCMake_test(cmake_host_system_information)
 439 add_RunCMake_test(cmake_language)
 440 add_RunCMake_test(cmake_minimum_required)
 441 add_RunCMake_test(cmake_parse_arguments)
 442 add_RunCMake_test(cmake_path -DMSYS=${MSYS})
 443 add_RunCMake_test(continue)
 444 add_executable(color_warning color_warning.c)
 445 add_executable(fake_build_command fake_build_command.c)
 446 add_RunCMake_test(ctest_build
 447   -DCOLOR_WARNING=$<TARGET_FILE:color_warning>
 448   -DFAKE_BUILD_COMMAND_EXE=$<TARGET_FILE:fake_build_command>
 449 )
 450 add_RunCMake_test(ctest_cmake_error)
 451 add_RunCMake_test(ctest_configure)
 452 if(COVERAGE_COMMAND)
 453   add_RunCMake_test(ctest_coverage -DCOVERAGE_COMMAND=${COVERAGE_COMMAND})
 454 endif()
 455 add_RunCMake_test(ctest_start)
 456 add_RunCMake_test(ctest_submit)
 457 add_RunCMake_test(ctest_test
 458   -DIMAGE_DIR=${CMAKE_SOURCE_DIR}/Utilities/Sphinx/static
 459 )
 460 add_RunCMake_test(ctest_disabled_test)
 461 add_RunCMake_test(ctest_skipped_test)
 462 add_RunCMake_test(ctest_update)
 463 add_RunCMake_test(ctest_upload)
 464 add_RunCMake_test(ctest_environment)
 465 add_RunCMake_test(ctest_fixtures)
 466 add_RunCMake_test(define_property)
 467 add_RunCMake_test(file -DCYGWIN=${CYGWIN} -DMSYS=${MSYS})
 468 add_RunCMake_test(file-CHMOD -DMSYS=${MSYS})
 469 add_RunCMake_test(file-RPATH -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
 470 add_RunCMake_test(find_file)
 471 add_RunCMake_test(find_library -DCYGWIN=${CYGWIN} -DMSYS=${MSYS})
 472 add_RunCMake_test(find_package -DMSYS=${MSYS})
 473 add_RunCMake_test(find_path)
 474 add_RunCMake_test(find_program -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
 475 add_RunCMake_test(foreach)
 476 add_RunCMake_test(function)
 477 add_RunCMake_test(block)
 478 add_RunCMake_test(get_filename_component)
 479 add_RunCMake_test(get_property)
 480 add_RunCMake_test(if)
 481 add_RunCMake_test(include)
 482 add_RunCMake_test(include_directories)
 483 add_RunCMake_test(include_guard)
 484 add_RunCMake_test(list)
 485 add_RunCMake_test(load_cache)
 486 add_RunCMake_test(math)
 487 add_RunCMake_test(message)
 488 add_RunCMake_test(option)
 489 add_RunCMake_test(PrintHelpers)
 490 add_RunCMake_test(project -DCMake_TEST_RESOURCES=${CMake_TEST_RESOURCES})
 491 add_RunCMake_test(project_injected)
 492 add_RunCMake_test(DependencyProviders)
 493 add_RunCMake_test(return)
 494 add_RunCMake_test(separate_arguments)
 495 add_RunCMake_test(set_property)
 496 add_RunCMake_test(string)
 497 add_RunCMake_test(test_include_dirs)
 498 add_RunCMake_test(BundleUtilities)
 499 if(APPLE)
 500   add_RunCMake_test(INSTALL_NAME_DIR)
 501   add_RunCMake_test(MacOSVersions)
 502 endif()
 503
 504 function(add_RunCMake_test_try_compile)
 505   if(CMAKE_VERSION VERSION_LESS 3.9.20170907 AND "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
 506     # Older CMake versions do not know about MSVC language standards.
 507     # Approximate our logic from MSVC-CXX.cmake.
 508     if ((NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.24215.1 AND
 509          CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10) OR
 510          NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10.25017)
 511       set(CMAKE_CXX_STANDARD_DEFAULT 14)
 512     elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
 513       set(CMAKE_CXX_STANDARD_DEFAULT "")
 514     else()
 515       unset(CMAKE_CXX_STANDARD_DEFAULT)
 516     endif()
 517   endif()
 518   if(CMAKE_VERSION VERSION_LESS 3.18.20200813 AND "x${CMAKE_C_COMPILER_ID}" STREQUAL "xMSVC")
 519     # Older CMake versions do not know about MSVC language standards.
 520     # Approximate our logic from MSVC-C.cmake.
 521     if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 19.27)
 522       set(CMAKE_C_STANDARD_DEFAULT 99)
 523     else()
 524       set(CMAKE_C_STANDARD_DEFAULT "")
 525     endif()
 526   endif()
 527   if(CMAKE_VERSION VERSION_LESS 3.20.20210225 AND "x${CMAKE_C_COMPILER_ID}" STREQUAL "xClang")
 528     # Older CMake versions do not know about Clang MSVC compatibility mode
 529     # standards. Approximate the logic from Clang-C.cmake.
 530     if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0)
 531       set(CMAKE_C_STANDARD_DEFAULT 17)
 532     elseif(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 3.5.2)
 533       set(CMAKE_C_STANDARD_DEFAULT 11)
 534     endif()
 535   endif()
 536   if(CMAKE_VERSION VERSION_LESS 3.20.6 AND "x${CMAKE_C_COMPILER_ID}" STREQUAL "xIntelLLVM" AND "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")
 537     # Older CMake versions accidentally set the default standards to empty when
 538     # IntelLLVM targets the MSVC ABI, thus not activating standard selection.
 539     # Approximate the logic from IntelLLVM-{C,CXX}.cmake.
 540     if(DEFINED CMAKE_C_STANDARD_DEFAULT AND "${CMAKE_C_STANDARD_DEFAULT}" STREQUAL "")
 541       set(CMAKE_C_STANDARD_DEFAULT 17)
 542     endif()
 543     if(DEFINED CMAKE_CXX_STANDARD_DEFAULT AND "${CMAKE_CXX_STANDARD_DEFAULT}" STREQUAL "")
 544       set(CMAKE_CXX_STANDARD_DEFAULT 14)
 545     endif()
 546   endif()
 547   foreach(
 548     var
 549     IN ITEMS
 550       CMAKE_SYSTEM_NAME
 551       CMAKE_C_COMPILER_ID
 552       CMAKE_C_COMPILER_VERSION
 553       CMAKE_C_STANDARD_DEFAULT
 554       CMAKE_CXX_COMPILER_ID
 555       CMAKE_CXX_COMPILER_VERSION
 556       CMAKE_CXX_STANDARD_DEFAULT
 557       CMake_TEST_CUDA
 558       CMake_TEST_ISPC
 559       CMake_TEST_HIP
 560       CMake_TEST_FILESYSTEM_1S
 561       CMAKE_OBJC_STANDARD_DEFAULT
 562       CMAKE_OBJCXX_STANDARD_DEFAULT
 563     )
 564     if(DEFINED ${var})
 565       list(APPEND try_compile_ARGS -D${var}=${${var}})
 566     endif()
 567   endforeach()
 568   add_RunCMake_test(try_compile)
 569   set_property(TEST RunCMake.try_compile APPEND
 570     PROPERTY LABELS "CUDA;ISPC")
 571 endfunction()
 572 add_RunCMake_test_try_compile()
 573
 574 add_RunCMake_test(try_run -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 575                           -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
 576 add_RunCMake_test(set)
 577 add_RunCMake_test(variable_watch)
 578 add_RunCMake_test(while)
 579 add_RunCMake_test(CMP0004)
 580 add_RunCMake_test(TargetPolicies)
 581 add_RunCMake_test(alias_targets)
 582 add_RunCMake_test(InterfaceLibrary)
 583 add_RunCMake_test(no_install_prefix)
 584 add_RunCMake_test(configure_file)
 585 add_RunCMake_test(CTestTimeout -DTIMEOUT=${CTestTestTimeout_TIME})
 586 add_RunCMake_test(CTestTimeoutAfterMatch)
 587 if(CMake_TEST_CUDA)
 588   add_RunCMake_test(CUDA_architectures)
 589   set_property(TEST RunCMake.CUDA_architectures APPEND PROPERTY LABELS "CUDA")
 590 endif()
 591 add_RunCMake_test(DependencyGraph -DCMAKE_Fortran_COMPILER=${CMAKE_Fortran_COMPILER})
 592
 593 # Add C++ Module tests.
 594 add_RunCMake_test(CXXModules -DCMake_TEST_MODULE_COMPILATION=${CMake_TEST_MODULE_COMPILATION} -DCMake_TEST_MODULE_COMPILATION_RULES=${CMake_TEST_MODULE_COMPILATION_RULES})
 595
 596 # ctresalloc links against CMakeLib and CTestLib, which means it can't be built
 597 # if CMake_TEST_EXTERNAL_CMAKE is activated (the compiler might be different.)
 598 # So, it has to be provided in the original build tree.
 599 if(CMake_TEST_EXTERNAL_CMAKE)
 600   set(no_package_root_path)
 601   if(NOT CMAKE_VERSION VERSION_LESS 3.12)
 602     set(no_package_root_path NO_PACKAGE_ROOT_PATH)
 603   endif()
 604   find_program(ctresalloc ctresalloc PATHS ${CMake_TEST_EXTERNAL_CMAKE}
 605     NO_DEFAULT_PATH
 606     ${no_package_root_path}
 607     NO_CMAKE_PATH
 608     NO_CMAKE_ENVIRONMENT_PATH
 609     NO_SYSTEM_ENVIRONMENT_PATH
 610     NO_CMAKE_SYSTEM_PATH
 611     NO_CMAKE_FIND_ROOT_PATH
 612     )
 613   if(ctresalloc)
 614     add_executable(ctresalloc IMPORTED)
 615     set_property(TARGET ctresalloc PROPERTY IMPORTED_LOCATION ${ctresalloc})
 616   endif()
 617 else()
 618   add_executable(ctresalloc CTestResourceAllocation/ctresalloc.cxx)
 619   target_link_libraries(ctresalloc CTestLib)
 620   target_include_directories(ctresalloc PRIVATE
 621     ${CMake_BINARY_DIR}/Source
 622     ${CMake_SOURCE_DIR}/Source
 623     ${CMake_SOURCE_DIR}/Source/CTest
 624     )
 625   set_property(TARGET ctresalloc PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMake_BIN_DIR})
 626 endif()
 627
 628 if(TARGET ctresalloc)
 629   add_RunCMake_test(CTestResourceAllocation -DCTRESALLOC_COMMAND=$<TARGET_FILE:ctresalloc>)
 630 else()
 631   message(STATUS "Could not find ctresalloc")
 632 endif()
 633
 634 if(NOT WIN32
 635     AND NOT MSYS # FIXME: This works on CYGWIN but not on MSYS
 636     )
 637   add_RunCMake_test(SymlinkTrees)
 638 endif ()
 639
 640 if(CMake_TEST_Qt4)
 641   find_package(Qt4 QUIET)
 642 endif()
 643 if(CMake_TEST_Qt5)
 644   find_package(Qt5Core QUIET)
 645 endif()
 646 if (CMake_TEST_Qt4 AND CMake_TEST_Qt5 AND QT4_FOUND AND Qt5Core_FOUND AND NOT Qt5Core_VERSION VERSION_LESS 5.1.0)
 647   add_RunCMake_test(IncompatibleQt)
 648 endif()
 649 if (CMake_TEST_Qt4 AND QT4_FOUND)
 650   add_RunCMake_test(ObsoleteQtMacros -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE})
 651 endif()
 652
 653 find_package(PkgConfig QUIET)
 654 if(PKG_CONFIG_FOUND)
 655   add_RunCMake_test(FindPkgConfig)
 656 endif()
 657
 658 if(CMake_TEST_FindGTK2)
 659   add_RunCMake_test(FindGTK2)
 660 endif()
 661
 662 if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
 663   add_RunCMake_test(CMAKE_MSVCIDE_RUN_PATH)
 664   add_RunCMake_test(include_external_msproject -DVS_PLATFORM_NAME=${CMAKE_VS_PLATFORM_NAME})
 665   if("${CMAKE_GENERATOR}" MATCHES "Visual Studio (9|10)" AND NOT CMAKE_VS_DEVENV_COMMAND)
 666     set(NO_USE_FOLDERS 1)
 667   endif()
 668   add_RunCMake_test(VSSolution -DNO_USE_FOLDERS=${NO_USE_FOLDERS})
 669 endif()
 670
 671 if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([^9]|9[0-9])")
 672   add_RunCMake_test(VS10Project
 673     -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 674     -DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
 675     )
 676   if( vs12 AND wince )
 677     add_RunCMake_test( VS10ProjectWinCE "-DRunCMake_GENERATOR_PLATFORM=${wince_sdk}")
 678   endif()
 679 endif()
 680
 681 if(CMAKE_GENERATOR MATCHES "^Visual Studio (1[6-9]|[2-9][0-9])")
 682   add_RunCMake_test(VsDotnetSdk)
 683   add_RunCMake_test(VsNugetPackageRestore)
 684 endif()
 685
 686 if(XCODE_VERSION)
 687   add_RunCMake_test(XcodeProject -DXCODE_VERSION=${XCODE_VERSION})
 688   add_RunCMake_test(XcodeProject-Embed -DXCODE_VERSION=${XCODE_VERSION})
 689
 690   # This test can take a very long time due to lots of combinations.
 691   # Use a long default timeout and provide an option to customize it.
 692   if(NOT DEFINED CMake_TEST_XcodeProject_TIMEOUT)
 693     set(CMake_TEST_XcodeProject_TIMEOUT 2000)
 694   endif()
 695   set_property(TEST RunCMake.XcodeProject PROPERTY TIMEOUT ${CMake_TEST_XcodeProject_TIMEOUT})
 696 endif()
 697
 698 if(CMAKE_C_COMPILER_ID STREQUAL "AppleClang"
 699     AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 6.0)
 700   add_RunCMake_test(Framework)
 701 endif()
 702
 703 add_RunCMake_test(File_Archive)
 704 add_RunCMake_test(File_Configure)
 705 add_RunCMake_test(File_Generate)
 706 add_RunCMake_test(ExportWithoutLanguage)
 707 add_RunCMake_test(target_link_directories)
 708 add_RunCMake_test(target_link_libraries)
 709 add_RunCMake_test(target_link_libraries-ALIAS)
 710 add_RunCMake_test(target_link_libraries-LINK_LANGUAGE)
 711 add_RunCMake_test(target_link_libraries-LINK_LANG_AND_ID)
 712 add_RunCMake_test(target_link_libraries-LINK_LIBRARY -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 713                                                      -DMINGW=${MINGW}
 714                                                      -DMSYS=${MSYS}
 715                                                      -DCYGWIN=${CYGWIN}
 716                                                      -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 717                                                      -DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
 718                                                      -DMSVC_VERSION=${MSVC_VERSION}
 719                                                      -DXCODE=${XCODE}
 720                                                      -DXCODE_VERSION=${XCODE_VERSION}
 721                                                      -DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
 722                                                      -DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX}
 723                                                      -DCMAKE_IMPORT_LIBRARY_PREFIX=${CMAKE_IMPORT_LIBRARY_PREFIX}
 724                                                      -DCMAKE_IMPORT_LIBRARY_SUFFIX=${CMAKE_IMPORT_LIBRARY_SUFFIX}
 725                                                      -DCMAKE_LINK_LIBRARY_FLAG=${CMAKE_LINK_LIBRARY_FLAG})
 726 add_RunCMake_test(target_link_libraries-LINK_GROUP -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 727                                                    -DMINGW=${MINGW}
 728                                                    -DMSYS=${MSYS}
 729                                                    -DCYGWIN=${CYGWIN}
 730                                                    -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 731                                                    -DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
 732                                                    -DMSVC_VERSION=${MSVC_VERSION}
 733                                                    -DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
 734                                                    -DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX}
 735                                                    -DCMAKE_IMPORT_LIBRARY_PREFIX=${CMAKE_IMPORT_LIBRARY_PREFIX}
 736                                                    -DCMAKE_IMPORT_LIBRARY_SUFFIX=${CMAKE_IMPORT_LIBRARY_SUFFIX}
 737                                                    -DCMAKE_LINK_LIBRARY_FLAG=${CMAKE_LINK_LIBRARY_FLAG})
 738 add_RunCMake_test(add_link_options -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
 739 add_RunCMake_test(target_link_options -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 740                                       -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
 741 set_property(TEST RunCMake.target_link_options APPEND
 742   PROPERTY LABELS "CUDA")
 743
 744 add_RunCMake_test(target_compile_definitions)
 745 add_RunCMake_test(target_compile_features)
 746 add_RunCMake_test(target_compile_options
 747   -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 748   -DCMAKE_C_SIMULATE_ID=${CMAKE_C_SIMULATE_ID}
 749   )
 750 add_RunCMake_test(target_include_directories)
 751 add_RunCMake_test(target_sources)
 752 add_RunCMake_test(CheckCompilerFlag   -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
 753                                       -DCMake_TEST_ISPC=${CMake_TEST_ISPC}
 754                                       -DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
 755                                       -DCMake_TEST_HIP=${CMake_TEST_HIP})
 756 add_RunCMake_test(CheckSourceCompiles -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
 757                                       -DCMake_TEST_ISPC=${CMake_TEST_ISPC}
 758                                       -DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
 759                                       -DCMake_TEST_HIP=${CMake_TEST_HIP})
 760 add_RunCMake_test(CheckSourceRuns     -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
 761                                       -DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
 762                                       -DCMake_TEST_HIP=${CMake_TEST_HIP})
 763 set_property(TEST RunCMake.CheckCompilerFlag
 764                   RunCMake.CheckSourceCompiles
 765                   RunCMake.CheckSourceRuns
 766     APPEND PROPERTY LABELS "CUDA")
 767 set_property(TEST RunCMake.CheckSourceCompiles
 768                   RunCMake.CheckCompilerFlag
 769     APPEND PROPERTY LABELS "ISPC")
 770 set_property(TEST RunCMake.CheckCompilerFlag
 771                   RunCMake.CheckSourceCompiles
 772                   RunCMake.CheckSourceRuns
 773     APPEND PROPERTY LABELS "HIP")
 774 add_RunCMake_test(CheckModules)
 775 add_RunCMake_test(CheckIPOSupported)
 776 if (CMAKE_SYSTEM_NAME MATCHES "(Linux|Darwin)"
 777     AND (CMAKE_C_COMPILER_ID MATCHES "Clang|GNU|LCC" OR CMAKE_Fortran_COMPILER_ID MATCHES "GNU|LCC"))
 778   add_RunCMake_test(CheckLinkerFlag -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 779                                     -DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
 780                                     -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
 781                                     -DCMake_TEST_HIP=${CMake_TEST_HIP})
 782   set_property(TEST RunCMake.CheckLinkerFlag APPEND PROPERTY LABELS "CUDA")
 783   set_property(TEST RunCMake.CheckLinkerFlag APPEND PROPERTY LABELS "HIP")
 784 endif()
 785
 786
 787 add_executable(pseudo_llvm-rc pseudo_llvm-rc.c)
 788 add_RunCMake_test(CommandLine -DLLVM_RC=$<TARGET_FILE:pseudo_llvm-rc> -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 789                   -DCYGWIN=${CYGWIN} -DMSYS=${MSYS} -DPython_EXECUTABLE=${Python_EXECUTABLE}
 790                   -DEXIT_CODE_EXE=$<TARGET_FILE:exit_code>)
 791 add_RunCMake_test(CommandLineTar)
 792
 793 if(CMAKE_PLATFORM_NO_VERSIONED_SONAME OR (NOT CMAKE_SHARED_LIBRARY_SONAME_FLAG AND NOT CMAKE_SHARED_LIBRARY_SONAME_C_FLAG))
 794   set(NO_NAMELINK 1)
 795 else()
 796   set(NO_NAMELINK 0)
 797 endif()
 798
 799 add_RunCMake_test(install -DNO_NAMELINK=${NO_NAMELINK} -DCYGWIN=${CYGWIN} -DMSYS=${MSYS}
 800   -DCMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN=${CMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN}
 801   -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 802   -DCMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG=${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG}
 803   -DCMAKE_EXECUTABLE_FORMAT=${CMAKE_EXECUTABLE_FORMAT}
 804   -DCMake_TEST_ISPC=${CMake_TEST_ISPC}
 805   )
 806 set_property(TEST RunCMake.install APPEND
 807   PROPERTY LABELS "ISPC")
 808
 809 add_RunCMake_test(file-GET_RUNTIME_DEPENDENCIES
 810   -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 811   -DCMake_INSTALL_NAME_TOOL_BUG=${CMake_INSTALL_NAME_TOOL_BUG}
 812   )
 813
 814 add_RunCMake_test(CPackCommandLine)
 815 add_RunCMake_test(CPackConfig)
 816 add_RunCMake_test(CPackInstallProperties)
 817 if(XCODE_VERSION)
 818   set(ExternalProject_ARGS -DXCODE_VERSION=${XCODE_VERSION})
 819 endif()
 820 if(CMake_TEST_RunCMake_ExternalProject_DOWNLOAD_SERVER_TIMEOUT)
 821   list(APPEND ExternalProject_ARGS -DDOWNLOAD_SERVER_TIMEOUT=${CMake_TEST_RunCMake_ExternalProject_DOWNLOAD_SERVER_TIMEOUT})
 822 endif()
 823 add_RunCMake_test(ExternalProject)
 824 add_RunCMake_test(FetchContent)
 825 add_RunCMake_test(FetchContent_find_package)
 826 set(CTestCommandLine_ARGS -DPython_EXECUTABLE=${Python_EXECUTABLE})
 827 if(NOT CMake_TEST_EXTERNAL_CMAKE)
 828   list(APPEND CTestCommandLine_ARGS -DTEST_AFFINITY=$<TARGET_FILE:testAffinity>)
 829 endif()
 830 add_executable(print_stdin print_stdin.c)
 831 add_RunCMake_test(CTestCommandLine -DTEST_PRINT_STDIN=$<TARGET_FILE:print_stdin>)
 832 add_RunCMake_test(CacheNewline)
 833 # Only run this test on unix platforms that support
 834 # symbolic links
 835 if(UNIX)
 836   add_RunCMake_test(CPackSymlinks)
 837 endif()
 838
 839 set(IfacePaths_INCDIRS_ARGS -DTEST_PROP=INCLUDE_DIRECTORIES)
 840 add_RunCMake_test(IfacePaths_INCDIRS TEST_DIR IfacePaths)
 841
 842 set(IfacePaths_SOURCES_ARGS -DTEST_PROP=SOURCES)
 843 add_RunCMake_test(IfacePaths_SOURCES TEST_DIR IfacePaths)
 844
 845 # Matlab module related tests
 846 if(CMake_TEST_FindMatlab OR CMake_TEST_FindMatlab_MCR OR (NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL ""))
 847     set(FindMatlab_additional_test_options )
 848     if(CMake_TEST_FindMatlab_MCR OR NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL "")
 849       set(FindMatlab_additional_test_options -DIS_MCR=TRUE)
 850     endif()
 851     if(NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL "")
 852       set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMCR_ROOT:FILEPATH=${CMake_TEST_FindMatlab_MCR_ROOT_DIR}")
 853     endif()
 854
 855   add_RunCMake_test(FindMatlab ${FindMatlab_additional_test_options})
 856   set_property(TEST RunCMake.FindMatlab APPEND PROPERTY LABELS "Matlab")
 857 endif()
 858
 859 add_executable(pseudo_emulator pseudo_emulator.c)
 860 add_executable(pseudo_emulator_custom_command pseudo_emulator_custom_command.c)
 861 add_executable(pseudo_emulator_custom_command_arg pseudo_emulator_custom_command_arg.c)
 862 add_RunCMake_test(CrosscompilingEmulator
 863  -DPSEUDO_EMULATOR=$<TARGET_FILE:pseudo_emulator>
 864  -DPSEUDO_EMULATOR_CUSTOM_COMMAND=$<TARGET_FILE:pseudo_emulator_custom_command>
 865  -DPSEUDO_EMULATOR_CUSTOM_COMMAND_ARG=$<TARGET_FILE:pseudo_emulator_custom_command_arg>)
 866 if("${CMAKE_GENERATOR}" MATCHES "Make|Ninja")
 867   if(UNIX AND NOT CYGWIN)
 868     execute_process(COMMAND ldd --help
 869       OUTPUT_VARIABLE LDD_HELP
 870       ERROR_VARIABLE LDD_ERR)
 871     if("${LDD_HELP}" MATCHES
 872         "(-r, --function-relocs.*process data and function relocations.*-u, --unused.*print unused direct dependencies)")
 873       add_RunCMake_test(LinkWhatYouUse)
 874     endif()
 875   endif()
 876   add_executable(pseudo_tidy pseudo_tidy.c)
 877   add_executable(pseudo_iwyu pseudo_iwyu.c)
 878   add_executable(pseudo_cpplint pseudo_cpplint.c)
 879   add_executable(pseudo_cppcheck pseudo_cppcheck.c)
 880   add_RunCMake_test(ClangTidy -DPSEUDO_TIDY=$<TARGET_FILE:pseudo_tidy>)
 881   add_RunCMake_test(IncludeWhatYouUse -DPSEUDO_IWYU=$<TARGET_FILE:pseudo_iwyu>)
 882   add_RunCMake_test(Cpplint -DPSEUDO_CPPLINT=$<TARGET_FILE:pseudo_cpplint>)
 883   add_RunCMake_test(Cppcheck -DPSEUDO_CPPCHECK=$<TARGET_FILE:pseudo_cppcheck>)
 884   add_RunCMake_test(MultiLint
 885     -DPSEUDO_TIDY=$<TARGET_FILE:pseudo_tidy>
 886     -DPSEUDO_IWYU=$<TARGET_FILE:pseudo_iwyu>
 887     -DPSEUDO_CPPLINT=$<TARGET_FILE:pseudo_cpplint>
 888     -DPSEUDO_CPPCHECK=$<TARGET_FILE:pseudo_cppcheck>
 889     )
 890   if(DEFINED CMake_TEST_CUDA)
 891     list(APPEND CompilerLauncher_ARGS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
 892   endif()
 893   if(DEFINED CMake_TEST_HIP)
 894     list(APPEND CompilerLauncher_ARGS -DCMake_TEST_HIP=${CMake_TEST_HIP})
 895   endif()
 896   if(DEFINED CMake_TEST_ISPC)
 897     list(APPEND CompilerLauncher_ARGS -DCMake_TEST_ISPC=${CMake_TEST_ISPC})
 898   endif()
 899   if(CMAKE_Fortran_COMPILER)
 900     list(APPEND CompilerLauncher_ARGS -DCMake_TEST_Fortran=1)
 901   endif()
 902   if (APPLE AND CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
 903     list(APPEND CompilerLauncher_ARGS -DCMake_TEST_OBJC=1)
 904     list(APPEND LinkerLauncher_ARGS -DCMake_TEST_OBJC=1)
 905   endif()
 906   add_RunCMake_test(CompilerLauncher)
 907   set_property(TEST RunCMake.CompilerLauncher APPEND
 908     PROPERTY LABELS "CUDA;HIP;ISPC")
 909   add_RunCMake_test(ctest_labels_for_subprojects)
 910   add_RunCMake_test(CompilerArgs)
 911   add_RunCMake_test(LinkerLauncher)
 912 endif()
 913
 914 set(cpack_tests
 915   DEB.CUSTOM_NAMES
 916   DEB.DEBUGINFO
 917   DEB.DEFAULT_PERMISSIONS
 918   DEB.DEPENDENCIES
 919   DEB.EMPTY_DIR
 920   DEB.VERSION
 921   DEB.EXTRA
 922   DEB.GENERATE_SHLIBS
 923   DEB.GENERATE_SHLIBS_LDCONFIG
 924   DEB.LONG_FILENAMES
 925   DEB.MINIMAL
 926   DEB.PER_COMPONENT_FIELDS
 927   DEB.TIMESTAMPS
 928   DEB.MD5SUMS
 929   DEB.DEB_PACKAGE_VERSION_BACK_COMPATIBILITY
 930   DEB.DEB_DESCRIPTION
 931   DEB.PROJECT_META
 932
 933   RPM.CUSTOM_BINARY_SPEC_FILE
 934   RPM.CUSTOM_NAMES
 935   RPM.DEBUGINFO
 936   RPM.DEFAULT_PERMISSIONS
 937   RPM.DEPENDENCIES
 938   RPM.DIST
 939   RPM.EMPTY_DIR
 940   RPM.VERSION
 941   RPM.INSTALL_SCRIPTS
 942   RPM.MAIN_COMPONENT
 943   RPM.MINIMAL
 944   RPM.PARTIALLY_RELOCATABLE_WARNING
 945   RPM.PER_COMPONENT_FIELDS
 946   RPM.SINGLE_DEBUGINFO
 947   RPM.EXTRA_SLASH_IN_PATH
 948   RPM.SOURCE_PACKAGE
 949   RPM.SUGGESTS
 950   RPM.SYMLINKS
 951   RPM.USER_FILELIST
 952   RPM.PROJECT_META
 953
 954   7Z
 955   TBZ2
 956   TGZ
 957   TXZ
 958   TZ
 959   ZIP
 960   STGZ
 961   External
 962   )
 963 if(APPLE)
 964   list(APPEND cpack_tests DragNDrop)
 965 endif()
 966 add_RunCMake_test_group(CPack "${cpack_tests}")
 967 # add a test to make sure symbols are exported from a shared library
 968 # for MSVC compilers CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS property is used
 969 add_RunCMake_test(AutoExportDll
 970   -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 971   -DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID}
 972   )
 973
 974 add_RunCMake_test(AndroidMK)
 975
 976 if(CMake_TEST_ANDROID_NDK OR CMake_TEST_ANDROID_STANDALONE_TOOLCHAIN)
 977   if(NOT "${CMAKE_GENERATOR}" MATCHES "Make|Ninja|Visual Studio 1[456]")
 978     message(FATAL_ERROR "Android tests supported only by Makefile, Ninja, and Visual Studio >= 14 generators")
 979   endif()
 980   foreach(v IN ITEMS TEST_ANDROID_NDK TEST_ANDROID_STANDALONE_TOOLCHAIN)
 981     if(CMake_${v})
 982       string(REPLACE ";" "|" ${v} "${CMake_${v}}")
 983       list(APPEND Android_ARGS "-D${v}=${${v}}")
 984     endif()
 985   endforeach()
 986
 987   add_RunCMake_test(Android)
 988
 989   # This test can take a very long time due to lots of combinations.
 990   # Use a long default timeout and provide an option to customize it.
 991   if(NOT DEFINED CMake_TEST_ANDROID_TIMEOUT)
 992     set(CMake_TEST_ANDROID_TIMEOUT 3000)
 993   endif()
 994   set_property(TEST RunCMake.Android PROPERTY TIMEOUT ${CMake_TEST_ANDROID_TIMEOUT})
 995 endif()
 996
 997 if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|9[0-9])")
 998   add_RunCMake_test(CSharpCustomCommand)
 999   if(NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
1000     add_RunCMake_test(CSharpReferenceImport)
1001   endif()
1002 endif()
1003
1004 add_RunCMake_test("CTestCommandExpandLists")
1005
1006 add_RunCMake_test(PrecompileHeaders -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
1007   -DCMAKE_C_SIMULATE_ID=${CMAKE_C_SIMULATE_ID}
1008   -DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION})
1009
1010 add_RunCMake_test("UnityBuild")
1011 add_RunCMake_test(CMakePresets
1012   -DPython_EXECUTABLE=${Python_EXECUTABLE}
1013   -DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
1014   )
1015 add_RunCMake_test(CMakePresetsBuild
1016   -DPython_EXECUTABLE=${Python_EXECUTABLE}
1017   -DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
1018   -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
1019   )
1020 add_RunCMake_test(CMakePresetsTest
1021   -DPython_EXECUTABLE=${Python_EXECUTABLE}
1022   -DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
1023   )
1024 add_RunCMake_test(CMakePresetsPackage
1025   -DPython_EXECUTABLE=${Python_EXECUTABLE}
1026   -DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
1027   )
1028 add_RunCMake_test(CMakePresetsWorkflow
1029   -DPython_EXECUTABLE=${Python_EXECUTABLE}
1030   -DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
1031   )
1032
1033 add_RunCMake_test(VerifyHeaderSets)
1034
1035 if(${CMAKE_GENERATOR} MATCHES "Make|Ninja")
1036   add_RunCMake_test(TransformDepfile)
1037 endif()
1038
1039 if(WIN32)
1040   add_RunCMake_test(Win32GenEx)
1041 endif()