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 endmacro()
  33
  34 function(add_RunCMake_test_group test types)
  35   # create directory for common content
  36   set(TEST_CONFIG_DIR "${CMAKE_CURRENT_BINARY_DIR}/${test}/conf")
  37   file(REMOVE_RECURSE "${TEST_CONFIG_DIR}")
  38   file(MAKE_DIRECTORY "${TEST_CONFIG_DIR}")
  39
  40   foreach(type IN LISTS types)
  41     # generate prerequirements config file in cmake as ctest doesn't have as
  42     # much system information so it is easier to set programs and environment
  43     # values here
  44     unset(${test}_${type}_FOUND_PREREQUIREMENTS)
  45     if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test}/${type}/Prerequirements.cmake")
  46       include("${CMAKE_CURRENT_SOURCE_DIR}/${test}/${type}/Prerequirements.cmake")
  47     else()
  48       string(REGEX MATCH "^[^.]*" main_type "${type}")
  49       include("${CMAKE_CURRENT_SOURCE_DIR}/${test}/${main_type}/Prerequirements.cmake")
  50     endif()
  51     get_test_prerequirements("${test}_${type}_FOUND_PREREQUIREMENTS"
  52         "${TEST_CONFIG_DIR}/${type}_config.cmake")
  53
  54     # only add the test if prerequirements are met
  55     if(${test}_${type}_FOUND_PREREQUIREMENTS)
  56       add_test(NAME RunCMake.${test}_${type} COMMAND ${CMAKE_CMAKE_COMMAND}
  57         -DTEST_TYPE=${type}
  58         -DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}
  59         -DRunCMake_GENERATOR_IS_MULTI_CONFIG=${_isMultiConfig}
  60         -DRunCMake_GENERATOR=${CMAKE_GENERATOR}
  61         -DRunCMake_GENERATOR_INSTANCE=${CMAKE_GENERATOR_INSTANCE}
  62         -DRunCMake_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
  63         -DRunCMake_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
  64         -DRunCMake_MAKE_PROGRAM=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
  65         -DRunCMake_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${test}
  66         -DRunCMake_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/${type}/${test}
  67         -Dconfig_file=${TEST_CONFIG_DIR}/${type}_config.cmake
  68         -P "${CMAKE_CURRENT_SOURCE_DIR}/${test}/RunCMakeTest.cmake"
  69         )
  70     endif()
  71   endforeach()
  72 endfunction()
  73
  74 # Some tests use python for extra checks.
  75 find_package(PythonInterp QUIET)
  76
  77 if(XCODE_VERSION AND "${XCODE_VERSION}" VERSION_LESS 6.1)
  78   set(Swift_ARGS -DXCODE_BELOW_6_1=1)
  79 endif()
  80
  81 # Test MSVC for older host CMake versions, and test
  82 # WIN32/CMAKE_C_COMPILER_ID to fix check on Intel for Windows.
  83 if(MSVC OR (WIN32 AND CMAKE_C_COMPILER_ID MATCHES "MSVC|Intel"))
  84   set(LINKER_SUPPORTS_PDB 1)
  85 else()
  86   set(LINKER_SUPPORTS_PDB 0)
  87 endif()
  88
  89 add_RunCMake_test(CMP0019)
  90 add_RunCMake_test(CMP0022)
  91 add_RunCMake_test(CMP0026)
  92 add_RunCMake_test(CMP0027)
  93 add_RunCMake_test(CMP0028)
  94 add_RunCMake_test(CMP0037)
  95 add_RunCMake_test(CMP0038)
  96 add_RunCMake_test(CMP0039)
  97 add_RunCMake_test(CMP0040)
  98 add_RunCMake_test(CMP0041)
  99 if(CMAKE_SYSTEM_NAME MATCHES Darwin AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
 100   add_RunCMake_test(CMP0042)
 101 endif()
 102 add_RunCMake_test(CMP0043)
 103 add_RunCMake_test(CMP0045)
 104 add_RunCMake_test(CMP0046)
 105 add_RunCMake_test(CMP0049)
 106 add_RunCMake_test(CMP0050)
 107 add_RunCMake_test(CMP0051)
 108 add_RunCMake_test(CMP0053)
 109 add_RunCMake_test(CMP0054)
 110 add_RunCMake_test(CMP0055)
 111 add_RunCMake_test(CMP0057)
 112 add_RunCMake_test(CMP0059)
 113 add_RunCMake_test(CMP0060)
 114 add_RunCMake_test(CMP0064)
 115 if(CMAKE_SYSTEM_NAME MATCHES Darwin AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
 116   add_RunCMake_test(CMP0068)
 117 endif()
 118 add_RunCMake_test(CMP0069)
 119 add_RunCMake_test(CMP0081)
 120 add_RunCMake_test(CMP0102)
 121 if(CMake_TEST_CUDA)
 122   add_RunCMake_test(CMP0104)
 123   set_property(TEST RunCMake.CMP0104 APPEND
 124     PROPERTY LABELS "CUDA")
 125 endif()
 126 add_RunCMake_test(CMP0106)
 127
 128 # The test for Policy 65 requires the use of the
 129 # CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS variable, which both the VS and Xcode
 130 # generators ignore.  The policy will have no effect on those generators.
 131 if(NOT CMAKE_GENERATOR MATCHES "Visual Studio|Xcode")
 132   add_RunCMake_test(CMP0065 -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
 133 endif()
 134 if(CMAKE_GENERATOR MATCHES "Make")
 135   add_RunCMake_test(Make -DMAKE_IS_GNU=${MAKE_IS_GNU})
 136 endif()
 137 if(CMAKE_GENERATOR MATCHES "Ninja")
 138   set(Ninja_ARGS
 139     -DCMAKE_C_OUTPUT_EXTENSION=${CMAKE_C_OUTPUT_EXTENSION}
 140     -DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
 141     -DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX})
 142   if(CMAKE_Fortran_COMPILER)
 143     list(APPEND Ninja_ARGS -DTEST_Fortran=1)
 144   endif()
 145   if(CMake_TEST_Qt5 AND Qt5Core_FOUND)
 146     list(APPEND Ninja_ARGS -DCMake_TEST_Qt5=1 -DCMAKE_TEST_Qt5Core_Version=${Qt5Core_VERSION})
 147   endif()
 148   add_RunCMake_test(Ninja)
 149   set(NinjaMultiConfig_ARGS
 150     -DCYGWIN=${CYGWIN}
 151     )
 152   if(CMake_TEST_Qt5 AND Qt5Core_FOUND)
 153     list(APPEND NinjaMultiConfig_ARGS -DCMake_TEST_Qt5=1)
 154   endif()
 155   if(DEFINED CMake_TEST_CUDA)
 156     list(APPEND NinjaMultiConfig_ARGS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
 157   endif()
 158   add_RunCMake_test(NinjaMultiConfig)
 159   set_property(TEST RunCMake.NinjaMultiConfig APPEND
 160     PROPERTY LABELS "CUDA")
 161 endif()
 162 add_RunCMake_test(CTest)
 163
 164 if(NOT CMake_TEST_EXTERNAL_CMAKE)
 165   add_RunCMake_test(ctest_memcheck
 166     -DPSEUDO_BC=$<TARGET_FILE:pseudo_BC>
 167     -DPSEUDO_PURIFY=$<TARGET_FILE:pseudo_purify>
 168     -DPSEUDO_VALGRIND=$<TARGET_FILE:pseudo_valgrind>
 169     -DPSEUDO_BC_NOLOG=$<TARGET_FILE:pseudonl_BC>
 170     -DPSEUDO_PURIFY_NOLOG=$<TARGET_FILE:pseudonl_purify>
 171     -DPSEUDO_VALGRIND_NOLOG=$<TARGET_FILE:pseudonl_valgrind>
 172     -DMEMCHECK_FAIL=$<TARGET_FILE:memcheck_fail>
 173     )
 174 endif()
 175
 176 add_RunCMake_test(AndroidTestUtilities)
 177 set(autogen_with_qt5 FALSE)
 178 if(CMake_TEST_Qt5)
 179   find_package(Qt5Widgets QUIET NO_MODULE)
 180 endif()
 181 if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND)
 182   set(autogen_with_qt5 TRUE)
 183 endif ()
 184 add_RunCMake_test(Autogen -Dwith_qt5=${autogen_with_qt5})
 185 if(NOT DEFINED CMake_TEST_BuildDepends_GNU_AS
 186     AND CMAKE_C_COMPILER_ID STREQUAL "GNU"
 187     AND CMAKE_GENERATOR MATCHES "^Ninja"
 188     )
 189   execute_process(COMMAND "${CMAKE_C_COMPILER}" -print-prog-name=as
 190     RESULT_VARIABLE _gnu_res
 191     OUTPUT_VARIABLE _gnu_as OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
 192   if(_gnu_res EQUAL 0 AND _gnu_as)
 193     set(CMake_TEST_BuildDepends_GNU_AS "${_gnu_as}")
 194   endif()
 195 endif()
 196 add_RunCMake_test(BuildDepends
 197   -DCMake_TEST_BuildDepends_GNU_AS=${CMake_TEST_BuildDepends_GNU_AS}
 198   )
 199 if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
 200   add_RunCMake_test(Byproducts)
 201 endif()
 202 add_RunCMake_test(CMakeRoleGlobalProperty)
 203 if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
 204   add_RunCMake_test(CompilerChange)
 205 endif()
 206 add_RunCMake_test(CompilerNotFound)
 207 add_RunCMake_test(Configure -DMSVC_IDE=${MSVC_IDE})
 208 add_RunCMake_test(DisallowedCommands)
 209 if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
 210   add_RunCMake_test(ExportCompileCommands)
 211 endif()
 212 add_RunCMake_test(ExternalData)
 213 add_RunCMake_test(FeatureSummary)
 214 add_RunCMake_test(FPHSA)
 215 add_RunCMake_test(FileAPI -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
 216                           -DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID})
 217 add_RunCMake_test(FindBoost)
 218 add_RunCMake_test(FindLua)
 219 add_RunCMake_test(FindOpenGL)
 220 if(CMake_TEST_UseSWIG)
 221   add_RunCMake_test(FindSWIG)
 222   add_RunCMake_test(UseSWIG -DCMake_TEST_FindPython=${CMake_TEST_FindPython})
 223 endif()
 224 if(NOT CMAKE_C_COMPILER_ID MATCHES "Watcom")
 225   add_RunCMake_test(GenerateExportHeader)
 226 endif()
 227 add_RunCMake_test(GenEx-COMPILE_LANGUAGE)
 228 add_RunCMake_test(GenEx-COMPILE_LANG_AND_ID)
 229 add_RunCMake_test(GenEx-LINK_LANGUAGE)
 230 add_RunCMake_test(GenEx-LINK_LANG_AND_ID)
 231 add_RunCMake_test(GenEx-HOST_LINK)
 232 add_RunCMake_test(GenEx-DEVICE_LINK)
 233 add_RunCMake_test(GenEx-TARGET_FILE -DLINKER_SUPPORTS_PDB=${LINKER_SUPPORTS_PDB})
 234 add_RunCMake_test(GenEx-GENEX_EVAL)
 235 add_RunCMake_test(GeneratorExpression)
 236 add_RunCMake_test(GeneratorInstance)
 237 add_RunCMake_test(GeneratorPlatform)
 238 add_RunCMake_test(GeneratorToolset)
 239 add_RunCMake_test(GetPrerequisites)
 240 add_RunCMake_test(GNUInstallDirs -DSYSTEM_NAME=${CMAKE_SYSTEM_NAME})
 241 add_RunCMake_test(GoogleTest) # Note: does not actually depend on Google Test
 242 add_RunCMake_test(Graphviz)
 243 add_RunCMake_test(TargetPropertyGeneratorExpressions)
 244 add_RunCMake_test(Languages)
 245 add_RunCMake_test(LinkStatic)
 246 if(CMAKE_CXX_COMPILER_ID MATCHES "^(Cray|PGI|XL|XLClang)$")
 247   add_RunCMake_test(MetaCompileFeatures)
 248 endif()
 249 if(MSVC)
 250   add_RunCMake_test(MSVCRuntimeLibrary)
 251   add_RunCMake_test(MSVCWarningFlags)
 252 endif()
 253 add_RunCMake_test(ObjectLibrary)
 254 add_RunCMake_test(ParseImplicitIncludeInfo)
 255 add_RunCMake_test(ParseImplicitLinkInfo)
 256 if(UNIX AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG AND CMAKE_EXECUTABLE_FORMAT STREQUAL "ELF")
 257   add_RunCMake_test(RuntimePath)
 258 endif()
 259 add_RunCMake_test(ScriptMode)
 260 add_RunCMake_test(Swift -DCMAKE_Swift_COMPILER=${CMAKE_Swift_COMPILER})
 261 add_RunCMake_test(TargetObjects)
 262 add_RunCMake_test(TargetSources)
 263 add_RunCMake_test(TargetProperties)
 264 add_RunCMake_test(ToolchainFile)
 265 add_RunCMake_test(find_dependency)
 266 add_RunCMake_test(CompileDefinitions)
 267 add_RunCMake_test(CompileFeatures)
 268 add_RunCMake_test(PolicyScope)
 269 add_RunCMake_test(WriteBasicConfigVersionFile)
 270 add_RunCMake_test(WriteCompilerDetectionHeader)
 271 add_RunCMake_test(SourceProperties)
 272 if(NOT WIN32)
 273   add_RunCMake_test(PositionIndependentCode -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 274                                             -DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID})
 275 endif()
 276 if(NOT CMAKE_GENERATOR MATCHES "Visual Studio")
 277   add_RunCMake_test(VisibilityPreset)
 278 endif()
 279 if (QT4_FOUND)
 280   set(CompatibleInterface_ARGS -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE})
 281 endif()
 282 add_RunCMake_test(CompatibleInterface)
 283 add_RunCMake_test(Syntax)
 284 add_RunCMake_test(WorkingDirectory)
 285 add_RunCMake_test(MaxRecursionDepth)
 286
 287 add_RunCMake_test(add_custom_command)
 288 add_RunCMake_test(add_custom_target)
 289 add_RunCMake_test(add_dependencies)
 290 add_RunCMake_test(add_executable)
 291 add_RunCMake_test(add_library)
 292 add_RunCMake_test(add_subdirectory)
 293 add_RunCMake_test(build_command)
 294 add_executable(exit_code exit_code.c)
 295 set(execute_process_ARGS -DEXIT_CODE_EXE=$<TARGET_FILE:exit_code>)
 296 if(NOT CMake_TEST_EXTERNAL_CMAKE)
 297   list(APPEND execute_process_ARGS -DTEST_ENCODING_EXE=$<TARGET_FILE:testEncoding>)
 298 endif()
 299 add_RunCMake_test(execute_process)
 300 add_RunCMake_test(export)
 301 add_RunCMake_test(cmake_language)
 302 add_RunCMake_test(cmake_minimum_required)
 303 add_RunCMake_test(cmake_parse_arguments)
 304 add_RunCMake_test(continue)
 305 add_executable(color_warning color_warning.c)
 306 add_RunCMake_test(ctest_build -DCOLOR_WARNING=$<TARGET_FILE:color_warning>)
 307 add_RunCMake_test(ctest_cmake_error)
 308 add_RunCMake_test(ctest_configure)
 309 if(COVERAGE_COMMAND)
 310   add_RunCMake_test(ctest_coverage -DCOVERAGE_COMMAND=${COVERAGE_COMMAND})
 311 endif()
 312 add_RunCMake_test(ctest_start)
 313 add_RunCMake_test(ctest_submit)
 314 add_RunCMake_test(ctest_test)
 315 add_RunCMake_test(ctest_disabled_test)
 316 add_RunCMake_test(ctest_skipped_test)
 317 add_RunCMake_test(ctest_update)
 318 add_RunCMake_test(ctest_upload)
 319 add_RunCMake_test(ctest_fixtures)
 320 add_RunCMake_test(file)
 321 add_RunCMake_test(find_file)
 322 add_RunCMake_test(find_library -DCYGWIN=${CYGWIN})
 323 add_RunCMake_test(find_package)
 324 add_RunCMake_test(find_path)
 325 add_RunCMake_test(find_program -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
 326 add_RunCMake_test(foreach)
 327 add_RunCMake_test(function)
 328 add_RunCMake_test(get_filename_component)
 329 add_RunCMake_test(get_property)
 330 add_RunCMake_test(if)
 331 add_RunCMake_test(include)
 332 add_RunCMake_test(include_directories)
 333 add_RunCMake_test(include_guard)
 334 add_RunCMake_test(list)
 335 add_RunCMake_test(load_cache)
 336 add_RunCMake_test(math)
 337 add_RunCMake_test(message)
 338 add_RunCMake_test(option)
 339 add_RunCMake_test(project -DCMake_TEST_RESOURCES=${CMake_TEST_RESOURCES})
 340 add_RunCMake_test(project_injected)
 341 add_RunCMake_test(return)
 342 add_RunCMake_test(separate_arguments)
 343 add_RunCMake_test(set_property)
 344 add_RunCMake_test(string)
 345 add_RunCMake_test(test_include_dirs)
 346 add_RunCMake_test(BundleUtilities)
 347 if(APPLE)
 348   add_RunCMake_test(INSTALL_NAME_DIR)
 349   add_RunCMake_test(MacOSVersions)
 350 endif()
 351
 352 function(add_RunCMake_test_try_compile)
 353   if(CMAKE_VERSION VERSION_LESS 3.9.20170907 AND "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
 354     # Older CMake versions do not know about MSVC language standards.
 355     # Approximate our logic from MSVC-CXX.cmake.
 356     if ((NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.24215.1 AND
 357          CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10) OR
 358          NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10.25017)
 359       set(CMAKE_CXX_STANDARD_DEFAULT 14)
 360     elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
 361       set(CMAKE_CXX_STANDARD_DEFAULT "")
 362     else()
 363       unset(CMAKE_CXX_STANDARD_DEFAULT)
 364     endif()
 365   endif()
 366   if(CMAKE_VERSION VERSION_LESS 3.18.20200813 AND "x${CMAKE_C_COMPILER_ID}" STREQUAL "xMSVC")
 367     # Older CMake versions do not know about MSVC language standards.
 368     # Approximate our logic from MSVC-C.cmake.
 369     if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 19.27)
 370       set(CMAKE_C_STANDARD_DEFAULT 99)
 371     else()
 372       set(CMAKE_C_STANDARD_DEFAULT "")
 373     endif()
 374   endif()
 375   foreach(var
 376       CMAKE_SYSTEM_NAME
 377       CMAKE_C_COMPILER_ID
 378       CMAKE_C_COMPILER_VERSION
 379       CMAKE_C_STANDARD_DEFAULT
 380       CMAKE_CXX_COMPILER_ID
 381       CMAKE_CXX_COMPILER_VERSION
 382       CMAKE_CXX_STANDARD_DEFAULT
 383       CMake_TEST_CUDA
 384       CMake_TEST_FILESYSTEM_1S
 385       CMAKE_OBJC_STANDARD_DEFAULT
 386       CMAKE_OBJCXX_STANDARD_DEFAULT
 387       )
 388     if(DEFINED ${var})
 389       list(APPEND try_compile_ARGS -D${var}=${${var}})
 390     endif()
 391   endforeach()
 392   add_RunCMake_test(try_compile)
 393   set_property(TEST RunCMake.try_compile APPEND
 394     PROPERTY LABELS "CUDA")
 395 endfunction()
 396 add_RunCMake_test_try_compile()
 397
 398 add_RunCMake_test(try_run -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 399                           -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
 400 add_RunCMake_test(set)
 401 add_RunCMake_test(variable_watch)
 402 add_RunCMake_test(while)
 403 add_RunCMake_test(CMP0004)
 404 add_RunCMake_test(TargetPolicies)
 405 add_RunCMake_test(alias_targets)
 406 add_RunCMake_test(interface_library)
 407 add_RunCMake_test(no_install_prefix)
 408 add_RunCMake_test(configure_file)
 409 add_RunCMake_test(CTestTimeout -DTIMEOUT=${CTestTestTimeout_TIME})
 410 add_RunCMake_test(CTestTimeoutAfterMatch)
 411
 412 # ctresalloc links against CMakeLib and CTestLib, which means it can't be built
 413 # if CMake_TEST_EXTERNAL_CMAKE is activated (the compiler might be different.)
 414 # So, it has to be provided in the original build tree.
 415 if(CMake_TEST_EXTERNAL_CMAKE)
 416   set(no_package_root_path)
 417   if(NOT CMAKE_VERSION VERSION_LESS 3.12)
 418     set(no_package_root_path NO_PACKAGE_ROOT_PATH)
 419   endif()
 420   find_program(ctresalloc ctresalloc PATHS ${CMake_TEST_EXTERNAL_CMAKE}
 421     NO_DEFAULT_PATH
 422     ${no_package_root_path}
 423     NO_CMAKE_PATH
 424     NO_CMAKE_ENVIRONMENT_PATH
 425     NO_SYSTEM_ENVIRONMENT_PATH
 426     NO_CMAKE_SYSTEM_PATH
 427     NO_CMAKE_FIND_ROOT_PATH
 428     )
 429   if(ctresalloc)
 430     add_executable(ctresalloc IMPORTED)
 431     set_property(TARGET ctresalloc PROPERTY IMPORTED_LOCATION ${ctresalloc})
 432   endif()
 433 else()
 434   add_executable(ctresalloc CTestResourceAllocation/ctresalloc.cxx)
 435   target_link_libraries(ctresalloc CTestLib)
 436   target_include_directories(ctresalloc PRIVATE
 437     ${CMake_BINARY_DIR}/Source
 438     ${CMake_SOURCE_DIR}/Source
 439     ${CMake_SOURCE_DIR}/Source/CTest
 440     )
 441   set_property(TARGET ctresalloc PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMake_BIN_DIR})
 442 endif()
 443
 444 if(TARGET ctresalloc)
 445   add_RunCMake_test(CTestResourceAllocation -DCTRESALLOC_COMMAND=$<TARGET_FILE:ctresalloc>)
 446 else()
 447   message(STATUS "Could not find ctresalloc")
 448 endif()
 449
 450 if(NOT WIN32)
 451   add_RunCMake_test(SymlinkTrees)
 452 endif ()
 453
 454 find_package(Qt4 QUIET)
 455 find_package(Qt5Core QUIET)
 456 if (QT4_FOUND AND Qt5Core_FOUND AND NOT Qt5Core_VERSION VERSION_LESS 5.1.0)
 457   add_RunCMake_test(IncompatibleQt)
 458 endif()
 459 if (QT4_FOUND)
 460   add_RunCMake_test(ObsoleteQtMacros -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE})
 461 endif()
 462
 463 find_package(PkgConfig QUIET)
 464 if(PKG_CONFIG_FOUND)
 465   add_RunCMake_test(FindPkgConfig)
 466 endif()
 467
 468 if(CMake_TEST_FindGTK2)
 469   add_RunCMake_test(FindGTK2)
 470 endif()
 471
 472 if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
 473   add_RunCMake_test(include_external_msproject -DVS_PLATFORM_NAME=${CMAKE_VS_PLATFORM_NAME})
 474   if("${CMAKE_GENERATOR}" MATCHES "Visual Studio (9|10)" AND NOT CMAKE_VS_DEVENV_COMMAND)
 475     set(NO_USE_FOLDERS 1)
 476   endif()
 477   add_RunCMake_test(VSSolution -DNO_USE_FOLDERS=${NO_USE_FOLDERS})
 478 endif()
 479
 480 if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([^9]|9[0-9])")
 481   add_RunCMake_test(VS10Project
 482     -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 483     -DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
 484     )
 485   if( vs12 AND wince )
 486     add_RunCMake_test( VS10ProjectWinCE "-DRunCMake_GENERATOR_PLATFORM=${wince_sdk}")
 487   endif()
 488 endif()
 489
 490 if(XCODE_VERSION)
 491   add_RunCMake_test(XcodeProject -DXCODE_VERSION=${XCODE_VERSION})
 492
 493   # This test can take a very long time due to lots of combinations.
 494   # Use a long default timeout and provide an option to customize it.
 495   if(NOT DEFINED CMake_TEST_XcodeProject_TIMEOUT)
 496     set(CMake_TEST_XcodeProject_TIMEOUT 2000)
 497   endif()
 498   set_property(TEST RunCMake.XcodeProject PROPERTY TIMEOUT ${CMake_TEST_XcodeProject_TIMEOUT})
 499 endif()
 500
 501 if(CMAKE_C_COMPILER_ID STREQUAL "AppleClang"
 502     AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 6.0)
 503   add_RunCMake_test(Framework)
 504 endif()
 505
 506 add_RunCMake_test(File_Archive)
 507 add_RunCMake_test(File_Configure)
 508 add_RunCMake_test(File_Generate)
 509 add_RunCMake_test(ExportWithoutLanguage)
 510 add_RunCMake_test(target_link_directories)
 511 add_RunCMake_test(target_link_libraries)
 512 add_RunCMake_test(target_link_libraries-ALIAS)
 513 add_RunCMake_test(target_link_libraries-LINK_LANGUAGE)
 514 add_RunCMake_test(target_link_libraries-LINK_LANG_AND_ID)
 515 add_RunCMake_test(add_link_options -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
 516 add_RunCMake_test(target_link_options -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 517                                       -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
 518 set_property(TEST RunCMake.target_link_options APPEND
 519   PROPERTY LABELS "CUDA")
 520
 521 add_RunCMake_test(target_compile_definitions)
 522 add_RunCMake_test(target_compile_features)
 523 add_RunCMake_test(target_compile_options -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
 524 add_RunCMake_test(target_include_directories)
 525 add_RunCMake_test(target_sources)
 526 add_RunCMake_test(CheckModules)
 527 add_RunCMake_test(CheckIPOSupported)
 528 if (CMAKE_SYSTEM_NAME MATCHES "(Linux|Darwin)"
 529     AND (CMAKE_C_COMPILER_ID MATCHES "Clang|GNU" OR CMAKE_Fortran_COMPILER_ID MATCHES "GNU"))
 530   add_RunCMake_test(CheckLinkerFlag -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 531                                     -DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID})
 532 endif()
 533
 534 add_RunCMake_test(CommandLine -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME} -DCYGWIN=${CYGWIN} -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE})
 535 add_RunCMake_test(CommandLineTar)
 536
 537 if(CMAKE_PLATFORM_NO_VERSIONED_SONAME OR (NOT CMAKE_SHARED_LIBRARY_SONAME_FLAG AND NOT CMAKE_SHARED_LIBRARY_SONAME_C_FLAG))
 538   set(NO_NAMELINK 1)
 539 else()
 540   set(NO_NAMELINK 0)
 541 endif()
 542
 543 add_RunCMake_test(install -DNO_NAMELINK=${NO_NAMELINK} -DCYGWIN=${CYGWIN}
 544   -DCMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN=${CMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN}
 545   -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 546   -DCMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG=${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG}
 547   -DCMAKE_EXECUTABLE_FORMAT=${CMAKE_EXECUTABLE_FORMAT}
 548   )
 549
 550 add_RunCMake_test(file-GET_RUNTIME_DEPENDENCIES
 551   -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
 552   -DCMake_INSTALL_NAME_TOOL_BUG=${CMake_INSTALL_NAME_TOOL_BUG}
 553   )
 554
 555 add_RunCMake_test(CPackCommandLine)
 556 add_RunCMake_test(CPackConfig)
 557 add_RunCMake_test(CPackInstallProperties)
 558 add_RunCMake_test(ExternalProject)
 559 add_RunCMake_test(FetchContent)
 560 set(CTestCommandLine_ARGS -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE})
 561 if(NOT CMake_TEST_EXTERNAL_CMAKE)
 562   list(APPEND CTestCommandLine_ARGS -DTEST_AFFINITY=$<TARGET_FILE:testAffinity>)
 563 endif()
 564 add_executable(print_stdin print_stdin.c)
 565 add_RunCMake_test(CTestCommandLine -DTEST_PRINT_STDIN=$<TARGET_FILE:print_stdin>)
 566 add_RunCMake_test(CacheNewline)
 567 # Only run this test on unix platforms that support
 568 # symbolic links
 569 if(UNIX)
 570   add_RunCMake_test(CPackSymlinks)
 571 endif()
 572
 573 set(IfacePaths_INCDIRS_ARGS -DTEST_PROP=INCLUDE_DIRECTORIES)
 574 add_RunCMake_test(IfacePaths_INCDIRS TEST_DIR IfacePaths)
 575
 576 set(IfacePaths_SOURCES_ARGS -DTEST_PROP=SOURCES)
 577 add_RunCMake_test(IfacePaths_SOURCES TEST_DIR IfacePaths)
 578
 579 # Matlab module related tests
 580 if(CMake_TEST_FindMatlab OR CMake_TEST_FindMatlab_MCR OR (NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL ""))
 581     set(FindMatlab_additional_test_options )
 582     if(CMake_TEST_FindMatlab_MCR OR NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL "")
 583       set(FindMatlab_additional_test_options -DIS_MCR=TRUE)
 584     endif()
 585     if(NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL "")
 586       set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMCR_ROOT:FILEPATH=${CMake_TEST_FindMatlab_MCR_ROOT_DIR}")
 587     endif()
 588
 589   add_RunCMake_test(FindMatlab ${FindMatlab_additional_test_options})
 590 endif()
 591
 592 add_executable(pseudo_emulator pseudo_emulator.c)
 593 add_executable(pseudo_emulator_custom_command pseudo_emulator_custom_command.c)
 594 add_executable(pseudo_emulator_custom_command_arg pseudo_emulator_custom_command_arg.c)
 595 add_RunCMake_test(CrosscompilingEmulator
 596  -DPSEUDO_EMULATOR=$<TARGET_FILE:pseudo_emulator>
 597  -DPSEUDO_EMULATOR_CUSTOM_COMMAND=$<TARGET_FILE:pseudo_emulator_custom_command>
 598  -DPSEUDO_EMULATOR_CUSTOM_COMMAND_ARG=$<TARGET_FILE:pseudo_emulator_custom_command_arg>)
 599 if("${CMAKE_GENERATOR}" MATCHES "Make|Ninja")
 600   if(UNIX AND NOT CYGWIN)
 601     execute_process(COMMAND ldd --help
 602       OUTPUT_VARIABLE LDD_HELP
 603       ERROR_VARIABLE LDD_ERR)
 604     if("${LDD_HELP}" MATCHES
 605         "(-r, --function-relocs.*process data and function relocations.*-u, --unused.*print unused direct dependencies)")
 606       add_RunCMake_test(LinkWhatYouUse)
 607     endif()
 608   endif()
 609   add_executable(pseudo_tidy pseudo_tidy.c)
 610   add_executable(pseudo_iwyu pseudo_iwyu.c)
 611   add_executable(pseudo_cpplint pseudo_cpplint.c)
 612   add_executable(pseudo_cppcheck pseudo_cppcheck.c)
 613   add_RunCMake_test(ClangTidy -DPSEUDO_TIDY=$<TARGET_FILE:pseudo_tidy>)
 614   add_RunCMake_test(IncludeWhatYouUse -DPSEUDO_IWYU=$<TARGET_FILE:pseudo_iwyu>)
 615   add_RunCMake_test(Cpplint -DPSEUDO_CPPLINT=$<TARGET_FILE:pseudo_cpplint>)
 616   add_RunCMake_test(Cppcheck -DPSEUDO_CPPCHECK=$<TARGET_FILE:pseudo_cppcheck>)
 617   add_RunCMake_test(MultiLint
 618     -DPSEUDO_TIDY=$<TARGET_FILE:pseudo_tidy>
 619     -DPSEUDO_IWYU=$<TARGET_FILE:pseudo_iwyu>
 620     -DPSEUDO_CPPLINT=$<TARGET_FILE:pseudo_cpplint>
 621     -DPSEUDO_CPPCHECK=$<TARGET_FILE:pseudo_cppcheck>
 622     )
 623   if(DEFINED CMake_TEST_CUDA)
 624     list(APPEND CompilerLauncher_ARGS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
 625   endif()
 626   if(CMAKE_Fortran_COMPILER)
 627     list(APPEND CompilerLauncher_ARGS -DCMake_TEST_Fortran=1)
 628   endif()
 629   if (APPLE AND CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
 630     list(APPEND CompilerLauncher_ARGS -DCMake_TEST_OBJC=1)
 631   endif()
 632   add_RunCMake_test(CompilerLauncher)
 633   set_property(TEST RunCMake.CompilerLauncher APPEND
 634     PROPERTY LABELS "CUDA")
 635   add_RunCMake_test(ctest_labels_for_subprojects)
 636 endif()
 637
 638 set(cpack_tests
 639   DEB.CUSTOM_NAMES
 640   DEB.DEBUGINFO
 641   DEB.DEFAULT_PERMISSIONS
 642   DEB.DEPENDENCIES
 643   DEB.EMPTY_DIR
 644   DEB.VERSION
 645   DEB.EXTRA
 646   DEB.GENERATE_SHLIBS
 647   DEB.GENERATE_SHLIBS_LDCONFIG
 648   DEB.LONG_FILENAMES
 649   DEB.MINIMAL
 650   DEB.PER_COMPONENT_FIELDS
 651   DEB.TIMESTAMPS
 652   DEB.MD5SUMS
 653   DEB.DEB_PACKAGE_VERSION_BACK_COMPATIBILITY
 654   DEB.DEB_DESCRIPTION
 655   DEB.PROJECT_META
 656
 657   RPM.CUSTOM_BINARY_SPEC_FILE
 658   RPM.CUSTOM_NAMES
 659   RPM.DEBUGINFO
 660   RPM.DEFAULT_PERMISSIONS
 661   RPM.DEPENDENCIES
 662   RPM.DIST
 663   RPM.EMPTY_DIR
 664   RPM.VERSION
 665   RPM.INSTALL_SCRIPTS
 666   RPM.MAIN_COMPONENT
 667   RPM.MINIMAL
 668   RPM.PARTIALLY_RELOCATABLE_WARNING
 669   RPM.PER_COMPONENT_FIELDS
 670   RPM.SINGLE_DEBUGINFO
 671   RPM.EXTRA_SLASH_IN_PATH
 672   RPM.SOURCE_PACKAGE
 673   RPM.SUGGESTS
 674   RPM.SYMLINKS
 675   RPM.USER_FILELIST
 676   RPM.PROJECT_META
 677
 678   7Z
 679   TBZ2
 680   TGZ
 681   TXZ
 682   TZ
 683   ZIP
 684   STGZ
 685   External
 686   )
 687 if(APPLE)
 688   list(APPEND cpack_tests DragNDrop)
 689 endif()
 690 add_RunCMake_test_group(CPack "${cpack_tests}")
 691 # add a test to make sure symbols are exported from a shared library
 692 # for MSVC compilers CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS property is used
 693 add_RunCMake_test(AutoExportDll
 694   -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
 695   -DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID}
 696   )
 697
 698 add_RunCMake_test(AndroidMK)
 699
 700 if(CMake_TEST_ANDROID_NDK OR CMake_TEST_ANDROID_STANDALONE_TOOLCHAIN)
 701   if(NOT "${CMAKE_GENERATOR}" MATCHES "Make|Ninja")
 702     message(FATAL_ERROR "Android tests supported only by Makefile and Ninja generators")
 703   endif()
 704   foreach(v TEST_ANDROID_NDK TEST_ANDROID_STANDALONE_TOOLCHAIN)
 705     if(CMake_${v})
 706       string(REPLACE ";" "|" ${v} "${CMake_${v}}")
 707       list(APPEND Android_ARGS "-D${v}=${${v}}")
 708     endif()
 709   endforeach()
 710
 711   add_RunCMake_test(Android)
 712
 713   # This test can take a very long time due to lots of combinations.
 714   # Use a long default timeout and provide an option to customize it.
 715   if(NOT DEFINED CMake_TEST_ANDROID_TIMEOUT)
 716     set(CMake_TEST_ANDROID_TIMEOUT 3000)
 717   endif()
 718   set_property(TEST RunCMake.Android PROPERTY TIMEOUT ${CMake_TEST_ANDROID_TIMEOUT})
 719 endif()
 720
 721 if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|9[0-9])")
 722   add_RunCMake_test(CSharpCustomCommand)
 723   add_RunCMake_test(CSharpReferenceImport)
 724 endif()
 725
 726 add_RunCMake_test("CTestCommandExpandLists")
 727
 728 add_RunCMake_test(PrecompileHeaders -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
 729 add_RunCMake_test("UnityBuild")