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