Tests/CMakeLists.txt

   1 # a macro for tests that have a simple format where the name matches the
   2 # directory and project
   3 macro(ADD_TEST_MACRO NAME)
   4   if(${ARGC} GREATER 1)
   5     set(_test_command --test-command ${ARGN})
   6   endif()
   7   string(REPLACE "." "/" dir "${NAME}")
   8   string(REGEX REPLACE "[^.]*\\." "" proj "${NAME}")
   9   add_test(NAME "${NAME}" COMMAND "${CMAKE_CTEST_COMMAND}"
  10     --build-and-test
  11     "${CMake_SOURCE_DIR}/Tests/${dir}"
  12     "${CMake_BINARY_DIR}/Tests/${dir}"
  13     --build-two-config
  14     ${build_generator_args}
  15     --build-project ${proj}
  16     ${${NAME}_CTEST_OPTIONS}
  17     --build-options
  18       ${${NAME}_BUILD_OPTIONS}
  19     ${_test_command})
  20   unset(_test_command)
  21   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${dir}")
  22 endmacro()
  23
  24 include(${CMAKE_CURRENT_SOURCE_DIR}/CheckFortran.cmake)
  25 include(${CMAKE_CURRENT_SOURCE_DIR}/CheckSwift.cmake)
  26
  27 # Fake a user home directory to avoid polluting the real one.
  28 if(NOT CTEST_NO_TEST_HOME AND (NOT WIN32 OR DEFINED ENV{HOME}))
  29   set(TEST_HOME "${CMake_BINARY_DIR}/Tests/CMakeFiles/TestHome")
  30   file(MAKE_DIRECTORY "${TEST_HOME}")
  31   file(WRITE "${TEST_HOME}/.cvspass" ":pserver:anoncvs@www.cmake.org:/cvsroot/KWSys A\n")
  32   set(TEST_HOME_ENV_CODE "# Fake a user home directory to avoid polluting the real one.
  33 # But provide original ENV{HOME} value in ENV{CTEST_REAL_HOME} for tests that
  34 # need access to the real HOME directory.
  35 if(DEFINED ENV{HOME} AND NOT DEFINED ENV{CTEST_REAL_HOME})
  36   set(ENV{CTEST_REAL_HOME} \"\$ENV{HOME}\")
  37 endif()
  38 set(ENV{HOME} \"${TEST_HOME}\")
  39 ")
  40 endif()
  41
  42 # Suppress generator deprecation warnings in test suite.
  43 if(CMAKE_GENERATOR MATCHES "^Visual Studio 11 2012")
  44   set(TEST_WARN_VS11_CODE "set(ENV{CMAKE_WARN_VS11} OFF)")
  45 else()
  46   set(TEST_WARN_VS11_CODE "")
  47 endif()
  48
  49 # 3.9 or later provides a definitive answer to whether we are multi-config
  50 # through a global property. Prior to 3.9, CMAKE_CONFIGURATION_TYPES being set
  51 # is assumed to mean multi-config, but developers might modify it so it is
  52 # technically not as reliable.
  53 if(NOT CMAKE_VERSION VERSION_LESS 3.9)
  54   get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
  55 elseif(CMAKE_CONFIGURATION_TYPES)
  56   set(_isMultiConfig True)
  57 else()
  58   set(_isMultiConfig False)
  59 endif()
  60
  61 # Choose a default configuration for CTest tests.
  62 set(CTestTest_CONFIG Debug)
  63 if(NOT _isMultiConfig AND CMAKE_BUILD_TYPE)
  64   set(CTestTest_CONFIG ${CMAKE_BUILD_TYPE})
  65 endif()
  66
  67 configure_file(${CMake_SOURCE_DIR}/Tests/EnforceConfig.cmake.in
  68                ${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake @ONLY)
  69
  70 # Testing
  71 if(BUILD_TESTING)
  72   set(CMake_TEST_DEVENV "")
  73   if(CMAKE_VS_DEVENV_COMMAND)
  74     set(CMake_TEST_DEVENV "${CMAKE_VS_DEVENV_COMMAND}")
  75   elseif(CMAKE_GENERATOR MATCHES "Visual Studio 9 " AND
  76       NOT CMAKE_MAKE_PROGRAM MATCHES "[mM][sS][bB][uU][iI][lL][dD]\\.[eE][xX][eE]")
  77     set(CMake_TEST_DEVENV "${CMAKE_MAKE_PROGRAM}")
  78   endif()
  79
  80   if(CMAKE_GENERATOR MATCHES "Visual Studio|Xcode")
  81     set(CMake_TEST_EXPLICIT_MAKE_PROGRAM "")
  82   else()
  83     set(CMake_TEST_EXPLICIT_MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM}")
  84   endif()
  85
  86   if(NOT CMake_TEST_EXTERNAL_CMAKE)
  87     if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles" OR ("${CMAKE_GENERATOR}" MATCHES Ninja AND NOT WIN32))
  88       set(TEST_CompileCommandOutput 1)
  89     endif()
  90   endif()
  91
  92   set(MAKE_IS_GNU)
  93   if(CMAKE_MAKE_PROGRAM MATCHES make)
  94     execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} no_such_target --version
  95       RESULT_VARIABLE res OUTPUT_VARIABLE out ERROR_VARIABLE out)
  96     if("${res}" STREQUAL "0")
  97       if("${out}" MATCHES "GNU")
  98         set(MAKE_IS_GNU 1)
  99       endif()
 100     endif()
 101   endif()
 102
 103   # some old versions of make simply cannot handle spaces in paths
 104   if(MAKE_IS_GNU OR
 105       CMAKE_MAKE_PROGRAM MATCHES "nmake|gmake|wmake" OR
 106       CMAKE_GENERATOR MATCHES "Visual Studio|Xcode|Borland|Ninja")
 107     set(MAKE_SUPPORTS_SPACES 1)
 108   else()
 109     set(MAKE_SUPPORTS_SPACES 0)
 110   endif()
 111
 112   # assume no resources building to test
 113   set(CMake_TEST_RESOURCES FALSE)
 114   # for windows and cygwin assume we have resources
 115   if(WIN32 OR CYGWIN)
 116     set(CMake_TEST_RESOURCES TRUE)
 117   endif()
 118   # for borland and watcom there is no resource support
 119   if(WATCOM OR BORLAND)
 120     set(CMake_TEST_RESOURCES FALSE)
 121   endif()
 122
 123   set(build_generator_args
 124     --build-generator ${CMAKE_GENERATOR}
 125     )
 126   if(CMAKE_GENERATOR_PLATFORM)
 127     list(APPEND build_generator_args
 128       --build-generator-platform ${CMAKE_GENERATOR_PLATFORM}
 129       )
 130   endif()
 131   if(CMAKE_GENERATOR_TOOLSET)
 132     list(APPEND build_generator_args
 133       --build-generator-toolset ${CMAKE_GENERATOR_TOOLSET}
 134       )
 135   endif()
 136
 137   if(CMake_TEST_EXPLICIT_MAKE_PROGRAM)
 138     list(APPEND build_generator_args
 139       --build-makeprogram ${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
 140       )
 141   endif()
 142
 143   # Look for rpmbuild to use for tests.
 144   # The tool does not work with spaces in the path.
 145   if(NOT CMAKE_CURRENT_BINARY_DIR MATCHES " ")
 146     find_program(RPMBUILD_EXECUTABLE NAMES rpmbuild)
 147   else()
 148     set(RPMBUILD_EXECUTABLE "RPMBUILD_EXECUTABLE-NOTFOUND")
 149   endif()
 150
 151   if(RPMBUILD_EXECUTABLE)
 152     set(CPACK_BINARY_RPM ON)
 153   else()
 154     set(CPACK_BINARY_RPM OFF)
 155   endif()
 156
 157   # Look for dpkg to use for tests.
 158   find_program(DPKG_EXECUTABLE NAMES dpkg)
 159
 160   if(DPKG_EXECUTABLE)
 161     set(CPACK_BINARY_DEB ON)
 162   else()
 163     set(CPACK_BINARY_DEB OFF)
 164   endif()
 165
 166   # Look for NuGet to use for tests.
 167   find_program(NUGET_EXECUTABLE NAMES NuGet nuget)
 168
 169   if(NUGET_EXECUTABLE)
 170     set(CPACK_BINARY_NUGET ON)
 171   else()
 172     set(CPACK_BINARY_NUGET OFF)
 173   endif()
 174
 175   if(WIN32)
 176     # Macro to search for available Windows CE SDKs in the windows Registry
 177     macro(select_wince_sdk selected_reg selected_sdk)
 178       if(CMAKE_HOST_WIN32)
 179         execute_process(COMMAND reg QUERY "HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows CE Tools\\SDKs"
 180                     OUTPUT_VARIABLE sdk_reg
 181                     ERROR_VARIABLE my_err)
 182         string(REGEX REPLACE "HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Wow6432Node\\\\Microsoft\\\\Windows CE Tools\\\\SDKs\\\\"  ";" sdk_list "${sdk_reg}")
 183         list(LENGTH sdk_list sdk_list_len)
 184         if(${sdk_list_len} GREATER 1)
 185           list(GET sdk_list 1 _sdk) # The first entry is always empty due to the regex replace above
 186           string(STRIP ${_sdk} _sdk) # Make sure there is no newline in the SDK name
 187         endif()
 188         # Build a key to be used by get_filename_component that is pointing to the SDK directory
 189         set(_reg "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows CE Tools\\SDKs\\${_sdk}]")
 190         # Set return values
 191         set(${selected_reg} ${_reg})
 192         set(${selected_sdk} ${_sdk})
 193       endif(CMAKE_HOST_WIN32)
 194     endmacro(select_wince_sdk)
 195
 196     set(reg_vs10 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0;InstallDir]")
 197     set(reg_vs11 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\11.0;InstallDir]")
 198     set(reg_vs12 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\12.0;InstallDir]")
 199     set(reg_vs14 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\14.0;InstallDir]")
 200     set(reg_ws80 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.0;InstallationFolder]")
 201     set(reg_ws81 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.1;InstallationFolder]")
 202     set(reg_ws10_0 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\14.0\\Setup\\Build Tools for Windows 10;srcPath]")
 203     set(reg_wp80 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\WindowsPhone\\v8.0;InstallationFolder]")
 204     set(reg_wp81 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\WindowsPhone\\v8.1;InstallationFolder]")
 205     select_wince_sdk(reg_wince wince_sdk)
 206     set(reg_tegra "[HKEY_LOCAL_MACHINE\\SOFTWARE\\NVIDIA Corporation\\Nsight Tegra;sdkRoot]")
 207     set(reg_nasm "[HKEY_CURRENT_USER\\SOFTWARE\\nasm]")
 208     foreach(reg IN ITEMS vs10 vs11 vs12 vs14 ws80 ws81 ws10_0 wp80 wp81 wince tegra nasm)
 209       get_filename_component(r "${reg_${reg}}" ABSOLUTE)
 210       if(IS_DIRECTORY "${r}" AND NOT "${r}" STREQUAL "/registry")
 211         set(${reg} 1)
 212       else()
 213         set(${reg} 0)
 214       endif()
 215     endforeach()
 216     if(CMAKE_HOST_WIN32 AND COMMAND cmake_host_system_information)
 217       set(info_vs15 "VS_15_DIR")
 218       set(info_vs16 "VS_16_DIR")
 219       set(info_vs17 "VS_17_DIR")
 220       set(vs_versions)
 221       if(WIN32)
 222         if(NOT CMAKE_VERSION VERSION_LESS 3.21.20210624)
 223           set(vs_versions vs15 vs16 vs17)
 224         elseif(NOT CMAKE_VERSION VERSION_LESS 3.14)
 225           set(vs_versions vs15 vs16)
 226         elseif(NOT CMAKE_VERSION VERSION_LESS 3.8)
 227           set(vs_versions vs15)
 228         endif()
 229       endif()
 230       foreach(info IN LISTS vs_versions)
 231         cmake_host_system_information(RESULT found QUERY "${info_${info}}")
 232         if(found)
 233           set(${info} 1)
 234         else()
 235           set(${info} 0)
 236         endif()
 237       endforeach()
 238     endif()
 239   endif()
 240
 241   if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT DEFINED CMake_TEST_APPLE_SILICON)
 242     execute_process(COMMAND sysctl -q hw.optional.arm64
 243       OUTPUT_VARIABLE _sysctl_stdout
 244       ERROR_VARIABLE  _sysctl_stderr
 245       RESULT_VARIABLE _sysctl_result
 246       )
 247     if(_sysctl_result EQUAL 0 AND _sysctl_stdout MATCHES "hw.optional.arm64: 1")
 248       set(CMake_TEST_APPLE_SILICON 1)
 249     else()
 250       set(CMake_TEST_APPLE_SILICON 0)
 251     endif()
 252     unset(_sysctl_result)
 253     unset(_sysctl_stderr)
 254     unset(_sysctl_stdout)
 255   endif()
 256
 257   #---------------------------------------------------------------------------
 258   # Add tests below here.
 259
 260   if(NOT DEFINED CMake_TEST_Qt6)
 261     set(CMake_TEST_Qt6 1)
 262   endif()
 263   if(CMake_TEST_Qt6)
 264     find_package(Qt6 COMPONENTS Core Widgets QUIET NO_MODULE)
 265   endif()
 266
 267   if(NOT DEFINED CMake_TEST_Qt5)
 268     set(CMake_TEST_Qt5 1)
 269   endif()
 270   if(CMake_TEST_Qt5)
 271     find_package(Qt5Widgets QUIET NO_MODULE)
 272   endif()
 273
 274   if(NOT CMake_TEST_EXTERNAL_CMAKE)
 275     add_subdirectory(CMakeLib)
 276   endif()
 277   add_subdirectory(CMakeOnly)
 278   add_subdirectory(RunCMake)
 279
 280   add_subdirectory(FindPackageModeMakefileTest)
 281
 282   # Collect a list of all test build directories.
 283   set(TEST_BUILD_DIRS)
 284
 285   # Should the long tests be run?
 286   option(CMAKE_RUN_LONG_TESTS
 287     "Should the long tests be run (such as Bootstrap)." ON)
 288   mark_as_advanced(CMAKE_RUN_LONG_TESTS)
 289
 290   if(CMAKE_RUN_LONG_TESTS)
 291     option(CTEST_TEST_CTEST
 292       "Should the tests that run a full sub ctest process be run?"
 293       OFF)
 294     mark_as_advanced(CTEST_TEST_CTEST)
 295   endif()
 296
 297   option(CTEST_TEST_CPACK
 298     "Should the tests that use '--build-target package' be run?"
 299     ON)
 300   mark_as_advanced(CTEST_TEST_CPACK)
 301   set(CTEST_TEST_OSX_ARCH 0)
 302   set(CMake_TEST_XCODE_VERSION 0)
 303   if(APPLE)
 304     set(CTEST_TEST_OSX_ARCH 1)
 305     if(XCODE_VERSION)
 306       set(CMake_TEST_XCODE_VERSION "${XCODE_VERSION}")
 307     else()
 308       execute_process(
 309         COMMAND xcodebuild -version
 310         OUTPUT_VARIABLE _version ERROR_VARIABLE _version_err
 311         )
 312       if(_version MATCHES "^Xcode ([0-9]+(\\.[0-9]+)*)")
 313         set(CMake_TEST_XCODE_VERSION "${CMAKE_MATCH_1}")
 314       endif()
 315     endif()
 316     if(NOT CMake_TEST_XCODE_VERSION VERSION_LESS 10)
 317       # Since Xcode 10 we do not have two supported architectures for the host.
 318       set(CTEST_TEST_OSX_ARCH 0)
 319     endif()
 320     if(CMAKE_OSX_SYSROOT)
 321       execute_process(
 322         COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version ProductName
 323         OUTPUT_VARIABLE _stdout
 324         OUTPUT_STRIP_TRAILING_WHITESPACE
 325         ERROR_VARIABLE _stderr
 326         RESULT_VARIABLE _failed
 327         )
 328       if(NOT _failed)
 329         set(CMAKE_OSX_SDKPRODUCT "${_stdout}")
 330       endif()
 331
 332       execute_process(
 333         COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version SDKVersion
 334         OUTPUT_VARIABLE _stdout
 335         OUTPUT_STRIP_TRAILING_WHITESPACE
 336         ERROR_VARIABLE _stderr
 337         RESULT_VARIABLE _failed
 338         )
 339       if(NOT _failed)
 340         set(CMAKE_OSX_SDKVERSION "${_stdout}")
 341       endif()
 342     endif()
 343   endif()
 344
 345   # Use 1500 or CTEST_TEST_TIMEOUT for long test timeout value,
 346   # whichever is greater.
 347   set(CMAKE_LONG_TEST_TIMEOUT 1500)
 348   if(CTEST_TEST_TIMEOUT)
 349     set(CMAKE_LONG_TEST_TIMEOUT ${CTEST_TEST_TIMEOUT})
 350   endif()
 351   if(CMAKE_LONG_TEST_TIMEOUT LESS 1500)
 352     set(CMAKE_LONG_TEST_TIMEOUT 1500)
 353   endif()
 354
 355   add_test(NAME CMake.Copyright
 356     COMMAND ${CMAKE_CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/CMakeCopyright.cmake)
 357
 358   # add a bunch of standard build-and-test style tests
 359   ADD_TEST_MACRO(CommandLineTest CommandLineTest)
 360   ADD_TEST_MACRO(FindPackageTest FindPackageTest)
 361   ADD_TEST_MACRO(StringFileTest StringFileTest)
 362   ADD_TEST_MACRO(TryCompile TryCompile)
 363   ADD_TEST_MACRO(SystemInformation SystemInformation)
 364   ADD_TEST_MACRO(MathTest MathTest)
 365   ADD_TEST_MACRO(CompileFeatures CompileFeatures)
 366   ADD_TEST_MACRO(CMakeCommands.target_compile_features)
 367
 368   if(CMake_TEST_RESOURCES)
 369     ADD_TEST_MACRO(VSResource VSResource)
 370     if(CMAKE_GENERATOR MATCHES "Ninja")
 371       add_test_macro(VSResourceNinjaForceRSP VSResourceNinjaForceRSP)
 372     endif()
 373   endif()
 374   if(_isMultiConfig)
 375     set(MSManifest_CTEST_OPTIONS -C $<CONFIGURATION>)
 376   endif()
 377   ADD_TEST_MACRO(MSManifest ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
 378   ADD_TEST_MACRO(Simple Simple)
 379   ADD_TEST_MACRO(PreOrder PreOrder)
 380   ADD_TEST_MACRO(MissingSourceFile MissingSourceFile)
 381   set_tests_properties(MissingSourceFile PROPERTIES
 382     PASS_REGULAR_EXPRESSION "CMake Error at CMakeLists.txt:3 \\(add_executable\\):[ \r\n]*Cannot find source file:[ \r\n]*DoesNotExist/MissingSourceFile.c")
 383   if(CMake_TEST_XCODE_VERSION AND CMAKE_OSX_SDKVERSION AND CMAKE_OSX_SDKPRODUCT)
 384     if((NOT CMake_TEST_XCODE_VERSION VERSION_LESS 6.1) AND
 385        ((NOT CMAKE_OSX_SDKPRODUCT STREQUAL "Mac OS X") OR
 386         (NOT CMAKE_OSX_SDKVERSION VERSION_LESS 10.10)))
 387       if(CMAKE_GENERATOR STREQUAL "Xcode")
 388         set(CMake_TEST_XCODE_SWIFT 1)
 389       endif()
 390     endif()
 391   endif()
 392   if(CMAKE_Swift_COMPILER OR CMake_TEST_XCODE_SWIFT)
 393     ADD_TEST_MACRO(SwiftOnly SwiftOnly)
 394     if(CMake_TEST_XCODE_SWIFT)
 395       ADD_TEST_MACRO(SwiftMix SwiftMix)
 396     endif()
 397     if(CMAKE_Swift_COMPILER_VERSION VERSION_GREATER_EQUAL 5.1)
 398       ADD_TEST_MACRO(SwiftMixLib Swifty)
 399     endif()
 400   endif()
 401   if(CMAKE_Fortran_COMPILER)
 402     ADD_TEST_MACRO(FortranOnly FortranOnly)
 403   endif()
 404   # test Visual Studio GNU Fortran mixing with cmake_add_fortran_subdirectory
 405   # run this project if we have a working fortran compiler or
 406   # the test is enabled with CMAKE_TEST_CMAKE_ADD_FORTRAN cache variable.
 407   # If you enable the test, CMake should find the MinGW fortran install,
 408   # or in some cases you might need to set the PATH so that cmake can find
 409   # the gfortran from mingw.
 410   if(CMAKE_Fortran_COMPILER OR CMAKE_TEST_CMAKE_ADD_FORTRAN)
 411     set(CMAKE_SKIP_VSGNUFortran FALSE)
 412     # disable test for apple builds using ifort if they are building
 413     # more than one architecture, as ifort does not support that.
 414     if(APPLE AND (CMAKE_Fortran_COMPILER MATCHES ifort))
 415       list(LENGTH CMAKE_OSX_ARCHITECTURES len)
 416       if("${len}" GREATER 1)
 417         message(STATUS "Skip VSGNUFortran for ifort dual cpu mac build")
 418         set(CMAKE_SKIP_VSGNUFortran TRUE)
 419       endif()
 420     endif()
 421     if(CMAKE_Fortran_COMPILER_ID STREQUAL IntelLLVM)
 422       message(STATUS "Skip VSGNUFortran for ifx until DLLEXPORT support is implemented")
 423       set(CMAKE_SKIP_VSGNUFortran TRUE)
 424     endif()
 425     if((CMAKE_C_COMPILER MATCHES lsb)
 426         AND (CMAKE_Fortran_COMPILER MATCHES ifort))
 427       message(STATUS "Skip VSGNUFortran for ifort and lsb compilers")
 428       set(CMAKE_SKIP_VSGNUFortran TRUE)
 429     endif()
 430     if(NOT CMAKE_SKIP_VSGNUFortran)
 431       ADD_TEST_MACRO(VSGNUFortran ${CMAKE_CMAKE_COMMAND} -P runtest.cmake)
 432     endif()
 433   endif()
 434
 435   if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|[9][0-9])")
 436     ADD_TEST_MACRO(CSharpOnly CSharpOnly)
 437     if(NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
 438       ADD_TEST_MACRO(CSharpLinkToCxx CSharpLinkToCxx)
 439       ADD_TEST_MACRO(CSharpLinkFromCxx CSharpLinkFromCxx)
 440     endif()
 441     ADD_TEST_MACRO(CSharpWin32GenEx CSharpWin32GenEx)
 442     set_tests_properties(CSharpWin32GenEx PROPERTIES
 443       PASS_REGULAR_EXPRESSION "Target \"CSharpWin32GenEx\" has a generator expression in its\n  WIN32_EXECUTABLE property\\.  This is not supported on managed executables\\."
 444       )
 445   endif()
 446
 447   ADD_TEST_MACRO(COnly COnly)
 448   ADD_TEST_MACRO(CxxOnly CxxOnly)
 449   ADD_TEST_MACRO(CxxSubdirC CxxSubdirC)
 450   ADD_TEST_MACRO(OutDir runtime/OutDir)
 451   ADD_TEST_MACRO(OutName exe.OutName.exe)
 452   ADD_TEST_MACRO(ObjectLibrary UseCshared)
 453   ADD_TEST_MACRO(NewlineArgs NewlineArgs)
 454   ADD_TEST_MACRO(SetLang SetLangX)
 455   ADD_TEST_MACRO(EmptyProperty EmptyProperty)
 456   ADD_TEST_MACRO(ExternalOBJ ExternalOBJ)
 457   if(NOT CMake_TEST_EXTERNAL_CMAKE)
 458     ADD_TEST_MACRO(LoadCommand LoadedCommand)
 459   endif()
 460   ADD_TEST_MACRO(LinkDirectory bin/LinkDirectory)
 461   ADD_TEST_MACRO(LinkLanguage LinkLanguage)
 462   ADD_TEST_MACRO(LinkLine LinkLine)
 463   ADD_TEST_MACRO(MacroTest miniMacroTest)
 464   ADD_TEST_MACRO(FunctionTest miniFunctionTest)
 465   ADD_TEST_MACRO(ReturnTest ReturnTest)
 466   ADD_TEST_MACRO(Properties Properties)
 467   ADD_TEST_MACRO(Assembler HelloAsm)
 468   ADD_TEST_MACRO(SourceGroups SourceGroups)
 469   ADD_TEST_MACRO(Preprocess Preprocess)
 470   set(ExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
 471                                  -DCMake_TEST_CUDA:BOOL=${CMake_TEST_CUDA}
 472                                  -DCMake_INSTALL_NAME_TOOL_BUG:BOOL=${CMake_INSTALL_NAME_TOOL_BUG}
 473                                  )
 474   ADD_TEST_MACRO(ExportImport ExportImport)
 475   set_property(TEST ExportImport APPEND
 476     PROPERTY LABELS "CUDA")
 477   ADD_TEST_MACRO(Unset Unset)
 478   ADD_TEST_MACRO(PolicyScope PolicyScope)
 479   ADD_TEST_MACRO(EmptyLibrary EmptyLibrary)
 480   ADD_TEST_MACRO(CompileDefinitions CompileDefinitions)
 481   if(CMAKE_Fortran_COMPILER)
 482     set(CompileOptions_BUILD_OPTIONS -DTEST_FORTRAN=1)
 483   endif()
 484   if(_isMultiConfig)
 485     set(CompileOptions_CTEST_OPTIONS --build-config $<CONFIGURATION>)
 486   else()
 487     set(CompileOptions_BUILD_OPTIONS -DCMAKE_BUILD_TYPE=$<CONFIGURATION>)
 488   endif()
 489   ADD_TEST_MACRO(CompileOptions CompileOptions)
 490   ADD_TEST_MACRO(CompatibleInterface CompatibleInterface)
 491   ADD_TEST_MACRO(AliasTarget AliasTarget)
 492   ADD_TEST_MACRO(StagingPrefix StagingPrefix)
 493   ADD_TEST_MACRO(ImportedSameName ImportedSameName)
 494   ADD_TEST_MACRO(InterfaceLibrary InterfaceLibrary)
 495   if(NOT CMAKE_GENERATOR STREQUAL "Xcode")
 496     if(_isMultiConfig)
 497       set(ConfigSources_CTEST_OPTIONS --build-config $<CONFIGURATION>)
 498     else()
 499       set(ConfigSources_BUILD_OPTIONS -DCMAKE_BUILD_TYPE=$<CONFIGURATION>)
 500     endif()
 501     ADD_TEST_MACRO(ConfigSources ConfigSources)
 502   endif()
 503   ADD_TEST_MACRO(SourcesProperty SourcesProperty)
 504   ADD_TEST_MACRO(SourceFileProperty SourceFileProperty)
 505   if(NOT CMAKE_GENERATOR STREQUAL "Xcode")
 506     ADD_TEST_MACRO(SourceFileIncludeDirProperty SourceFileIncludeDirProperty)
 507   endif()
 508   if(CMAKE_CXX_COMPILER_ID STREQUAL "LCC" OR (CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
 509       AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7))
 510     set(runCxxDialectTest 1)
 511   endif()
 512   if(CMAKE_CXX_COMPILER_ID STREQUAL Clang
 513         AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4 AND NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
 514     if(NOT APPLE OR POLICY CMP0025)
 515       set(runCxxDialectTest 1)
 516     endif()
 517   endif()
 518   if(runCxxDialectTest)
 519     ADD_TEST_MACRO(CxxDialect CxxDialect)
 520   endif()
 521   set_tests_properties(EmptyLibrary PROPERTIES
 522     PASS_REGULAR_EXPRESSION "CMake Error: CMake can not determine linker language for target: test")
 523   ADD_TEST_MACRO(CrossCompile CrossCompile)
 524   set_tests_properties(CrossCompile PROPERTIES
 525     PASS_REGULAR_EXPRESSION "try_run.. invoked in cross-compiling mode")
 526   if("${CMAKE_GENERATOR}" MATCHES "Make")
 527     ADD_TEST_MACRO(Policy0002 Policy0002)
 528   endif()
 529   if(CTEST_TEST_OSX_ARCH)
 530     ADD_TEST_MACRO(Architecture Architecture)
 531     set_tests_properties(Architecture PROPERTIES
 532       PASS_REGULAR_EXPRESSION "(file is not of required architecture|does not match cputype|not the architecture being linked|but attempting to link with file built for)")
 533   endif()
 534
 535   list(APPEND TEST_BUILD_DIRS ${CMake_TEST_INSTALL_PREFIX})
 536
 537   if(NOT DEFINED CMake_TEST_Qt4)
 538     set(CMake_TEST_Qt4 1)
 539   endif()
 540   if(CMake_TEST_Qt4 AND NOT QT4_FOUND)
 541     find_package(Qt4 QUIET)
 542   endif()
 543
 544   if(CMake_TEST_Qt4 AND QT4_FOUND)
 545     # test whether the Qt4 which has been found works, on some machines
 546     # which run nightly builds there were errors like "wrong file format"
 547     # for libQtCore.so. So first check it works, and only if it does add
 548     # the automoc test.
 549     include(CheckCXXSourceCompiles)
 550     set(_save_CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}")
 551     set(_save_CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}")
 552
 553     set(CMAKE_REQUIRED_INCLUDES ${QT_INCLUDES})
 554     set(CMAKE_REQUIRED_LIBRARIES ${QT_QTCORE_LIBRARIES})
 555
 556     CHECK_CXX_SOURCE_COMPILES("#include <QCoreApplication>\n int main() {return (qApp == 0 ? 0 : 1); }\n"
 557                               QT4_WORKS)
 558
 559     set(CMAKE_REQUIRED_INCLUDES "${_save_CMAKE_REQUIRED_INCLUDES}")
 560     set(CMAKE_REQUIRED_LIBRARIES "${_save_CMAKE_REQUIRED_LIBRARIES}")
 561   endif()
 562
 563   # run test for BundleUtilities on supported platforms/compilers
 564   if(MSVC OR
 565      MINGW OR
 566      CMAKE_SYSTEM_NAME MATCHES "Linux" OR
 567      CMAKE_SYSTEM_NAME MATCHES "Darwin")
 568   if(NOT "${CMAKE_GENERATOR}" STREQUAL "Watcom WMake")
 569
 570     add_test(BundleUtilities ${CMAKE_CTEST_COMMAND}
 571       --build-and-test
 572       "${CMake_SOURCE_DIR}/Tests/BundleUtilities"
 573       "${CMake_BINARY_DIR}/Tests/BundleUtilities"
 574       ${build_generator_args}
 575       --build-project BundleUtilities
 576       )
 577     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleUtilities")
 578
 579     # run test for DeployQt4 on supported platforms/compilers (which depends on BundleUtilities)
 580     # this test also depends on the existence of the standard qtiff plugin
 581     if(QT4_WORKS AND QT_QTSQL_FOUND)
 582       add_test(Qt4Deploy ${CMAKE_CTEST_COMMAND}
 583         --build-and-test
 584         "${CMake_SOURCE_DIR}/Tests/Qt4Deploy"
 585         "${CMake_BINARY_DIR}/Tests/Qt4Deploy"
 586         ${build_generator_args}
 587         --build-project Qt4Deploy
 588         --build-options
 589           -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
 590           -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
 591         )
 592       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Deploy")
 593     endif()
 594
 595   endif()
 596   endif()
 597
 598   set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/COnly")
 599   set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/CMakeBuildCOnly")
 600   set(CMAKE_BUILD_TEST_EXE COnly)
 601   configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
 602     "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake" @ONLY)
 603   add_test(CMakeBuildTest ${CMAKE_CMAKE_COMMAND} -P
 604     "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake")
 605   list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
 606   # now do it again for a project that has two project commands
 607   set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/DoubleProject")
 608   set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/DoubleProject")
 609   set(CMAKE_BUILD_TEST_EXE just_silly)
 610   configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
 611     "${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake" @ONLY)
 612   add_test(CMakeDoubleProject ${CMAKE_CMAKE_COMMAND} -P
 613     "${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake")
 614   list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
 615
 616   ADD_TEST_MACRO(Module.CheckTypeSize CheckTypeSize)
 617
 618   set(Module.CheckIPOSupported-C_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_C=${CMake_TEST_IPO_WORKS_C})
 619   ADD_TEST_MACRO(Module.CheckIPOSupported-C CheckIPOSupported-C)
 620
 621   set(Module.CheckIPOSupported-CXX_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_CXX=${CMake_TEST_IPO_WORKS_CXX})
 622   ADD_TEST_MACRO(Module.CheckIPOSupported-CXX CheckIPOSupported-CXX)
 623
 624   if(CMake_TEST_CUDA)
 625     ADD_TEST_MACRO(Module.CheckIPOSupported-CUDA CheckIPOSupported-CUDA)
 626     set_property(TEST Module.CheckIPOSupported-CUDA APPEND PROPERTY LABELS "CUDA")
 627   endif()
 628
 629   if(CMAKE_Fortran_COMPILER)
 630     set(Module.CheckIPOSupported-Fortran_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_Fortran=${CMake_TEST_IPO_WORKS_Fortran})
 631     ADD_TEST_MACRO(Module.CheckIPOSupported-Fortran CheckIPOSupported-Fortran)
 632   endif()
 633
 634   add_test(Module.ExternalData ${CMAKE_CTEST_COMMAND}
 635     --build-and-test
 636     "${CMake_SOURCE_DIR}/Tests/Module/ExternalData"
 637     "${CMake_BINARY_DIR}/Tests/Module/ExternalData"
 638     ${build_generator_args}
 639     --build-project ExternalDataTest
 640     --build-noclean
 641     --force-new-ctest-process
 642     --build-options
 643       -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
 644     --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} -V
 645     )
 646   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Module/ExternalData")
 647
 648   ADD_TEST_MACRO(Module.FindDependency FindDependency)
 649
 650   ADD_TEST_MACRO(Module.WriteCompilerDetectionHeader WriteCompilerDetectionHeader)
 651
 652   if(APPLE OR CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "LCC")
 653     include(CheckCXXCompilerFlag)
 654     check_cxx_compiler_flag(-fPIE run_pic_test)
 655   else()
 656     if(CMAKE_CXX_COMPILER_ID MATCHES "PGI"
 657         OR CMAKE_CXX_COMPILER_ID MATCHES "PathScale"
 658         OR CMAKE_CXX_COMPILER_ID MATCHES "Intel")
 659       set(run_pic_test 0)
 660     else()
 661       set(run_pic_test 1)
 662     endif()
 663   endif()
 664
 665   if(run_pic_test)
 666     ADD_TEST_MACRO(PositionIndependentTargets PositionIndependentTargets)
 667   endif()
 668
 669   if(CMAKE_CXX_COMPILER_ID MATCHES "LCC" OR
 670     ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") AND
 671     (NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 4.2) AND
 672     (CMAKE_SYSTEM_NAME MATCHES "Linux")))
 673
 674     include(CheckCXXCompilerFlag)
 675     check_cxx_compiler_flag(
 676       -fvisibility-inlines-hidden run_inlines_hidden_test)
 677   endif()
 678
 679   if(run_inlines_hidden_test)
 680     add_test(Visibility ${CMAKE_CTEST_COMMAND}
 681       --build-and-test
 682       "${CMake_SOURCE_DIR}/Tests/Visibility"
 683       "${CMake_BINARY_DIR}/Tests/Visibility"
 684       ${build_generator_args}
 685       --build-project Visibility
 686     )
 687     list(APPEND TEST_BUILD_DIRS
 688       "${CMake_BINARY_DIR}/Tests/Visibility"
 689     )
 690   endif()
 691
 692   add_test(LinkFlags-prepare
 693     ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
 694     --build-and-test
 695     "${CMake_SOURCE_DIR}/Tests/LinkFlags"
 696     "${CMake_BINARY_DIR}/Tests/LinkFlags"
 697     ${build_generator_args}
 698     --build-project LinkFlags
 699     --build-target LinkFlags
 700     --build-options
 701       -DTEST_CONFIG=\${CTEST_CONFIGURATION_TYPE}
 702     )
 703   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkFlags")
 704
 705   macro(ADD_LINK_FLAGS_TEST name depends)
 706     add_test(LinkFlags-${name}
 707       ${CMAKE_CMAKE_COMMAND} --build "${CMake_BINARY_DIR}/Tests/LinkFlags"
 708       --target LinkFlags_${name} --config \${CTEST_CONFIGURATION_TYPE}
 709       )
 710     set_tests_properties(LinkFlags-${name} PROPERTIES
 711       PASS_REGULAR_EXPRESSION "BADFLAG" DEPENDS LinkFlags-${depends})
 712   endmacro()
 713   ADD_LINK_FLAGS_TEST(lib prepare)
 714   ADD_LINK_FLAGS_TEST(dll lib)
 715   ADD_LINK_FLAGS_TEST(mod dll)
 716   ADD_LINK_FLAGS_TEST(exe mod)
 717   ADD_LINK_FLAGS_TEST(lib_config exe)
 718   ADD_LINK_FLAGS_TEST(dll_config lib_config)
 719   ADD_LINK_FLAGS_TEST(mod_config dll_config)
 720   ADD_LINK_FLAGS_TEST(exe_config mod_config)
 721   ADD_LINK_FLAGS_TEST(lib_flags exe_config)
 722   ADD_LINK_FLAGS_TEST(dll_flags lib_flags)
 723   ADD_LINK_FLAGS_TEST(mod_flags dll_flags)
 724   ADD_LINK_FLAGS_TEST(exe_flags mod_flags)
 725   ADD_LINK_FLAGS_TEST(lib_flags_config exe_flags)
 726   ADD_LINK_FLAGS_TEST(dll_flags_config lib_flags_config)
 727   ADD_LINK_FLAGS_TEST(mod_flags_config dll_flags_config)
 728   ADD_LINK_FLAGS_TEST(exe_flags_config mod_flags_config)
 729
 730   # If we are running right now with a Unix Makefiles or Ninja based generator,
 731   # build the "Simple" test with the ExtraGenerators, if available
 732   # This doesn't test whether the generated project files work (unfortunately),
 733   # mainly it tests that cmake doesn't crash when generating these project files.
 734   if(CMAKE_GENERATOR MATCHES "^(Unix Makefiles|Ninja)$"
 735       AND NOT "${CMAKE_CURRENT_BINARY_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}")
 736     foreach(
 737       extraGenerator
 738       IN ITEMS
 739         "CodeBlocks"
 740         "CodeLite"
 741         "Eclipse CDT4"
 742         "Kate"
 743         "Sublime Text 2"
 744       )
 745       string(REPLACE " " "" extraGeneratorTestName "Simple_${extraGenerator}Generator")
 746       add_test(${extraGeneratorTestName} ${CMAKE_CTEST_COMMAND}
 747         --build-and-test
 748         "${CMake_SOURCE_DIR}/Tests/Simple"
 749         "${CMake_BINARY_DIR}/Tests/${extraGeneratorTestName}"
 750         --build-two-config
 751         --build-generator "${extraGenerator} - ${CMAKE_GENERATOR}"
 752         --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
 753         --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
 754         --build-project Simple
 755         --test-command Simple)
 756       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${extraGeneratorTestName}")
 757     endforeach()
 758   endif()
 759
 760   # test for correct sub-project generation
 761   # not implemented in Xcode or Ninja
 762   if(NOT CMAKE_GENERATOR MATCHES "Xcode|Ninja")
 763     # run cmake and configure all of SubProject
 764     # but only build the independent executable car
 765     add_test(SubProject ${CMAKE_CTEST_COMMAND}
 766       --build-and-test
 767       "${CMake_SOURCE_DIR}/Tests/SubProject"
 768       "${CMake_BINARY_DIR}/Tests/SubProject"
 769       --build-project SubProject
 770       ${build_generator_args}
 771       --build-target car
 772       --test-command car
 773       )
 774
 775     # For stage 2, do not run cmake again.
 776     # Then build the foo sub project which should build
 777     # the bar library which should be referenced because
 778     # foo links to the static library bar, but bar is not
 779     # directly in the foo sub project
 780     if(CMake_TEST_EXPLICIT_MAKE_PROGRAM)
 781       set(SubProject-Stage2_BUILD_MAKEPROGRAM
 782         --build-makeprogram ${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
 783         )
 784     endif()
 785     add_test(SubProject-Stage2  ${CMAKE_CTEST_COMMAND}
 786       --build-and-test
 787       "${CMake_SOURCE_DIR}/Tests/SubProject/foo"
 788       "${CMake_BINARY_DIR}/Tests/SubProject/foo"
 789       --build-generator ${CMAKE_GENERATOR}
 790       --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
 791       --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
 792       ${SubProject-Stage2_BUILD_MAKEPROGRAM}
 793       --build-nocmake
 794       --build-project foo
 795       --build-target foo
 796       --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubProject/foo"
 797       --test-command foo
 798       )
 799     set_tests_properties(SubProject-Stage2 PROPERTIES DEPENDS SubProject)
 800     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubProject")
 801   endif()
 802
 803   # add tests with more complex invocations
 804   add_test(Framework ${CMAKE_CTEST_COMMAND}
 805     --build-and-test
 806     "${CMake_SOURCE_DIR}/Tests/Framework"
 807     "${CMake_BINARY_DIR}/Tests/Framework"
 808     --build-two-config
 809     ${build_generator_args}
 810     --build-project Framework
 811     --build-options
 812       -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
 813     "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/Framework/Install"
 814     --test-command bar)
 815   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Framework")
 816
 817   add_test(TargetName ${CMAKE_CTEST_COMMAND}
 818     --build-and-test
 819     "${CMake_SOURCE_DIR}/Tests/TargetName"
 820     "${CMake_BINARY_DIR}/Tests/TargetName"
 821     --build-two-config
 822     ${build_generator_args}
 823     --build-project TargetName
 824     --test-command ${CMAKE_CMAKE_COMMAND} -E compare_files
 825     ${CMake_SOURCE_DIR}/Tests/TargetName/scripts/hello_world
 826     ${CMake_BINARY_DIR}/Tests/TargetName/scripts/hello_world)
 827   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TargetName")
 828
 829   add_test(LibName ${CMAKE_CTEST_COMMAND}
 830     --build-and-test
 831     "${CMake_SOURCE_DIR}/Tests/LibName"
 832     "${CMake_BINARY_DIR}/Tests/LibName"
 833     --build-two-config
 834     ${build_generator_args}
 835     --build-project LibName
 836     --build-exe-dir "${CMake_BINARY_DIR}/Tests/LibName/lib"
 837     --build-options
 838       -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
 839     --test-command foobar
 840     )
 841   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LibName")
 842
 843   add_test(CustComDepend ${CMAKE_CTEST_COMMAND}
 844     --build-and-test
 845     "${CMake_SOURCE_DIR}/Tests/CustComDepend"
 846     "${CMake_BINARY_DIR}/Tests/CustComDepend"
 847     --build-two-config
 848     ${build_generator_args}
 849     --build-project CustComDepend
 850     --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustComDepend/bin"
 851     --test-command foo bar.c
 852     )
 853   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustComDepend")
 854
 855   add_test(ArgumentExpansion  ${CMAKE_CTEST_COMMAND}
 856     --build-and-test
 857     "${CMake_SOURCE_DIR}/Tests/ArgumentExpansion"
 858     "${CMake_BINARY_DIR}/Tests/ArgumentExpansion"
 859     ${build_generator_args}
 860     --build-project ArgumentExpansion
 861     --build-exe-dir "${CMake_BINARY_DIR}/Tests/ArgumentExpansion/bin"
 862     )
 863   set_tests_properties(ArgumentExpansion PROPERTIES
 864     FAIL_REGULAR_EXPRESSION "Unexpected: ")
 865   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ArgumentExpansion")
 866
 867   add_test(GeneratorExpression
 868     ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
 869     --build-and-test
 870     "${CMake_SOURCE_DIR}/Tests/GeneratorExpression"
 871     "${CMake_BINARY_DIR}/Tests/GeneratorExpression"
 872     ${build_generator_args}
 873     --build-project GeneratorExpression
 874     --build-options
 875       -DCMAKE_BUILD_TYPE=\${CTEST_CONFIGURATION_TYPE}
 876     --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} -V
 877     )
 878   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/GeneratorExpression")
 879
 880   add_test(CustomCommand  ${CMAKE_CTEST_COMMAND}
 881     --build-and-test
 882     "${CMake_SOURCE_DIR}/Tests/CustomCommand"
 883     "${CMake_BINARY_DIR}/Tests/CustomCommand"
 884     --build-two-config
 885     ${build_generator_args}
 886     --build-project CustomCommand
 887     --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustomCommand/bin"
 888     --build-options
 889     --test-command CustomCommand
 890     )
 891   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommand")
 892
 893   ADD_TEST_MACRO(CustomCommandByproducts CustomCommandByproducts)
 894
 895   ADD_TEST_MACRO(CommandLength CommandLength)
 896
 897   ADD_TEST_MACRO(EmptyDepends ${CMAKE_CTEST_COMMAND})
 898
 899   add_test(CustomCommandWorkingDirectory  ${CMAKE_CTEST_COMMAND}
 900     --build-and-test
 901     "${CMake_SOURCE_DIR}/Tests/CustomCommandWorkingDirectory"
 902     "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory"
 903     --build-two-config
 904     ${build_generator_args}
 905     --build-project TestWorkingDir
 906     --test-command working
 907     )
 908   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory")
 909
 910   add_test(OutOfSource ${CMAKE_CTEST_COMMAND}
 911     --build-and-test
 912     "${CMake_SOURCE_DIR}/Tests/OutOfSource"
 913     "${CMake_BINARY_DIR}/Tests/OutOfSource"
 914     ${build_generator_args}
 915     --build-project OutOfSource
 916     --build-two-config
 917     --test-command
 918     "${CMake_BINARY_DIR}/Tests/OutOfSource/SubDir/OutOfSourceSubdir/simple")
 919   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSource")
 920   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSourceDeep")
 921   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfBinary")
 922
 923   add_test(BuildDepends ${CMAKE_CTEST_COMMAND}
 924     --build-and-test
 925     "${CMake_SOURCE_DIR}/Tests/BuildDepends"
 926     "${CMake_BINARY_DIR}/Tests/BuildDepends"
 927     ${build_generator_args}
 928     --build-project BuildDepends
 929     )
 930   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BuildDepends")
 931
 932   set(MissingInstallInstallDir
 933     "${CMake_BINARY_DIR}/Tests/MissingInstall/InstallDirectory")
 934   add_test(MissingInstall ${CMAKE_CTEST_COMMAND}
 935     --build-and-test
 936     "${CMake_SOURCE_DIR}/Tests/MissingInstall"
 937     "${CMake_BINARY_DIR}/Tests/MissingInstall"
 938     ${build_generator_args}
 939     --build-project TestMissingInstall
 940     --build-two-config
 941     --build-options
 942     "-DCMAKE_INSTALL_PREFIX:PATH=${MissingInstallInstallDir}")
 943   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MissingInstall")
 944
 945   # By default, run the CPackComponents test if the CTEST_TEST_CPACK
 946   # option is ON:
 947   #
 948   set(CTEST_RUN_CPackComponents ${CTEST_TEST_CPACK})
 949   set(CTEST_package_X11_TEST ${CTEST_TEST_CPACK})
 950   set(CTEST_RUN_CPackComponentsForAll ${CTEST_TEST_CPACK})
 951   set(CTEST_RUN_CPackComponentsPrefix ${CTEST_TEST_CPACK})
 952
 953   find_program(NSIS_MAKENSIS_EXECUTABLE NAMES makensis
 954     PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
 955     DOC "makensis program location"
 956     )
 957
 958   # But on Windows, only run the CPackComponents test if the NSIS
 959   # installer builder is available:
 960   #
 961   if(WIN32)
 962     if(NSIS_MAKENSIS_EXECUTABLE)
 963       set(CTEST_RUN_CPackComponents ON)
 964     else()
 965       set(CTEST_RUN_CPackComponents OFF)
 966       set(CTEST_package_X11_TEST OFF)
 967     endif()
 968   endif()
 969
 970   # On Windows run the CPackWiXGenerator test
 971   # if the WiX Toolset seems to be available
 972   if(WIN32)
 973     file(TO_CMAKE_PATH "$ENV{WIX}" WIX_ROOT)
 974
 975     find_program(WIX_LIGHT_EXECUTABLE light
 976       PATHS "${WIX_ROOT}/bin"
 977       DOC "WiX Toolset light.exe location")
 978
 979     if(WIX_LIGHT_EXECUTABLE)
 980       add_test(CPackWiXGenerator ${CMAKE_CTEST_COMMAND}
 981         -C \${CTEST_CONFIGURATION_TYPE}
 982         --build-and-test
 983         "${CMake_SOURCE_DIR}/Tests/CPackWiXGenerator"
 984         "${CMake_BINARY_DIR}/Tests/CPackWiXGenerator"
 985         ${build_generator_args}
 986         --build-project CPackWiXGenerator
 987         --build-options
 988         --test-command ${CMAKE_CMAKE_COMMAND}
 989           "-DCPackWiXGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackWiXGenerator"
 990           "-Dno_verify:BOOL=${CMake_TEST_WIX_NO_VERIFY}"
 991           "-Dconfig=\${CTEST_CONFIGURATION_TYPE}"
 992           -P "${CMake_SOURCE_DIR}/Tests/CPackWiXGenerator/RunCPackVerifyResult.cmake")
 993
 994       set_property(TEST CPackWiXGenerator PROPERTY
 995         ATTACHED_FILES_ON_FAIL
 996         "${CMake_BINARY_DIR}/Tests/CPackWiXGenerator/_CPack_Packages/win32/WIX/wix.log")
 997     endif()
 998   endif()
 999
1000   # On Windows run the CPackNSISGenerator test
1001   # if the nsis is available
1002   if(WIN32 AND NSIS_MAKENSIS_EXECUTABLE)
1003     add_test(CPackNSISGenerator ${CMAKE_CTEST_COMMAND}
1004       -C \${CTEST_CONFIGURATION_TYPE}
1005       --build-and-test
1006       "${CMake_SOURCE_DIR}/Tests/CPackNSISGenerator"
1007       "${CMake_BINARY_DIR}/Tests/CPackNSISGenerator"
1008       ${build_generator_args}
1009       --build-project CPackNSISGenerator
1010       --build-options
1011       --test-command ${CMAKE_CMAKE_COMMAND}
1012         "-DCPackNSISGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackNSISGenerator"
1013         "-Dconfig=\${CTEST_CONFIGURATION_TYPE}"
1014         -P "${CMake_SOURCE_DIR}/Tests/CPackNSISGenerator/RunCPackVerifyResult.cmake")
1015
1016     set_property(TEST CPackNSISGenerator PROPERTY
1017       ATTACHED_FILES_ON_FAIL
1018       "${CMake_BINARY_DIR}/Tests/CPackNSISGenerator/_CPack_Packages/win32/NSIS/NSISOutput.log")
1019   endif()
1020
1021   if(CTEST_TEST_CPACK)
1022     add_test(CPackUseDefaultVersion ${CMAKE_CTEST_COMMAND}
1023       --build-and-test
1024       "${CMake_SOURCE_DIR}/Tests/CPackUseDefaultVersion"
1025       "${CMake_BINARY_DIR}/Tests/CPackUseDefaultVersion"
1026       ${build_generator_args}
1027       --build-project CPackUseDefaultVersion
1028       --build-two-config
1029       --build-options
1030         ${CPackUseDefaultVersion_BUILD_OPTIONS})
1031     set_tests_properties(CPackUseDefaultVersion PROPERTIES PASS_REGULAR_EXPRESSION "CPACK_PACKAGE_VERSION=0\\.1\\.1")
1032     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackUseDefaultVersion")
1033
1034     add_test(CPackUseProjectVersion ${CMAKE_CTEST_COMMAND}
1035       --build-and-test
1036       "${CMake_SOURCE_DIR}/Tests/CPackUseProjectVersion"
1037       "${CMake_BINARY_DIR}/Tests/CPackUseProjectVersion"
1038       ${build_generator_args}
1039       --build-project CPackUseProjectVersion
1040       --build-two-config
1041       --build-options
1042         ${CPackUseProjectVersion_BUILD_OPTIONS})
1043     set_tests_properties(CPackUseProjectVersion PROPERTIES PASS_REGULAR_EXPRESSION "CPACK_PACKAGE_VERSION=1\\.2\\.3")
1044     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackUseProjectVersion")
1045
1046     add_test(CPackUseShortProjectVersion ${CMAKE_CTEST_COMMAND}
1047       --build-and-test
1048       "${CMake_SOURCE_DIR}/Tests/CPackUseShortProjectVersion"
1049       "${CMake_BINARY_DIR}/Tests/CPackUseShortProjectVersion"
1050       ${build_generator_args}
1051       --build-project CPackUseShortProjectVersion
1052       --build-two-config
1053       --build-options
1054         ${CPackUseProjectVersion_BUILD_OPTIONS})
1055     set_tests_properties(CPackUseShortProjectVersion PROPERTIES PASS_REGULAR_EXPRESSION "CPACK_PACKAGE_VERSION=2")
1056     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackUseShortProjectVersion")
1057   endif()
1058
1059   if(CTEST_RUN_CPackComponents)
1060     set(CPackComponents_BUILD_OPTIONS)
1061     if(APPLE)
1062       set(CPackComponents_BUILD_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
1063       if(CMake_TEST_XCODE_VERSION VERSION_GREATER "4.6")
1064         set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1065           -DCPACK_BINARY_PRODUCTBUILD:BOOL=ON)
1066       endif()
1067     endif()
1068     if(NSIS_MAKENSIS_EXECUTABLE)
1069       execute_process(COMMAND ${NSIS_MAKENSIS_EXECUTABLE} "-VERSION" ERROR_QUIET OUTPUT_QUIET RESULT_VARIABLE NSIS_OK)
1070       if("${NSIS_OK}" STREQUAL "0")
1071         set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1072           -DCPACK_BINARY_NSIS:BOOL=ON)
1073       endif()
1074     endif()
1075
1076     add_test(CPackComponents ${CMAKE_CTEST_COMMAND}
1077       --build-and-test
1078       "${CMake_SOURCE_DIR}/Tests/CPackComponents"
1079       "${CMake_BINARY_DIR}/Tests/CPackComponents"
1080       ${build_generator_args}
1081       --build-project CPackComponents
1082       --build-two-config
1083       --build-target package
1084       --build-options
1085         -DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
1086         -DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
1087         ${CPackComponents_BUILD_OPTIONS}
1088         --graphviz=CPackComponents.dot
1089       --test-command ${CMAKE_CMAKE_COMMAND}
1090         "-DCPackComponents_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponents"
1091         -P "${CMake_SOURCE_DIR}/Tests/CPackComponents/VerifyResult.cmake")
1092     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponents")
1093   endif()
1094
1095   if(CTEST_RUN_CPackComponentsForAll)
1096     # Check whether if rpmbuild command is found
1097     # before adding RPM tests
1098     if(CPACK_BINARY_RPM)
1099       list(APPEND ACTIVE_CPACK_GENERATORS RPM)
1100     endif()
1101     # Check whether if dpkg command is found
1102     # before adding DEB tests
1103     if(CPACK_BINARY_DEB)
1104       list(APPEND ACTIVE_CPACK_GENERATORS DEB)
1105     endif()
1106     # Check whether if NuGet command is found
1107     # before adding NuGet tests
1108     if(CPACK_BINARY_NUGET)
1109       list(APPEND ACTIVE_CPACK_GENERATORS NUGET)
1110       set(CPACK_GENERATOR_STRING_NUGET NuGet)
1111     endif()
1112
1113     # ACTIVE_CPACK_GENERATORS variable
1114     # now contains the list of 'active generators'
1115     set(CPackComponentsForAll_BUILD_OPTIONS)
1116     # set up list of CPack generators
1117     list(APPEND ACTIVE_CPACK_GENERATORS "ZIP")
1118     if(APPLE)
1119       list(APPEND ACTIVE_CPACK_GENERATORS "DragNDrop")
1120       if(CMake_TEST_XCODE_VERSION VERSION_GREATER "4.6")
1121         list(APPEND ACTIVE_CPACK_GENERATORS "productbuild")
1122       endif()
1123     endif()
1124
1125     # set up list of component packaging ways
1126     list(APPEND CWAYLST "default")
1127     list(APPEND CWAYLST "OnePackPerGroup")
1128     list(APPEND CWAYLST "IgnoreGroup")
1129     list(APPEND CWAYLST "AllInOne")
1130     foreach(CPackGen IN LISTS ACTIVE_CPACK_GENERATORS)
1131       if(NOT DEFINED CPACK_GENERATOR_STRING_${CPackGen})
1132         set(CPACK_GENERATOR_STRING_${CPackGen} ${CPackGen})
1133       endif()
1134       set(CPackRun_CPackGen  "-DCPackGen=${CPACK_GENERATOR_STRING_${CPackGen}}")
1135       foreach(CPackComponentWay IN LISTS CWAYLST)
1136         set(CPackRun_CPackComponentWay "-DCPackComponentWay=${CPackComponentWay}")
1137         add_test(CPackComponentsForAll-${CPackGen}-${CPackComponentWay}
1138           ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
1139           --build-and-test
1140           "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll"
1141           "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
1142           ${build_generator_args}
1143           --build-project CPackComponentsForAll
1144           --build-options
1145              -DCPACK_GENERATOR:STRING=${CPACK_GENERATOR_STRING_${CPackGen}}
1146              -DCPACK_BINARY_${CPackGen}:BOOL=ON
1147              ${CPackRun_CPackComponentWay}
1148              ${CPackComponentsForAll_BUILD_OPTIONS}
1149              --graphviz=CPackComponentsForAll.dot
1150           --test-command ${CMAKE_CMAKE_COMMAND}
1151             "-DCPackComponentsForAll_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
1152             "${CPackRun_CPackGen}"
1153             "${CPackRun_CPackComponentWay}"
1154             -P "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll/RunCPackVerifyResult.cmake")
1155         list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}")
1156       endforeach()
1157     endforeach()
1158
1159     # debian specific
1160     if(DPKG_EXECUTABLE)
1161       unset(CPackRun_CPackDEBConfiguration_ALL_CONFIGS)
1162       set(DEB_TEST_NAMES "CPackComponentsDEB")
1163       set(DEB_CONFIGURATIONS_TO_TEST "components-lintian-dpkgdeb-checks"
1164                                      "components-description1"
1165                                      "components-description2"
1166                                      "components-source"
1167                                      "components-shlibdeps1"
1168                                      "components-depend1"
1169                                      "compression")
1170       # Run additional tests if dpkg-shlibdeps is available (and is new enough version)
1171       find_program(SHLIBDEPS_EXECUTABLE NAMES dpkg-shlibdeps)
1172       if(SHLIBDEPS_EXECUTABLE)
1173         # Check version of the dpkg-shlibdeps tool
1174         execute_process(COMMAND ${CMAKE_COMMAND} -E env LC_ALL=C ${SHLIBDEPS_EXECUTABLE} --version
1175           OUTPUT_VARIABLE _TMP_VERSION
1176           ERROR_QUIET
1177           OUTPUT_STRIP_TRAILING_WHITESPACE)
1178         if(_TMP_VERSION MATCHES "dpkg-shlibdeps version ([0-9]+\\.[0-9]+\\.[0-9]+)")
1179           set(SHLIBDEPS_EXECUTABLE_VERSION "${CMAKE_MATCH_1}")
1180         else()
1181           unset(SHLIBDEPS_EXECUTABLE_VERSION)
1182         endif()
1183         if(NOT SHLIBDEPS_EXECUTABLE_VERSION VERSION_LESS 1.19 OR
1184           (NOT SHLIBDEPS_EXECUTABLE_VERSION VERSION_LESS 1.17 AND NOT CMAKE_BINARY_DIR MATCHES ".*[ ].*"))
1185             list(APPEND DEB_CONFIGURATIONS_TO_TEST "shlibdeps-with-private-lib-failure"
1186                                                    "shlibdeps-with-private-lib-success")
1187         endif()
1188         # Check if distro has symbols or shlibs data
1189         file(GLOB SHLIBS_FILES_EXIST "/var/lib/dpkg/info/*.shlibs" "/var/lib/dpkg/info/*.symbols")
1190         if(SHLIBS_FILES_EXIST)
1191           list(APPEND DEB_CONFIGURATIONS_TO_TEST "components-depend2")
1192         endif()
1193       endif()
1194
1195       set(CPackGen "DEB")
1196       set(CPackRun_CPackGen "-DCPackGen=${CPackGen}")
1197
1198       foreach(CPackDEBConfiguration IN LISTS DEB_CONFIGURATIONS_TO_TEST)
1199         set(CPackRun_CPackDEBConfiguration "-DCPackDEBConfiguration=${CPackDEBConfiguration}")
1200         add_test(NAME ${DEB_TEST_NAMES}-${CPackDEBConfiguration} COMMAND
1201           ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
1202           --build-and-test
1203               "${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}"
1204               "${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}"
1205               ${build_generator_args}
1206           --build-project CPackComponentsDEB
1207           --build-options
1208               -DCPACK_GENERATOR:STRING=${CPackGen}
1209               -DCPACK_BINARY_${CPackGen}:BOOL=ON
1210               ${CPackRun_CPackDEBConfiguration}
1211               ${CPackRun_CPackDEBConfiguration_ALL_CONFIGS}
1212           --graphviz=${DEB_TEST_NAMES}.dot
1213           --test-command ${CMAKE_CMAKE_COMMAND}
1214               "-D${DEB_TEST_NAMES}_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}"
1215               "-D${DEB_TEST_NAMES}_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}"
1216               "${CPackRun_CPackGen}"
1217               "${CPackRun_CPackDEBConfiguration}"
1218               "-DCONFIG=$<CONFIG>"
1219               -P "${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}/RunCPackVerifyResult-${CPackDEBConfiguration}.cmake")
1220           list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}")
1221       endforeach()
1222     endif()
1223
1224   endif()
1225
1226   # By default, turn this test off (because it takes a long time...)
1227   #
1228   if(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
1229     set(CTEST_RUN_CPackTestAllGenerators OFF)
1230
1231     # ...but: if it appears to be a coverage dashboard, or long tests are
1232     # on, then set it to the generic CTEST_TEST_CPACK setting.
1233     #
1234     if(CMAKE_CXX_FLAGS MATCHES "-ftest-coverage" OR
1235       NOT "$ENV{COVFILE}" STREQUAL "" OR
1236       CMAKE_RUN_LONG_TESTS)
1237       set(CTEST_RUN_CPackTestAllGenerators ${CTEST_TEST_CPACK})
1238     endif()
1239   endif()
1240
1241   if(CTEST_RUN_CPackTestAllGenerators)
1242     add_test(CPackTestAllGenerators ${CMAKE_CTEST_COMMAND}
1243       --build-and-test
1244       "${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators"
1245       "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators"
1246       ${build_generator_args}
1247       --build-project CPackTestAllGenerators
1248       --test-command
1249       ${CMAKE_CMAKE_COMMAND}
1250         -D dir=${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators
1251         -P ${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators/RunCPack.cmake
1252       )
1253     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators")
1254   endif()
1255
1256   if(CTEST_RUN_CPackComponentsPrefix)
1257     set(CPackComponents_BUILD_OPTIONS)
1258     if(APPLE)
1259       set(CPackComponents_BUILD_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
1260       if(CMake_TEST_XCODE_VERSION VERSION_GREATER "4.6")
1261         set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1262           -DCPACK_BINARY_PRODUCTBUILD:BOOL=ON)
1263       endif()
1264     endif()
1265     if(NOT NSIS_MAKENSIS_EXECUTABLE)
1266       set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1267         -DCPACK_BINARY_NSIS:BOOL=OFF)
1268     endif()
1269
1270     add_test(CPackComponentsPrefix ${CMAKE_CTEST_COMMAND}
1271       --build-and-test
1272       "${CMake_SOURCE_DIR}/Tests/CPackComponentsPrefix"
1273       "${CMake_BINARY_DIR}/Tests/CPackComponentsPrefix"
1274       ${build_generator_args}
1275       --build-project CPackComponentsPrefix
1276       --build-two-config
1277       --build-target package
1278       --build-options
1279         -DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
1280         -DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
1281         -DCPACK_BINARY_ZIP:BOOL=ON
1282         ${CPackComponents_BUILD_OPTIONS}
1283         )
1284     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsPrefix")
1285   endif()
1286
1287   if(CTEST_package_X11_TEST)
1288     set(X11_build_target_arg --build-target package)
1289   else()
1290     set(X11_build_target_arg)
1291   endif()
1292
1293   add_test(X11 ${CMAKE_CTEST_COMMAND}
1294     --build-and-test
1295     "${CMake_SOURCE_DIR}/Tests/X11"
1296     "${CMake_BINARY_DIR}/Tests/X11"
1297     ${build_generator_args}
1298     --build-project UseX11
1299     --build-two-config
1300     ${X11_build_target_arg}
1301     --test-command  UseX11)
1302   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/X11")
1303
1304   if(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
1305     set(CTEST_RUN_CMakeTestAllGenerators ON)
1306   endif()
1307
1308   if(CTEST_RUN_CMakeTestAllGenerators)
1309     add_test(CMakeTestAllGenerators ${CMAKE_CMAKE_COMMAND}
1310         -D dir=${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators
1311         -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
1312         -P ${CMake_SOURCE_DIR}/Tests/CMakeTestAllGenerators/RunCMake.cmake
1313       )
1314     list(APPEND TEST_BUILD_DIRS
1315       "${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators")
1316     # This test runs a lot of processes.  Do not make them compete
1317     # for resources with other tests.
1318     set_property(TEST CMakeTestAllGenerators PROPERTY RUN_SERIAL 1)
1319   endif()
1320
1321   if(NOT CMake_TEST_EXTERNAL_CMAKE)
1322     add_test(LoadedCommandOneConfig  ${CMAKE_CTEST_COMMAND}
1323       --build-and-test
1324       "${CMake_SOURCE_DIR}/Tests/LoadCommandOneConfig"
1325       "${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig"
1326       ${build_generator_args}
1327       --build-project LoadCommand
1328       --test-command  LoadedCommand
1329       )
1330     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig")
1331   endif()
1332
1333   add_test(complex  ${CMAKE_CTEST_COMMAND}
1334     --build-and-test
1335     "${CMake_SOURCE_DIR}/Tests/Complex"
1336     "${CMake_BINARY_DIR}/Tests/Complex"
1337     --build-two-config
1338     --build-config-sample "${CMAKE_CTEST_COMMAND}"
1339     ${build_generator_args}
1340     --build-project Complex
1341     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Complex/bin"
1342     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
1343     --test-command complex
1344     )
1345   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Complex")
1346
1347   add_test(complexOneConfig  ${CMAKE_CTEST_COMMAND}
1348     --build-and-test
1349     "${CMake_SOURCE_DIR}/Tests/ComplexOneConfig"
1350     "${CMake_BINARY_DIR}/Tests/ComplexOneConfig"
1351     ${build_generator_args}
1352     --build-project Complex
1353     --build-exe-dir "${CMake_BINARY_DIR}/Tests/ComplexOneConfig/bin"
1354     -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
1355     --test-command complex)
1356   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ComplexOneConfig")
1357   # because of the registry write these tests depend on each other
1358   set_tests_properties(complex PROPERTIES DEPENDS complexOneConfig)
1359
1360   add_test(Environment ${CMAKE_CTEST_COMMAND}
1361     --build-and-test
1362     "${CMake_SOURCE_DIR}/Tests/Environment"
1363     "${CMake_BINARY_DIR}/Tests/Environment"
1364     ${build_generator_args}
1365     --build-project EnvironmentProj
1366     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Environment"
1367     --force-new-ctest-process
1368     --test-command ${CMAKE_CTEST_COMMAND} -V
1369     )
1370   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Environment")
1371   set_property(TEST Environment APPEND
1372     PROPERTY ENVIRONMENT
1373       "SET_FROM_AMBIENT_unset=base"
1374       "SET_FROM_AMBIENT_replace=base"
1375       "SET_FROM_AMBIENT_string=base"
1376       "SET_FROM_AMBIENT_path=base"
1377       "SET_FROM_AMBIENT_list=base")
1378
1379   add_test(QtAutomocNoQt  ${CMAKE_CTEST_COMMAND}
1380     --build-and-test
1381     "${CMake_SOURCE_DIR}/Tests/QtAutomocNoQt"
1382     "${CMake_BINARY_DIR}/Tests/QtAutomocNoQt"
1383     ${build_generator_args}
1384     --build-project QtAutomocNoQt
1385     --build-options
1386       -DCMAKE_BUILD_TYPE=\${CTEST_CONFIGURATION_TYPE}
1387     )
1388   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/QtAutomocNoQt")
1389
1390   if(CMake_TEST_Qt6 AND Qt6Widgets_FOUND)
1391     add_subdirectory(Qt6Autogen)
1392   endif()
1393   if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND)
1394     add_subdirectory(Qt5Autogen)
1395   endif()
1396   if(QT4_WORKS AND QT_QTGUI_FOUND)
1397     add_subdirectory(Qt4Autogen)
1398
1399     add_test(Qt4Targets ${CMAKE_CTEST_COMMAND}
1400       --build-and-test
1401       "${CMake_SOURCE_DIR}/Tests/Qt4Targets"
1402       "${CMake_BINARY_DIR}/Tests/Qt4Targets"
1403       ${build_generator_args}
1404       --build-project Qt4Targets
1405       --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4Targets"
1406       --force-new-ctest-process
1407       --build-options
1408         -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
1409       --test-command ${CMAKE_CTEST_COMMAND} -V
1410       )
1411     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Targets")
1412
1413     if(Qt5Widgets_FOUND AND NOT Qt5Widgets_VERSION VERSION_LESS 5.1.0)
1414       add_test(Qt4And5AutomocForward ${CMAKE_CTEST_COMMAND}
1415         --build-and-test
1416         "${CMake_SOURCE_DIR}/Tests/Qt4And5Automoc"
1417         "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocForward"
1418         ${build_generator_args}
1419         --build-project Qt4And5Automoc
1420         --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocForward"
1421         --force-new-ctest-process
1422         --test-command ${CMAKE_CTEST_COMMAND} -V
1423         )
1424       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocForward")
1425       add_test(Qt4And5AutomocReverse ${CMAKE_CTEST_COMMAND}
1426         --build-and-test
1427         "${CMake_SOURCE_DIR}/Tests/Qt4And5Automoc"
1428         "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse"
1429         ${build_generator_args}
1430         --build-project Qt4And5Automoc
1431         --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse"
1432         --force-new-ctest-process
1433         --build-options -DQT_REVERSE_FIND_ORDER=1
1434         --test-command ${CMAKE_CTEST_COMMAND} -V
1435         )
1436       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse")
1437     endif()
1438   endif()
1439
1440   # test for Find modules, simple cases
1441   foreach(
1442   _mod
1443   IN ITEMS
1444       ALSA
1445       BLAS
1446       Boost
1447       BZip2
1448       Cups
1449       CURL
1450       DevIL
1451       Doxygen
1452       EnvModules
1453       EXPAT
1454       Fontconfig
1455       Freetype
1456       GDAL
1457       GIF
1458       Git
1459       GLEW
1460       GLUT
1461       GnuTLS
1462       GSL
1463       GTK2
1464       Iconv
1465       ICU
1466       Intl
1467       Jasper
1468       JNI
1469       JPEG
1470       JsonCpp
1471       LAPACK
1472       LibArchive
1473       Libinput
1474       LibLZMA
1475       LibRHash
1476       LibUV
1477       LibXml2
1478       LibXslt
1479       LTTngUST
1480       MPI
1481       ODBC
1482       OpenACC
1483       OpenAL
1484       OpenCL
1485       OpenGL
1486       OpenMP
1487       OpenSP
1488       OpenSSL
1489       Patch
1490       PNG
1491       PostgreSQL
1492       Protobuf
1493       SDL
1494       SQLite3
1495       TIFF
1496       Vulkan
1497       X11
1498       XalanC
1499       XercesC
1500     )
1501     if(CMake_TEST_Find${_mod})
1502       add_subdirectory(Find${_mod})
1503     endif()
1504   endforeach()
1505
1506   if(CMake_TEST_CUDA)
1507     add_subdirectory(Cuda)
1508     add_subdirectory(CudaOnly)
1509   endif()
1510
1511   if(CMake_TEST_HIP)
1512     add_subdirectory(HIP)
1513   endif()
1514
1515   if(CMake_TEST_ISPC)
1516     add_subdirectory(ISPC)
1517   endif()
1518
1519   if(CMake_TEST_FindGTest)
1520     add_subdirectory(FindGTest)
1521     add_subdirectory(GoogleTest)
1522   endif()
1523
1524   if(CMake_TEST_FindPython OR CMake_TEST_FindPython_NumPy
1525       OR CMake_TEST_FindPython_Conda OR CMake_TEST_FindPython_IronPython OR CMake_TEST_FindPython_PyPy)
1526     add_subdirectory(FindPython)
1527   endif()
1528
1529   if(CMake_TEST_UseSWIG)
1530     add_subdirectory(UseSWIG)
1531   endif()
1532
1533   if(CMake_TEST_FindRuby)
1534     add_subdirectory(FindRuby)
1535   endif()
1536
1537   add_subdirectory(FindThreads)
1538
1539   # Matlab module
1540   # CMake_TEST_FindMatlab: indicates to look for Matlab (from PATH for Linux)
1541   # CMake_TEST_FindMatlab_ROOT_DIR: indicates an optional root directory for Matlab, allows to select a version.
1542   # CMake_TEST_FindMatlab_MCR: indicates the MCR is installed
1543   # CMake_TEST_FindMatlab_MCR_ROOT_DIR: indicates an optional root directory for the MCR, required on Linux
1544   if(CMake_TEST_FindMatlab OR CMake_TEST_FindMatlab_ROOT_DIR OR
1545      CMake_TEST_FindMatlab_MCR OR CMake_TEST_FindMatlab_MCR_ROOT_DIR)
1546     set(FindMatlab_additional_test_options)
1547     if(CMake_TEST_FindMatlab_MCR OR CMake_TEST_FindMatlab_MCR_ROOT_DIR)
1548       set(FindMatlab_additional_test_options -DIS_MCR=TRUE)
1549     endif()
1550     if(CMake_TEST_FindMatlab_ROOT_DIR)
1551       set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMatlab_ROOT_DIR=${CMake_TEST_FindMatlab_ROOT_DIR}")
1552     endif()
1553     if(CMake_TEST_FindMatlab_MCR_ROOT_DIR)
1554       set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMCR_ROOT:FILEPATH=${CMake_TEST_FindMatlab_MCR_ROOT_DIR}")
1555     endif()
1556     set(FindMatlab.basic_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1557     ADD_TEST_MACRO(FindMatlab.basic_checks      ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1558     set_property(TEST FindMatlab.basic_checks APPEND PROPERTY LABELS "Matlab")
1559     set(FindMatlab.versions_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1560     ADD_TEST_MACRO(FindMatlab.versions_checks   ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1561     set_property(TEST FindMatlab.versions_checks APPEND PROPERTY LABELS "Matlab")
1562     set(FindMatlab.components_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1563     ADD_TEST_MACRO(FindMatlab.components_checks ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1564     set_property(TEST FindMatlab.components_checks APPEND PROPERTY LABELS "Matlab")
1565     set(FindMatlab.failure_reports_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1566     ADD_TEST_MACRO(FindMatlab.failure_reports   ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1567     set_property(TEST FindMatlab.failure_reports APPEND PROPERTY LABELS "Matlab")
1568     set(FindMatlab.r2018a_check_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1569     ADD_TEST_MACRO(FindMatlab.r2018a_check   ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1570     set_property(TEST FindMatlab.r2018a_check APPEND PROPERTY LABELS "Matlab")
1571     set(FindMatlab.targets_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1572     ADD_TEST_MACRO(FindMatlab.targets_checks      ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1573     set_property(TEST FindMatlab.targets_checks APPEND PROPERTY LABELS "Matlab")
1574     set(FindMatlab.no_implicit_link_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1575     ADD_TEST_MACRO(FindMatlab.no_implicit_link_checks      ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1576     set_property(TEST FindMatlab.no_implicit_link_checks APPEND PROPERTY LABELS "Matlab")
1577   endif()
1578
1579   set(ExternalProject_BUILD_OPTIONS "")
1580   foreach(vcs IN ITEMS CVS SVN GIT HG)
1581     if(DEFINED CMake_TEST_ExternalProject_${vcs})
1582       list(APPEND ExternalProject_BUILD_OPTIONS -DEP_TEST_${vcs}=${CMake_TEST_ExternalProject_${vcs}})
1583     endif()
1584   endforeach()
1585   add_test(ExternalProject ${CMAKE_CTEST_COMMAND}
1586     --build-and-test
1587     "${CMake_SOURCE_DIR}/Tests/ExternalProject"
1588     "${CMake_BINARY_DIR}/Tests/ExternalProject"
1589     ${build_generator_args}
1590     --build-project ExternalProjectTest
1591     --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProject"
1592     --force-new-ctest-process
1593     --build-options ${ExternalProject_BUILD_OPTIONS}
1594     --test-command ${CMAKE_CTEST_COMMAND} -V
1595     )
1596   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProject")
1597   set_tests_properties(ExternalProject PROPERTIES
1598     ENVIRONMENT GIT_ALLOW_PROTOCOL=file
1599     RUN_SERIAL 1
1600     TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
1601
1602   add_test(NAME ExternalProjectSubdir
1603     COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
1604     --build-and-test
1605     "${CMake_SOURCE_DIR}/Tests/ExternalProjectSubdir"
1606     "${CMake_BINARY_DIR}/Tests/ExternalProjectSubdir"
1607     ${build_generator_args}
1608     --build-project ExternalProjectSubdir
1609     --force-new-ctest-process
1610     )
1611   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectSubdir")
1612
1613   add_test(NAME ExternalProjectSourceSubdir
1614     COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
1615     --build-and-test
1616     "${CMake_SOURCE_DIR}/Tests/ExternalProjectSourceSubdir"
1617     "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdir"
1618     ${build_generator_args}
1619     --build-project ExternalProjectSourceSubdir
1620     --force-new-ctest-process
1621     )
1622   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdir")
1623
1624   add_test(NAME ExternalProjectSourceSubdirNotCMake
1625     COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
1626     --build-and-test
1627     "${CMake_SOURCE_DIR}/Tests/ExternalProjectSourceSubdirNotCMake"
1628     "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdirNotCMake"
1629     ${build_generator_args}
1630     --build-project ExternalProjectSourceSubdirNotCMake
1631     --force-new-ctest-process
1632     )
1633   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdirNotCMake")
1634
1635   add_test(ExternalProjectLocal ${CMAKE_CTEST_COMMAND}
1636     --build-and-test
1637     "${CMake_SOURCE_DIR}/Tests/ExternalProjectLocal"
1638     "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal"
1639     ${build_generator_args}
1640     --build-project ExternalProjectLocalTest
1641     --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal"
1642     --force-new-ctest-process
1643     --test-command ${CMAKE_CTEST_COMMAND} -V
1644     )
1645   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal")
1646   set_tests_properties(ExternalProjectLocal PROPERTIES
1647     RUN_SERIAL 1
1648     TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
1649
1650   add_test(ExternalProjectUpdateSetup ${CMAKE_CTEST_COMMAND}
1651     --build-and-test
1652     "${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate"
1653     "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
1654     ${build_generator_args}
1655     --build-project ExternalProjectUpdateTest
1656     --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
1657     --force-new-ctest-process
1658     --test-command ${CMAKE_CTEST_COMMAND} -V
1659     )
1660   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
1661   set_tests_properties(ExternalProjectUpdateSetup PROPERTIES
1662     RUN_SERIAL 1
1663     TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
1664
1665   add_test(NAME ExternalProjectUpdate
1666     COMMAND ${CMAKE_CMAKE_COMMAND}
1667     -DExternalProjectUpdate_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
1668     -DExternalProjectUpdate_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate
1669     -DCMAKE_GENERATOR=${CMAKE_GENERATOR}
1670     -DCMAKE_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
1671     -DCMAKE_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
1672     -DCMAKE_CTEST_COMMAND=${CMAKE_CTEST_COMMAND}
1673     -P ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate/ExternalProjectUpdateTest.cmake
1674     )
1675   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
1676   set_tests_properties(ExternalProjectUpdate PROPERTIES
1677     RUN_SERIAL 1
1678     TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT}
1679     WORKING_DIRECTORY ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
1680     DEPENDS ExternalProjectUpdateSetup
1681     )
1682
1683   execute_process(
1684     COMMAND ${CMAKE_COMMAND}
1685     "-E" create_symlink
1686     "${CMake_SOURCE_DIR}/Tests/CMakeLists.txt"        # random source file that exists
1687     "${CMake_BINARY_DIR}/Tests/try_to_create_symlink" # random target file in existing directory
1688     RESULT_VARIABLE _symlink_result
1689     OUTPUT_VARIABLE _symlink_stdout
1690     ERROR_VARIABLE _symlink_stderr
1691     )
1692   if(_symlink_result EQUAL 0)
1693     file(REMOVE "${CMake_BINARY_DIR}/Tests/try_to_create_symlink")
1694     function(add_installmode_test _mode)
1695       set(ENV{CMAKE_INSTALL_MODE} _mode)
1696       set(_maybe_InstallMode_CTEST_OPTIONS)
1697       set(_maybe_BUILD_OPTIONS)
1698       if(_isMultiConfig)
1699         set(_maybe_CTEST_OPTIONS -C $<CONFIGURATION>)
1700       else()
1701         set(_maybe_BUILD_OPTIONS "-DCMAKE_BUILD_TYPE=$<CONFIGURATION>")
1702       endif()
1703       add_test(
1704         NAME "InstallMode-${_mode}"
1705         COMMAND
1706           ${CMAKE_CTEST_COMMAND} -V ${_maybe_CTEST_OPTIONS}
1707         --build-and-test
1708           "${CMake_SOURCE_DIR}/Tests/InstallMode"
1709           "${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}"
1710         ${build_generator_args}
1711         --build-project superpro
1712         --build-exe-dir "${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}"
1713         --force-new-ctest-process
1714         --build-options
1715           ${_maybe_BUILD_OPTIONS}
1716           "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}/install"
1717         )
1718       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}")
1719       unset(ENV{CMAKE_INSTALL_MODE})
1720     endfunction()
1721
1722     add_installmode_test(COPY)
1723     add_installmode_test(REL_SYMLINK)
1724     add_installmode_test(REL_SYMLINK_OR_COPY)
1725     add_installmode_test(ABS_SYMLINK)
1726     add_installmode_test(ABS_SYMLINK_OR_COPY)
1727     add_installmode_test(SYMLINK)
1728     add_installmode_test(SYMLINK_OR_COPY)
1729   endif()
1730
1731
1732   # do each of the tutorial steps
1733   function(add_tutorial_test step_name use_mymath tutorial_arg pass_regex)
1734     set(tutorial_test_name Tutorial${step_name})
1735     set(tutorial_build_dir "${CMake_BINARY_DIR}/Tests/Tutorial/${step_name}")
1736     if(use_mymath)
1737       set(tutorial_build_options "")
1738     else()
1739       set(tutorial_test_name ${tutorial_test_name}_MYMATH)
1740       set(tutorial_build_dir "${tutorial_build_dir}_MYMATH")
1741       set(tutorial_build_options -DUSE_MYMATH:BOOL=OFF)
1742     endif()
1743     add_test(${tutorial_test_name} ${CMAKE_CTEST_COMMAND}
1744       -C "Release"
1745       --build-and-test
1746       "${CMake_SOURCE_DIR}/Help/guide/tutorial/${step_name}"
1747       ${tutorial_build_dir}_Build
1748       ${build_generator_args}
1749       --build-project Tutorial
1750       --build-options ${tutorial_build_options}
1751       --test-command Tutorial ${tutorial_arg})
1752     set_tests_properties(${tutorial_test_name} PROPERTIES
1753       PASS_REGULAR_EXPRESSION ${pass_regex})
1754
1755     list(APPEND TEST_BUILD_DIRS "${tutorial_build_dir}_Build")
1756   endfunction()
1757
1758   if(NOT CMake_TEST_EXTERNAL_CMAKE)
1759     foreach(STP RANGE 2 12)
1760       if(STP EQUAL 8)
1761         set(pass_regex ".*using log and exp")
1762       else()
1763         set(pass_regex "The square root of 25 is 5")
1764       endif()
1765       add_tutorial_test(Step${STP} TRUE 25 ${pass_regex})
1766     endforeach()
1767     set(pass_regex "The square root of 25 is 5")
1768     add_tutorial_test(Complete TRUE 25 ${pass_regex})
1769     foreach(STP RANGE 3 12)
1770       add_tutorial_test(Step${STP} FALSE 25 ${pass_regex})
1771     endforeach()
1772     add_tutorial_test(Complete FALSE 25 ${pass_regex})
1773   endif()
1774
1775   function(add_importexport_test export_name import_name)
1776     set(install_dir
1777       "${CMake_BINARY_DIR}/Tests/ImportExport/Install${export_name}")
1778     set(export_build_dir "${CMake_BINARY_DIR}/Tests/ImportExport/${export_name}Build")
1779     set(export_test_name "Guide.ImportExport.${export_name}")
1780     add_test(${export_test_name} ${CMAKE_CTEST_COMMAND}
1781       -C "Release"
1782       --build-and-test
1783       "${CMake_SOURCE_DIR}/Help/guide/importing-exporting/${export_name}"
1784       "${export_build_dir}"
1785       ${build_generator_args}
1786       --build-project ${export_name}
1787       --build-target install
1788       --build-options
1789       "-DCMAKE_INSTALL_PREFIX:PATH=${install_dir}")
1790     list(APPEND TEST_BUILD_DIRS "${export_build_dir}")
1791
1792     set(import_build_dir "${CMake_BINARY_DIR}/Tests/ImportExport/${import_name}Build")
1793     set(import_test_name "Guide.ImportExport.${import_name}")
1794     add_test(${import_test_name} ${CMAKE_CTEST_COMMAND}
1795       -C "Release"
1796       --build-and-test
1797       "${CMake_SOURCE_DIR}/Help/guide/importing-exporting/${import_name}"
1798       "${import_build_dir}"
1799       ${build_generator_args}
1800       --build-project ${import_name}
1801       --build-options
1802       "-DCMAKE_PREFIX_PATH:PATH=${install_dir}")
1803     set_tests_properties(${import_test_name} PROPERTIES DEPENDS ${export_test_name})
1804     list(APPEND TEST_BUILD_DIRS "${import_build_dir}")
1805   endfunction()
1806
1807   if(NOT CMake_TEST_EXTERNAL_CMAKE)
1808     add_importexport_test("MyExe" "Importing")
1809     add_importexport_test("MathFunctions" "Downstream")
1810     add_importexport_test("MathFunctionsComponents" "DownstreamComponents")
1811   endif()
1812
1813   add_test(testing ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
1814     --build-and-test
1815     "${CMake_SOURCE_DIR}/Tests/Testing"
1816     "${CMake_BINARY_DIR}/Tests/Testing"
1817     ${build_generator_args}
1818     --build-project Testing
1819     --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
1820     )
1821   set_tests_properties(testing PROPERTIES PASS_REGULAR_EXPRESSION "Passed")
1822   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Testing")
1823
1824   add_test(wrapping  ${CMAKE_CTEST_COMMAND}
1825     --build-and-test
1826     "${CMake_SOURCE_DIR}/Tests/Wrapping"
1827     "${CMake_BINARY_DIR}/Tests/Wrapping"
1828     ${build_generator_args}
1829     --build-project Wrapping
1830     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1831     --test-command wrapping
1832     )
1833   add_test(qtwrapping  ${CMAKE_CTEST_COMMAND}
1834     --build-and-test
1835     "${CMake_SOURCE_DIR}/Tests/Wrapping"
1836     "${CMake_BINARY_DIR}/Tests/Wrapping"
1837     ${build_generator_args}
1838     --build-project Wrapping
1839     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1840       --test-command qtwrapping
1841       )
1842   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Wrapping")
1843
1844   add_test(testdriver1 ${CMAKE_CTEST_COMMAND}
1845     --build-and-test
1846     "${CMake_SOURCE_DIR}/Tests/TestDriver"
1847     "${CMake_BINARY_DIR}/Tests/TestDriver1"
1848     ${build_generator_args}
1849     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1850     --build-project TestDriverTest
1851     --test-command TestDriverTest test1
1852     )
1853   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver1")
1854
1855   add_test(testdriver2 ${CMAKE_CTEST_COMMAND}
1856     --build-and-test
1857     "${CMake_SOURCE_DIR}/Tests/TestDriver"
1858     "${CMake_BINARY_DIR}/Tests/TestDriver2"
1859     ${build_generator_args}
1860     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1861     --build-project TestDriverTest
1862     --test-command TestDriverTest test2
1863     )
1864   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver2")
1865
1866   add_test(testdriver3  ${CMAKE_CTEST_COMMAND}
1867     --build-and-test
1868     "${CMake_SOURCE_DIR}/Tests/TestDriver"
1869     "${CMake_BINARY_DIR}/Tests/TestDriver3"
1870     ${build_generator_args}
1871     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1872     --build-project TestDriverTest
1873     --test-command TestDriverTest subdir/test3
1874     )
1875   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver3")
1876
1877   add_test(testdriver4  ${CMAKE_CTEST_COMMAND}
1878     --build-and-test
1879     "${CMake_SOURCE_DIR}/Tests/TestDriver"
1880     "${CMake_BINARY_DIR}/Tests/TestDriver4"
1881     ${build_generator_args}
1882     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1883     --build-project TestDriverTest
1884     --test-command TestDriverTest -A test2
1885     )
1886   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver4")
1887
1888   add_test(testdriver5  ${CMAKE_CTEST_COMMAND}
1889     --build-and-test
1890     "${CMake_SOURCE_DIR}/Tests/TestDriver"
1891     "${CMake_BINARY_DIR}/Tests/TestDriver5"
1892     ${build_generator_args}
1893     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1894     --build-project TestDriverTest
1895     --test-command TestDriverTest -A test2
1896     )
1897   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver5")
1898   set_tests_properties(testdriver5 PROPERTIES
1899     PASS_REGULAR_EXPRESSION
1900     "TAP version 13\n1\\.\\.3.+ok 1 test1 # [0-9]+\\.[0-9]+.*All tests finished."
1901     )
1902
1903   add_test(Dependency ${CMAKE_CTEST_COMMAND}
1904     --build-and-test
1905     "${CMake_SOURCE_DIR}/Tests/Dependency"
1906     "${CMake_BINARY_DIR}/Tests/Dependency"
1907     --build-exe-dir "${CMake_BINARY_DIR}/Tests/Dependency/Exec"
1908     ${build_generator_args}
1909     --build-project Dependency
1910     --test-command exec
1911     )
1912   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Dependency")
1913
1914   if(CMAKE_SYSTEM_NAME MATCHES syllable)
1915
1916 # RPATH isn't supported under Syllable, so the tests don't
1917 # find their libraries. In order to fix that LIBRARY_OUTPUT_DIR
1918 # in the tests would have to be adjusted to ${EXECUTABLE_OUTPUT_DIR}/lib .
1919 # For now we just require on Syllable that the user adjusts the DLL_PATH
1920 # environment variable, so except the two tests below all other tests will succeed.
1921
1922     set(_DLL_PATH "$ENV{DLL_PATH}")
1923     if(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.(:.*)?$")
1924       message(FATAL_ERROR "In order to successfully run the CMake test suite on Syllable you need to add \"\\@bindir\\@/.\" to the DLL_PATH environment variable")
1925     endif()
1926     if(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.\\./lib(:.*)?$")
1927       message(FATAL_ERROR "In order to successfully run the CMake test suite on Syllable you need to add \"\\@bindir\\@/../lib\" to the DLL_PATH environment variable")
1928     endif()
1929
1930   else()
1931
1932     add_test(JumpWithLibOut  ${CMAKE_CTEST_COMMAND}
1933       --build-and-test
1934       "${CMake_SOURCE_DIR}/Tests/Jump"
1935       "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut"
1936       --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Executable"
1937       --build-project Jump
1938       ${build_generator_args}
1939       --build-options
1940         -DLIBRARY_OUTPUT_PATH:PATH=${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Lib
1941       --test-command jumpExecutable
1942       )
1943
1944     add_test(JumpNoLibOut  ${CMAKE_CTEST_COMMAND}
1945       --build-and-test
1946       "${CMake_SOURCE_DIR}/Tests/Jump"
1947       "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut"
1948       --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
1949       --build-run-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
1950       --build-project Jump
1951       ${build_generator_args}
1952       --test-command jumpExecutable
1953       )
1954     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Jump")
1955
1956     add_test(Plugin ${CMAKE_CTEST_COMMAND}
1957       --build-and-test
1958       "${CMake_SOURCE_DIR}/Tests/Plugin"
1959       "${CMake_BINARY_DIR}/Tests/Plugin"
1960       ${build_generator_args}
1961       --build-project Plugin
1962       --build-two-config
1963       --test-command bin/example)
1964     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Plugin")
1965
1966     if(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
1967       ADD_TEST_MACRO(RuntimePath RuntimePath)
1968     endif()
1969   endif()
1970
1971   if(APPLE AND "${DARWIN_MAJOR_VERSION}" GREATER 9)
1972     add_test(MacRuntimePath ${CMAKE_CTEST_COMMAND}
1973       --build-and-test
1974       "${CMake_SOURCE_DIR}/Tests/MacRuntimePath"
1975       "${CMake_BINARY_DIR}/Tests/MacRuntimePath"
1976       ${build_generator_args}
1977       --build-project MacRuntimePath
1978       --build-options
1979         -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
1980       )
1981   endif()
1982
1983   if(CMake_TEST_XCODE_VERSION AND NOT CMake_TEST_XCODE_VERSION VERSION_LESS 5)
1984     if(NOT CMake_TEST_XCTest_DEPLOYMENT_TARGET)
1985       execute_process(
1986         COMMAND sw_vers -productVersion
1987         OUTPUT_VARIABLE OSX_VERSION
1988         OUTPUT_STRIP_TRAILING_WHITESPACE
1989         )
1990       if(OSX_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
1991         set(CMake_TEST_XCTest_DEPLOYMENT_TARGET "${CMAKE_MATCH_1}")
1992       endif()
1993     endif()
1994     if(CMake_TEST_XCTest_DEPLOYMENT_TARGET)
1995       set(XCTest_CTEST_OPTIONS --build-config $<CONFIGURATION>)
1996       set(XCTest_BUILD_OPTIONS -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMake_TEST_XCTest_DEPLOYMENT_TARGET} -DCMAKE_OSX_SYSROOT=macosx)
1997       ADD_TEST_MACRO(XCTest ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION> -V)
1998     endif()
1999   endif()
2000
2001   add_test(linkorder1 ${CMAKE_CTEST_COMMAND}
2002     --build-and-test
2003     "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
2004     "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
2005     ${build_generator_args}
2006     --build-project LinkLineOrder
2007     --test-command Exec1
2008     )
2009
2010   add_test(linkorder2  ${CMAKE_CTEST_COMMAND}
2011     --build-and-test
2012     "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
2013     "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
2014     ${build_generator_args}
2015     --build-project LinkLineOrder
2016     --test-command Exec2
2017     )
2018   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkLineOrder")
2019   set_tests_properties(qtwrapping PROPERTIES DEPENDS wrapping)
2020   set_tests_properties(testdriver1 PROPERTIES DEPENDS qtwrapping)
2021   set_tests_properties(testdriver2 PROPERTIES DEPENDS testdriver1)
2022   set_tests_properties(testdriver3 PROPERTIES DEPENDS testdriver2)
2023   set_tests_properties(linkorder2 PROPERTIES DEPENDS linkorder1)
2024
2025   # Test static linking on toolchains known to support it.
2026   if((CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "LCC")
2027       AND NOT APPLE AND NOT WIN32 AND NOT CYGWIN
2028       AND EXISTS "/usr/lib/libm.a")
2029     add_test(LinkStatic  ${CMAKE_CTEST_COMMAND}
2030       --build-and-test
2031       "${CMake_SOURCE_DIR}/Tests/LinkStatic"
2032       "${CMake_BINARY_DIR}/Tests/LinkStatic"
2033       ${build_generator_args}
2034       --build-project LinkStatic
2035       --build-options
2036         -DMATH_LIBRARY:FILEPATH=/usr/lib/libm.a
2037       --test-command LinkStatic
2038       )
2039   endif()
2040
2041   if(MAKE_SUPPORTS_SPACES AND NOT CMAKE_GENERATOR STREQUAL "Xcode" AND NOT CMAKE_GENERATOR STREQUAL "Watcom WMake")
2042     add_test(SubDirSpaces ${CMAKE_CTEST_COMMAND}
2043       --build-and-test
2044       "${CMake_SOURCE_DIR}/Tests/SubDirSpaces"
2045       "${CMake_BINARY_DIR}/Tests/SubDirSpaces"
2046       --build-exe-dir
2047       "${CMake_BINARY_DIR}/Tests/SubDirSpaces/Executable Sources"
2048       ${build_generator_args}
2049       --build-project SUBDIR
2050       --test-command test
2051       "${CMake_BINARY_DIR}/Tests/SubDirSpaces/ShouldBeHere"
2052       "${CMake_BINARY_DIR}/Tests/SubDirSpaces/testfromsubdir.obj"
2053       )
2054     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDirSpaces")
2055   endif()
2056
2057   if(WIN32)
2058     add_test(SubDir ${CMAKE_CTEST_COMMAND}
2059       --build-and-test
2060       "${CMake_SOURCE_DIR}/Tests/SubDir"
2061       "${CMake_BINARY_DIR}/Tests/SubDir"
2062       --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
2063       ${build_generator_args}
2064       --build-project SUBDIR
2065       --test-command test
2066       "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
2067       "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.obj"
2068       )
2069   else()
2070     add_test(SubDir ${CMAKE_CTEST_COMMAND}
2071       --build-and-test
2072       "${CMake_SOURCE_DIR}/Tests/SubDir"
2073       "${CMake_BINARY_DIR}/Tests/SubDir"
2074       --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
2075       ${build_generator_args}
2076       --build-project SUBDIR
2077       --test-command test
2078       "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
2079       "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.o"
2080       )
2081   endif()
2082   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDir")
2083
2084   if(MSVC OR (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND CMAKE_C_SIMULATE_ID STREQUAL "MSVC"))
2085     ADD_TEST_MACRO(PDBDirectoryAndName myexe)
2086     if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" OR NOT "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
2087       ADD_TEST_MACRO(ForceInclude foo)
2088     endif()
2089     if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" AND NOT CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
2090       ADD_TEST_MACRO(PrecompiledHeader foo)
2091     endif()
2092
2093     set(MSVCDebugInformationFormat_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2094     if(CMAKE_Fortran_COMPILER)
2095       list(APPEND MSVCDebugInformationFormat_BUILD_OPTIONS -DCMake_TEST_Fortran=1)
2096     endif()
2097     ADD_TEST_MACRO(MSVCDebugInformationFormat)
2098     set_property(TEST MSVCDebugInformationFormat APPEND
2099       PROPERTY LABELS "CUDA")
2100
2101     set(MSVCRuntimeLibrary_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2102     ADD_TEST_MACRO(MSVCRuntimeLibrary)
2103     set_property(TEST MSVCRuntimeLibrary APPEND
2104       PROPERTY LABELS "CUDA")
2105     if(CMAKE_Fortran_COMPILER)
2106       ADD_TEST_MACRO(MSVCRuntimeLibrary.Fortran)
2107     endif()
2108   endif()
2109   if(MSVC OR
2110       "${CMAKE_GENERATOR}" MATCHES "(MSYS|MinGW) Makefiles")
2111     ADD_TEST_MACRO(ModuleDefinition example_exe)
2112   endif()
2113
2114   if(CMAKE_C_COMPILER_ID MATCHES "Watcom" AND WIN32)
2115     ADD_TEST_MACRO(WatcomRuntimeLibrary)
2116   endif()
2117
2118   ADD_TEST_MACRO(CheckCompilerRelatedVariables CheckCompilerRelatedVariables)
2119
2120   if("${CMAKE_GENERATOR}" MATCHES "Makefile" OR
2121      "${CMAKE_GENERATOR}" MATCHES "^Ninja$")
2122     add_test(MakeClean ${CMAKE_CTEST_COMMAND}
2123       --build-and-test
2124       "${CMake_SOURCE_DIR}/Tests/MakeClean"
2125       "${CMake_BINARY_DIR}/Tests/MakeClean"
2126       ${build_generator_args}
2127       --build-project MakeClean
2128       --build-exe-dir "${CMake_BINARY_DIR}/MakeClean"
2129       --test-command check_clean
2130       )
2131     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MakeClean")
2132   endif()
2133
2134   if(CMake_TEST_MFC)
2135     add_test(MFC ${CMAKE_CTEST_COMMAND}
2136       --build-and-test
2137       "${CMake_SOURCE_DIR}/Tests/MFC"
2138       "${CMake_BINARY_DIR}/Tests/MFC"
2139       --build-two-config
2140       ${build_generator_args}
2141       --build-project mfc_driver
2142       --test-command ${CMAKE_CTEST_COMMAND}
2143         -C \${CTEST_CONFIGURATION_TYPE} -VV)
2144     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MFC")
2145   endif()
2146
2147   if(MSVC AND NOT MSVC_VERSION LESS 1310
2148      AND (NOT CMAKE_GENERATOR MATCHES "Visual Studio 9 "
2149           OR CMAKE_SIZEOF_VOID_P EQUAL 4)
2150      AND (NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
2151       )
2152     ADD_TEST_MACRO(VSMASM VSMASM)
2153   endif()
2154
2155   if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
2156     if(NOT MSVC60)
2157       ADD_TEST_MACRO(SBCS SBCS)
2158     endif()
2159
2160     if(NOT "${CMAKE_GENERATOR}" MATCHES "Visual Studio 9 "
2161         AND NOT CMAKE_GENERATOR_TOOLSET STREQUAL "v90"
2162         AND NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
2163       ADD_TEST_MACRO(VSWindowsFormsResx VSWindowsFormsResx)
2164       ADD_TEST_MACRO(VSManagedCustomCommand)
2165     endif()
2166
2167     add_test(VSExternalInclude ${CMAKE_CTEST_COMMAND}
2168       --build-and-test
2169       "${CMake_SOURCE_DIR}/Tests/VSExternalInclude"
2170       "${CMake_BINARY_DIR}/Tests/VSExternalInclude"
2171       --build-two-config
2172       ${build_generator_args}
2173       --build-project VSExternalInclude
2174       --test-command VSExternalInclude)
2175     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExternalInclude")
2176
2177     add_test(VSMidl ${CMAKE_CTEST_COMMAND}
2178       --build-and-test
2179       "${CMake_SOURCE_DIR}/Tests/VSMidl"
2180       "${CMake_BINARY_DIR}/Tests/VSMidl"
2181       --build-two-config
2182       ${build_generator_args}
2183       --build-project VSMidl
2184       --test-command VSMidl)
2185     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSMidl")
2186
2187     if(CMake_TEST_DEVENV)
2188       # The test (and tested property) works with .sln files, so it's skipped when:
2189       # * cmake --build is set up to use MSBuild, since the MSBuild invocation does not use the .sln file
2190       set(_last_test "")
2191       foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES)
2192         add_test(NAME VSExcludeFromDefaultBuild-${config} COMMAND ${CMAKE_CTEST_COMMAND}
2193           --build-and-test
2194           "${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild"
2195           "${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
2196           --build-config ${config}
2197           --build-two-config
2198           --build-generator ${CMAKE_GENERATOR}
2199           --build-makeprogram ${CMake_TEST_DEVENV}
2200           --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
2201           --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
2202           --build-project VSExcludeFromDefaultBuild
2203           --build-target install
2204           --test-command ${CMAKE_COMMAND}
2205              -D "activeConfig=${config}"
2206              -D "allConfigs=${CMAKE_CONFIGURATION_TYPES}"
2207              -D "dir=${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
2208              -P "${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild/ResultTest.cmake")
2209         if(_last_test)
2210           set_property(TEST VSExcludeFromDefaultBuild-${config} PROPERTY DEPENDS ${_last_test})
2211         endif()
2212         set(_last_test "VSExcludeFromDefaultBuild-${config}")
2213       endforeach()
2214       unset(_last_test)
2215       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild")
2216     endif()
2217
2218     if(CMAKE_GENERATOR MATCHES "Visual Studio ([0-5]|[6-9][0-9])")
2219       # This is Visual Studio 10 or above, so the default build tool is MSBuild.
2220       add_test(NAME VSProjectInSubdir COMMAND ${CMAKE_CTEST_COMMAND}
2221         --build-and-test
2222         "${CMake_SOURCE_DIR}/Tests/VSProjectInSubdir"
2223         "${CMake_BINARY_DIR}/Tests/VSProjectInSubdir"
2224         --build-two-config
2225         --build-generator ${CMAKE_GENERATOR}
2226         --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
2227         --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
2228         --build-project VSProjectInSubdir
2229         --build-target test)
2230       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSProjectInSubdir")
2231     endif()
2232   endif()
2233
2234   get_filename_component(ntver "[HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows NT\\CurrentVersion;CurrentVersion]" NAME)
2235   if(WIN32 AND ntver VERSION_GREATER 6.1) # Windows >= 8.0
2236     macro(add_test_VSWinStorePhone name generator systemName systemVersion architecture)
2237       add_test(NAME VSWinStorePhone.${name} COMMAND ${CMAKE_CTEST_COMMAND}
2238         --build-and-test
2239         "${CMake_SOURCE_DIR}/Tests/VSWinStorePhone"
2240         "${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}"
2241         --build-generator "${generator}"
2242         --build-generator-platform "${architecture}"
2243         --build-project VSWinStorePhone
2244         --build-config $<CONFIGURATION>
2245         --build-options -DCMAKE_SYSTEM_NAME=${systemName}
2246                         -DCMAKE_SYSTEM_VERSION=${systemVersion}
2247         --test-command
2248           ${CMAKE_CMAKE_COMMAND} -DAPP_PACKAGE_DIR="${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}"
2249                                  -P "${CMake_SOURCE_DIR}/Tests/VSWinStorePhone/VerifyAppPackage.cmake"
2250         )
2251       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}")
2252     endmacro()
2253
2254     if(vs11 AND ws80)
2255       add_test_VSWinStorePhone(vs11-store80-X86 "Visual Studio 11 2012" WindowsStore 8.0 Win32)
2256       add_test_VSWinStorePhone(vs11-store80-ARM "Visual Studio 11 2012" WindowsStore 8.0 ARM)
2257       add_test_VSWinStorePhone(vs11-store80-X64 "Visual Studio 11 2012" WindowsStore 8.0 x64)
2258     endif()
2259     if(vs12 AND ws81)
2260       add_test_VSWinStorePhone(vs12-store81-X86 "Visual Studio 12 2013" WindowsStore 8.1 Win32)
2261       add_test_VSWinStorePhone(vs12-store81-ARM "Visual Studio 12 2013" WindowsStore 8.1 ARM)
2262       add_test_VSWinStorePhone(vs12-store81-X64 "Visual Studio 12 2013" WindowsStore 8.1 x64)
2263
2264       add_test(NAME VSXaml COMMAND ${CMAKE_CTEST_COMMAND}
2265         --build-and-test
2266           "${CMake_SOURCE_DIR}/Tests/VSXaml"
2267           "${CMake_BINARY_DIR}/Tests/VSXaml"
2268           --build-generator "Visual Studio 12 2013"
2269           --build-project VSXaml
2270           --build-config $<CONFIGURATION>
2271           --build-options -DCMAKE_SYSTEM_NAME=WindowsStore
2272                           -DCMAKE_SYSTEM_VERSION=8.1
2273         )
2274     endif()
2275     if(CMake_TEST_VSWinStorePhone_VS_2017 AND ws10_0)
2276       add_test_VSWinStorePhone(vs15-store10_0-X86 "Visual Studio 15 2017" WindowsStore 10.0 Win32)
2277       add_test_VSWinStorePhone(vs15-store10_0-ARM "Visual Studio 15 2017" WindowsStore 10.0 ARM)
2278       add_test_VSWinStorePhone(vs15-store10_0-X64 "Visual Studio 15 2017" WindowsStore 10.0 x64)
2279       add_test_VSWinStorePhone(vs15-store10_0-ARM64 "Visual Studio 15 2017" WindowsStore 10.0 ARM64)
2280     endif()
2281     if(vs14 AND ws10_0)
2282       add_test_VSWinStorePhone(vs14-store10_0-X86 "Visual Studio 14 2015" WindowsStore 10.0 Win32)
2283       add_test_VSWinStorePhone(vs14-store10_0-ARM "Visual Studio 14 2015" WindowsStore 10.0 ARM)
2284       add_test_VSWinStorePhone(vs14-store10_0-X64 "Visual Studio 14 2015" WindowsStore 10.0 x64)
2285     endif()
2286     if(vs11 AND wp80)
2287       add_test_VSWinStorePhone(vs11-phone80-X86 "Visual Studio 11 2012" WindowsPhone 8.0 Win32)
2288       add_test_VSWinStorePhone(vs11-phone80-ARM "Visual Studio 11 2012" WindowsPhone 8.0 ARM)
2289     endif()
2290     if(vs12 AND wp81)
2291       add_test_VSWinStorePhone(vs12-phone81-X86 "Visual Studio 12 2013" WindowsPhone 8.1 Win32)
2292       add_test_VSWinStorePhone(vs12-phone81-ARM "Visual Studio 12 2013" WindowsPhone 8.1 ARM)
2293     endif()
2294   endif()
2295
2296   if(WIN32 AND wince)
2297     macro(add_test_VSWinCE name generator systemName systemVersion generatorPlatform)
2298       # TODO: Fix the tutorial to make it work in cross compile
2299       # currently the MakeTable is build for target and can not be used on the host
2300       # This happens in part 5 so we build only through part 4 of the tutorial.
2301       foreach(STP RANGE 2 4)
2302         add_test(NAME "TutorialStep${STP}.${name}" COMMAND ${CMAKE_CTEST_COMMAND}
2303           --build-and-test
2304           "${CMake_SOURCE_DIR}/Help/guide/tutorial/Step${STP}"
2305           "${CMake_BINARY_DIR}/Tests/Tutorial/Step${STP}_${name}"
2306           --build-generator "${generator}"
2307           --build-project Tutorial
2308           --build-config $<CONFIGURATION>
2309           --build-options -DCMAKE_SYSTEM_NAME=${systemName}
2310                           -DCMAKE_SYSTEM_VERSION=${systemVersion}
2311                           -DCMAKE_GENERATOR_PLATFORM=${generatorPlatform})
2312         list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Tutorial/Step${STP}_${name}")
2313       endforeach()
2314     endmacro()
2315
2316     if(vs11)
2317       add_test_VSWinCE(vs11-ce80-ARM "Visual Studio 11 2012" WindowsCE 8.0 ${wince_sdk})
2318     endif()
2319
2320     if(vs12)
2321       add_test_VSWinCE(vs12-ce80-ARM "Visual Studio 12 2013" WindowsCE 8.0 ${wince_sdk})
2322     endif()
2323   endif()
2324
2325   if(CMAKE_GENERATOR MATCHES "Visual Studio ([^9]|9[0-9])" AND nasm)
2326     ADD_TEST_MACRO(VSNASM VSNASM)
2327   endif()
2328
2329   if(CMake_TEST_GreenHillsMULTI)
2330     macro(add_test_GhsMulti test_name test_dir bin_sub_dir build_opts)
2331       separate_arguments(_ghs_build_opts UNIX_COMMAND ${build_opts})
2332       separate_arguments(_ghs_toolset_extra UNIX_COMMAND ${ghs_toolset_extra})
2333       if(${ARGC} GREATER 4)
2334         set(_ghs_test_command --test-command ${ARGN})
2335       endif()
2336       if(ghs_config_name STREQUAL "__default__")
2337         set(_ghs_test_name "${test_name}")
2338       else()
2339         set(_ghs_test_name "${ghs_config_name}.${test_name}")
2340       endif()
2341       add_test(NAME GhsMulti.${_ghs_test_name}
2342         COMMAND ${CMAKE_CTEST_COMMAND}
2343         --build-and-test
2344         "${CMake_SOURCE_DIR}/Tests/GhsMulti/${test_dir}"
2345         "${CMake_BINARY_DIR}/Tests/GhsMulti/${ghs_config_name}/${test_dir}/${bin_sub_dir}"
2346         --build-generator "Green Hills MULTI"
2347         --build-project test
2348         --build-config $<CONFIGURATION>
2349         --force-new-ctest-process
2350         --build-options ${ghs_target_arch} ${ghs_toolset_name} ${ghs_toolset_root} ${ghs_target_platform}
2351           ${ghs_os_root} ${ghs_os_dir} ${ghs_bsp_name} ${_ghs_build_opts} ${_ghs_toolset_extra}
2352           ${_ghs_test_command}
2353         )
2354         unset(_ghs_build_opts)
2355         unset(_ghs_toolset_extra)
2356         unset(_ghs_test_command)
2357         unset(_ghs_test_name)
2358     endmacro()
2359     macro(add_test_GhsMulti_rename_install test_name)
2360       add_test_GhsMulti( ${test_name} GhsMultiRenameInstall ${test_name}
2361         "-DCMAKE_INSTALL_PREFIX=. -DRUN_TEST=${test_name}" ${CMAKE_CMAKE_COMMAND} --build . --target INSTALL)
2362     endmacro()
2363     #unset ghs config variables
2364     unset(ghs_config_name)
2365     unset(ghs_target_arch)
2366     unset(ghs_toolset_root)
2367     unset(ghs_toolset_name)
2368     unset(ghs_os_root)
2369     unset(ghs_os_dir)
2370     unset(ghs_target_platform)
2371     unset(ghs_bsp_name)
2372     unset(ghs_toolset_extra)
2373     if(NOT CMake_TEST_GreenHillsMULTI_config)
2374       #if list of config settings not defined then just run once as default
2375       set(CMake_TEST_GreenHillsMULTI_config "__default__")
2376     endif()
2377     foreach(ghs_file IN LISTS CMake_TEST_GreenHillsMULTI_config)
2378       # source GHS tools config file
2379       if(NOT ghs_file STREQUAL "__default__")
2380         if(IS_ABSOLUTE ${ghs_file})
2381           include(${ghs_file})
2382         else()
2383           include(${CMAKE_BINARY_DIR}/${ghs_file})
2384         endif()
2385       endif()
2386       if(NOT ghs_config_name)
2387         set(ghs_config_name "__default__")
2388       endif()
2389       # test integrity build
2390       if(NOT ghs_skip_integrity AND (NOT ghs_target_platform OR ghs_target_platform MATCHES "integrity"))
2391         add_test_GhsMulti(integrityDDInt GhsMultiIntegrity/GhsMultiIntegrityDDInt "" "")
2392         add_test_GhsMulti(integrityMonolith GhsMultiIntegrity/GhsMultiIntegrityMonolith "" "")
2393         add_test_GhsMulti(integrityDD GhsMultiIntegrity/GhsMultiIntegrityDD "" "")
2394       endif()
2395       add_test_GhsMulti(duplicate_source_filenames GhsMultiDuplicateSourceFilenames "" "")
2396       add_test_GhsMulti_rename_install(SINGLE_EXEC)
2397       add_test_GhsMulti_rename_install(SINGLE_EXEC_RENAMED)
2398       add_test_GhsMulti_rename_install(EXEC_AND_LIB)
2399       add_test_GhsMulti(multiple_source_groups GhsMultiSrcGroups Default "")
2400       add_test_GhsMulti(multiple_source_groups_folders GhsMultiSrcGroups PropFolders "-DTEST_PROP=ON")
2401       add_test_GhsMulti(multiple_source_groups_all_folders GhsMultiSrcGroups AllFolders "-DCMAKE_GHS_NO_SOURCE_GROUP_FILE=ON")
2402       add_test_GhsMulti(unsupported_targets GhsMultiUnsupportedTargets "" "")
2403       add_test_GhsMulti(object_library GhsMultiObjectLibrary "" "")
2404       add_test_GhsMulti(exclude GhsMultiExclude "" ""
2405         ${CMAKE_CMAKE_COMMAND} -P ${CMake_SOURCE_DIR}/Tests/GhsMulti/GhsMultiExclude/verify.cmake)
2406       add_test_GhsMulti(interface GhsMultiInterface "" "")
2407       add_test_GhsMulti(transitive_link_test GhsMultiLinkTest TransitiveLink "-DRUN_TEST=NO_FLAGS")
2408       add_test_GhsMulti(flags_link_test GhsMultiLinkTest FlagsCheck "-DRUN_TEST=CHECK_FLAGS")
2409       add_test_GhsMulti(sub_link_test GhsMultiLinkTestSub "" "")
2410       add_test_GhsMulti(multiple_projects GhsMultiMultipleProjects "" ""
2411         ${CMAKE_CMAKE_COMMAND} -P ${CMake_SOURCE_DIR}/Tests/GhsMulti/GhsMultiMultipleProjects/verify.cmake)
2412       add_test_GhsMulti(compiler_options_none GhsMultiCompilerOptions None "-DRUN_TEST=RELEASE_FLAGS -DRUN_TEST_BUILD_TYPE=\"\"")
2413       add_test_GhsMulti(compiler_options_kernel GhsMultiCompilerOptions Kernel "-DRUN_TEST=KERNEL_FLAGS -DRUN_TEST_BUILD_TYPE=DEBUG")
2414       add_test_GhsMulti(try_compile_copy GhsMultiCopyFile "" "")
2415       add_test_GhsMulti(ghs_platform GhsMultiPlatform "" "")
2416       add_test_GhsMulti(custom_target GhsMultiCustomTarget "" "")
2417       add_test_GhsMulti(dep_order GhsMultiDepOrder "" "")
2418       add_test_GhsMulti(external_project GhsMultiExternalProject "" "")
2419       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/GhsMulti/${ghs_config_name}")
2420       #unset ghs config variables
2421       unset(ghs_config_name)
2422       unset(ghs_target_arch)
2423       unset(ghs_toolset_root)
2424       unset(ghs_toolset_name)
2425       unset(ghs_os_root)
2426       unset(ghs_os_dir)
2427       unset(ghs_target_platform)
2428       unset(ghs_bsp_name)
2429       unset(ghs_toolset_extra)
2430     endforeach()
2431   endif()
2432
2433   macro(add_test_VSAndroid name generator platform)
2434     add_test(NAME "VSAndroid.${name}.${platform}" COMMAND ${CMAKE_CTEST_COMMAND}
2435       --build-and-test
2436       "${CMake_SOURCE_DIR}/Tests/VSAndroid"
2437       "${CMake_BINARY_DIR}/Tests/VSAndroid/${name}/${platform}"
2438       --build-generator "${generator}"
2439       --build-project VSAndroid
2440       --build-config $<CONFIGURATION>
2441       --build-options -DCMAKE_SYSTEM_NAME=Android "-A${platform}"
2442       )
2443     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSAndroid/${name}")
2444   endmacro()
2445   if(tegra AND NOT "${CMake_SOURCE_DIR};${CMake_BINARY_DIR}" MATCHES " ")
2446     if(vs11)
2447       add_test_VSAndroid(vs11 "Visual Studio 11 2012" "Tegra-Android")
2448     endif()
2449     if(vs12)
2450       add_test_VSAndroid(vs12 "Visual Studio 12 2013" "Tegra-Android")
2451     endif()
2452     if(vs14)
2453       add_test_VSAndroid(vs14 "Visual Studio 14 2015" "Tegra-Android")
2454     endif()
2455   endif()
2456   if(vs14 AND CMake_TEST_ANDROID_VS14)
2457     add_test_VSAndroid(vs14 "Visual Studio 14 2015" "ARM")
2458   endif()
2459   if(vs15 AND CMake_TEST_ANDROID_VS15)
2460     add_test_VSAndroid(vs15 "Visual Studio 15 2017" "ARM")
2461   endif()
2462   if(vs16 AND CMake_TEST_ANDROID_VS16)
2463     add_test_VSAndroid(vs16 "Visual Studio 16 2019" "ARM")
2464   endif()
2465   if(vs17 AND CMake_TEST_ANDROID_VS17)
2466     add_test_VSAndroid(vs17 "Visual Studio 17 2022" "ARM")
2467   endif()
2468
2469   if(APPLE)
2470     if(CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
2471       set(BundleTestInstallDir
2472         "${CMake_BINARY_DIR}/Tests/BundleTest/InstallDirectory")
2473       add_test(BundleTest ${CMAKE_CTEST_COMMAND}
2474         --build-and-test
2475         "${CMake_SOURCE_DIR}/Tests/BundleTest"
2476         "${CMake_BINARY_DIR}/Tests/BundleTest"
2477         --build-two-config
2478         ${build_generator_args}
2479         --build-project BundleTest
2480         --build-target install
2481 #       --build-target package
2482         --build-options
2483         "-DCMAKE_INSTALL_PREFIX:PATH=${BundleTestInstallDir}"
2484         "-DCMake_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}"
2485         --test-command
2486         ${BundleTestInstallDir}/Applications/SecondBundleExe.app/Contents/MacOS/SecondBundleExe)
2487       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleTest")
2488
2489       add_test(NAME CFBundleTest COMMAND ${CMAKE_CTEST_COMMAND}
2490         --build-and-test
2491         "${CMake_SOURCE_DIR}/Tests/CFBundleTest"
2492         "${CMake_BINARY_DIR}/Tests/CFBundleTest"
2493         --build-two-config
2494         ${build_generator_args}
2495         --build-project CFBundleTest
2496         --build-config $<CONFIGURATION>
2497         --test-command
2498         ${CMAKE_CMAKE_COMMAND} -DCTEST_CONFIGURATION_TYPE=$<CONFIGURATION>
2499         -Ddir=${CMake_BINARY_DIR}/Tests/CFBundleTest
2500         -Dgen=${CMAKE_GENERATOR}
2501         -P ${CMake_SOURCE_DIR}/Tests/CFBundleTest/VerifyResult.cmake)
2502       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CFBundleTest")
2503
2504       add_subdirectory(ObjC)
2505       add_subdirectory(ObjCXX)
2506     endif()
2507   endif()
2508
2509   if(APPLE AND CTEST_TEST_CPACK)
2510     add_test(BundleGeneratorTest ${CMAKE_CTEST_COMMAND}
2511       --build-and-test
2512       "${CMake_SOURCE_DIR}/Tests/BundleGeneratorTest"
2513       "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest"
2514       --build-two-config
2515       ${build_generator_args}
2516       --build-project BundleGeneratorTest
2517       --build-target package
2518       --build-options
2519         "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/BundleGeneratorTest/InstallDirectory"
2520       )
2521     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest")
2522   endif()
2523
2524   add_test(WarnUnusedCliUnused ${CMAKE_CTEST_COMMAND}
2525     --build-and-test
2526     "${CMake_SOURCE_DIR}/Tests/WarnUnusedCliUnused"
2527     "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused"
2528     ${build_generator_args}
2529     --build-project WarnUnusedCliUnused
2530     --build-options
2531       "-DUNUSED_CLI_VARIABLE=Unused")
2532   set_tests_properties(WarnUnusedCliUnused PROPERTIES
2533     PASS_REGULAR_EXPRESSION "CMake Warning:.*Manually-specified variables were not used by the project:.*  UNUSED_CLI_VARIABLE")
2534   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused")
2535
2536   add_test(WarnUnusedCliUsed ${CMAKE_CTEST_COMMAND}
2537     --build-and-test
2538     "${CMake_SOURCE_DIR}/Tests/VariableUsage"
2539     "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed"
2540     ${build_generator_args}
2541     --build-noclean
2542     --build-project WarnUnusedCliUsed
2543     --build-options
2544       "-DUSED_VARIABLE=Usage proven")
2545   set_tests_properties(WarnUnusedCliUsed PROPERTIES
2546     PASS_REGULAR_EXPRESSION "Usage proven")
2547   set_tests_properties(WarnUnusedCliUsed PROPERTIES
2548     FAIL_REGULAR_EXPRESSION "CMake Warning: The variable, 'USED_VARIABLE'")
2549   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed")
2550
2551   add_test(WarnUninitialized ${CMAKE_CTEST_COMMAND}
2552     --build-and-test
2553     "${CMake_SOURCE_DIR}/Tests/VariableUsage"
2554     "${CMake_BINARY_DIR}/Tests/WarnUninitialized"
2555     ${build_generator_args}
2556     --build-noclean
2557     --build-project WarnUninitialized
2558     --build-options
2559       "--warn-uninitialized")
2560   set_tests_properties(WarnUninitialized PROPERTIES
2561     PASS_REGULAR_EXPRESSION "uninitialized variable 'USED_VARIABLE'")
2562   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUninitialized")
2563
2564   add_test(TestsWorkingDirectory
2565     ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
2566     --build-and-test
2567     "${CMake_SOURCE_DIR}/Tests/TestsWorkingDirectory"
2568     "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
2569     ${build_generator_args}
2570     --build-project TestsWorkingDirectoryProj
2571     --build-exe-dir "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
2572     --force-new-ctest-process
2573     --test-command ${CMAKE_CTEST_COMMAND} -V -C \${CTEST_CONFIGURATION_TYPE}
2574     )
2575   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory")
2576
2577   # Make sure CTest can handle a test with no newline in output.
2578   add_test(CTest.NoNewline
2579     ${CMAKE_CMAKE_COMMAND} -E echo_append "This line has no newline!")
2580
2581   # A simple test for ctest in script mode
2582   configure_file("${CMake_SOURCE_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake.in"
2583           "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake" @ONLY)
2584 #  add_test(CTest.ScriptMode ${CMAKE_CTEST_COMMAND}
2585 #        -S "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake"
2586 #        )
2587
2588   # Test CTest Update with Subversion
2589   if(NOT DEFINED CMake_TEST_CTestUpdate_SVN OR CMake_TEST_CTestUpdate_SVN)
2590     find_package(Subversion QUIET)
2591     if(Subversion_FOUND)
2592       get_filename_component(_Subversion_BIN_DIR
2593         ${Subversion_SVN_EXECUTABLE} PATH)
2594       find_program(Subversion_SVNADMIN_EXECUTABLE svnadmin
2595         HINTS ${_Subversion_BIN_DIR}
2596         )
2597       mark_as_advanced(Subversion_SVNADMIN_EXECUTABLE)
2598       if(NOT Subversion_SVNADMIN_EXECUTABLE)
2599         set(Subversion_FOUND FALSE)
2600       endif()
2601     endif()
2602   endif()
2603   if(NOT DEFINED CMake_TEST_CTestUpdate_SVN AND Subversion_FOUND)
2604     set(CMake_TEST_CTestUpdate_SVN 1)
2605   endif()
2606   if(CMake_TEST_CTestUpdate_SVN)
2607     if(NOT Subversion_FOUND)
2608       message(FATAL_ERROR "CMake_TEST_CTestUpdate_SVN enabled but Subversion is not found.")
2609     endif()
2610     set(CTestUpdateSVN_DIR "CTest UpdateSVN")
2611     configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateSVN.cmake.in"
2612       "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake" @ONLY)
2613     add_test(CTest.UpdateSVN ${CMAKE_CMAKE_COMMAND}
2614       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake"
2615       )
2616     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateSVN_DIR}")
2617   endif()
2618
2619   # Test CTest Update with CVS
2620   if(NOT DEFINED CMake_TEST_CTestUpdate_CVS OR CMake_TEST_CTestUpdate_CVS)
2621     find_program(CVS_EXECUTABLE NAMES cvs)
2622     mark_as_advanced(CVS_EXECUTABLE)
2623   endif()
2624   if(NOT DEFINED CMake_TEST_CTestUpdate_CVS AND CVS_EXECUTABLE
2625       AND (UNIX OR NOT "${CVS_EXECUTABLE}" MATCHES "cygwin"))
2626     set(CMake_TEST_CTestUpdate_CVS 1)
2627   endif()
2628   if(CMake_TEST_CTestUpdate_CVS)
2629     if(NOT CVS_EXECUTABLE)
2630       message(FATAL_ERROR "CMake_TEST_CTestUpdate_CVS enabled but CVS_EXECUTABLE is not found.")
2631     endif()
2632     set(CTestUpdateCVS_DIR "CTest UpdateCVS")
2633     configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateCVS.cmake.in"
2634       "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake" @ONLY)
2635     add_test(CTest.UpdateCVS ${CMAKE_CMAKE_COMMAND}
2636       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake"
2637       )
2638     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateCVS_DIR}")
2639   endif()
2640
2641   # Test CTest Update with BZR
2642   if(CMake_TEST_CTestUpdate_BZR)
2643     if(TEST_HOME)
2644       file(MAKE_DIRECTORY "${TEST_HOME}/.bazaar")
2645     endif()
2646     find_program(BZR_EXECUTABLE NAMES bzr)
2647     mark_as_advanced(BZR_EXECUTABLE)
2648     if(NOT BZR_EXECUTABLE)
2649       message(FATAL_ERROR "CMake_TEST_CTestUpdate_BZR enabled but BZR_EXECUTABLE is not found.")
2650     endif()
2651     set(CTestUpdateBZR_DIR "CTest UpdateBZR")
2652     configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
2653       "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake" @ONLY)
2654     add_test(CTest.UpdateBZR ${CMAKE_CMAKE_COMMAND}
2655       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake"
2656       )
2657     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
2658     set(CTestUpdateBZR_DIR "CTest UpdateBZR_CLocale")
2659     configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
2660       "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake" @ONLY)
2661     add_test(CTest.UpdateBZR.CLocale ${CMAKE_CMAKE_COMMAND}
2662       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake"
2663       )
2664     set_tests_properties(CTest.UpdateBZR.CLocale PROPERTIES ENVIRONMENT LC_ALL=C)
2665     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
2666   endif()
2667
2668   # Test CTest Update with GIT
2669   if(NOT DEFINED CMake_TEST_CTestUpdate_GIT OR CMake_TEST_CTestUpdate_GIT)
2670     find_program(GIT_EXECUTABLE NAMES git)
2671     mark_as_advanced(GIT_EXECUTABLE)
2672   endif()
2673   if(NOT DEFINED CMake_TEST_CTestUpdate_GIT AND GIT_EXECUTABLE
2674       AND (UNIX OR NOT "${GIT_EXECUTABLE}" MATCHES "cygwin"))
2675     set(CMake_TEST_CTestUpdate_GIT 1)
2676   endif()
2677   if(CMake_TEST_CTestUpdate_GIT)
2678     if(NOT GIT_EXECUTABLE)
2679       message(FATAL_ERROR "CMake_TEST_CTestUpdate_GIT enabled but GIT_EXECUTABLE is not found.")
2680     endif()
2681     set(CTestUpdateGIT_DIR "CTest UpdateGIT")
2682     configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateGIT.cmake.in"
2683       "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake" @ONLY)
2684     add_test(CTest.UpdateGIT ${CMAKE_CMAKE_COMMAND}
2685       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake"
2686       )
2687     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateGIT_DIR}")
2688     set_property(TEST CTest.UpdateGIT PROPERTY ENVIRONMENT GIT_ALLOW_PROTOCOL=file)
2689   endif()
2690
2691   # Test CTest Update with HG
2692   if(NOT DEFINED CMake_TEST_CTestUpdate_HG OR CMake_TEST_CTestUpdate_HG)
2693     find_program(HG_EXECUTABLE NAMES hg)
2694     mark_as_advanced(HG_EXECUTABLE)
2695   endif()
2696   if(NOT DEFINED CMake_TEST_CTestUpdate_HG AND HG_EXECUTABLE
2697       AND (UNIX OR NOT "${HG_EXECUTABLE}" MATCHES "cygwin"))
2698     execute_process(COMMAND "${HG_EXECUTABLE}" --version OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE HG_RV)
2699     if(HG_RV EQUAL 0)
2700       set(CMake_TEST_CTestUpdate_HG 1)
2701     endif()
2702   endif()
2703   if(CMake_TEST_CTestUpdate_HG)
2704     if(NOT HG_EXECUTABLE)
2705       message(FATAL_ERROR "CMake_TEST_CTestUpdate_HG enabled but HG_EXECUTABLE is not found.")
2706     endif()
2707     set(CTestUpdateHG_DIR "CTest UpdateHG")
2708     configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateHG.cmake.in"
2709       "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake" @ONLY)
2710     add_test(CTest.UpdateHG ${CMAKE_CMAKE_COMMAND}
2711       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake"
2712       )
2713     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateHG_DIR}")
2714   endif()
2715
2716   # Test CTest Update with P4
2717   if(CMake_TEST_CTestUpdate_P4)
2718     find_program(P4_EXECUTABLE NAMES p4)
2719     find_program(P4D_EXECUTABLE NAMES p4d)
2720     mark_as_advanced(P4_EXECUTABLE P4D_EXECUTABLE)
2721     if(NOT P4_EXECUTABLE OR NOT P4D_EXECUTABLE)
2722       message(FATAL_ERROR "CMake_TEST_CTestUpdate_HG enabled but P4_EXECUTABLE and P4D_EXECUTABLE are not both not found.")
2723     endif()
2724     set(CTestUpdateP4_DIR "CTest UpdateP4")
2725     configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateP4.cmake.in"
2726       "${CMake_BINARY_DIR}/Tests/CTestUpdateP4.cmake" @ONLY)
2727     add_test(CTest.UpdateP4 ${CMAKE_CMAKE_COMMAND}
2728       -P "${CMake_BINARY_DIR}/Tests/CTestUpdateP4.cmake"
2729       )
2730     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateP4_DIR}")
2731   endif()
2732
2733   configure_file(
2734     "${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoBuild.cmake.in"
2735     "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake"
2736     @ONLY ESCAPE_QUOTES)
2737   add_test(CTestTestNoBuild ${CMAKE_CTEST_COMMAND}
2738     -S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake" -V
2739     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut1.log"
2740     )
2741   set_tests_properties(CTestTestNoBuild PROPERTIES
2742     FAIL_REGULAR_EXPRESSION "Error" WILL_FAIL true)
2743
2744   configure_file(
2745     "${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoExe.cmake.in"
2746     "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake"
2747     @ONLY ESCAPE_QUOTES)
2748   add_test(CTestTestNoExe ${CMAKE_CTEST_COMMAND}
2749     -S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake" -V
2750     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut2.log"
2751     )
2752   set_tests_properties(CTestTestNoExe PROPERTIES DEPENDS CTestTestNoBuild
2753     PASS_REGULAR_EXPRESSION "Could not find executable"
2754     FAIL_REGULAR_EXPRESSION "SegFault")
2755
2756   if(NOT CMake_TEST_NO_NETWORK)
2757     configure_file(
2758       "${CMake_SOURCE_DIR}/Tests/CTestTestUpload/test.cmake.in"
2759       "${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake"
2760       @ONLY ESCAPE_QUOTES)
2761     add_test(CTestTestUpload ${CMAKE_CTEST_COMMAND}
2762       -S "${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake" -V
2763       --output-log "${CMake_BINARY_DIR}/Tests/CTestTestUpload/testOut.log"
2764       )
2765     set_tests_properties(CTestTestUpload PROPERTIES
2766       PASS_REGULAR_EXPRESSION "Upload\\.xml")
2767   endif()
2768
2769   configure_file(
2770     "${CMake_SOURCE_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake.in"
2771     "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake"
2772     @ONLY ESCAPE_QUOTES)
2773   add_test(CTestCoverageCollectGCOV ${CMAKE_CTEST_COMMAND}
2774     -C \${CTEST_CONFIGURATION_TYPE}
2775     -S "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake" -VV
2776     --output-log "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/testOut.log"
2777     )
2778   set_property(TEST CTestCoverageCollectGCOV PROPERTY ENVIRONMENT CTEST_PARALLEL_LEVEL=)
2779
2780   configure_file(
2781     "${CMake_SOURCE_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake.in"
2782     "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake"
2783     @ONLY ESCAPE_QUOTES)
2784   add_test(CTestTestEmptyBinaryDirectory ${CMAKE_CTEST_COMMAND}
2785     -S "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake" -V
2786     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/testOut.log"
2787     )
2788   set_tests_properties(CTestTestEmptyBinaryDirectory PROPERTIES
2789     PASS_REGULAR_EXPRESSION "TEST_SUCCESS")
2790
2791   # test coverage for mumps
2792   # create a MumpsCoverage dir in the binary tree under Testing to
2793   # avoid the .NoDartCoverage files in the cmake testing tree
2794   configure_file(
2795      "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.tcl.in"
2796      "${CMake_BINARY_DIR}/Testing/MumpsCoverage/DartConfiguration.tcl")
2797   configure_file(
2798      "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/gtm_coverage.mcov.in"
2799      "${CMake_BINARY_DIR}/Testing/MumpsCoverage/gtm_coverage.mcov")
2800   file(REMOVE_RECURSE "${CMake_BINARY_DIR}/Testing/MumpsCoverage/VistA-FOIA")
2801   file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
2802     DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCoverage")
2803   add_test(NAME CTestGTMCoverage
2804     COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2805     ${CMake_BINARY_DIR}/Testing/MumpsCoverage
2806     $<TARGET_FILE:ctest> -T Coverage --debug)
2807   set_tests_properties(CTestGTMCoverage PROPERTIES
2808       PASS_REGULAR_EXPRESSION
2809       "Process file.*ZZCOVTST.m.*Total LOC:.*32.*Percentage Coverage: 81.25*"
2810       ENVIRONMENT COVFILE=)
2811
2812   configure_file(
2813      "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.cache.tcl.in"
2814      "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/DartConfiguration.tcl")
2815   configure_file(
2816     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/cache_coverage.cmcov.in"
2817     "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/cache_coverage.cmcov")
2818   file(REMOVE_RECURSE "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/VistA-FOIA")
2819   file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
2820     DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage")
2821   add_test(NAME CTestCacheCoverage
2822     COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2823     ${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage
2824     $<TARGET_FILE:ctest> -T Coverage --debug)
2825   set_tests_properties(CTestCacheCoverage PROPERTIES
2826       PASS_REGULAR_EXPRESSION
2827       "Process file.*ZZCOVTST.m.*Total LOC:.*32.*Percentage Coverage: 87.50.*"
2828       ENVIRONMENT COVFILE=)
2829
2830   # Adding a test case for Python Coverage
2831   configure_file(
2832      "${CMake_SOURCE_DIR}/Tests/PythonCoverage/coverage.xml.in"
2833      "${CMake_BINARY_DIR}/Testing/PythonCoverage/coverage.xml")
2834   configure_file(
2835      "${CMake_SOURCE_DIR}/Tests/PythonCoverage/DartConfiguration.tcl.in"
2836      "${CMake_BINARY_DIR}/Testing/PythonCoverage/DartConfiguration.tcl")
2837   file(COPY "${CMake_SOURCE_DIR}/Tests/PythonCoverage/coveragetest"
2838     DESTINATION "${CMake_BINARY_DIR}/Testing/PythonCoverage")
2839   add_test(NAME CTestPythonCoverage
2840     COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2841     ${CMake_BINARY_DIR}/Testing/PythonCoverage
2842     $<TARGET_FILE:ctest> -T Coverage --debug)
2843   set_tests_properties(CTestPythonCoverage PROPERTIES
2844       PASS_REGULAR_EXPRESSION
2845       "Process file.*foo.py.*Total LOC:.*13.*Percentage Coverage: 84.62.*"
2846       ENVIRONMENT COVFILE=)
2847
2848   # Adding a test case for non-python Cobertura Coverage
2849   configure_file(
2850      "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/DartConfiguration.tcl.in"
2851      "${CMake_BINARY_DIR}/Testing/CoberturaCoverage/DartConfiguration.tcl")
2852   configure_file(
2853      "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/coverage.xml.in"
2854      "${CMake_BINARY_DIR}/Testing/CoberturaCoverage/coverage.xml")
2855   file(COPY "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/src"
2856     DESTINATION "${CMake_BINARY_DIR}/Testing/CoberturaCoverage")
2857   add_test(NAME CTestCoberturaCoverage
2858     COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2859     ${CMake_BINARY_DIR}/Testing/CoberturaCoverage
2860     $<TARGET_FILE:ctest> -T Coverage --debug)
2861   set_tests_properties(CTestCoberturaCoverage PROPERTIES
2862       PASS_REGULAR_EXPRESSION
2863       "Process file.*CoverageTest.java.*Total LOC:.*18.*Percentage Coverage: 72.22.*"
2864       ENVIRONMENT COBERTURADIR=${CMake_BINARY_DIR}/Testing/CoberturaCoverage
2865       ENVIRONMENT COVFILE=)
2866
2867
2868   # Adding a test case for JaCoCo Coverage
2869   configure_file(
2870      "${CMake_SOURCE_DIR}/Tests/JacocoCoverage/DartConfiguration.tcl.in"
2871      "${CMake_BINARY_DIR}/Testing/JacocoCoverage/DartConfiguration.tcl")
2872   file(COPY "${CMake_SOURCE_DIR}/Tests/JacocoCoverage/Coverage"
2873     DESTINATION "${CMake_BINARY_DIR}/Testing/JacocoCoverage")
2874   configure_file("${CMake_BINARY_DIR}/Testing/JacocoCoverage/Coverage/target/site/jacoco.xml.in"
2875     "${CMake_BINARY_DIR}/Testing/JacocoCoverage/Coverage/target/site/jacoco.xml")
2876   add_test(NAME CTestJacocoCoverage
2877     COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2878     ${CMake_BINARY_DIR}/Testing/JacocoCoverage
2879     $<TARGET_FILE:ctest> -T Coverage --debug)
2880   set_tests_properties(CTestJacocoCoverage PROPERTIES
2881       PASS_REGULAR_EXPRESSION
2882       "Process file.*CoverageTest.java.*Total LOC:.*17.*Percentage Coverage: 76.47*"
2883       ENVIRONMENT COVFILE=)
2884
2885   # Adding a test case for Javascript Coverage
2886   configure_file(
2887      "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/DartConfiguration.tcl.in"
2888      "${CMake_BINARY_DIR}/Testing/JavascriptCoverage/DartConfiguration.tcl")
2889   configure_file(
2890      "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/output.json.in"
2891      "${CMake_BINARY_DIR}/Testing/JavascriptCoverage/output.json")
2892   file(COPY "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/"
2893     DESTINATION "${CMake_BINARY_DIR}/Testing/JavascriptCoverage"
2894     FILES_MATCHING PATTERN "*.js")
2895   add_test(NAME CTestJavascriptCoverage
2896     COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2897     ${CMake_BINARY_DIR}/Testing/JavascriptCoverage
2898     $<TARGET_FILE:ctest> -T Coverage --debug)
2899   set_tests_properties(CTestJavascriptCoverage PROPERTIES
2900       PASS_REGULAR_EXPRESSION
2901       "Process file.*test3.js.*Total LOC:.*49.*Percentage Coverage: 79.59*"
2902       ENVIRONMENT COVFILE=)
2903
2904   # test coverage for Delphi-code-Coverage
2905   configure_file(
2906      "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/DartConfiguration.tcl.in"
2907      "${CMake_BINARY_DIR}/Testing/DelphiCoverage/DartConfiguration.tcl")
2908   file(COPY "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/src"
2909     DESTINATION "${CMake_BINARY_DIR}/Testing/DelphiCoverage")
2910   configure_file(
2911     "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html.in"
2912     "${CMake_BINARY_DIR}/Testing/DelphiCoverage/UTCovTest(UTCovTest.pas).html")
2913   add_test(NAME CTestDelphiCoverage
2914     COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2915     ${CMake_BINARY_DIR}/Testing/DelphiCoverage
2916     $<TARGET_FILE:ctest> -T Coverage --debug)
2917   set_tests_properties(CTestDelphiCoverage PROPERTIES
2918       PASS_REGULAR_EXPRESSION
2919       "Process file.*UTCovTest.pas.*Total LOC:.*20.*Percentage Coverage: 95.*"
2920       ENVIRONMENT COVFILE=)
2921
2922   function(add_config_tests cfg)
2923     set(base "${CMake_BINARY_DIR}/Tests/CTestConfig")
2924
2925     # Test -S script with a -C config arg to ctest:
2926     configure_file(
2927       "${CMake_SOURCE_DIR}/Tests/CTestConfig/script.cmake.in"
2928       "${base}/${cfg}-script.cmake"
2929       @ONLY ESCAPE_QUOTES)
2930     add_test(CTestConfig.Script.${cfg} ${CMAKE_CTEST_COMMAND}
2931       -C ${cfg}
2932       -S "${base}/${cfg}-script.cmake" -VV
2933       --output-log "${base}/${cfg}-script.log"
2934       )
2935
2936     # Test -D dashboard with a -C config arg to ctest.
2937     # (Actual commands inside a cmake -P script because we need to be able to set
2938     #  the working directory reliably...)
2939     configure_file(
2940       "${CMake_SOURCE_DIR}/Tests/CTestConfig/dashboard.cmake.in"
2941       "${base}/${cfg}-dashboard.cmake"
2942       @ONLY ESCAPE_QUOTES)
2943     add_test(CTestConfig.Dashboard.${cfg} ${CMAKE_CMAKE_COMMAND}
2944       -P "${base}/${cfg}-dashboard.cmake" -VV
2945       )
2946   endfunction()
2947
2948   add_config_tests(Debug)
2949   add_config_tests(MinSizeRel)
2950   add_config_tests(Release)
2951   add_config_tests(RelWithDebInfo)
2952
2953   # Test -S script with some -D variable definition args to ctest:
2954   add_test(CTestConfig.ScriptWithArgs ${CMAKE_CTEST_COMMAND}
2955     -C "Release"
2956     -D arg1=this
2957     -D arg2=that
2958     -D "arg3=the other"
2959     "-Darg4=this is the fourth"
2960     -Darg5=the_fifth
2961     -Darg6:STRING=value-with-type
2962     -S "${CMake_SOURCE_DIR}/Tests/CTestConfig/ScriptWithArgs.cmake" -VV
2963     --output-log "${CMake_BINARY_DIR}/Tests/CTestConfig/ScriptWithArgs.log"
2964     )
2965
2966   ADD_TEST_MACRO(CMakeCommands.add_compile_definitions add_compile_definitions)
2967   ADD_TEST_MACRO(CMakeCommands.add_compile_options add_compile_options)
2968   ADD_TEST_MACRO(CMakeCommands.target_link_libraries target_link_libraries)
2969   ADD_TEST_MACRO(CMakeCommands.target_include_directories target_include_directories)
2970   ADD_TEST_MACRO(CMakeCommands.target_compile_definitions target_compile_definitions)
2971   ADD_TEST_MACRO(CMakeCommands.target_compile_options target_compile_options)
2972   ADD_TEST_MACRO(CMakeCommands.target_sources target_sources)
2973
2974   ADD_TEST_MACRO(CMakeCommands.add_link_options)
2975   ADD_TEST_MACRO(CMakeCommands.target_link_options)
2976   ADD_TEST_MACRO(CMakeCommands.link_directories)
2977   ADD_TEST_MACRO(CMakeCommands.target_link_directories)
2978
2979   configure_file(
2980     "${CMake_SOURCE_DIR}/Tests/CTestTestCrash/test.cmake.in"
2981     "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake"
2982     @ONLY ESCAPE_QUOTES)
2983   add_test(CTestTestCrash ${CMAKE_CTEST_COMMAND}
2984     -S "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake" -V
2985     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCrash/testOutput.log"
2986     )
2987   # with watcom the SEGFAULT is not found, it just fails
2988   if(CMAKE_GENERATOR MATCHES "Watcom WMake")
2989     set_tests_properties(CTestTestCrash PROPERTIES
2990       PASS_REGULAR_EXPRESSION "Failed")
2991   else()
2992     set_tests_properties(CTestTestCrash PROPERTIES
2993       PASS_REGULAR_EXPRESSION "(Illegal|SegFault|Subprocess aborted|SIGTRAP)")
2994   endif()
2995
2996   configure_file(
2997     "${CMake_SOURCE_DIR}/Tests/CTestTestBadExe/test.cmake.in"
2998     "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake"
2999     @ONLY ESCAPE_QUOTES)
3000   add_test(CTestTestBadExe ${CMAKE_CTEST_COMMAND}
3001     -S "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake" -V
3002     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/testOutput.log"
3003     )
3004   set(CTestTestBadExe_REGEX "BAD_COMMAND")
3005   # some cygwin can not be made to produce a BAD_COMMAND error
3006   # the best we can get from it is a failed test
3007   if(CYGWIN)
3008     set(CTestTestBadExe_REGEX "(\\*\\*\\*Failed)|BAD_COMMAND")
3009   endif()
3010   set_tests_properties(CTestTestBadExe PROPERTIES
3011     PASS_REGULAR_EXPRESSION "${CTestTestBadExe_REGEX}")
3012
3013   configure_file(
3014     "${CMake_SOURCE_DIR}/Tests/CTestTestBadGenerator/test.cmake.in"
3015     "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/test.cmake"
3016     @ONLY ESCAPE_QUOTES)
3017   add_test(CTestTestBadGenerator ${CMAKE_CTEST_COMMAND}
3018     -C "\${CTestTest_CONFIG}"
3019     -S "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/test.cmake" -V
3020     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/testOutput.log"
3021     )
3022   set_property(TEST CTestTestBadGenerator PROPERTY
3023     PASS_REGULAR_EXPRESSION "could not create generator named \"Bad Generator\"")
3024
3025   configure_file(
3026     "${CMake_SOURCE_DIR}/Tests/CTestTestParallel/test.cmake.in"
3027     "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake"
3028     @ONLY ESCAPE_QUOTES)
3029   add_test(CTestTestParallel ${CMAKE_CTEST_COMMAND}
3030     -S "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake" -V
3031     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestParallel/testOutput.log"
3032     )
3033
3034   configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestVerboseOutput/test.cmake.in"
3035     "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/test.cmake" @ONLY ESCAPE_QUOTES)
3036   add_test(CTestTestVerboseOutput ${CMAKE_CTEST_COMMAND}
3037     -S "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/test.cmake" -VV
3038     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/testOutput.log"
3039     -C "\${CTestTest_CONFIG}"
3040     )
3041   set_property(TEST CTestTestVerboseOutput PROPERTY PASS_REGULAR_EXPRESSION
3042     "Test command:.*Working Directory:.*Environment variables:.*foo=bar.*this=that"
3043   )
3044
3045   configure_file(
3046     "${CMake_SOURCE_DIR}/Tests/CTestTestSkipReturnCode/test.cmake.in"
3047     "${CMake_BINARY_DIR}/Tests/CTestTestSkipReturnCode/test.cmake"
3048     @ONLY ESCAPE_QUOTES)
3049   add_test(CTestTestSkipReturnCode ${CMAKE_CTEST_COMMAND}
3050     -S "${CMake_BINARY_DIR}/Tests/CTestTestSkipReturnCode/test.cmake" -V
3051     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestSkipReturnCode/testOutput.log"
3052     -C \${CTEST_CONFIGURATION_TYPE}
3053     )
3054   set_tests_properties(CTestTestSkipReturnCode PROPERTIES
3055     PASS_REGULAR_EXPRESSION "CMakeV1 \\.* +Passed.*CMakeV2 \\.+\\*+Skipped")
3056   set_property(TEST CTestTestSkipReturnCode PROPERTY ENVIRONMENT CTEST_PARALLEL_LEVEL=)
3057
3058   ADD_TEST_MACRO(CTestTestSerialInDepends ${CMAKE_CTEST_COMMAND} -j 4
3059     --output-on-failure -C "\${CTestTest_CONFIG}")
3060
3061   ADD_TEST_MACRO(CTestTestMissingDependsExe ${CMAKE_CTEST_COMMAND}
3062     --output-on-failure -C "\${CTestTest_CONFIG}")
3063   set_tests_properties(CTestTestMissingDependsExe PROPERTIES
3064     PASS_REGULAR_EXPRESSION "\\*\\*\\*Not Run"
3065   )
3066
3067   ADD_TEST_MACRO(CTestTestSerialOrder ${CMAKE_CTEST_COMMAND}
3068     --output-on-failure -C "\${CTestTest_CONFIG}")
3069   set_property(TEST CTestTestSerialOrder PROPERTY ENVIRONMENT CTEST_PARALLEL_LEVEL=)
3070
3071   if(NOT BORLAND)
3072     set(CTestLimitDashJ_CTEST_OPTIONS --force-new-ctest-process)
3073     add_test_macro(CTestLimitDashJ ${CMAKE_CTEST_COMMAND} -j 4
3074       --output-on-failure -C "\${CTestTest_CONFIG}")
3075   endif()
3076
3077   add_test(CTestTestPrintLabels ${CMAKE_CTEST_COMMAND} --print-labels)
3078   set_tests_properties(CTestTestPrintLabels PROPERTIES LABELS "Label1;Label2")
3079   set_tests_properties(CTestTestPrintLabels PROPERTIES PASS_REGULAR_EXPRESSION
3080     "All Labels:.*  Label1.*  Label2")
3081
3082   configure_file(
3083     "${CMake_SOURCE_DIR}/Tests/CTestTestLabelRegExp/test.cmake.in"
3084     "${CMake_BINARY_DIR}/Tests/CTestTestLabelRegExp/test.cmake"
3085     @ONLY ESCAPE_QUOTES)
3086   add_test(NAME CTestTestLabelRegExp
3087     COMMAND ${CMAKE_CMAKE_COMMAND}
3088       -DSOURCE_DIR=${CMAKE_SOURCE_DIR}/Tests/CTestTestLabelRegExp
3089       -P ${CMAKE_BINARY_DIR}/Tests/CTestTestLabelRegExp/test.cmake
3090     WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Tests/CTestTestLabelRegExp
3091   )
3092
3093   configure_file(
3094     "${CMake_SOURCE_DIR}/Tests/CTestTestResourceLock/test.cmake.in"
3095     "${CMake_BINARY_DIR}/Tests/CTestTestResourceLock/test.cmake"
3096     @ONLY ESCAPE_QUOTES)
3097   add_test(CTestTestResourceLock ${CMAKE_CTEST_COMMAND}
3098     -S "${CMake_BINARY_DIR}/Tests/CTestTestResourceLock/test.cmake" -V
3099     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestResourceLock/output.log"
3100     )
3101
3102   configure_file(
3103     "${CMake_SOURCE_DIR}/Tests/CTestTestScheduler/test.cmake.in"
3104     "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/test.cmake"
3105     @ONLY ESCAPE_QUOTES)
3106   add_test(CTestTestScheduler ${CMAKE_CTEST_COMMAND}
3107     -S "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/test.cmake" -V
3108     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/testOutput.log"
3109     )
3110   set_tests_properties(CTestTestScheduler PROPERTIES
3111     PASS_REGULAR_EXPRESSION "Start 1.*Start 2.*Start 3.*Start 4.*Start 4.*Start 3.*Start 2.*Start 1"
3112     RESOURCE_LOCK "CostData")
3113
3114   configure_file(
3115     "${CMake_SOURCE_DIR}/Tests/CTestTestCostSerial/test.cmake.in"
3116     "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake"
3117     @ONLY ESCAPE_QUOTES)
3118   add_test(CTestTestCostSerial ${CMAKE_CTEST_COMMAND}
3119     -S "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake" -V
3120     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/testOutput.log"
3121     )
3122   set_tests_properties(CTestTestCostSerial PROPERTIES
3123     PASS_REGULAR_EXPRESSION "Start 2.*Start 3.*Start 1.*Start 2.*Start 3.*Start 1"
3124     RESOURCE_LOCK "CostData")
3125
3126   configure_file(
3127     "${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/test.cmake.in"
3128     "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake"
3129     @ONLY ESCAPE_QUOTES)
3130   configure_file(
3131     "${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
3132     "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
3133     COPYONLY)
3134   add_test(CTestTestStopTime ${CMAKE_CTEST_COMMAND}
3135     -S "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake" -V
3136     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/testOutput.log"
3137     )
3138   set_tests_properties(CTestTestStopTime PROPERTIES
3139     PASS_REGULAR_EXPRESSION "The stop time has been passed")
3140
3141   configure_file(
3142     "${CMake_SOURCE_DIR}/Tests/CTestTestSubdir/test.cmake.in"
3143     "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake"
3144     @ONLY ESCAPE_QUOTES)
3145   add_test(CTestTestSubdir ${CMAKE_CTEST_COMMAND}
3146     -S "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake" -V
3147     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/testOutput.log"
3148     )
3149   #make sure all 3 subdirs were added
3150   set_tests_properties(CTestTestSubdir PROPERTIES
3151     PASS_REGULAR_EXPRESSION "0 tests failed out of 3")
3152
3153   configure_file(
3154     "${CMake_SOURCE_DIR}/Tests/CTestTestTimeout/test.cmake.in"
3155     "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake"
3156     @ONLY ESCAPE_QUOTES)
3157   add_test(CTestTestTimeout ${CMAKE_CTEST_COMMAND}
3158     -C "\${CTestTest_CONFIG}"
3159     -S "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake" -V
3160     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/testOutput.log"
3161     )
3162   set_tests_properties(CTestTestTimeout PROPERTIES
3163     PASS_REGULAR_EXPRESSION "TestTimeout *\\.+ *\\*\\*\\*Timeout.*TestSleep *\\.+ *Passed.*timeout correctly killed child")
3164
3165   add_test(
3166     NAME CTestTestRerunFailed
3167     COMMAND ${CMAKE_CTEST_COMMAND} --rerun-failed)
3168   set_tests_properties(CTestTestRerunFailed PROPERTIES
3169     PASS_REGULAR_EXPRESSION "1/1 Test #1: TestTimeout" DEPENDS CTestTestTimeout
3170     WORKING_DIRECTORY ${CMake_BINARY_DIR}/Tests/CTestTestTimeout)
3171
3172   configure_file(
3173     "${CMake_SOURCE_DIR}/Tests/CTestTestZeroTimeout/test.cmake.in"
3174     "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/test.cmake"
3175     @ONLY ESCAPE_QUOTES)
3176   add_test(CTestTestZeroTimeout ${CMAKE_CTEST_COMMAND}
3177     -S "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/test.cmake" -V
3178     --output-log
3179     "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/testOutput.log")
3180   set_tests_properties(CTestTestZeroTimeout PROPERTIES
3181     FAIL_REGULAR_EXPRESSION "\\*\\*\\*Timeout")
3182
3183   configure_file(
3184     "${CMake_SOURCE_DIR}/Tests/CTestTestDepends/test.cmake.in"
3185     "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake"
3186     @ONLY ESCAPE_QUOTES)
3187   add_test(CTestTestDepends ${CMAKE_CTEST_COMMAND}
3188     -C "\${CTestTest_CONFIG}"
3189     -S "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake" -V
3190     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestDepends/testOutput.log"
3191     )
3192
3193   configure_file(
3194     "${CMake_SOURCE_DIR}/Tests/CTestTestCycle/test.cmake.in"
3195     "${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake"
3196     @ONLY ESCAPE_QUOTES)
3197   add_test(CTestTestCycle ${CMAKE_CTEST_COMMAND}
3198     -C "\${CTestTest_CONFIG}"
3199     -S "${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake" -V
3200     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCycle/testOutput.log"
3201     )
3202   set_tests_properties(CTestTestCycle PROPERTIES
3203     PASS_REGULAR_EXPRESSION "a cycle exists in the test dependency graph")
3204
3205   configure_file(
3206     "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/test.cmake.in"
3207     "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake"
3208     @ONLY ESCAPE_QUOTES)
3209   configure_file(
3210     "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/hello.cmake.in"
3211     "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/hello.cmake"
3212     @ONLY ESCAPE_QUOTES)
3213   add_test(CTestTestRunScript ${CMAKE_CTEST_COMMAND}
3214     -S "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake" -V
3215     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/testOutput.log"
3216     )
3217
3218   add_test(CTestTestShowOnly ${CMAKE_CTEST_COMMAND} -N)
3219
3220   configure_file(
3221     "${CMake_SOURCE_DIR}/Tests/CTestTestFdSetSize/test.cmake.in"
3222     "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake"
3223     @ONLY ESCAPE_QUOTES)
3224   add_test(CTestTestFdSetSize ${CMAKE_CTEST_COMMAND}
3225     -S "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake" -j20 -V --timeout 120
3226     --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/testOutput.log"
3227     )
3228
3229   if(CMAKE_TESTS_CDASH_SERVER)
3230     set(regex "^([^:]+)://([^/]+)(.*)$")
3231
3232     if("${CMAKE_TESTS_CDASH_SERVER}" MATCHES "${regex}")
3233       set(protocol "${CMAKE_MATCH_1}")
3234       set(server "${CMAKE_MATCH_2}")
3235       set(path "${CMAKE_MATCH_3}")
3236     else()
3237       set(protocol "http")
3238       set(server "open.cdash.org")
3239       set(path "")
3240       message("warning: CMAKE_TESTS_CDASH_SERVER does not match expected regex...")
3241       message("         ...using default url='${protocol}://${server}${path}' for CTestTest[23]")
3242     endif()
3243   endif()
3244
3245
3246   if(CTEST_TEST_CTEST AND CMAKE_RUN_LONG_TESTS AND CMAKE_TESTS_CDASH_SERVER)
3247     configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest/test.cmake.in"
3248       "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" @ONLY ESCAPE_QUOTES)
3249     add_test(CTestTest ${CMAKE_CTEST_COMMAND}
3250       -S "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" -V
3251       --output-log "${CMake_BINARY_DIR}/Tests/CTestTest/testOutput.log"
3252       )
3253
3254     if(NOT CMake_TEST_EXTERNAL_CMAKE)
3255       configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest2/test.cmake.in"
3256         "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" @ONLY ESCAPE_QUOTES)
3257       add_test(CTestTest2 ${CMAKE_CTEST_COMMAND}
3258         -S "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" -V
3259         --output-log "${CMake_BINARY_DIR}/Tests/CTestTest2/testOutput.log"
3260         )
3261     endif()
3262
3263     if("${CMAKE_GENERATOR}" MATCHES "Makefiles" OR "${CMAKE_GENERATOR}" MATCHES "Ninja")
3264       configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestLaunchers/test.cmake.in"
3265         "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/test.cmake" @ONLY ESCAPE_QUOTES)
3266       add_test(CTestTestLaunchers ${CMAKE_CTEST_COMMAND}
3267         -S "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/test.cmake" -V
3268         --output-log "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/testOutput.log"
3269         )
3270       set_tests_properties(CTestTestLaunchers PROPERTIES
3271         PASS_REGULAR_EXPRESSION "CTEST_TEST_LAUNCHER_SUCCESS")
3272     endif()
3273
3274     configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestChecksum/test.cmake.in"
3275       "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" @ONLY
3276       ESCAPE_QUOTES)
3277     add_test(CTestTestChecksum ${CMAKE_CTEST_COMMAND}
3278       -S "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" -V
3279       --output-log
3280       "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/testOutput.log"
3281       )
3282     set_tests_properties(CTestTestChecksum PROPERTIES PASS_REGULAR_EXPRESSION
3283       "Submission failed: Checksum failed for file")
3284
3285     # these tests take a long time, make sure they have it
3286     # if timeouts have not already been set
3287     get_test_property(CTestTest TIMEOUT PREVIOUS_TIMEOUT)
3288     if("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
3289       set_tests_properties(CTestTest
3290         PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
3291     endif()
3292
3293     if(NOT CMake_TEST_EXTERNAL_CMAKE)
3294       get_test_property(CTestTest2 TIMEOUT PREVIOUS_TIMEOUT)
3295       if("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
3296         set_tests_properties(CTestTest2
3297           PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
3298       endif()
3299     endif()
3300   endif()
3301
3302   if(CMake_TEST_EXTERNAL_CMAKE)
3303     set(CMAKE_SKIP_BOOTSTRAP_TEST 1)
3304   endif()
3305   if("${CMAKE_GENERATOR}" MATCHES Xcode)
3306     set(CMAKE_SKIP_BOOTSTRAP_TEST 1)
3307   endif()
3308   if(EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt")
3309     # If there is CMakeLists.txt in the binary tree, assume in-source build
3310     set(CMAKE_SKIP_BOOTSTRAP_TEST 1)
3311   endif()
3312   set(bootstrap "")
3313   if(CMAKE_RUN_LONG_TESTS AND NOT CMAKE_SKIP_BOOTSTRAP_TEST)
3314     if(UNIX)
3315       set(bootstrap ${CMake_SOURCE_DIR}/bootstrap)
3316     elseif(MSYS)
3317       configure_file(${CMAKE_CURRENT_SOURCE_DIR}/bootstrap.bat.in
3318                      ${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat @ONLY)
3319       set(bootstrap ${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat)
3320     endif()
3321   endif()
3322   if(bootstrap)
3323     add_test(NAME BootstrapTest
3324       COMMAND ${CMAKE_CMAKE_COMMAND}
3325         -D "bootstrap=${bootstrap}"
3326         -D "bin_dir=${CMake_BINARY_DIR}/Tests/BootstrapTest"
3327         -D "generator=${CMAKE_GENERATOR}"
3328         -P ${CMAKE_CURRENT_SOURCE_DIR}/BootstrapTest.cmake
3329       )
3330     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BootstrapTest")
3331     # This test will use all processors.
3332     set_tests_properties(BootstrapTest PROPERTIES RUN_SERIAL 1)
3333
3334     # provide more time for the bootstrap test
3335     get_test_property(BootstrapTest TIMEOUT PREVIOUS_TIMEOUT)
3336     if("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
3337       set_tests_properties(BootstrapTest PROPERTIES TIMEOUT 5400)
3338     endif()
3339   endif()
3340
3341   if(CMAKE_Fortran_COMPILER)
3342     add_test(Fortran ${CMAKE_CTEST_COMMAND}
3343       --build-and-test
3344       "${CMake_SOURCE_DIR}/Tests/Fortran"
3345       "${CMake_BINARY_DIR}/Tests/Fortran"
3346       ${build_generator_args}
3347       --build-project testf
3348       --build-two-config
3349       --test-command testf)
3350     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Fortran")
3351
3352     if(CMAKE_Fortran_COMPILER_SUPPORTS_F90)
3353       add_test(FortranModules ${CMAKE_CTEST_COMMAND}
3354         --build-and-test
3355         "${CMake_SOURCE_DIR}/Tests/FortranModules"
3356         "${CMake_BINARY_DIR}/Tests/FortranModules"
3357         ${build_generator_args}
3358         --build-project FortranModules
3359         --build-options
3360           -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
3361           -DCMake_TEST_Fortran_SUBMODULES:BOOL=${CMake_TEST_Fortran_SUBMODULES}
3362           ${CMake_TEST_FortranModules_BUILD_OPTIONS}
3363         )
3364       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranModules")
3365     endif()
3366
3367     # FortranCInterface tests.
3368     if(UNIX)
3369       configure_file(${CMAKE_CURRENT_SOURCE_DIR}/FortranC/Flags.cmake.in
3370         ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake @ONLY)
3371       add_test(FortranC.Flags ${CMAKE_CMAKE_COMMAND} -P
3372         ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake)
3373       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC/Flags")
3374     else()
3375       add_test(FortranC ${CMAKE_CTEST_COMMAND}
3376         --build-and-test
3377         "${CMake_SOURCE_DIR}/Tests/FortranC"
3378         "${CMake_BINARY_DIR}/Tests/FortranC"
3379         ${build_generator_args}
3380         --build-project FortranC
3381         --build-two-config
3382         --test-command CMakeFiles/FortranCInterface/FortranCInterface)
3383       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC")
3384     endif()
3385   endif()
3386
3387   if(NOT DEFINED CMake_TEST_Java)
3388     if(APPLE OR MINGW)
3389       set(CMake_TEST_Java 0)
3390     else()
3391       set(CMake_TEST_Java 1)
3392     endif()
3393   endif()
3394   if(CMake_TEST_Java)
3395     find_package(Java COMPONENTS Development QUIET)
3396   endif()
3397   if(Java_JAVA_EXECUTABLE AND Java_JAVAC_EXECUTABLE AND Java_JAR_EXECUTABLE)
3398
3399     set(JavaExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM})
3400     ADD_TEST_MACRO(JavaExportImport JavaExportImport)
3401
3402     get_filename_component(JAVACPATH ${Java_JAVAC_EXECUTABLE} REALPATH)
3403     get_filename_component(JNIPATH ${JAVACPATH} PATH)
3404     find_file(JNI_H jni.h
3405       "${JNIPATH}/../include"
3406       "${JNIPATH}/../java/include")
3407     if(JNI_H AND EXISTS "${JNI_H}") # in case jni.h is a broken symlink
3408       file(READ "${JNI_H}" JNI_FILE)
3409       if("${JNI_FILE}" MATCHES "JDK1_2")
3410
3411         execute_process(
3412           COMMAND "${Java_JAVA_EXECUTABLE}" -version
3413           OUTPUT_VARIABLE _version ERROR_VARIABLE _version RESULT_VARIABLE _result
3414           )
3415
3416         # E2K has broken Java RVM before 3.5.2
3417         if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "e2k" AND _result EQUAL 0)
3418           string(REGEX MATCH "RVM ([0-9.]+)" RVMVER "${_version}")
3419           # Consider empty match a broken version too
3420           if("${CMAKE_MATCH_1}" VERSION_LESS "3.5.2")
3421             set(BROKEN_RVM TRUE)
3422           endif()
3423         endif()
3424
3425         if(NOT BROKEN_RVM)
3426           add_test(NAME Java.Jar COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3427             --build-and-test
3428             "${CMake_SOURCE_DIR}/Tests/Java"
3429             "${CMake_BINARY_DIR}/Tests/JavaJar"
3430             ${build_generator_args}
3431             --build-project hello
3432             --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaJar/"
3433             --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
3434           list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaJar")
3435
3436           # For next tests, java tool must have same architecture as toolchain
3437           math(EXPR _object_mode "${CMAKE_SIZEOF_VOID_P} * 8")
3438           if(_result EQUAL 0 AND _version MATCHES "${_object_mode}-Bit")
3439             ## next test is valid only if Java version is less than 1.10
3440             if("${Java_VERSION}" VERSION_LESS 1.10)
3441               add_test(NAME Java.Javah COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3442                 --build-and-test
3443                 "${CMake_SOURCE_DIR}/Tests/JavaJavah"
3444                 "${CMake_BINARY_DIR}/Tests/JavaJavah"
3445                 ${build_generator_args}
3446                 --build-project helloJavah
3447                 --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaJavah/"
3448                 --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
3449               list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaJavah")
3450             endif()
3451             ## next test is valid only if Java is, at least, version 1.8
3452             if(NOT "${Java_VERSION}" VERSION_LESS 1.8)
3453               add_test(NAME Java.NativeHeaders COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3454                 --build-and-test
3455                 "${CMake_SOURCE_DIR}/Tests/JavaNativeHeaders"
3456                 "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders"
3457                 ${build_generator_args}
3458                 --build-project helloJavaNativeHeaders
3459                 --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders/"
3460                 --build-target install
3461                 --build-options
3462                 "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/JavaNativeHeaders/Install"
3463                 --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
3464               list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders")
3465             endif()
3466           endif()
3467         endif()
3468       endif()
3469     endif()
3470   endif()
3471
3472   # add some cross compiler tests, for now only with makefile based generators
3473   if(CMAKE_GENERATOR MATCHES "Makefiles")
3474
3475     # if sdcc is found, build the SimpleCOnly project with sdcc
3476     find_program(SDCC_EXECUTABLE sdcc)
3477     mark_as_advanced(SDCC_EXECUTABLE)
3478     if(SDCC_EXECUTABLE)
3479       add_test(SimpleCOnly_sdcc ${CMAKE_CTEST_COMMAND}
3480         --build-and-test
3481         "${CMake_SOURCE_DIR}/Tests/SimpleCOnly"
3482         "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc"
3483         ${build_generator_args}
3484         --build-project SimpleC
3485         --build-options
3486           "-DCMAKE_SYSTEM_NAME=Generic"
3487           "-DCMAKE_C_COMPILER=${SDCC_EXECUTABLE}")
3488       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc")
3489     endif()
3490
3491     # If a Linux -> MinGW cross compiler is found then try it
3492     find_program(MINGW_CC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-gcc)
3493     find_program(MINGW_CXX_LINUX2WIN_EXECUTABLE i586-mingw32msvc-g++)
3494     find_program(MINGW_RC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-windres)
3495     mark_as_advanced(MINGW_CC_LINUX2WIN_EXECUTABLE MINGW_CXX_LINUX2WIN_EXECUTABLE MINGW_RC_LINUX2WIN_EXECUTABLE)
3496     if(MINGW_CC_LINUX2WIN_EXECUTABLE AND MINGW_CXX_LINUX2WIN_EXECUTABLE AND MINGW_RC_LINUX2WIN_EXECUTABLE)
3497       add_test(Simple_Mingw_Linux2Win ${CMAKE_CTEST_COMMAND}
3498         --build-and-test
3499         "${CMake_SOURCE_DIR}/Tests/Simple"
3500         "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win"
3501         ${build_generator_args}
3502         --build-project Simple
3503         --build-options
3504           "-DCMAKE_SYSTEM_NAME=Windows"
3505           "-DCMAKE_C_COMPILER=${MINGW_CC_LINUX2WIN_EXECUTABLE}"
3506           "-DCMAKE_CXX_COMPILER=${MINGW_CXX_LINUX2WIN_EXECUTABLE}"
3507           "-DCMAKE_RC_COMPILER=${MINGW_RC_LINUX2WIN_EXECUTABLE}"
3508         )
3509       list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win")
3510     endif()
3511   endif()
3512
3513   if(CMAKE_TEST_PROJECT_CSE_DIR)
3514     set(script "${CMAKE_TEST_PROJECT_CSE_DIR}/BuildProjectCSE.cmake")
3515     if(NOT EXISTS "${script}")
3516       set(script "${CMAKE_TEST_PROJECT_CSE_DIR}/cse_build.cmake")
3517     endif()
3518     if(NOT EXISTS "${script}")
3519       message("warning: CMAKE_TEST_PROJECT_CSE_DIR set, but no build script found...")
3520     endif()
3521
3522     add_test(BuildCSE ${CMAKE_CTEST_COMMAND} -V -S "${script}")
3523     set_tests_properties(BuildCSE PROPERTIES TIMEOUT 5400)
3524   endif()
3525
3526   if(CMAKE_TEST_PLPLOT_DIR)
3527     add_test(plplot ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_PLPLOT_DIR}/../../EasyDashboardScripts/plplot.cmake)
3528     set_tests_properties ( plplot PROPERTIES TIMEOUT 5400)
3529   endif()
3530
3531   if(CMAKE_TEST_CHICKEN_DIR)
3532     add_test(Chicken ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_CHICKEN_DIR}/../../EasyDashboardScripts/Chicken.cmake)
3533     set_tests_properties(Chicken PROPERTIES TIMEOUT 5400)
3534   endif()
3535
3536   if(CMAKE_TEST_KDELIBS_ALPHA_1_DIR)
3537     add_test(KDELibsAlpha1 ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_KDELIBS_ALPHA_1_DIR}/../../EasyDashboardScripts/kdelibs.cmake)
3538     set_tests_properties(KDELibsAlpha1 PROPERTIES TIMEOUT 5400)
3539   endif()
3540
3541   # Define a set of "contract" tests, each activated by a cache entry
3542   # named "CMake_TEST_CONTRACT_<project>".  For each Contract test,
3543   # the project should provide a directory with a CMakeLists.txt file
3544   # that uses ExternalProject to download and configure the project.
3545   # The directory should also contain a Configure.cmake file that
3546   # sets "CMake_TEST_CONTRACT_<project>_<var>" variables to configure
3547   # the code below.
3548   foreach(project IN ITEMS PLplot Trilinos VTK)
3549     if(CMake_TEST_CONTRACT_${project})
3550       include(Contracts/${project}/Configure.cmake)
3551       ADD_TEST_MACRO(Contracts.${project} ${CMake_TEST_CONTRACT_${project}_RUN_TEST})
3552       # The external projects may take a long time to build.
3553       if(DEFINED CMake_TEST_CONTRACT_${project}_TIMEOUT)
3554         set(timeout ${CMake_TEST_CONTRACT_${project}_TIMEOUT})
3555       elseif(CMake_TEST_CONTRACT_DEFAULT_TIMEOUT)
3556         set(timeout ${CMake_TEST_CONTRACT_DEFAULT_TIMEOUT})
3557       else()
3558         set(timeout 21600)
3559       endif()
3560       set_property(TEST Contracts.${project} PROPERTY TIMEOUT "${timeout}")
3561     endif()
3562   endforeach()
3563
3564   if(TEST_CompileCommandOutput)
3565     set(CompileCommandOutput_BUILD_OPTIONS
3566       -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES})
3567     ADD_TEST_MACRO(CompileCommandOutput
3568       "${CMake_BINARY_DIR}/Tests/CMakeLib/runcompilecommands")
3569   endif()
3570
3571   add_test(IncludeDirectories ${CMAKE_CTEST_COMMAND}
3572     --build-and-test
3573     "${CMake_SOURCE_DIR}/Tests/IncludeDirectories"
3574     "${CMake_BINARY_DIR}/Tests/IncludeDirectories"
3575     --build-two-config
3576     ${build_generator_args}
3577     --build-project IncludeDirectories
3578     --build-options
3579       -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
3580     --test-command IncludeDirectories)
3581   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/IncludeDirectories")
3582
3583   if(CMAKE_GENERATOR MATCHES "^((Unix|MSYS) Makefiles|Ninja)$" AND
3584      ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.4)
3585       OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
3586       OR (CMAKE_CXX_COMPILER_ID STREQUAL "LCC")
3587       OR (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")))
3588     add_test(IncludeDirectoriesCPATH ${CMAKE_CTEST_COMMAND}
3589       --build-and-test
3590       "${CMake_SOURCE_DIR}/Tests/IncludeDirectoriesCPATH"
3591       "${CMake_BINARY_DIR}/Tests/IncludeDirectoriesCPATH"
3592       --build-two-config
3593       ${build_generator_args}
3594       --build-project IncludeDirectoriesCPATH)
3595     list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/IncludeDirectoriesCPATH")
3596     set_tests_properties(IncludeDirectoriesCPATH
3597       PROPERTIES
3598         ENVIRONMENT "CPATH=${CMAKE_CURRENT_SOURCE_DIR}/IncludeDirectoriesCPATH/viacpath")
3599   endif()
3600
3601   add_test(InterfaceLinkLibraries ${CMAKE_CTEST_COMMAND}
3602     --build-and-test
3603     "${CMake_SOURCE_DIR}/Tests/InterfaceLinkLibraries"
3604     "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries"
3605     --build-two-config
3606     ${build_generator_args}
3607     --build-project InterfaceLinkLibraries
3608     --test-command InterfaceLinkLibraries)
3609   list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries")
3610
3611   ADD_TEST_MACRO(InterfaceLinkLibrariesDirect)
3612
3613   if(NOT CMake_TEST_EXTERNAL_CMAKE)
3614     add_subdirectory(CMakeTests)
3615   endif()
3616
3617   if(BUILD_QtDialog AND CMake_TEST_GUI AND NOT CMake_TEST_EXTERNAL_CMAKE)
3618     add_subdirectory(CMakeGUI)
3619   endif()
3620
3621   # Run CheckSourceTree as the very last test in the CMake/CTest/CPack test
3622   # suite. It detects if any changes have been made to the CMake source tree
3623   # by any previous configure, build or test steps.
3624   if(GIT_EXECUTABLE AND EXISTS "${CMake_SOURCE_DIR}/.git"
3625       AND NOT "${CMake_SOURCE_DIR}" STREQUAL "${CMake_BINARY_DIR}")
3626     add_subdirectory(CheckSourceTree)
3627   endif()
3628
3629   # If this is not an in-source build, provide a target to wipe out
3630   # all the test build directories. This must come at the end after
3631   # all the above logic has finished adding to TEST_BUILD_DIRS
3632   if(NOT EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt")
3633     configure_file(${CMake_SOURCE_DIR}/Tests/test_clean.cmake.in
3634                    ${CMake_BINARY_DIR}/Tests/test_clean.cmake @ONLY)
3635     add_custom_target(test_clean
3636       COMMAND ${CMAKE_COMMAND} -P ${CMake_BINARY_DIR}/Tests/test_clean.cmake
3637       COMMENT "Removing test build directories."
3638       )
3639   endif()
3640 endif()