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