CoCalc -- CMakeLists.txt

GitHub Repository: Kitware/CMake
Path: blob/master/Tests/CMakeLists.txt
⁵⁰¹⁵ views
1
# Creates a test named <NAME> that runs ctest --build-and-test on the
2
# subdirectory of this one named by replacing "." with "/" in
3
# <NAME>. Any arguments following NAME are passed to ctest as a
4
# --test-command.  See the implementation for additional details.
5
#
6
# The subdirectory is added to TEST_BUILD_DIRS in the caller's scope.
7
#
8
# Requires: the name of the project in the subdirectory is the part of
9
# <NAME> following the last dot ("."), or all of <NAME> if there is no
10
# "." in <NAME>.
11
macro(ADD_TEST_MACRO NAME)
12
  if(${ARGC} GREATER 1)
13
    set(_test_command --test-command ${ARGN})
14
  endif()
15
  string(REPLACE "." "/" dir "${NAME}")
16
  string(REGEX REPLACE "[^.]*\\." "" proj "${NAME}")
17
  add_test(NAME "${NAME}" COMMAND "${CMAKE_CTEST_COMMAND}"
18
    --build-and-test
19
    "${CMake_SOURCE_DIR}/Tests/${dir}"
20
    "${CMake_BINARY_DIR}/Tests/${dir}"
21
    --build-two-config
22
    ${build_generator_args}
23
    --build-project ${proj}
24
    ${${NAME}_CTEST_OPTIONS}
25
    --build-options
26
      ${${NAME}_BUILD_OPTIONS}
27
    ${_test_command})
28
  unset(_test_command)
29
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${dir}")
30
endmacro()
31

32
include(${CMAKE_CURRENT_SOURCE_DIR}/CheckFortran.cmake)
33
include(${CMAKE_CURRENT_SOURCE_DIR}/CheckSwift.cmake)
34

35
# Isolate tests from user-wide configuration.
36
set(TEST_HOME "${CMake_BINARY_DIR}/Tests/CMakeFiles/TestHome")
37
set(TEST_CONFIG_ENV_CODE "# Isolate tests from user-wide configuration.
38
set(ENV{CMAKE_CONFIG_DIR} \"${TEST_HOME}/.config/cmake\")\n")
39
set(TEST_INSTRUMENTATION_ENV_CODE "# Isolate tests from CTEST_USE_INSTRUMENTATION var
40
unset(ENV{CTEST_USE_INSTRUMENTATION})\n")
41
file(MAKE_DIRECTORY "${TEST_HOME}/.config/cmake")
42

43
# Fake a user home directory to avoid polluting the real one.
44
if(NOT CTEST_NO_TEST_HOME AND (NOT WIN32 OR DEFINED ENV{HOME}))
45
  set(TEST_HOME_ENV_CODE "# Fake a user home directory to avoid polluting the real one.
46
# But provide original ENV{HOME} value in ENV{CTEST_REAL_HOME} for tests that
47
# need access to the real HOME directory.
48
if(DEFINED ENV{HOME} AND NOT DEFINED ENV{CTEST_REAL_HOME})
49
  set(ENV{CTEST_REAL_HOME} \"\$ENV{HOME}\")
50
endif()
51
set(ENV{HOME} \"${TEST_HOME}\")
52
")
53
endif()
54

55
# Suppress generator deprecation warnings in test suite.
56
if(CMAKE_GENERATOR MATCHES "^Visual Studio 14 2015")
57
  set(TEST_WARN_VS_CODE "set(ENV{CMAKE_WARN_VS14} OFF)")
58
else()
59
  set(TEST_WARN_VS_CODE "")
60
endif()
61

62
# 3.9 or later provides a definitive answer to whether we are multi-config
63
# through a global property. Prior to 3.9, CMAKE_CONFIGURATION_TYPES being set
64
# is assumed to mean multi-config, but developers might modify it so it is
65
# technically not as reliable.
66
if(NOT CMAKE_VERSION VERSION_LESS 3.9)
67
  get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
68
elseif(CMAKE_CONFIGURATION_TYPES)
69
  set(_isMultiConfig True)
70
else()
71
  set(_isMultiConfig False)
72
endif()
73

74
# Choose a default configuration for CTest tests.
75
set(CTestTest_CONFIG Debug)
76
if(NOT _isMultiConfig AND CMAKE_BUILD_TYPE)
77
  set(CTestTest_CONFIG ${CMAKE_BUILD_TYPE})
78
endif()
79

80
configure_file(${CMake_SOURCE_DIR}/Tests/EnforceConfig.cmake.in
81
               ${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake @ONLY)
82

83
# Fuzzing targets (outside BUILD_TESTING for OSS-Fuzz compatibility)
84
if(CMake_BUILD_FUZZING AND NOT CMake_TEST_EXTERNAL_CMAKE)
85
  add_subdirectory(Fuzzing)
86
endif()
87

88
# Testing
89
if(BUILD_TESTING)
90
  set(CMake_TEST_DEVENV "")
91
  if(CMAKE_VS_DEVENV_COMMAND)
92
    set(CMake_TEST_DEVENV "${CMAKE_VS_DEVENV_COMMAND}")
93
  endif()
94

95
  if(CMAKE_GENERATOR MATCHES "Visual Studio|Xcode")
96
    set(CMake_TEST_EXPLICIT_MAKE_PROGRAM "")
97
  else()
98
    set(CMake_TEST_EXPLICIT_MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM}")
99
  endif()
100

101
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
102
    if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles" OR ("${CMAKE_GENERATOR}" MATCHES Ninja AND NOT WIN32))
103
      set(TEST_CompileCommandOutput 1)
104
    endif()
105
  endif()
106

107
  set(MAKE_IS_GNU)
108
  if(CMAKE_MAKE_PROGRAM MATCHES make)
109
    execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} no_such_target --version
110
      RESULT_VARIABLE res OUTPUT_VARIABLE out ERROR_VARIABLE out)
111
    if("${res}" STREQUAL "0")
112
      if("${out}" MATCHES "GNU")
113
        set(MAKE_IS_GNU 1)
114
      endif()
115
    endif()
116
  endif()
117

118
  # some old versions of make simply cannot handle spaces in paths
119
  if(MAKE_IS_GNU OR
120
      CMAKE_MAKE_PROGRAM MATCHES "nmake|gmake|wmake" OR
121
      CMAKE_GENERATOR MATCHES "Visual Studio|Xcode|Borland|Ninja|FASTBuild")
122
    set(MAKE_SUPPORTS_SPACES 1)
123
  else()
124
    set(MAKE_SUPPORTS_SPACES 0)
125
  endif()
126

127
  # assume no resources building to test
128
  set(CMake_TEST_RESOURCES FALSE)
129
  # for windows and cygwin assume we have resources
130
  if(WIN32 OR CYGWIN)
131
    set(CMake_TEST_RESOURCES TRUE)
132
  endif()
133
  # For some Windows toolchains there is no resource support.
134
  if(WATCOM OR BORLAND OR CMAKE_C_COMPILER_ID STREQUAL "OrangeC")
135
    set(CMake_TEST_RESOURCES FALSE)
136
  endif()
137

138
  set(build_generator_args
139
    --build-generator ${CMAKE_GENERATOR}
140
    )
141
  if(CMAKE_GENERATOR_PLATFORM)
142
    list(APPEND build_generator_args
143
      --build-generator-platform ${CMAKE_GENERATOR_PLATFORM}
144
      )
145
  endif()
146
  if(CMAKE_GENERATOR_TOOLSET)
147
    list(APPEND build_generator_args
148
      --build-generator-toolset ${CMAKE_GENERATOR_TOOLSET}
149
      )
150
  endif()
151

152
  if(CMake_TEST_EXPLICIT_MAKE_PROGRAM)
153
    list(APPEND build_generator_args
154
      --build-makeprogram ${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
155
      )
156
  endif()
157

158
  if(_isMultiConfig)
159
    set(test_options -C Debug)
160
  endif()
161

162
  # Look for git to use for tests.
163
  find_program(GIT_EXECUTABLE NAMES git)
164

165
  if(NOT DEFINED CMake_TEST_CPACK_RPM)
166
    # Look for rpmbuild to use for tests.
167
    # The tool does not work with spaces in the path.
168
    if(NOT CMAKE_CURRENT_BINARY_DIR MATCHES " ")
169
      find_program(RPMBUILD_EXECUTABLE NAMES rpmbuild)
170
    else()
171
      set(RPMBUILD_EXECUTABLE "RPMBUILD_EXECUTABLE-NOTFOUND")
172
    endif()
173
    if(RPMBUILD_EXECUTABLE)
174
      set(CMake_TEST_CPACK_RPM 1)
175
    else()
176
      set(CMake_TEST_CPACK_RPM 0)
177
    endif()
178
  endif()
179

180
  if(CMake_TEST_CPACK_RPM)
181
    set(CPACK_BINARY_RPM ON)
182
  else()
183
    set(CPACK_BINARY_RPM OFF)
184
  endif()
185

186
  if(NOT DEFINED CMake_TEST_CPACK_DEB)
187
    # Look for dpkg to use for tests.
188
    find_program(DPKG_EXECUTABLE NAMES dpkg)
189
    if(DPKG_EXECUTABLE)
190
      set(CMake_TEST_CPACK_DEB 1)
191
    else()
192
      set(CMake_TEST_CPACK_DEB 0)
193
    endif()
194
  endif()
195

196
  if(CMake_TEST_CPACK_DEB)
197
    set(CPACK_BINARY_DEB ON)
198
  else()
199
    set(CPACK_BINARY_DEB OFF)
200
  endif()
201

202
  if(CMake_TEST_CPACK_NUGET)
203
    set(CPACK_BINARY_NUGET ON)
204
  else()
205
    set(CPACK_BINARY_NUGET OFF)
206
  endif()
207

208
  if(WIN32)
209
    set(reg_vs14 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\14.0;InstallDir]")
210
    set(reg_ws10_0 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\14.0\\Setup\\Build Tools for Windows 10;srcPath]")
211
    set(reg_tegra "[HKEY_LOCAL_MACHINE\\SOFTWARE\\NVIDIA Corporation\\Nsight Tegra;sdkRoot]")
212
    set(reg_nasm "[HKEY_CURRENT_USER\\SOFTWARE\\nasm]")
213
    foreach(reg IN ITEMS vs14 ws10_0 tegra nasm)
214
      get_filename_component(r "${reg_${reg}}" ABSOLUTE)
215
      if(IS_DIRECTORY "${r}" AND NOT "${r}" STREQUAL "/registry")
216
        set(${reg} 1)
217
      else()
218
        set(${reg} 0)
219
      endif()
220
    endforeach()
221
    if(CMAKE_HOST_WIN32 AND COMMAND cmake_host_system_information)
222
      set(info_vs15 "VS_15_DIR")
223
      set(info_vs16 "VS_16_DIR")
224
      set(info_vs17 "VS_17_DIR")
225
      set(info_vs18 "VS_18_DIR")
226
      set(vs_versions)
227
      if(WIN32)
228
        if(NOT CMAKE_VERSION VERSION_LESS 4.2)
229
          set(vs_versions vs15 vs16 vs17 vs18)
230
        elseif(NOT CMAKE_VERSION VERSION_LESS 3.21)
231
          set(vs_versions vs15 vs16 vs17)
232
        elseif(NOT CMAKE_VERSION VERSION_LESS 3.14)
233
          set(vs_versions vs15 vs16)
234
        elseif(NOT CMAKE_VERSION VERSION_LESS 3.8)
235
          set(vs_versions vs15)
236
        endif()
237
      endif()
238
      foreach(info IN LISTS vs_versions)
239
        cmake_host_system_information(RESULT found QUERY "${info_${info}}")
240
        if(found)
241
          set(${info} 1)
242
        else()
243
          set(${info} 0)
244
        endif()
245
      endforeach()
246
    endif()
247
  endif()
248

249
  if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT DEFINED CMake_TEST_APPLE_SILICON)
250
    execute_process(COMMAND sysctl -q hw.optional.arm64
251
      OUTPUT_VARIABLE _sysctl_stdout
252
      ERROR_VARIABLE  _sysctl_stderr
253
      RESULT_VARIABLE _sysctl_result
254
      )
255
    if(_sysctl_result EQUAL 0 AND _sysctl_stdout MATCHES "hw.optional.arm64: 1")
256
      set(CMake_TEST_APPLE_SILICON 1)
257
    else()
258
      set(CMake_TEST_APPLE_SILICON 0)
259
    endif()
260
    unset(_sysctl_result)
261
    unset(_sysctl_stderr)
262
    unset(_sysctl_stdout)
263
  endif()
264

265
  #---------------------------------------------------------------------------
266
  # Add tests below here.
267

268
  if(NOT DEFINED CMake_TEST_Qt6)
269
    set(CMake_TEST_Qt6 1)
270
  endif()
271
  if(CMake_TEST_Qt6)
272
    find_package(Qt6 COMPONENTS Core Widgets QUIET NO_MODULE)
273
  endif()
274

275
  if(NOT DEFINED CMake_TEST_Qt5)
276
    set(CMake_TEST_Qt5 1)
277
  endif()
278
  if(CMake_TEST_Qt5)
279
    find_package(Qt5Widgets QUIET NO_MODULE)
280
  endif()
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(CMake_TEST_XCODE_VERSION 0)
302
  if(APPLE)
303
    if(XCODE_VERSION)
304
      set(CMake_TEST_XCODE_VERSION "${XCODE_VERSION}")
305
    else()
306
      execute_process(
307
        COMMAND xcodebuild -version
308
        OUTPUT_VARIABLE _version
309
        ERROR_VARIABLE _stderr
310
        RESULT_VARIABLE _failed
311
        )
312
      if(NOT _failed AND _version MATCHES "^Xcode ([0-9]+(\\.[0-9]+)*)")
313
        set(CMake_TEST_XCODE_VERSION "${CMAKE_MATCH_1}")
314
      endif()
315
    endif()
316
    if(CMAKE_OSX_SYSROOT)
317
      execute_process(
318
        COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version ProductName
319
        OUTPUT_VARIABLE _stdout
320
        OUTPUT_STRIP_TRAILING_WHITESPACE
321
        ERROR_VARIABLE _stderr
322
        RESULT_VARIABLE _failed
323
        )
324
      if(NOT _failed)
325
        set(CMAKE_OSX_SDKPRODUCT "${_stdout}")
326
      endif()
327

328
      execute_process(
329
        COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version SDKVersion
330
        OUTPUT_VARIABLE _stdout
331
        OUTPUT_STRIP_TRAILING_WHITESPACE
332
        ERROR_VARIABLE _stderr
333
        RESULT_VARIABLE _failed
334
        )
335
      if(NOT _failed)
336
        set(CMAKE_OSX_SDKVERSION "${_stdout}")
337
      endif()
338
    endif()
339
  endif()
340

341
  if(CMake_TEST_XCODE_VERSION AND CMAKE_OSX_SDKVERSION AND CMAKE_OSX_SDKPRODUCT)
342
    if((NOT CMake_TEST_XCODE_VERSION VERSION_LESS 6.1) AND
343
      ((NOT CMAKE_OSX_SDKPRODUCT STREQUAL "Mac OS X") OR
344
      (NOT CMAKE_OSX_SDKVERSION VERSION_LESS 10.10)))
345
      if(CMAKE_GENERATOR STREQUAL "Xcode")
346
        set(CMake_TEST_XCODE_SWIFT 1)
347
      endif()
348
    endif()
349
  endif()
350
  if(NOT DEFINED CMake_TEST_Swift)
351
    if(CMAKE_Swift_COMPILER OR CMake_TEST_XCODE_SWIFT)
352
      set(CMake_TEST_Swift 1)
353
    endif()
354
  endif()
355

356
  if(NOT DEFINED CMake_TEST_OBJC)
357
    if(APPLE AND CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
358
      set(CMake_TEST_OBJC 1)
359
    endif()
360
  endif()
361

362
  if(CMake_TEST_FindPython)
363
    set(CMake_TEST_FindPython2 TRUE)
364
    set(CMake_TEST_FindPython3 TRUE)
365
  endif()
366
  if(CMake_TEST_FindPython_SABIModule)
367
    set(CMake_TEST_FindPython2_SABIModule TRUE)
368
    set(CMake_TEST_FindPython3_SABIModule TRUE)
369
  endif()
370
  if(CMake_TEST_FindPython_NumPy)
371
    set(CMake_TEST_FindPython2_NumPy TRUE)
372
    set(CMake_TEST_FindPython3_NumPy TRUE)
373
  endif()
374
  if(CMake_TEST_FindPython_Conda)
375
    set(CMake_TEST_FindPython3_Conda TRUE)
376
  endif()
377
  if(CMake_TEST_FindPython_IronPython)
378
    set(CMake_TEST_FindPython2_IronPython TRUE)
379
    set(CMake_TEST_FindPython3_IronPython TRUE)
380
  endif()
381
  if(CMake_TEST_FindPython_PyPy)
382
    set(CMake_TEST_FindPython2_PyPy TRUE)
383
    set(CMake_TEST_FindPython3_PyPy TRUE)
384
  endif()
385
  if (CMake_TEST_FindPython2 AND CMAKE_SYSTEM_NAME MATCHES "Linux|Darwin")
386
    set(CMake_TEST_FindPython2_SABIModule TRUE)
387
  endif()
388
  if (CMake_TEST_FindPython3 AND CMAKE_SYSTEM_NAME MATCHES "Linux|Darwin")
389
    set(CMake_TEST_FindPython3_SABIModule TRUE)
390
  endif()
391

392
  # Use 1500 or CTEST_TEST_TIMEOUT for long test timeout value,
393
  # whichever is greater.
394
  set(CMAKE_LONG_TEST_TIMEOUT 1500)
395
  if(CTEST_TEST_TIMEOUT)
396
    set(CMAKE_LONG_TEST_TIMEOUT ${CTEST_TEST_TIMEOUT})
397
  endif()
398
  if(CMAKE_LONG_TEST_TIMEOUT LESS 1500)
399
    set(CMAKE_LONG_TEST_TIMEOUT 1500)
400
  endif()
401

402
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
403
    add_subdirectory(CMakeLib)
404
  endif()
405
  add_subdirectory(CMakeOnly)
406
  add_subdirectory(RunCMake)
407

408
  add_subdirectory(FindPackageModeMakefileTest)
409

410
  add_test(NAME CMake.Copyright
411
    COMMAND ${CMAKE_CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/CMakeCopyright.cmake)
412

413
  # add a bunch of standard build-and-test style tests
414
  ADD_TEST_MACRO(CommandLineTest CommandLineTest)
415
  ADD_TEST_MACRO(FindPackageCMakeTest FindPackageCMakeTest)
416
  ADD_TEST_MACRO(FindPackageCpsTest FindPackageCpsTest)
417
  ADD_TEST_MACRO(StringFileTest StringFileTest)
418
  ADD_TEST_MACRO(TryCompile TryCompile)
419
  ADD_TEST_MACRO(SystemInformation SystemInformation)
420
  ADD_TEST_MACRO(MathTest MathTest)
421

422
  string(REPLACE ";" "$<SEMICOLON>" TEST_STDS_C "${CMake_TEST_C_STANDARDS}")
423
  string(REPLACE ";" "$<SEMICOLON>" TEST_STDS_CXX "${CMake_TEST_CXX_STANDARDS}")
424
  string(REPLACE ";" "$<SEMICOLON>" TEST_STDS_CUDA "${CMake_TEST_CUDA_STANDARDS}")
425
  string(REPLACE ";" "$<SEMICOLON>" TEST_STDS_HIP "${CMake_TEST_HIP_STANDARDS}")
426
  set(CompileFeatures_BUILD_OPTIONS
427
    -DCMake_TEST_C_STANDARDS=${TEST_STDS_C}
428
    -DCMake_TEST_CXX_STANDARDS=${TEST_STDS_CXX}
429
    -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
430
    -DCMake_TEST_CUDA_STANDARDS=${TEST_STDS_CUDA}
431
    -DCMake_TEST_HIP=${CMake_TEST_HIP}
432
    -DCMake_TEST_HIP_STANDARDS=${TEST_STDS_HIP}
433
    )
434
  ADD_TEST_MACRO(CompileFeatures CompileFeatures)
435
  set_property(TEST CompileFeatures APPEND PROPERTY LABELS "CUDA" "HIP")
436

437
  ADD_TEST_MACRO(CMakeCommands.target_compile_features)
438

439
  if(CMake_TEST_RESOURCES)
440
    ADD_TEST_MACRO(VSResource VSResource)
441
    if(CMAKE_GENERATOR MATCHES "Ninja")
442
      add_test_macro(VSResourceNinjaForceRSP VSResourceNinjaForceRSP)
443
    endif()
444
  endif()
445
  if(_isMultiConfig)
446
    set(MSManifest_CTEST_OPTIONS -C $<CONFIGURATION>)
447
  endif()
448
  ADD_TEST_MACRO(MSManifest ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
449
  ADD_TEST_MACRO(Simple Simple)
450
  ADD_TEST_MACRO(PreOrder PreOrder)
451
  ADD_TEST_MACRO(MissingSourceFile MissingSourceFile)
452
  set_tests_properties(MissingSourceFile PROPERTIES
453
    PASS_REGULAR_EXPRESSION "CMake Error at CMakeLists\.txt:3 \\(add_executable\\):[ \r\n]*Cannot find source file:[ \r\n]*DoesNotExist/MissingSourceFile.c")
454
  if(CMake_TEST_Swift)
455
    ADD_TEST_MACRO(SwiftOnly SwiftOnly)
456
    ADD_TEST_MACRO(SwiftMixPCH SwiftMixPCH)
457
    if(CMake_TEST_XCODE_SWIFT)
458
      ADD_TEST_MACRO(SwiftMix SwiftMix)
459
    endif()
460
    if(CMAKE_Swift_COMPILER_VERSION VERSION_GREATER_EQUAL 5.1)
461
      ADD_TEST_MACRO(SwiftMixLib Swifty)
462
    endif()
463
  endif()
464
  if(CMake_TEST_Rust)
465
    ADD_TEST_MACRO(RustOnly RustOnly)
466
    ADD_TEST_MACRO(RustMix RustMix)
467
  endif()
468
  if(CMAKE_Fortran_COMPILER)
469
    ADD_TEST_MACRO(FortranOnly FortranOnly)
470
    set_property(TEST FortranOnly APPEND PROPERTY LABELS "Fortran")
471
  endif()
472
  # test Visual Studio GNU Fortran mixing with cmake_add_fortran_subdirectory
473
  # run this project if we have a working fortran compiler or
474
  # the test is enabled with CMAKE_TEST_CMAKE_ADD_FORTRAN cache variable.
475
  # If you enable the test, CMake should find the MinGW fortran install,
476
  # or in some cases you might need to set the PATH so that cmake can find
477
  # the gfortran from mingw.
478
  if(CMAKE_Fortran_COMPILER OR CMAKE_TEST_CMAKE_ADD_FORTRAN)
479
    set(CMAKE_SKIP_VSGNUFortran FALSE)
480
    # disable test for apple builds using ifort if they are building
481
    # more than one architecture, as ifort does not support that.
482
    if(APPLE AND (CMAKE_Fortran_COMPILER MATCHES ifort))
483
      list(LENGTH CMAKE_OSX_ARCHITECTURES len)
484
      if("${len}" GREATER 1)
485
        message(STATUS "Skip VSGNUFortran for ifort dual cpu mac build")
486
        set(CMAKE_SKIP_VSGNUFortran TRUE)
487
      endif()
488
    endif()
489
    if(CMAKE_Fortran_COMPILER_ID STREQUAL LLVMFlang)
490
      # No DLLEXPORT for 'Tests/VSGNUFortran/subdir/fortran/world.f'.
491
      set(CMAKE_SKIP_VSGNUFortran TRUE)
492
    endif()
493
    if(CMAKE_Fortran_COMPILER_ID STREQUAL IntelLLVM)
494
      message(STATUS "Skip VSGNUFortran for ifx until DLLEXPORT support is implemented")
495
      set(CMAKE_SKIP_VSGNUFortran TRUE)
496
    endif()
497
    if((CMAKE_C_COMPILER MATCHES lsb)
498
        AND (CMAKE_Fortran_COMPILER MATCHES ifort))
499
      message(STATUS "Skip VSGNUFortran for ifort and lsb compilers")
500
      set(CMAKE_SKIP_VSGNUFortran TRUE)
501
    endif()
502
    if(NOT CMAKE_SKIP_VSGNUFortran)
503
      ADD_TEST_MACRO(VSGNUFortran ${CMAKE_CMAKE_COMMAND} -P runtest.cmake)
504
      set_property(TEST VSGNUFortran APPEND PROPERTY LABELS "Fortran")
505
    endif()
506
  endif()
507

508
  if(CMake_TEST_OBJC)
509
    add_subdirectory(ObjC)
510
    add_subdirectory(ObjCXX)
511
  endif()
512

513
  if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
514
    ADD_TEST_MACRO(CSharpOnly CSharpOnly)
515
    if(NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
516
      ADD_TEST_MACRO(CSharpLinkToCxx CSharpLinkToCxx)
517
      ADD_TEST_MACRO(CSharpLinkFromCxx CSharpLinkFromCxx)
518
    endif()
519
    ADD_TEST_MACRO(CSharpWin32GenEx CSharpWin32GenEx)
520
    set_tests_properties(CSharpWin32GenEx PROPERTIES
521
      PASS_REGULAR_EXPRESSION "Target \"CSharpWin32GenEx\" has a generator expression in its\n  WIN32_EXECUTABLE property\\.  This is not supported on managed executables\\."
522
      )
523
  endif()
524

525
  ADD_TEST_MACRO(COnly COnly)
526
  ADD_TEST_MACRO(CxxOnly CxxOnly)
527
  ADD_TEST_MACRO(CxxSubdirC CxxSubdirC)
528
  ADD_TEST_MACRO(OutDir runtime/OutDir)
529
  ADD_TEST_MACRO(OutName exe.OutName.exe)
530
  ADD_TEST_MACRO(ObjectLibrary UseCshared)
531
  ADD_TEST_MACRO(SharedLibraryArchive UseSLA)
532
  ADD_TEST_MACRO(NewlineArgs NewlineArgs)
533
  ADD_TEST_MACRO(SetLang SetLangX)
534
  ADD_TEST_MACRO(EmptyProperty EmptyProperty)
535
  ADD_TEST_MACRO(ExternalOBJ ExternalOBJ)
536
  ADD_TEST_MACRO(LinkDirectory bin/LinkDirectory)
537
  ADD_TEST_MACRO(LinkLanguage LinkLanguage)
538
  ADD_TEST_MACRO(LinkLine LinkLine)
539
  ADD_TEST_MACRO(MacroTest miniMacroTest)
540
  ADD_TEST_MACRO(FunctionTest miniFunctionTest)
541
  ADD_TEST_MACRO(ReturnTest ReturnTest)
542
  ADD_TEST_MACRO(Properties Properties)
543
  ADD_TEST_MACRO(Assembler HelloAsm)
544
  # relies on Linux syscall interface
545
  if(CMake_TEST_ASM_NASM AND CMAKE_SYSTEM_NAME MATCHES "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
546
    ADD_TEST_MACRO(NasmOnly NasmOnly)
547
  endif()
548
  ADD_TEST_MACRO(SourceGroups SourceGroups)
549
  ADD_TEST_MACRO(Preprocess Preprocess)
550
  set(ExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
551
                                 -DCMake_TEST_CUDA:BOOL=${CMake_TEST_CUDA}
552
                                 -DCMake_INSTALL_NAME_TOOL_BUG:BOOL=${CMake_INSTALL_NAME_TOOL_BUG}
553
                                 )
554
  ADD_TEST_MACRO(ExportImport ExportImport)
555
  set_property(TEST ExportImport APPEND
556
    PROPERTY LABELS "CUDA")
557
  ADD_TEST_MACRO(Unset Unset)
558
  ADD_TEST_MACRO(PolicyScope PolicyScope)
559
  ADD_TEST_MACRO(EmptyLibrary EmptyLibrary)
560
  ADD_TEST_MACRO(CompileDefinitions CompileDefinitions)
561

562
  if(_isMultiConfig)
563
    set(CompileOptions_CTEST_OPTIONS --build-config $<CONFIGURATION>)
564
  else()
565
    set(CompileOptions_BUILD_OPTIONS -DCMAKE_BUILD_TYPE=$<CONFIGURATION>)
566
  endif()
567
  if(CMAKE_Fortran_COMPILER)
568
    list(APPEND CompileOptions_BUILD_OPTIONS -DTEST_FORTRAN=1)
569
  endif()
570
  ADD_TEST_MACRO(CompileOptions CompileOptions)
571
  set_property(TEST CompileOptions APPEND PROPERTY LABELS "Fortran")
572

573
  ADD_TEST_MACRO(CompatibleInterface CompatibleInterface)
574
  ADD_TEST_MACRO(CustomTransitiveProperties CustomTransitiveProperties)
575
  ADD_TEST_MACRO(AliasTarget AliasTarget)
576
  ADD_TEST_MACRO(StagingPrefix StagingPrefix)
577
  ADD_TEST_MACRO(ImportedSameName ImportedSameName)
578
  ADD_TEST_MACRO(InterfaceLibrary InterfaceLibrary)
579
  if(NOT CMAKE_GENERATOR STREQUAL "Xcode")
580
    if(_isMultiConfig)
581
      set(ConfigSources_CTEST_OPTIONS --build-config $<CONFIGURATION>)
582
    else()
583
      set(ConfigSources_BUILD_OPTIONS -DCMAKE_BUILD_TYPE=$<CONFIGURATION>)
584
    endif()
585
    ADD_TEST_MACRO(ConfigSources ConfigSources)
586
  endif()
587
  ADD_TEST_MACRO(SourcesProperty SourcesProperty)
588
  ADD_TEST_MACRO(SourceFileProperty SourceFileProperty)
589
  if(NOT CMAKE_GENERATOR STREQUAL "Xcode")
590
    ADD_TEST_MACRO(SourceFileIncludeDirProperty SourceFileIncludeDirProperty)
591
  endif()
592
  if(CMAKE_CXX_COMPILER_ID STREQUAL "LCC" OR (CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
593
      AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7))
594
    set(runCxxDialectTest 1)
595
  endif()
596
  if(CMAKE_CXX_COMPILER_ID STREQUAL Clang
597
        AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4 AND NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
598
    if(NOT APPLE OR POLICY CMP0025)
599
      set(runCxxDialectTest 1)
600
    endif()
601
  endif()
602
  if(runCxxDialectTest)
603
    ADD_TEST_MACRO(CxxDialect CxxDialect)
604
  endif()
605
  set_tests_properties(EmptyLibrary PROPERTIES
606
    PASS_REGULAR_EXPRESSION "CMake Error: CMake can not determine linker language for target: test")
607
  ADD_TEST_MACRO(CrossCompile CrossCompile)
608
  set_tests_properties(CrossCompile PROPERTIES
609
    PASS_REGULAR_EXPRESSION "try_run.. invoked in cross-compiling mode")
610
  if(CMake_TEST_XCODE_VERSION)
611
    set(Architecture_BUILD_OPTIONS -DCMake_TEST_XCODE_VERSION=${CMake_TEST_XCODE_VERSION})
612
    ADD_TEST_MACRO(Architecture Architecture)
613
    set_tests_properties(Architecture PROPERTIES
614
      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)")
615
    set_property(TEST Architecture APPEND PROPERTY
616
      PASS_REGULAR_EXPRESSION "Skip test x86_64 only|found architecture '.*', required architecture '.*'")
617
  endif()
618

619
  list(APPEND TEST_BUILD_DIRS ${CMake_TEST_INSTALL_PREFIX})
620

621
  if(NOT DEFINED CMake_TEST_Qt4)
622
    set(CMake_TEST_Qt4 1)
623
  endif()
624
  if(CMake_TEST_Qt4 AND NOT Qt4_FOUND)
625
    find_package(Qt4 QUIET)
626
  endif()
627

628
  if(CMake_TEST_Qt4 AND Qt4_FOUND)
629
    # test whether the Qt4 which has been found works, on some machines
630
    # which run nightly builds there were errors like "wrong file format"
631
    # for libQtCore.so. So first check it works, and only if it does add
632
    # the automoc test.
633
    include(CheckCXXSourceCompiles)
634
    set(_save_CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}")
635
    set(_save_CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}")
636

637
    set(CMAKE_REQUIRED_INCLUDES ${QT_INCLUDES})
638
    set(CMAKE_REQUIRED_LIBRARIES ${QT_QTCORE_LIBRARIES})
639

640
    check_cxx_source_compiles("#include <QCoreApplication>\n int main() {return (qApp == 0 ? 0 : 1); }\n"
641
                              QT4_WORKS)
642

643
    set(CMAKE_REQUIRED_INCLUDES "${_save_CMAKE_REQUIRED_INCLUDES}")
644
    set(CMAKE_REQUIRED_LIBRARIES "${_save_CMAKE_REQUIRED_LIBRARIES}")
645
  endif()
646

647
  # run test for BundleUtilities on supported platforms/compilers
648
  if((MSVC OR
649
      MINGW OR
650
      CMAKE_SYSTEM_NAME MATCHES "Linux" OR
651
      CMAKE_SYSTEM_NAME MATCHES "Darwin")
652
    AND NOT CMAKE_GENERATOR STREQUAL "Watcom WMake")
653

654
    add_test(BundleUtilities ${CMAKE_CTEST_COMMAND}
655
      --build-and-test
656
      "${CMake_SOURCE_DIR}/Tests/BundleUtilities"
657
      "${CMake_BINARY_DIR}/Tests/BundleUtilities"
658
      ${build_generator_args}
659
      --build-project BundleUtilities
660
      )
661
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleUtilities")
662

663
    # run test for DeployQt4 on supported platforms/compilers (which depends on BundleUtilities)
664
    # this test also depends on the existence of the standard qtiff plugin
665
    if(QT4_WORKS AND QT_QTSQL_FOUND)
666
      add_test(Qt4Deploy ${CMAKE_CTEST_COMMAND}
667
        --build-and-test
668
        "${CMake_SOURCE_DIR}/Tests/Qt4Deploy"
669
        "${CMake_BINARY_DIR}/Tests/Qt4Deploy"
670
        ${build_generator_args}
671
        --build-project Qt4Deploy
672
        --build-options
673
          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
674
          -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
675
        )
676
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Deploy")
677
    endif()
678

679
  endif()
680

681
  set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/COnly")
682
  set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/CMakeBuildCOnly")
683
  set(CMAKE_BUILD_TEST_EXE COnly)
684
  configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
685
    "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake" @ONLY)
686
  add_test(CMakeBuildTest ${CMAKE_CMAKE_COMMAND} -P
687
    "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake")
688
  list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
689
  # now do it again for a project that has two project commands
690
  set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/DoubleProject")
691
  set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/DoubleProject")
692
  set(CMAKE_BUILD_TEST_EXE just_silly)
693
  configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
694
    "${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake" @ONLY)
695
  add_test(CMakeDoubleProject ${CMAKE_CMAKE_COMMAND} -P
696
    "${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake")
697
  list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
698

699
  set(Module.CheckIPOSupported-C_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_C=${CMake_TEST_IPO_WORKS_C})
700
  ADD_TEST_MACRO(Module.CheckIPOSupported-C CheckIPOSupported-C)
701

702
  set(Module.CheckIPOSupported-CXX_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_CXX=${CMake_TEST_IPO_WORKS_CXX})
703
  ADD_TEST_MACRO(Module.CheckIPOSupported-CXX CheckIPOSupported-CXX)
704

705
  if(CMake_TEST_CUDA)
706
    ADD_TEST_MACRO(Module.CheckIPOSupported-CUDA CheckIPOSupported-CUDA)
707
    set_property(TEST Module.CheckIPOSupported-CUDA APPEND PROPERTY LABELS "CUDA")
708
  endif()
709

710
  if(CMAKE_Fortran_COMPILER)
711
    set(Module.CheckIPOSupported-Fortran_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_Fortran=${CMake_TEST_IPO_WORKS_Fortran})
712
    ADD_TEST_MACRO(Module.CheckIPOSupported-Fortran CheckIPOSupported-Fortran)
713
    set_property(TEST Module.CheckIPOSupported-Fortran APPEND PROPERTY LABELS "Fortran")
714
  endif()
715

716
  add_test(Module.ExternalData ${CMAKE_CTEST_COMMAND}
717
    --build-and-test
718
    "${CMake_SOURCE_DIR}/Tests/Module/ExternalData"
719
    "${CMake_BINARY_DIR}/Tests/Module/ExternalData"
720
    ${build_generator_args}
721
    --build-project ExternalDataTest
722
    --build-noclean
723
    --build-options
724
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
725
    --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} -V
726
    )
727
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Module/ExternalData")
728

729
  ADD_TEST_MACRO(Module.FindDependency FindDependency)
730

731
  ADD_TEST_MACRO(Module.WriteCompilerDetectionHeader WriteCompilerDetectionHeader)
732

733
  if(APPLE OR CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "LCC")
734
    include(CheckCXXCompilerFlag)
735
    check_cxx_compiler_flag(-fPIE run_pic_test)
736
  else()
737
    if(CMAKE_CXX_COMPILER_ID MATCHES "PGI"
738
        OR CMAKE_CXX_COMPILER_ID MATCHES "PathScale"
739
        OR CMAKE_CXX_COMPILER_ID MATCHES "Intel")
740
      set(run_pic_test 0)
741
    else()
742
      set(run_pic_test 1)
743
    endif()
744
  endif()
745

746
  if(run_pic_test)
747
    ADD_TEST_MACRO(PositionIndependentTargets PositionIndependentTargets)
748
  endif()
749

750
  if(CMAKE_CXX_COMPILER_ID MATCHES "LCC" OR
751
    ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") AND
752
    (NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 4.2) AND
753
    (CMAKE_SYSTEM_NAME MATCHES "Linux")))
754

755
    include(CheckCXXCompilerFlag)
756
    check_cxx_compiler_flag(
757
      -fvisibility-inlines-hidden run_inlines_hidden_test)
758
  endif()
759

760
  if(run_inlines_hidden_test)
761
    add_test(Visibility ${CMAKE_CTEST_COMMAND}
762
      --build-and-test
763
      "${CMake_SOURCE_DIR}/Tests/Visibility"
764
      "${CMake_BINARY_DIR}/Tests/Visibility"
765
      ${build_generator_args}
766
      --build-project Visibility
767
    )
768
    list(APPEND TEST_BUILD_DIRS
769
      "${CMake_BINARY_DIR}/Tests/Visibility"
770
    )
771
  endif()
772

773
  # test for correct sub-project generation
774
  # not implemented in Xcode or Ninja
775
  if(NOT CMAKE_GENERATOR MATCHES "Xcode|Ninja|FASTBuild")
776
    # run cmake and configure all of SubProject
777
    # but only build the independent executable car
778
    add_test(SubProject ${CMAKE_CTEST_COMMAND}
779
      --build-and-test
780
      "${CMake_SOURCE_DIR}/Tests/SubProject"
781
      "${CMake_BINARY_DIR}/Tests/SubProject"
782
      --build-project SubProject
783
      ${build_generator_args}
784
      --build-target car
785
      --test-command car
786
      )
787

788
    # For stage 2, do not run cmake again.
789
    # Then build the foo sub project which should build
790
    # the bar library which should be referenced because
791
    # foo links to the static library bar, but bar is not
792
    # directly in the foo sub project
793
    if(CMake_TEST_EXPLICIT_MAKE_PROGRAM)
794
      set(SubProject-Stage2_BUILD_MAKEPROGRAM
795
        --build-makeprogram ${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
796
        )
797
    endif()
798
    add_test(SubProject-Stage2  ${CMAKE_CTEST_COMMAND}
799
      --build-and-test
800
      "${CMake_SOURCE_DIR}/Tests/SubProject/foo"
801
      "${CMake_BINARY_DIR}/Tests/SubProject/foo"
802
      --build-generator ${CMAKE_GENERATOR}
803
      --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
804
      --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
805
      ${SubProject-Stage2_BUILD_MAKEPROGRAM}
806
      --build-nocmake
807
      --build-project foo
808
      --build-target foo
809
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubProject/foo"
810
      --test-command foo
811
      )
812
    set_tests_properties(SubProject-Stage2 PROPERTIES DEPENDS SubProject)
813
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubProject")
814
  endif()
815

816
  # add tests with more complex invocations
817
  add_test(Framework ${CMAKE_CTEST_COMMAND}
818
    --build-and-test
819
    "${CMake_SOURCE_DIR}/Tests/Framework"
820
    "${CMake_BINARY_DIR}/Tests/Framework"
821
    --build-two-config
822
    ${build_generator_args}
823
    --build-project Framework
824
    --build-options
825
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
826
    "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/Framework/Install"
827
    --test-command bar)
828
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Framework")
829

830
  add_test(TargetName ${CMAKE_CTEST_COMMAND}
831
    --build-and-test
832
    "${CMake_SOURCE_DIR}/Tests/TargetName"
833
    "${CMake_BINARY_DIR}/Tests/TargetName"
834
    --build-two-config
835
    ${build_generator_args}
836
    --build-project TargetName
837
    --test-command ${CMAKE_CMAKE_COMMAND} -E compare_files
838
    ${CMake_SOURCE_DIR}/Tests/TargetName/scripts/hello_world
839
    ${CMake_BINARY_DIR}/Tests/TargetName/scripts/hello_world)
840
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TargetName")
841

842
  add_test(LibName ${CMAKE_CTEST_COMMAND}
843
    --build-and-test
844
    "${CMake_SOURCE_DIR}/Tests/LibName"
845
    "${CMake_BINARY_DIR}/Tests/LibName"
846
    --build-two-config
847
    ${build_generator_args}
848
    --build-project LibName
849
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/LibName/lib"
850
    --build-options
851
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
852
    --test-command foobar
853
    )
854
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LibName")
855

856
  add_test(CustComDepend ${CMAKE_CTEST_COMMAND}
857
    --build-and-test
858
    "${CMake_SOURCE_DIR}/Tests/CustComDepend"
859
    "${CMake_BINARY_DIR}/Tests/CustComDepend"
860
    --build-two-config
861
    ${build_generator_args}
862
    --build-project CustComDepend
863
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustComDepend/bin"
864
    --test-command foo bar.c
865
    )
866
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustComDepend")
867

868
  add_test(ArgumentExpansion  ${CMAKE_CTEST_COMMAND}
869
    --build-and-test
870
    "${CMake_SOURCE_DIR}/Tests/ArgumentExpansion"
871
    "${CMake_BINARY_DIR}/Tests/ArgumentExpansion"
872
    ${build_generator_args}
873
    --build-project ArgumentExpansion
874
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ArgumentExpansion/bin"
875
    )
876
  set_tests_properties(ArgumentExpansion PROPERTIES
877
    FAIL_REGULAR_EXPRESSION "Unexpected: ")
878
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ArgumentExpansion")
879

880
  add_test(GeneratorExpression
881
    ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
882
    --build-and-test
883
    "${CMake_SOURCE_DIR}/Tests/GeneratorExpression"
884
    "${CMake_BINARY_DIR}/Tests/GeneratorExpression"
885
    ${build_generator_args}
886
    --build-project GeneratorExpression
887
    --build-options
888
      -DCMAKE_BUILD_TYPE=\${CTEST_CONFIGURATION_TYPE}
889
    --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} -V
890
    )
891
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/GeneratorExpression")
892

893
  add_test(CustomCommand  ${CMAKE_CTEST_COMMAND}
894
    --build-and-test
895
    "${CMake_SOURCE_DIR}/Tests/CustomCommand"
896
    "${CMake_BINARY_DIR}/Tests/CustomCommand"
897
    --build-two-config
898
    ${build_generator_args}
899
    --build-project CustomCommand
900
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustomCommand/bin"
901
    --build-options
902
    --test-command CustomCommand
903
    )
904
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommand")
905

906
  ADD_TEST_MACRO(CustomCommandByproducts CustomCommandByproducts)
907

908
  ADD_TEST_MACRO(CommandLength CommandLength)
909

910
  ADD_TEST_MACRO(EmptyDepends ${CMAKE_CTEST_COMMAND})
911

912
  add_test(CustomCommandWorkingDirectory  ${CMAKE_CTEST_COMMAND}
913
    --build-and-test
914
    "${CMake_SOURCE_DIR}/Tests/CustomCommandWorkingDirectory"
915
    "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory"
916
    --build-two-config
917
    ${build_generator_args}
918
    --build-project TestWorkingDir
919
    --test-command working
920
    )
921
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory")
922

923
  add_test(OutOfSource ${CMAKE_CTEST_COMMAND}
924
    --build-and-test
925
    "${CMake_SOURCE_DIR}/Tests/OutOfSource"
926
    "${CMake_BINARY_DIR}/Tests/OutOfSource"
927
    ${build_generator_args}
928
    --build-project OutOfSource
929
    --build-two-config
930
    --test-command
931
    "${CMake_BINARY_DIR}/Tests/OutOfSource/SubDir/OutOfSourceSubdir/simple")
932
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSource")
933
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSourceDeep")
934
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfBinary")
935

936
  add_test(BuildDepends ${CMAKE_CTEST_COMMAND}
937
    --build-and-test
938
    "${CMake_SOURCE_DIR}/Tests/BuildDepends"
939
    "${CMake_BINARY_DIR}/Tests/BuildDepends"
940
    ${build_generator_args}
941
    --build-project BuildDepends
942
    --build-options
943
    "-DCMake_TEST_XCODE_VERSION=${CMake_TEST_XCODE_VERSION}"
944
    )
945
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BuildDepends")
946

947
  set(MissingInstallInstallDir
948
    "${CMake_BINARY_DIR}/Tests/MissingInstall/InstallDirectory")
949
  add_test(MissingInstall ${CMAKE_CTEST_COMMAND}
950
    --build-and-test
951
    "${CMake_SOURCE_DIR}/Tests/MissingInstall"
952
    "${CMake_BINARY_DIR}/Tests/MissingInstall"
953
    ${build_generator_args}
954
    --build-project TestMissingInstall
955
    --build-two-config
956
    --build-options
957
    "-DCMAKE_INSTALL_PREFIX:PATH=${MissingInstallInstallDir}")
958
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MissingInstall")
959

960
  # By default, run the CPackComponents test if the CTEST_TEST_CPACK
961
  # option is ON:
962
  #
963
  set(CTEST_RUN_CPackComponents ${CTEST_TEST_CPACK})
964
  set(CTEST_package_X11_TEST ${CTEST_TEST_CPACK})
965
  set(CTEST_RUN_CPackComponentsForAll ${CTEST_TEST_CPACK})
966
  set(CTEST_RUN_CPackComponentsPrefix ${CTEST_TEST_CPACK})
967

968
  find_program(NSIS_MAKENSIS_EXECUTABLE NAMES makensis
969
    PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
970
    DOC "makensis program location"
971
    )
972

973
  # But on Windows, only run the CPackComponents test if the NSIS
974
  # installer builder is available:
975
  #
976
  if(WIN32)
977
    if(NSIS_MAKENSIS_EXECUTABLE)
978
      set(CTEST_RUN_CPackComponents ON)
979
    else()
980
      set(CTEST_RUN_CPackComponents OFF)
981
      set(CTEST_package_X11_TEST OFF)
982
    endif()
983
  endif()
984

985
  # On Windows run the CPackInnoSetupGenerator test
986
  if(WIN32 AND CMake_TEST_CPACK_INNOSETUP)
987
    add_test(CPackInnoSetupGenerator ${CMAKE_CTEST_COMMAND}
988
      -C \${CTEST_CONFIGURATION_TYPE}
989
      --build-and-test
990
      "${CMake_SOURCE_DIR}/Tests/CPackInnoSetupGenerator"
991
      "${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator"
992
      ${build_generator_args}
993
      --build-project CPackInnoSetupGenerator
994
      --build-options
995
      --test-command ${CMAKE_CMAKE_COMMAND}
996
      "-DCPackInnoSetupGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator"
997
      "-Dconfig=\${CTEST_CONFIGURATION_TYPE}"
998
      -P "${CMake_SOURCE_DIR}/Tests/CPackInnoSetupGenerator/RunCPackVerifyResult.cmake")
999

1000
    set_property(TEST CPackInnoSetupGenerator PROPERTY
1001
      ATTACHED_FILES_ON_FAIL
1002
      "${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator/_CPack_Packages/win32/INNOSETUP/ISCCOutput.log")
1003

1004
    set_property(TEST CPackInnoSetupGenerator PROPERTY
1005
      ATTACHED_FILES
1006
      "${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator/_CPack_Packages/win32/INNOSETUP/ISScript.iss")
1007
  endif()
1008

1009
  # On Windows run the CPackNSISGenerator test
1010
  # if the nsis is available
1011
  if(WIN32 AND NSIS_MAKENSIS_EXECUTABLE)
1012
    add_test(CPackNSISGenerator ${CMAKE_CTEST_COMMAND}
1013
      -C \${CTEST_CONFIGURATION_TYPE}
1014
      --build-and-test
1015
      "${CMake_SOURCE_DIR}/Tests/CPackNSISGenerator"
1016
      "${CMake_BINARY_DIR}/Tests/CPackNSISGenerator"
1017
      ${build_generator_args}
1018
      --build-project CPackNSISGenerator
1019
      --build-options
1020
      --test-command ${CMAKE_CMAKE_COMMAND}
1021
        "-DCPackNSISGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackNSISGenerator"
1022
        "-Dconfig=\${CTEST_CONFIGURATION_TYPE}"
1023
        -P "${CMake_SOURCE_DIR}/Tests/CPackNSISGenerator/RunCPackVerifyResult.cmake")
1024

1025
    set_property(TEST CPackNSISGenerator PROPERTY
1026
      ATTACHED_FILES_ON_FAIL
1027
      "${CMake_BINARY_DIR}/Tests/CPackNSISGenerator/_CPack_Packages/win32/NSIS/NSISOutput.log")
1028
  endif()
1029

1030
  find_program(IFW_BINARYCREATOR_EXECUTABLE NAMES binarycreator
1031
    DOC "IFW binarycreator program location"
1032
  )
1033

1034
  if(IFW_BINARYCREATOR_EXECUTABLE)
1035
    add_test(CPackIFWGenerator ${CMAKE_CTEST_COMMAND}
1036
      -C \${CTEST_CONFIGURATION_TYPE}
1037
      --build-and-test
1038
      "${CMake_SOURCE_DIR}/Tests/CPackIFWGenerator"
1039
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator"
1040
      ${build_generator_args}
1041
      --build-project CPackIFWGenerator
1042
      --build-options
1043
      --test-command ${CMAKE_CMAKE_COMMAND}
1044
      "-DCPackIFWGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackIFWGenerator"
1045
      "-Dconfig=\${CTEST_CONFIGURATION_TYPE}"
1046
      -P "${CMake_SOURCE_DIR}/Tests/CPackIFWGenerator/RunCPackVerifyResult.cmake")
1047

1048
    set_property(TEST CPackIFWGenerator PROPERTY
1049
      ATTACHED_FILES_ON_FAIL
1050
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator/_CPack_Packages/Linux/IFW/IFWOutput.log"
1051
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator/_CPack_Packages/Darwin/IFW/IFWOutput.log"
1052
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator/_CPack_Packages/win32/IFW/IFWOutput.log"
1053
    )
1054
  endif()
1055

1056
  if(CTEST_TEST_CPACK)
1057
    add_test(CPackUseDefaultVersion ${CMAKE_CTEST_COMMAND}
1058
      --build-and-test
1059
      "${CMake_SOURCE_DIR}/Tests/CPackUseDefaultVersion"
1060
      "${CMake_BINARY_DIR}/Tests/CPackUseDefaultVersion"
1061
      ${build_generator_args}
1062
      --build-project CPackUseDefaultVersion
1063
      --build-two-config
1064
      --build-options
1065
        ${CPackUseDefaultVersion_BUILD_OPTIONS})
1066
    set_tests_properties(CPackUseDefaultVersion PROPERTIES PASS_REGULAR_EXPRESSION "CPACK_PACKAGE_VERSION=0\\.1\\.1")
1067
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackUseDefaultVersion")
1068

1069
    add_test(CPackUseProjectVersion ${CMAKE_CTEST_COMMAND}
1070
      --build-and-test
1071
      "${CMake_SOURCE_DIR}/Tests/CPackUseProjectVersion"
1072
      "${CMake_BINARY_DIR}/Tests/CPackUseProjectVersion"
1073
      ${build_generator_args}
1074
      --build-project CPackUseProjectVersion
1075
      --build-two-config
1076
      --build-options
1077
        ${CPackUseProjectVersion_BUILD_OPTIONS})
1078
    set_tests_properties(CPackUseProjectVersion PROPERTIES PASS_REGULAR_EXPRESSION "CPACK_PACKAGE_VERSION=1\\.2\\.3")
1079
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackUseProjectVersion")
1080

1081
    add_test(CPackUseShortProjectVersion ${CMAKE_CTEST_COMMAND}
1082
      --build-and-test
1083
      "${CMake_SOURCE_DIR}/Tests/CPackUseShortProjectVersion"
1084
      "${CMake_BINARY_DIR}/Tests/CPackUseShortProjectVersion"
1085
      ${build_generator_args}
1086
      --build-project CPackUseShortProjectVersion
1087
      --build-two-config
1088
      --build-options
1089
        ${CPackUseProjectVersion_BUILD_OPTIONS})
1090
    set_tests_properties(CPackUseShortProjectVersion PROPERTIES PASS_REGULAR_EXPRESSION "CPACK_PACKAGE_VERSION=2")
1091
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackUseShortProjectVersion")
1092
  endif()
1093

1094
  if(CTEST_RUN_CPackComponents)
1095
    set(CPackComponents_BUILD_OPTIONS)
1096
    if(APPLE)
1097
      set(CPackComponents_BUILD_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
1098
      if(CMake_TEST_XCODE_VERSION VERSION_GREATER "4.6")
1099
        set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1100
          -DCPACK_BINARY_PRODUCTBUILD:BOOL=ON)
1101
      endif()
1102
    endif()
1103
    if(NSIS_MAKENSIS_EXECUTABLE)
1104
      execute_process(COMMAND ${NSIS_MAKENSIS_EXECUTABLE} "-VERSION" ERROR_QUIET OUTPUT_QUIET RESULT_VARIABLE NSIS_OK)
1105
      if("${NSIS_OK}" STREQUAL "0")
1106
        set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1107
          -DCPACK_BINARY_NSIS:BOOL=ON)
1108
      endif()
1109
    endif()
1110

1111
    add_test(CPackComponents ${CMAKE_CTEST_COMMAND}
1112
      --build-and-test
1113
      "${CMake_SOURCE_DIR}/Tests/CPackComponents"
1114
      "${CMake_BINARY_DIR}/Tests/CPackComponents"
1115
      ${build_generator_args}
1116
      --build-project CPackComponents
1117
      --build-two-config
1118
      --build-target package
1119
      --build-options
1120
        -DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
1121
        -DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
1122
        ${CPackComponents_BUILD_OPTIONS}
1123
        --graphviz=CPackComponents.dot
1124
      --test-command ${CMAKE_CMAKE_COMMAND}
1125
        "-DCPackComponents_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponents"
1126
        -P "${CMake_SOURCE_DIR}/Tests/CPackComponents/VerifyResult.cmake")
1127
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponents")
1128
  endif()
1129

1130
  if(CTEST_RUN_CPackComponentsForAll)
1131
    # Check whether if rpmbuild command is found
1132
    # before adding RPM tests
1133
    if(CPACK_BINARY_RPM)
1134
      list(APPEND ACTIVE_CPACK_GENERATORS RPM)
1135
    endif()
1136
    # Check whether if dpkg command is found
1137
    # before adding DEB tests
1138
    if(CPACK_BINARY_DEB)
1139
      list(APPEND ACTIVE_CPACK_GENERATORS DEB)
1140
    endif()
1141
    if(CMake_TEST_CPACK_NUGET)
1142
      list(APPEND ACTIVE_CPACK_GENERATORS NUGET)
1143
      set(CPACK_GENERATOR_STRING_NUGET NuGet)
1144
    endif()
1145

1146
    # ACTIVE_CPACK_GENERATORS variable
1147
    # now contains the list of 'active generators'
1148
    set(CPackComponentsForAll_BUILD_OPTIONS)
1149
    # set up list of CPack generators
1150
    list(APPEND ACTIVE_CPACK_GENERATORS "ZIP")
1151
    if(APPLE)
1152
      list(APPEND ACTIVE_CPACK_GENERATORS "DragNDrop")
1153
      if(CMake_TEST_XCODE_VERSION VERSION_GREATER "4.6")
1154
        list(APPEND ACTIVE_CPACK_GENERATORS "productbuild")
1155
      endif()
1156
    endif()
1157

1158
    # set up list of component packaging ways
1159
    list(APPEND CWAYLST "default")
1160
    list(APPEND CWAYLST "OnePackPerGroup")
1161
    list(APPEND CWAYLST "IgnoreGroup")
1162
    list(APPEND CWAYLST "AllInOne")
1163
    foreach(CPackGen IN LISTS ACTIVE_CPACK_GENERATORS)
1164
      if(NOT DEFINED CPACK_GENERATOR_STRING_${CPackGen})
1165
        set(CPACK_GENERATOR_STRING_${CPackGen} ${CPackGen})
1166
      endif()
1167
      set(CPackRun_CPackGen  "-DCPackGen=${CPACK_GENERATOR_STRING_${CPackGen}}")
1168
      foreach(CPackComponentWay IN LISTS CWAYLST)
1169
        set(CPackRun_CPackComponentWay "-DCPackComponentWay=${CPackComponentWay}")
1170
        add_test(CPackComponentsForAll-${CPackGen}-${CPackComponentWay}
1171
          ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
1172
          --build-and-test
1173
          "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll"
1174
          "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
1175
          ${build_generator_args}
1176
          --build-project CPackComponentsForAll
1177
          --build-options
1178
             -DCPACK_GENERATOR:STRING=${CPACK_GENERATOR_STRING_${CPackGen}}
1179
             -DCPACK_BINARY_${CPackGen}:BOOL=ON
1180
             ${CPackRun_CPackComponentWay}
1181
             ${CPackComponentsForAll_BUILD_OPTIONS}
1182
             --graphviz=CPackComponentsForAll.dot
1183
          --test-command ${CMAKE_CMAKE_COMMAND}
1184
            "-DCPackComponentsForAll_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
1185
            "${CPackRun_CPackGen}"
1186
            "${CPackRun_CPackComponentWay}"
1187
            -P "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll/RunCPackVerifyResult.cmake")
1188
        list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}")
1189
      endforeach()
1190
    endforeach()
1191

1192
    # debian specific
1193
    if(CMake_TEST_CPACK_DEB)
1194
      unset(CPackRun_CPackDEBConfiguration_ALL_CONFIGS)
1195
      set(DEB_TEST_NAMES "CPackComponentsDEB")
1196
      set(DEB_CONFIGURATIONS_TO_TEST "components-lintian-dpkgdeb-checks"
1197
                                     "components-description1"
1198
                                     "components-description2"
1199
                                     "components-source"
1200
                                     "components-shlibdeps1"
1201
                                     "components-depend1"
1202
                                     "compression")
1203
      # Run additional tests if dpkg-shlibdeps is available (and is new enough version)
1204
      find_program(SHLIBDEPS_EXECUTABLE NAMES dpkg-shlibdeps)
1205
      if(SHLIBDEPS_EXECUTABLE)
1206
        # Check version of the dpkg-shlibdeps tool
1207
        execute_process(COMMAND ${CMAKE_COMMAND} -E env LC_ALL=C ${SHLIBDEPS_EXECUTABLE} --version
1208
          OUTPUT_VARIABLE _TMP_VERSION
1209
          ERROR_QUIET
1210
          OUTPUT_STRIP_TRAILING_WHITESPACE)
1211
        if(_TMP_VERSION MATCHES "dpkg-shlibdeps version ([0-9]+\\.[0-9]+\\.[0-9]+)")
1212
          set(SHLIBDEPS_EXECUTABLE_VERSION "${CMAKE_MATCH_1}")
1213
        else()
1214
          unset(SHLIBDEPS_EXECUTABLE_VERSION)
1215
        endif()
1216
        # Check if distro has symbols or shlibs data
1217
        file(GLOB SHLIBS_FILES_EXIST "/var/lib/dpkg/info/*.shlibs" "/var/lib/dpkg/info/*.symbols")
1218
        if(NOT SHLIBDEPS_EXECUTABLE_VERSION VERSION_LESS 1.19 OR
1219
          (NOT SHLIBDEPS_EXECUTABLE_VERSION VERSION_LESS 1.17 AND NOT CMAKE_BINARY_DIR MATCHES ".*[ ].*"))
1220
            list(APPEND DEB_CONFIGURATIONS_TO_TEST "shlibdeps-with-private-lib-failure"
1221
                                                   "shlibdeps-with-private-lib-success"
1222
                                                   "shlibdeps-with-ORIGIN-RPATH-failure")
1223
            if(SHLIBS_FILES_EXIST)
1224
                list(APPEND DEB_CONFIGURATIONS_TO_TEST "shlibdeps-with-ORIGIN-RPATH-success")
1225
            endif()
1226
        endif()
1227
        if(SHLIBS_FILES_EXIST)
1228
          list(APPEND DEB_CONFIGURATIONS_TO_TEST "components-depend2")
1229
        endif()
1230
      endif()
1231

1232
      set(CPackGen "DEB")
1233
      set(CPackRun_CPackGen "-DCPackGen=${CPackGen}")
1234

1235
      foreach(CPackDEBConfiguration IN LISTS DEB_CONFIGURATIONS_TO_TEST)
1236
        set(CPackRun_CPackDEBConfiguration "-DCPackDEBConfiguration=${CPackDEBConfiguration}")
1237
        add_test(NAME ${DEB_TEST_NAMES}-${CPackDEBConfiguration} COMMAND
1238
          ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
1239
          --build-and-test
1240
              "${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}"
1241
              "${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}"
1242
              ${build_generator_args}
1243
          --build-project CPackComponentsDEB
1244
          --build-options
1245
              -DCPACK_GENERATOR:STRING=${CPackGen}
1246
              -DCPACK_BINARY_${CPackGen}:BOOL=ON
1247
              ${CPackRun_CPackDEBConfiguration}
1248
              ${CPackRun_CPackDEBConfiguration_ALL_CONFIGS}
1249
          --graphviz=${DEB_TEST_NAMES}.dot
1250
          --test-command ${CMAKE_CMAKE_COMMAND}
1251
              "-D${DEB_TEST_NAMES}_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}"
1252
              "-D${DEB_TEST_NAMES}_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}"
1253
              "${CPackRun_CPackGen}"
1254
              "${CPackRun_CPackDEBConfiguration}"
1255
              "-DCONFIG=$<CONFIG>"
1256
              -P "${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}/RunCPackVerifyResult-${CPackDEBConfiguration}.cmake")
1257
          list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}")
1258
      endforeach()
1259
    endif()
1260

1261
  endif()
1262

1263
  # By default, turn this test off (because it takes a long time...)
1264
  #
1265
  if(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
1266
    set(CTEST_RUN_CPackTestAllGenerators OFF)
1267

1268
    # ...but: if it appears to be a coverage dashboard, or long tests are
1269
    # on, then set it to the generic CTEST_TEST_CPACK setting.
1270
    #
1271
    if(CMAKE_CXX_FLAGS MATCHES "-ftest-coverage" OR
1272
      NOT "$ENV{COVFILE}" STREQUAL "" OR
1273
      CMAKE_RUN_LONG_TESTS)
1274
      set(CTEST_RUN_CPackTestAllGenerators ${CTEST_TEST_CPACK})
1275
    endif()
1276
  endif()
1277

1278
  if(CTEST_RUN_CPackTestAllGenerators)
1279
    add_test(CPackTestAllGenerators ${CMAKE_CTEST_COMMAND}
1280
      --build-and-test
1281
      "${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators"
1282
      "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators"
1283
      ${build_generator_args}
1284
      --build-project CPackTestAllGenerators
1285
      --test-command
1286
      ${CMAKE_CMAKE_COMMAND}
1287
        -D dir=${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators
1288
        -P ${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators/RunCPack.cmake
1289
      )
1290
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators")
1291
  endif()
1292

1293
  if(CTEST_RUN_CPackComponentsPrefix)
1294
    set(CPackComponents_BUILD_OPTIONS)
1295
    if(APPLE)
1296
      set(CPackComponents_BUILD_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
1297
      if(CMake_TEST_XCODE_VERSION VERSION_GREATER "4.6")
1298
        set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1299
          -DCPACK_BINARY_PRODUCTBUILD:BOOL=ON)
1300
      endif()
1301
    endif()
1302
    if(NOT NSIS_MAKENSIS_EXECUTABLE)
1303
      set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1304
        -DCPACK_BINARY_NSIS:BOOL=OFF)
1305
    endif()
1306

1307
    add_test(CPackComponentsPrefix ${CMAKE_CTEST_COMMAND}
1308
      --build-and-test
1309
      "${CMake_SOURCE_DIR}/Tests/CPackComponentsPrefix"
1310
      "${CMake_BINARY_DIR}/Tests/CPackComponentsPrefix"
1311
      ${build_generator_args}
1312
      --build-project CPackComponentsPrefix
1313
      --build-two-config
1314
      --build-target package
1315
      --build-options
1316
        -DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
1317
        -DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
1318
        -DCPACK_BINARY_ZIP:BOOL=ON
1319
        ${CPackComponents_BUILD_OPTIONS}
1320
        )
1321
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsPrefix")
1322
  endif()
1323

1324
  if(CTEST_package_X11_TEST)
1325
    set(X11_build_target_arg --build-target package)
1326
  else()
1327
    set(X11_build_target_arg)
1328
  endif()
1329

1330
  add_test(X11 ${CMAKE_CTEST_COMMAND}
1331
    --build-and-test
1332
    "${CMake_SOURCE_DIR}/Tests/X11"
1333
    "${CMake_BINARY_DIR}/Tests/X11"
1334
    ${build_generator_args}
1335
    --build-project UseX11
1336
    --build-two-config
1337
    ${X11_build_target_arg}
1338
    --test-command  UseX11)
1339
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/X11")
1340

1341
  if(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
1342
    set(CTEST_RUN_CMakeTestAllGenerators ON)
1343
  endif()
1344

1345
  if(CTEST_RUN_CMakeTestAllGenerators)
1346
    add_test(CMakeTestAllGenerators ${CMAKE_CMAKE_COMMAND}
1347
        -D dir=${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators
1348
        -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
1349
        -P ${CMake_SOURCE_DIR}/Tests/CMakeTestAllGenerators/RunCMake.cmake
1350
      )
1351
    list(APPEND TEST_BUILD_DIRS
1352
      "${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators")
1353
    # This test runs a lot of processes.  Do not make them compete
1354
    # for resources with other tests.
1355
    set_property(TEST CMakeTestAllGenerators PROPERTY RUN_SERIAL 1)
1356
  endif()
1357

1358
  add_test(complex  ${CMAKE_CTEST_COMMAND}
1359
    --build-and-test
1360
    "${CMake_SOURCE_DIR}/Tests/Complex"
1361
    "${CMake_BINARY_DIR}/Tests/Complex"
1362
    --build-two-config
1363
    --build-config-sample "${CMAKE_CTEST_COMMAND}"
1364
    ${build_generator_args}
1365
    --build-project Complex
1366
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Complex/bin"
1367
    -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
1368
    --test-command complex
1369
    )
1370
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Complex")
1371

1372
  add_test(complexOneConfig  ${CMAKE_CTEST_COMMAND}
1373
    --build-and-test
1374
    "${CMake_SOURCE_DIR}/Tests/ComplexOneConfig"
1375
    "${CMake_BINARY_DIR}/Tests/ComplexOneConfig"
1376
    ${build_generator_args}
1377
    --build-project Complex
1378
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ComplexOneConfig/bin"
1379
    -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
1380
    --test-command complex)
1381
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ComplexOneConfig")
1382
  # because of the registry write these tests depend on each other
1383
  set_tests_properties(complex PROPERTIES DEPENDS complexOneConfig)
1384

1385
  add_test(Environment ${CMAKE_CTEST_COMMAND}
1386
    --build-and-test
1387
    "${CMake_SOURCE_DIR}/Tests/Environment"
1388
    "${CMake_BINARY_DIR}/Tests/Environment"
1389
    ${build_generator_args}
1390
    --build-project EnvironmentProj
1391
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Environment"
1392
    --test-command ${CMAKE_CTEST_COMMAND} -V
1393
    )
1394
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Environment")
1395
  set_property(TEST Environment APPEND
1396
    PROPERTY ENVIRONMENT
1397
      "SET_FROM_AMBIENT_unset=base"
1398
      "SET_FROM_AMBIENT_replace=base"
1399
      "SET_FROM_AMBIENT_string=base"
1400
      "SET_FROM_AMBIENT_path=base"
1401
      "SET_FROM_AMBIENT_list=base")
1402

1403
  add_test(QtAutomocNoQt  ${CMAKE_CTEST_COMMAND}
1404
    --build-and-test
1405
    "${CMake_SOURCE_DIR}/Tests/QtAutomocNoQt"
1406
    "${CMake_BINARY_DIR}/Tests/QtAutomocNoQt"
1407
    ${build_generator_args}
1408
    --build-project QtAutomocNoQt
1409
    --build-options
1410
      -DCMAKE_BUILD_TYPE=\${CTEST_CONFIGURATION_TYPE}
1411
    )
1412
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/QtAutomocNoQt")
1413

1414
  if(CMake_TEST_Qt6 AND Qt6Widgets_FOUND)
1415
    add_subdirectory(Qt6Autogen)
1416
  endif()
1417
  if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND)
1418
    add_subdirectory(Qt5Autogen)
1419
  endif()
1420
  if(QT4_WORKS AND QT_QTGUI_FOUND)
1421
    add_subdirectory(Qt4Autogen)
1422

1423
    add_test(Qt4Targets ${CMAKE_CTEST_COMMAND}
1424
      --build-and-test
1425
      "${CMake_SOURCE_DIR}/Tests/Qt4Targets"
1426
      "${CMake_BINARY_DIR}/Tests/Qt4Targets"
1427
      ${build_generator_args}
1428
      --build-project Qt4Targets
1429
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4Targets"
1430
      --build-options
1431
        -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
1432
      --test-command ${CMAKE_CTEST_COMMAND} -V
1433
      )
1434
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Targets")
1435

1436
    if(Qt5Widgets_FOUND AND NOT Qt5Widgets_VERSION VERSION_LESS 5.1.0)
1437
      add_test(Qt4And5AutomocForward ${CMAKE_CTEST_COMMAND}
1438
        --build-and-test
1439
        "${CMake_SOURCE_DIR}/Tests/Qt4And5Automoc"
1440
        "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocForward"
1441
        ${build_generator_args}
1442
        --build-project Qt4And5Automoc
1443
        --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocForward"
1444
        --test-command ${CMAKE_CTEST_COMMAND} -V
1445
        )
1446
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocForward")
1447
      add_test(Qt4And5AutomocReverse ${CMAKE_CTEST_COMMAND}
1448
        --build-and-test
1449
        "${CMake_SOURCE_DIR}/Tests/Qt4And5Automoc"
1450
        "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse"
1451
        ${build_generator_args}
1452
        --build-project Qt4And5Automoc
1453
        --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse"
1454
        --build-options -DQT_REVERSE_FIND_ORDER=1
1455
        --test-command ${CMAKE_CTEST_COMMAND} -V
1456
        )
1457
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse")
1458
    endif()
1459
  endif()
1460

1461
  # test for Find modules, simple cases
1462
  foreach(
1463
  _mod
1464
  IN ITEMS
1465
      ALSA
1466
      ASPELL
1467
      Backtrace
1468
      BLAS
1469
      Boost
1470
      BZip2
1471
      Cups
1472
      CURL
1473
      DevIL
1474
      Doxygen
1475
      EnvModules
1476
      EXPAT
1477
      Fontconfig
1478
      Freetype
1479
      GDAL
1480
      GIF
1481
      Git
1482
      GLEW
1483
      GLUT
1484
      GnuTLS
1485
      GSL
1486
      GTK2
1487
      HDF5
1488
      Iconv
1489
      ICU
1490
      ImageMagick
1491
      Intl
1492
      Jasper
1493
      JNI
1494
      JPEG
1495
      JsonCpp
1496
      LAPACK
1497
      LibArchive
1498
      Libinput
1499
      LibLZMA
1500
      LibRHash
1501
      LibUV
1502
      LibXml2
1503
      LibXslt
1504
      LTTngUST
1505
      MPI
1506
      ODBC
1507
      OpenACC
1508
      OpenAL
1509
      OpenCL
1510
      OpenGL
1511
      OpenMP
1512
      OpenSP
1513
      OpenSSL
1514
      Patch
1515
      PNG
1516
      PostgreSQL
1517
      Protobuf
1518
      SDL
1519
      SQLite3
1520
      TIFF
1521
      Vulkan
1522
      wxWidgets
1523
      X11
1524
      XalanC
1525
      XercesC
1526
    )
1527
    if(CMake_TEST_Find${_mod})
1528
      add_subdirectory(Find${_mod})
1529
    endif()
1530
  endforeach()
1531

1532
  if(CMake_TEST_CUDA)
1533
    add_subdirectory(Cuda)
1534
    add_subdirectory(CudaOnly)
1535
  endif()
1536

1537
  if(CMake_TEST_HIP)
1538
    add_subdirectory(HIP)
1539
  endif()
1540

1541
  if(CMake_TEST_ISPC)
1542
    add_subdirectory(ISPC)
1543
  endif()
1544

1545
  if(CMake_TEST_FindGTest)
1546
    add_subdirectory(FindGTest)
1547
    add_subdirectory(GoogleTest)
1548
  endif()
1549

1550
  if(CMake_TEST_UseSWIG)
1551
    add_subdirectory(UseSWIG)
1552
  endif()
1553

1554
  add_subdirectory(FindThreads)
1555

1556
  # Matlab module
1557
  # CMake_TEST_FindMatlab: indicates to look for Matlab (from PATH for Linux)
1558
  # CMake_TEST_FindMatlab_ROOT_DIR: indicates an optional root directory for Matlab, allows to select a version.
1559
  # CMake_TEST_FindMatlab_MCR: indicates the MCR is installed
1560
  # CMake_TEST_FindMatlab_MCR_ROOT_DIR: indicates an optional root directory for the MCR, required on Linux
1561
  if(CMake_TEST_FindMatlab OR CMake_TEST_FindMatlab_ROOT_DIR OR
1562
     CMake_TEST_FindMatlab_MCR OR CMake_TEST_FindMatlab_MCR_ROOT_DIR)
1563
    set(FindMatlab_additional_test_options)
1564
    if(CMake_TEST_FindMatlab_MCR OR CMake_TEST_FindMatlab_MCR_ROOT_DIR)
1565
      set(FindMatlab_additional_test_options -DIS_MCR=TRUE)
1566
    endif()
1567
    if(CMake_TEST_FindMatlab_ROOT_DIR)
1568
      set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMatlab_ROOT_DIR=${CMake_TEST_FindMatlab_ROOT_DIR}")
1569
    endif()
1570
    if(CMake_TEST_FindMatlab_MCR_ROOT_DIR)
1571
      set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMCR_ROOT:FILEPATH=${CMake_TEST_FindMatlab_MCR_ROOT_DIR}")
1572
    endif()
1573
    set(FindMatlab.basic_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1574
    ADD_TEST_MACRO(FindMatlab.basic_checks      ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1575
    set_property(TEST FindMatlab.basic_checks APPEND PROPERTY LABELS "Matlab")
1576
    set(FindMatlab.versions_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1577
    ADD_TEST_MACRO(FindMatlab.versions_checks   ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1578
    set_property(TEST FindMatlab.versions_checks APPEND PROPERTY LABELS "Matlab")
1579
    set(FindMatlab.components_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1580
    ADD_TEST_MACRO(FindMatlab.components_checks ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1581
    set_property(TEST FindMatlab.components_checks APPEND PROPERTY LABELS "Matlab")
1582
    set(FindMatlab.failure_reports_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1583
    ADD_TEST_MACRO(FindMatlab.failure_reports   ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1584
    set_property(TEST FindMatlab.failure_reports APPEND PROPERTY LABELS "Matlab")
1585
    set(FindMatlab.r2018a_check_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1586
    ADD_TEST_MACRO(FindMatlab.r2018a_check   ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1587
    set_property(TEST FindMatlab.r2018a_check APPEND PROPERTY LABELS "Matlab")
1588
    set(FindMatlab.targets_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1589
    ADD_TEST_MACRO(FindMatlab.targets_checks      ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1590
    set_property(TEST FindMatlab.targets_checks APPEND PROPERTY LABELS "Matlab")
1591
    set(FindMatlab.no_implicit_link_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1592
    ADD_TEST_MACRO(FindMatlab.no_implicit_link_checks      ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1593
    set_property(TEST FindMatlab.no_implicit_link_checks APPEND PROPERTY LABELS "Matlab")
1594
  endif()
1595

1596
  set(ExternalProject_BUILD_OPTIONS "")
1597
  foreach(vcs IN ITEMS CVS SVN GIT HG)
1598
    if(DEFINED CMake_TEST_ExternalProject_${vcs})
1599
      list(APPEND ExternalProject_BUILD_OPTIONS -DEP_TEST_${vcs}=${CMake_TEST_ExternalProject_${vcs}})
1600
    endif()
1601
  endforeach()
1602
  add_test(ExternalProject ${CMAKE_CTEST_COMMAND}
1603
    --build-and-test
1604
    "${CMake_SOURCE_DIR}/Tests/ExternalProject"
1605
    "${CMake_BINARY_DIR}/Tests/ExternalProject"
1606
    ${build_generator_args}
1607
    --build-project ExternalProjectTest
1608
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProject"
1609
    --build-options ${ExternalProject_BUILD_OPTIONS}
1610
    --test-command ${CMAKE_CTEST_COMMAND} -V
1611
    )
1612
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProject")
1613
  set_tests_properties(ExternalProject PROPERTIES
1614
    ENVIRONMENT GIT_ALLOW_PROTOCOL=file
1615
    RUN_SERIAL 1
1616
    TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
1617

1618
  add_test(NAME ExternalProjectSubdir
1619
    COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
1620
    --build-and-test
1621
    "${CMake_SOURCE_DIR}/Tests/ExternalProjectSubdir"
1622
    "${CMake_BINARY_DIR}/Tests/ExternalProjectSubdir"
1623
    ${build_generator_args}
1624
    --build-project ExternalProjectSubdir
1625
    )
1626
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectSubdir")
1627

1628
  add_test(NAME ExternalProjectSourceSubdir
1629
    COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
1630
    --build-and-test
1631
    "${CMake_SOURCE_DIR}/Tests/ExternalProjectSourceSubdir"
1632
    "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdir"
1633
    ${build_generator_args}
1634
    --build-project ExternalProjectSourceSubdir
1635
    )
1636
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdir")
1637

1638
  add_test(NAME ExternalProjectSourceSubdirNotCMake
1639
    COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
1640
    --build-and-test
1641
    "${CMake_SOURCE_DIR}/Tests/ExternalProjectSourceSubdirNotCMake"
1642
    "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdirNotCMake"
1643
    ${build_generator_args}
1644
    --build-project ExternalProjectSourceSubdirNotCMake
1645
    )
1646
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdirNotCMake")
1647

1648
  add_test(ExternalProjectLocal ${CMAKE_CTEST_COMMAND}
1649
    --build-and-test
1650
    "${CMake_SOURCE_DIR}/Tests/ExternalProjectLocal"
1651
    "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal"
1652
    ${build_generator_args}
1653
    --build-project ExternalProjectLocalTest
1654
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal"
1655
    --test-command ${CMAKE_CTEST_COMMAND} -V
1656
    )
1657
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal")
1658
  set_tests_properties(ExternalProjectLocal PROPERTIES
1659
    RUN_SERIAL 1
1660
    TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
1661

1662
  add_test(ExternalProjectUpdateSetup ${CMAKE_CTEST_COMMAND}
1663
    --build-and-test
1664
    "${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate"
1665
    "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
1666
    ${build_generator_args}
1667
    --build-project ExternalProjectUpdateTest
1668
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
1669
    --test-command ${CMAKE_CTEST_COMMAND} -V
1670
    )
1671
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
1672
  set_tests_properties(ExternalProjectUpdateSetup PROPERTIES
1673
    RUN_SERIAL 1
1674
    TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
1675

1676
  add_test(NAME ExternalProjectUpdate
1677
    COMMAND ${CMAKE_CMAKE_COMMAND}
1678
    -DExternalProjectUpdate_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
1679
    -DExternalProjectUpdate_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate
1680
    -DCMAKE_GENERATOR=${CMAKE_GENERATOR}
1681
    -DCMAKE_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
1682
    -DCMAKE_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
1683
    -DCMAKE_CTEST_COMMAND=${CMAKE_CTEST_COMMAND}
1684
    -P ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate/ExternalProjectUpdateTest.cmake
1685
    )
1686
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
1687
  set_tests_properties(ExternalProjectUpdate PROPERTIES
1688
    RUN_SERIAL 1
1689
    TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT}
1690
    WORKING_DIRECTORY ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
1691
    DEPENDS ExternalProjectUpdateSetup
1692
    )
1693

1694
  execute_process(
1695
    COMMAND ${CMAKE_COMMAND}
1696
    "-E" create_symlink
1697
    "${CMake_SOURCE_DIR}/Tests/CMakeLists.txt"        # random source file that exists
1698
    "${CMake_BINARY_DIR}/Tests/try_to_create_symlink" # random target file in existing directory
1699
    RESULT_VARIABLE _symlink_result
1700
    OUTPUT_VARIABLE _symlink_stdout
1701
    ERROR_VARIABLE _symlink_stderr
1702
    )
1703
  if(_symlink_result EQUAL 0)
1704
    file(REMOVE "${CMake_BINARY_DIR}/Tests/try_to_create_symlink")
1705
    function(add_installmode_test _mode)
1706
      set(ENV{CMAKE_INSTALL_MODE} _mode)
1707
      set(_maybe_InstallMode_CTEST_OPTIONS)
1708
      set(_maybe_BUILD_OPTIONS)
1709
      if(_isMultiConfig)
1710
        set(_maybe_CTEST_OPTIONS -C $<CONFIGURATION>)
1711
      else()
1712
        set(_maybe_BUILD_OPTIONS "-DCMAKE_BUILD_TYPE=$<CONFIGURATION>")
1713
      endif()
1714
      add_test(
1715
        NAME "InstallMode-${_mode}"
1716
        COMMAND
1717
          ${CMAKE_CTEST_COMMAND} -V ${_maybe_CTEST_OPTIONS}
1718
        --build-and-test
1719
          "${CMake_SOURCE_DIR}/Tests/InstallMode"
1720
          "${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}"
1721
        ${build_generator_args}
1722
        --build-project superpro
1723
        --build-exe-dir "${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}"
1724
        --build-options
1725
          ${_maybe_BUILD_OPTIONS}
1726
          "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}/install"
1727
        )
1728
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}")
1729
      unset(ENV{CMAKE_INSTALL_MODE})
1730
    endfunction()
1731

1732
    add_installmode_test(COPY)
1733
    add_installmode_test(REL_SYMLINK)
1734
    add_installmode_test(REL_SYMLINK_OR_COPY)
1735
    add_installmode_test(ABS_SYMLINK)
1736
    add_installmode_test(ABS_SYMLINK_OR_COPY)
1737
    add_installmode_test(SYMLINK)
1738
    add_installmode_test(SYMLINK_OR_COPY)
1739
  endif()
1740

1741
  function(add_importexport_test export_name import_name)
1742
    set(install_dir
1743
      "${CMake_BINARY_DIR}/Tests/ImportExport/Install${export_name}")
1744
    set(export_build_dir "${CMake_BINARY_DIR}/Tests/ImportExport/${export_name}Build")
1745
    set(export_test_name "Guide.ImportExport.${export_name}")
1746
    add_test(${export_test_name} ${CMAKE_CTEST_COMMAND}
1747
      -C "Release"
1748
      --build-and-test
1749
      "${CMake_SOURCE_DIR}/Help/guide/importing-exporting/${export_name}"
1750
      "${export_build_dir}"
1751
      ${build_generator_args}
1752
      --build-project ${export_name}
1753
      --build-target install
1754
      --build-options
1755
      "-DCMAKE_INSTALL_PREFIX:PATH=${install_dir}")
1756
    list(APPEND TEST_BUILD_DIRS "${export_build_dir}")
1757

1758
    set(import_build_dir "${CMake_BINARY_DIR}/Tests/ImportExport/${import_name}Build")
1759
    set(import_test_name "Guide.ImportExport.${import_name}")
1760
    add_test(${import_test_name} ${CMAKE_CTEST_COMMAND}
1761
      -C "Release"
1762
      --build-and-test
1763
      "${CMake_SOURCE_DIR}/Help/guide/importing-exporting/${import_name}"
1764
      "${import_build_dir}"
1765
      ${build_generator_args}
1766
      --build-project ${import_name}
1767
      --build-options
1768
      "-DCMAKE_PREFIX_PATH:PATH=${install_dir}")
1769
    set_tests_properties(${import_test_name} PROPERTIES DEPENDS ${export_test_name})
1770
    list(APPEND TEST_BUILD_DIRS "${import_build_dir}")
1771
  endfunction()
1772

1773
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
1774
    add_importexport_test("MyExe" "Importing")
1775
    add_importexport_test("MathFunctions" "Downstream")
1776
    add_importexport_test("MathFunctionsComponents" "DownstreamComponents")
1777
  endif()
1778

1779
  add_test(testing ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
1780
    --build-and-test
1781
    "${CMake_SOURCE_DIR}/Tests/Testing"
1782
    "${CMake_BINARY_DIR}/Tests/Testing"
1783
    ${build_generator_args}
1784
    --build-project Testing
1785
    --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
1786
    )
1787
  set_tests_properties(testing PROPERTIES PASS_REGULAR_EXPRESSION "Passed")
1788
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Testing")
1789

1790
  add_test(wrapping  ${CMAKE_CTEST_COMMAND}
1791
    --build-and-test
1792
    "${CMake_SOURCE_DIR}/Tests/Wrapping"
1793
    "${CMake_BINARY_DIR}/Tests/Wrapping"
1794
    ${build_generator_args}
1795
    --build-project Wrapping
1796
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1797
    --test-command wrapping
1798
    )
1799
  add_test(qtwrapping  ${CMAKE_CTEST_COMMAND}
1800
    --build-and-test
1801
    "${CMake_SOURCE_DIR}/Tests/Wrapping"
1802
    "${CMake_BINARY_DIR}/Tests/Wrapping"
1803
    ${build_generator_args}
1804
    --build-project Wrapping
1805
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1806
      --test-command qtwrapping
1807
      )
1808
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Wrapping")
1809

1810
  add_test(testdriver1 ${CMAKE_CTEST_COMMAND}
1811
    --build-and-test
1812
    "${CMake_SOURCE_DIR}/Tests/TestDriver"
1813
    "${CMake_BINARY_DIR}/Tests/TestDriver1"
1814
    ${build_generator_args}
1815
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1816
    --build-project TestDriverTest
1817
    --test-command TestDriverTest test1
1818
    )
1819
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver1")
1820

1821
  add_test(testdriver2 ${CMAKE_CTEST_COMMAND}
1822
    --build-and-test
1823
    "${CMake_SOURCE_DIR}/Tests/TestDriver"
1824
    "${CMake_BINARY_DIR}/Tests/TestDriver2"
1825
    ${build_generator_args}
1826
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1827
    --build-project TestDriverTest
1828
    --test-command TestDriverTest test2
1829
    )
1830
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver2")
1831

1832
  add_test(testdriver3  ${CMAKE_CTEST_COMMAND}
1833
    --build-and-test
1834
    "${CMake_SOURCE_DIR}/Tests/TestDriver"
1835
    "${CMake_BINARY_DIR}/Tests/TestDriver3"
1836
    ${build_generator_args}
1837
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1838
    --build-project TestDriverTest
1839
    --test-command TestDriverTest subdir/test3
1840
    )
1841
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver3")
1842

1843
  add_test(testdriver4  ${CMAKE_CTEST_COMMAND}
1844
    --build-and-test
1845
    "${CMake_SOURCE_DIR}/Tests/TestDriver"
1846
    "${CMake_BINARY_DIR}/Tests/TestDriver4"
1847
    ${build_generator_args}
1848
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1849
    --build-project TestDriverTest
1850
    --test-command TestDriverTest -A test2
1851
    )
1852
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver4")
1853

1854
  add_test(testdriver5  ${CMAKE_CTEST_COMMAND}
1855
    --build-and-test
1856
    "${CMake_SOURCE_DIR}/Tests/TestDriver"
1857
    "${CMake_BINARY_DIR}/Tests/TestDriver5"
1858
    ${build_generator_args}
1859
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1860
    --build-project TestDriverTest
1861
    --test-command TestDriverTest -A test2
1862
    )
1863
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver5")
1864
  set_tests_properties(testdriver5 PROPERTIES
1865
    PASS_REGULAR_EXPRESSION
1866
    "TAP version 13\n1\\.\\.3.+ok 1 test1 # [0-9]+\\.[0-9]+.*All tests finished."
1867
    )
1868

1869
  add_test(Dependency ${CMAKE_CTEST_COMMAND}
1870
    --build-and-test
1871
    "${CMake_SOURCE_DIR}/Tests/Dependency"
1872
    "${CMake_BINARY_DIR}/Tests/Dependency"
1873
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Dependency/Exec"
1874
    ${build_generator_args}
1875
    --build-project Dependency
1876
    --test-command exec
1877
    )
1878
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Dependency")
1879

1880
  if(CMAKE_SYSTEM_NAME MATCHES syllable)
1881

1882
# RPATH isn't supported under Syllable, so the tests don't
1883
# find their libraries. In order to fix that LIBRARY_OUTPUT_DIR
1884
# in the tests would have to be adjusted to ${EXECUTABLE_OUTPUT_DIR}/lib .
1885
# For now we just require on Syllable that the user adjusts the DLL_PATH
1886
# environment variable, so except the two tests below all other tests will succeed.
1887

1888
    set(_DLL_PATH "$ENV{DLL_PATH}")
1889
    if(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.(:.*)?$")
1890
      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")
1891
    endif()
1892
    if(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.\\./lib(:.*)?$")
1893
      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")
1894
    endif()
1895

1896
  else()
1897

1898
    add_test(JumpWithLibOut  ${CMAKE_CTEST_COMMAND}
1899
      --build-and-test
1900
      "${CMake_SOURCE_DIR}/Tests/Jump"
1901
      "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut"
1902
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Executable"
1903
      --build-project Jump
1904
      ${build_generator_args}
1905
      --build-options
1906
        -DLIBRARY_OUTPUT_PATH:PATH=${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Lib
1907
      --test-command jumpExecutable
1908
      )
1909

1910
    add_test(JumpNoLibOut  ${CMAKE_CTEST_COMMAND}
1911
      --build-and-test
1912
      "${CMake_SOURCE_DIR}/Tests/Jump"
1913
      "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut"
1914
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
1915
      --build-run-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
1916
      --build-project Jump
1917
      ${build_generator_args}
1918
      --test-command jumpExecutable
1919
      )
1920
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Jump")
1921

1922
    add_test(Plugin ${CMAKE_CTEST_COMMAND}
1923
      --build-and-test
1924
      "${CMake_SOURCE_DIR}/Tests/Plugin"
1925
      "${CMake_BINARY_DIR}/Tests/Plugin"
1926
      ${build_generator_args}
1927
      --build-project Plugin
1928
      --build-two-config
1929
      --test-command bin/example)
1930
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Plugin")
1931

1932
    if(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
1933
      ADD_TEST_MACRO(RuntimePath RuntimePath)
1934
    endif()
1935
  endif()
1936

1937
  if(APPLE AND "${DARWIN_MAJOR_VERSION}" GREATER 9)
1938
    add_test(MacRuntimePath ${CMAKE_CTEST_COMMAND}
1939
      --build-and-test
1940
      "${CMake_SOURCE_DIR}/Tests/MacRuntimePath"
1941
      "${CMake_BINARY_DIR}/Tests/MacRuntimePath"
1942
      ${build_generator_args}
1943
      --build-project MacRuntimePath
1944
      --build-options
1945
        -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
1946
      )
1947
  endif()
1948

1949
  if(CMake_TEST_XCODE_VERSION AND NOT CMake_TEST_XCODE_VERSION VERSION_LESS 5)
1950
    if(NOT CMake_TEST_XCTest_DEPLOYMENT_TARGET)
1951
      execute_process(
1952
        COMMAND sw_vers -productVersion
1953
        OUTPUT_VARIABLE OSX_VERSION
1954
        OUTPUT_STRIP_TRAILING_WHITESPACE
1955
        )
1956
      if(OSX_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
1957
        set(CMake_TEST_XCTest_DEPLOYMENT_TARGET "${CMAKE_MATCH_1}")
1958
      endif()
1959
    endif()
1960
    if(CMake_TEST_XCTest_DEPLOYMENT_TARGET)
1961
      set(XCTest_CTEST_OPTIONS --build-config $<CONFIGURATION>)
1962
      set(XCTest_BUILD_OPTIONS -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMake_TEST_XCTest_DEPLOYMENT_TARGET} -DCMAKE_OSX_SYSROOT=macosx)
1963
      ADD_TEST_MACRO(XCTest ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION> -V)
1964
    endif()
1965
  endif()
1966

1967
  add_test(linkorder1 ${CMAKE_CTEST_COMMAND}
1968
    --build-and-test
1969
    "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
1970
    "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
1971
    ${build_generator_args}
1972
    --build-project LinkLineOrder
1973
    --test-command Exec1
1974
    )
1975

1976
  add_test(linkorder2  ${CMAKE_CTEST_COMMAND}
1977
    --build-and-test
1978
    "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
1979
    "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
1980
    ${build_generator_args}
1981
    --build-project LinkLineOrder
1982
    --test-command Exec2
1983
    )
1984
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkLineOrder")
1985
  set_tests_properties(qtwrapping PROPERTIES DEPENDS wrapping)
1986
  set_tests_properties(testdriver1 PROPERTIES DEPENDS qtwrapping)
1987
  set_tests_properties(testdriver2 PROPERTIES DEPENDS testdriver1)
1988
  set_tests_properties(testdriver3 PROPERTIES DEPENDS testdriver2)
1989
  set_tests_properties(linkorder2 PROPERTIES DEPENDS linkorder1)
1990

1991
  # Test static linking on toolchains known to support it.
1992
  if((CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "LCC")
1993
      AND NOT APPLE AND NOT WIN32 AND NOT CYGWIN
1994
      AND EXISTS "/usr/lib/libm.a")
1995
    add_test(LinkStatic  ${CMAKE_CTEST_COMMAND}
1996
      --build-and-test
1997
      "${CMake_SOURCE_DIR}/Tests/LinkStatic"
1998
      "${CMake_BINARY_DIR}/Tests/LinkStatic"
1999
      ${build_generator_args}
2000
      --build-project LinkStatic
2001
      --build-options
2002
        -DMATH_LIBRARY:FILEPATH=/usr/lib/libm.a
2003
      --test-command LinkStatic
2004
      )
2005
  endif()
2006

2007
  if(MAKE_SUPPORTS_SPACES
2008
      AND NOT CMAKE_GENERATOR STREQUAL "Xcode"
2009
      AND NOT CMAKE_GENERATOR STREQUAL "Watcom WMake"
2010
      )
2011
    add_test(SubDirSpaces ${CMAKE_CTEST_COMMAND}
2012
      --build-and-test
2013
      "${CMake_SOURCE_DIR}/Tests/SubDirSpaces"
2014
      "${CMake_BINARY_DIR}/Tests/SubDirSpaces"
2015
      --build-exe-dir
2016
      "${CMake_BINARY_DIR}/Tests/SubDirSpaces/Executable Sources"
2017
      ${build_generator_args}
2018
      --build-project SUBDIR
2019
      --test-command test
2020
      "${CMake_BINARY_DIR}/Tests/SubDirSpaces/ShouldBeHere"
2021
      "${CMake_BINARY_DIR}/Tests/SubDirSpaces/testfromsubdir.obj"
2022
      )
2023
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDirSpaces")
2024
  endif()
2025

2026
  if(WIN32)
2027
    add_test(SubDir ${CMAKE_CTEST_COMMAND}
2028
      --build-and-test
2029
      "${CMake_SOURCE_DIR}/Tests/SubDir"
2030
      "${CMake_BINARY_DIR}/Tests/SubDir"
2031
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
2032
      ${build_generator_args}
2033
      --build-project SUBDIR
2034
      --test-command test
2035
      "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
2036
      "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.obj"
2037
      )
2038
  else()
2039
    add_test(SubDir ${CMAKE_CTEST_COMMAND}
2040
      --build-and-test
2041
      "${CMake_SOURCE_DIR}/Tests/SubDir"
2042
      "${CMake_BINARY_DIR}/Tests/SubDir"
2043
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
2044
      ${build_generator_args}
2045
      --build-project SUBDIR
2046
      --test-command test
2047
      "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
2048
      "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.o"
2049
      )
2050
  endif()
2051
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDir")
2052

2053
  if(MSVC OR (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND CMAKE_C_SIMULATE_ID STREQUAL "MSVC"))
2054
    ADD_TEST_MACRO(PDBDirectoryAndName myexe)
2055
    if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" OR NOT "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
2056
      ADD_TEST_MACRO(ForceInclude foo)
2057
    endif()
2058
    if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" AND NOT CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
2059
      ADD_TEST_MACRO(PrecompiledHeader foo)
2060
    endif()
2061

2062
    set(MSVCDebugInformationFormat_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2063
    if(CMAKE_Fortran_COMPILER)
2064
      list(APPEND MSVCDebugInformationFormat_BUILD_OPTIONS -DCMake_TEST_Fortran=1)
2065
    endif()
2066
    ADD_TEST_MACRO(MSVCDebugInformationFormat)
2067
    set_property(TEST MSVCDebugInformationFormat APPEND
2068
      PROPERTY LABELS "CUDA" "Fortran")
2069

2070
    set(MSVCRuntimeChecks_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2071
    if(CMAKE_Fortran_COMPILER)
2072
      list(APPEND MSVCRuntimeChecks_BUILD_OPTIONS -DCMake_TEST_Fortran=1)
2073
    endif()
2074
    ADD_TEST_MACRO(MSVCRuntimeChecks)
2075
    set_property(TEST MSVCRuntimeChecks APPEND
2076
      PROPERTY LABELS "CUDA" "Fortran")
2077

2078
    set(MSVCRuntimeLibrary_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2079
    ADD_TEST_MACRO(MSVCRuntimeLibrary)
2080
    set_property(TEST MSVCRuntimeLibrary APPEND
2081
      PROPERTY LABELS "CUDA")
2082
    if(CMAKE_Fortran_COMPILER)
2083
      ADD_TEST_MACRO(MSVCRuntimeLibrary.Fortran)
2084
      set_property(TEST MSVCRuntimeLibrary.Fortran APPEND PROPERTY LABELS "Fortran")
2085
    endif()
2086
  endif()
2087
  if(MSVC OR
2088
      "${CMAKE_GENERATOR}" MATCHES "(MSYS|MinGW) Makefiles")
2089
    ADD_TEST_MACRO(ModuleDefinition example_exe)
2090
  endif()
2091

2092
  if(CMAKE_C_COMPILER_ID MATCHES "Watcom" AND WIN32)
2093
    ADD_TEST_MACRO(WatcomRuntimeLibrary)
2094
  endif()
2095

2096
  ADD_TEST_MACRO(CheckCompilerRelatedVariables CheckCompilerRelatedVariables)
2097

2098
  if("${CMAKE_GENERATOR}" MATCHES "^Ninja$|Makefile|FASTBuild")
2099
    add_test(MakeClean ${CMAKE_CTEST_COMMAND}
2100
      --build-and-test
2101
      "${CMake_SOURCE_DIR}/Tests/MakeClean"
2102
      "${CMake_BINARY_DIR}/Tests/MakeClean"
2103
      ${build_generator_args}
2104
      --build-project MakeClean
2105
      --build-exe-dir "${CMake_BINARY_DIR}/MakeClean"
2106
      --test-command check_clean
2107
      )
2108
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MakeClean")
2109
  endif()
2110

2111
  if(CMake_TEST_MFC)
2112
    add_test(MFC ${CMAKE_CTEST_COMMAND}
2113
      --build-and-test
2114
      "${CMake_SOURCE_DIR}/Tests/MFC"
2115
      "${CMake_BINARY_DIR}/Tests/MFC"
2116
      --build-two-config
2117
      ${build_generator_args}
2118
      --build-project mfc_driver
2119
      --test-command ${CMAKE_CTEST_COMMAND}
2120
        -C \${CTEST_CONFIGURATION_TYPE} -VV)
2121
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MFC")
2122
  endif()
2123

2124
  if(MSVC AND NOT MSVC_VERSION LESS 1700
2125
     AND (CMAKE_C_COMPILER_ARCHITECTURE_ID STREQUAL "ARM64")
2126
      )
2127
    ADD_TEST_MACRO(VSMARMASM VSMARMASM)
2128
  endif()
2129

2130
  if(MSVC AND NOT MSVC_VERSION LESS 1310
2131
     AND (NOT CMAKE_C_COMPILER_ARCHITECTURE_ID STREQUAL "ARM64")
2132
      )
2133
    ADD_TEST_MACRO(VSMASM VSMASM)
2134
  endif()
2135

2136
  if(CMAKE_GENERATOR MATCHES "Visual Studio")
2137
    if(NOT MSVC60)
2138
      ADD_TEST_MACRO(SBCS SBCS)
2139
    endif()
2140

2141
    if(NOT CMAKE_GENERATOR_TOOLSET STREQUAL "v90"
2142
        AND NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
2143
      ADD_TEST_MACRO(VSWindowsFormsResx VSWindowsFormsResx)
2144
      ADD_TEST_MACRO(VSManagedCustomCommand)
2145
    endif()
2146

2147
    add_test(VSExternalInclude ${CMAKE_CTEST_COMMAND}
2148
      --build-and-test
2149
      "${CMake_SOURCE_DIR}/Tests/VSExternalInclude"
2150
      "${CMake_BINARY_DIR}/Tests/VSExternalInclude"
2151
      --build-two-config
2152
      ${build_generator_args}
2153
      --build-project VSExternalInclude
2154
      --test-command VSExternalInclude)
2155
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExternalInclude")
2156

2157
    add_test(VSMidl ${CMAKE_CTEST_COMMAND}
2158
      --build-and-test
2159
      "${CMake_SOURCE_DIR}/Tests/VSMidl"
2160
      "${CMake_BINARY_DIR}/Tests/VSMidl"
2161
      --build-two-config
2162
      ${build_generator_args}
2163
      --build-project VSMidl
2164
      --test-command VSMidl)
2165
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSMidl")
2166

2167
    if(CMake_TEST_DEVENV)
2168
      # The test (and tested property) works with .sln files, so it's skipped when:
2169
      # * cmake --build is set up to use MSBuild, since the MSBuild invocation does not use the .sln file
2170
      set(_last_test "")
2171
      foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES)
2172
        add_test(NAME VSExcludeFromDefaultBuild-${config} COMMAND ${CMAKE_CTEST_COMMAND}
2173
          --build-and-test
2174
          "${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild"
2175
          "${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
2176
          --build-config ${config}
2177
          --build-two-config
2178
          --build-generator ${CMAKE_GENERATOR}
2179
          --build-makeprogram ${CMake_TEST_DEVENV}
2180
          --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
2181
          --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
2182
          --build-project VSExcludeFromDefaultBuild
2183
          --build-target install
2184
          --test-command ${CMAKE_COMMAND}
2185
             -D "activeConfig=${config}"
2186
             -D "allConfigs=${CMAKE_CONFIGURATION_TYPES}"
2187
             -D "dir=${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
2188
             -P "${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild/ResultTest.cmake")
2189
        if(_last_test)
2190
          set_property(TEST VSExcludeFromDefaultBuild-${config} PROPERTY DEPENDS ${_last_test})
2191
        endif()
2192
        set(_last_test "VSExcludeFromDefaultBuild-${config}")
2193
      endforeach()
2194
      unset(_last_test)
2195
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild")
2196
    endif()
2197

2198
    add_test(NAME VSProjectInSubdir COMMAND ${CMAKE_CTEST_COMMAND}
2199
      --build-and-test
2200
      "${CMake_SOURCE_DIR}/Tests/VSProjectInSubdir"
2201
      "${CMake_BINARY_DIR}/Tests/VSProjectInSubdir"
2202
      --build-two-config
2203
      --build-generator ${CMAKE_GENERATOR}
2204
      --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
2205
      --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
2206
      --build-project VSProjectInSubdir
2207
      --build-target test)
2208
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSProjectInSubdir")
2209
  endif()
2210

2211
  get_filename_component(ntver "[HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows NT\\CurrentVersion;CurrentVersion]" NAME)
2212
  if(WIN32 AND ntver VERSION_GREATER 6.1) # Windows >= 8.0
2213
    macro(add_test_VSWinStorePhone name generator systemName systemVersion architecture)
2214
      add_test(NAME VSWinStorePhone.${name} COMMAND ${CMAKE_CTEST_COMMAND}
2215
        --build-and-test
2216
        "${CMake_SOURCE_DIR}/Tests/VSWinStorePhone"
2217
        "${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}"
2218
        --build-generator "${generator}"
2219
        --build-generator-platform "${architecture}"
2220
        --build-project VSWinStorePhone
2221
        --build-config $<CONFIGURATION>
2222
        --build-options -DCMAKE_SYSTEM_NAME=${systemName}
2223
                        -DCMAKE_SYSTEM_VERSION=${systemVersion}
2224
        --test-command
2225
          ${CMAKE_CMAKE_COMMAND} -DAPP_PACKAGE_DIR="${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}"
2226
                                 -P "${CMake_SOURCE_DIR}/Tests/VSWinStorePhone/VerifyAppPackage.cmake"
2227
        )
2228
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}")
2229
    endmacro()
2230

2231
    # FIXME(#26248): Update this test to work with newer VS and Win 10.0.
2232
    # It previously ran with Visual Studio 12 2013 targeting Win 8.1.
2233
    if(FALSE AND CMAKE_GENERATOR MATCHES "Visual Studio")
2234
      add_test(NAME VSXaml COMMAND ${CMAKE_CTEST_COMMAND}
2235
        --build-and-test
2236
          "${CMake_SOURCE_DIR}/Tests/VSXaml"
2237
          "${CMake_BINARY_DIR}/Tests/VSXaml"
2238
          --build-generator "${CMAKE_GENERATOR}"
2239
          --build-project VSXaml
2240
          --build-config $<CONFIGURATION>
2241
          --build-options -DCMAKE_SYSTEM_NAME=WindowsStore
2242
                          -DCMAKE_SYSTEM_VERSION=10.0
2243
        )
2244
    endif()
2245

2246
    if(CMake_TEST_VSWinStorePhone_VS_2017 AND ws10_0)
2247
      add_test_VSWinStorePhone(vs15-store10_0-X86 "Visual Studio 15 2017" WindowsStore 10.0 Win32)
2248
      add_test_VSWinStorePhone(vs15-store10_0-ARM "Visual Studio 15 2017" WindowsStore 10.0 ARM)
2249
      add_test_VSWinStorePhone(vs15-store10_0-X64 "Visual Studio 15 2017" WindowsStore 10.0 x64)
2250
      add_test_VSWinStorePhone(vs15-store10_0-ARM64 "Visual Studio 15 2017" WindowsStore 10.0 ARM64)
2251
    endif()
2252
    if(vs14 AND ws10_0)
2253
      add_test_VSWinStorePhone(vs14-store10_0-X86 "Visual Studio 14 2015" WindowsStore 10.0 Win32)
2254
      add_test_VSWinStorePhone(vs14-store10_0-ARM "Visual Studio 14 2015" WindowsStore 10.0 ARM)
2255
      add_test_VSWinStorePhone(vs14-store10_0-X64 "Visual Studio 14 2015" WindowsStore 10.0 x64)
2256
    endif()
2257
  endif()
2258

2259
  if(CMAKE_GENERATOR MATCHES "Visual Studio" AND nasm)
2260
    ADD_TEST_MACRO(VSNASM VSNASM)
2261
  endif()
2262

2263
  if(CMake_TEST_GreenHillsMULTI)
2264
    macro(add_test_GhsMulti test_name test_dir bin_sub_dir build_opts)
2265
      separate_arguments(_ghs_build_opts UNIX_COMMAND ${build_opts})
2266
      separate_arguments(_ghs_toolset_extra UNIX_COMMAND ${ghs_toolset_extra})
2267
      if(${ARGC} GREATER 4)
2268
        set(_ghs_test_command --test-command ${ARGN})
2269
      endif()
2270
      if(ghs_config_name STREQUAL "__default__")
2271
        set(_ghs_test_name "${test_name}")
2272
      else()
2273
        set(_ghs_test_name "${ghs_config_name}.${test_name}")
2274
      endif()
2275
      add_test(NAME GhsMulti.${_ghs_test_name}
2276
        COMMAND ${CMAKE_CTEST_COMMAND}
2277
        --build-and-test
2278
        "${CMake_SOURCE_DIR}/Tests/GhsMulti/${test_dir}"
2279
        "${CMake_BINARY_DIR}/Tests/GhsMulti/${ghs_config_name}/${test_dir}/${bin_sub_dir}"
2280
        --build-generator "Green Hills MULTI"
2281
        --build-project test
2282
        --build-config $<CONFIGURATION>
2283
        --build-options ${ghs_target_arch} ${ghs_toolset_name} ${ghs_toolset_root} ${ghs_target_platform}
2284
          ${ghs_os_root} ${ghs_os_dir} ${ghs_bsp_name} ${_ghs_build_opts} ${_ghs_toolset_extra}
2285
          ${_ghs_test_command}
2286
        )
2287
        unset(_ghs_build_opts)
2288
        unset(_ghs_toolset_extra)
2289
        unset(_ghs_test_command)
2290
        unset(_ghs_test_name)
2291
    endmacro()
2292
    macro(add_test_GhsMulti_rename_install test_name)
2293
      add_test_GhsMulti( ${test_name} GhsMultiRenameInstall ${test_name}
2294
        "-DCMAKE_INSTALL_PREFIX=. -DRUN_TEST=${test_name}" ${CMAKE_CMAKE_COMMAND} --build . --target INSTALL)
2295
    endmacro()
2296
    #unset ghs config variables
2297
    unset(ghs_config_name)
2298
    unset(ghs_target_arch)
2299
    unset(ghs_toolset_root)
2300
    unset(ghs_toolset_name)
2301
    unset(ghs_os_root)
2302
    unset(ghs_os_dir)
2303
    unset(ghs_target_platform)
2304
    unset(ghs_bsp_name)
2305
    unset(ghs_toolset_extra)
2306
    if(NOT CMake_TEST_GreenHillsMULTI_config)
2307
      #if list of config settings not defined then just run once as default
2308
      set(CMake_TEST_GreenHillsMULTI_config "__default__")
2309
    endif()
2310
    foreach(ghs_file IN LISTS CMake_TEST_GreenHillsMULTI_config)
2311
      # source GHS tools config file
2312
      if(NOT ghs_file STREQUAL "__default__")
2313
        if(IS_ABSOLUTE ${ghs_file})
2314
          include(${ghs_file})
2315
        else()
2316
          include(${CMAKE_BINARY_DIR}/${ghs_file})
2317
        endif()
2318
      endif()
2319
      if(NOT ghs_config_name)
2320
        set(ghs_config_name "__default__")
2321
      endif()
2322
      # test integrity build
2323
      if(NOT ghs_skip_integrity AND (NOT ghs_target_platform OR ghs_target_platform MATCHES "integrity"))
2324
        add_test_GhsMulti(integrityDDInt GhsMultiIntegrity/GhsMultiIntegrityDDInt "" "")
2325
        add_test_GhsMulti(integrityMonolith GhsMultiIntegrity/GhsMultiIntegrityMonolith "" "")
2326
        add_test_GhsMulti(integrityDD GhsMultiIntegrity/GhsMultiIntegrityDD "" "")
2327
      endif()
2328
      add_test_GhsMulti(duplicate_source_filenames GhsMultiDuplicateSourceFilenames "" "")
2329
      add_test_GhsMulti_rename_install(SINGLE_EXEC)
2330
      add_test_GhsMulti_rename_install(SINGLE_EXEC_RENAMED)
2331
      add_test_GhsMulti_rename_install(EXEC_AND_LIB)
2332
      add_test_GhsMulti(multiple_source_groups GhsMultiSrcGroups Default "")
2333
      add_test_GhsMulti(multiple_source_groups_folders GhsMultiSrcGroups PropFolders "-DTEST_PROP=ON")
2334
      add_test_GhsMulti(multiple_source_groups_all_folders GhsMultiSrcGroups AllFolders "-DCMAKE_GHS_NO_SOURCE_GROUP_FILE=ON")
2335
      add_test_GhsMulti(unsupported_targets GhsMultiUnsupportedTargets "" "")
2336
      add_test_GhsMulti(object_library GhsMultiObjectLibrary "" "")
2337
      add_test_GhsMulti(exclude GhsMultiExclude "" ""
2338
        ${CMAKE_CMAKE_COMMAND} -P ${CMake_SOURCE_DIR}/Tests/GhsMulti/GhsMultiExclude/verify.cmake)
2339
      add_test_GhsMulti(interface GhsMultiInterface "" "")
2340
      add_test_GhsMulti(transitive_link_test GhsMultiLinkTest TransitiveLink "-DRUN_TEST=NO_FLAGS")
2341
      add_test_GhsMulti(flags_link_test GhsMultiLinkTest FlagsCheck "-DRUN_TEST=CHECK_FLAGS")
2342
      add_test_GhsMulti(sub_link_test GhsMultiLinkTestSub "" "")
2343
      add_test_GhsMulti(multiple_projects GhsMultiMultipleProjects "" ""
2344
        ${CMAKE_CMAKE_COMMAND} -P ${CMake_SOURCE_DIR}/Tests/GhsMulti/GhsMultiMultipleProjects/verify.cmake)
2345
      add_test_GhsMulti(compiler_options_none GhsMultiCompilerOptions None "-DRUN_TEST=RELEASE_FLAGS -DRUN_TEST_BUILD_TYPE=\"\"")
2346
      add_test_GhsMulti(compiler_options_kernel GhsMultiCompilerOptions Kernel "-DRUN_TEST=KERNEL_FLAGS -DRUN_TEST_BUILD_TYPE=DEBUG")
2347
      add_test_GhsMulti(try_compile_copy GhsMultiCopyFile "" "")
2348
      add_test_GhsMulti(ghs_platform GhsMultiPlatform "" "")
2349
      add_test_GhsMulti(custom_target GhsMultiCustomTarget "" "")
2350
      add_test_GhsMulti(dep_order GhsMultiDepOrder "" "")
2351
      add_test_GhsMulti(external_project GhsMultiExternalProject "" "")
2352
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/GhsMulti/${ghs_config_name}")
2353
      #unset ghs config variables
2354
      unset(ghs_config_name)
2355
      unset(ghs_target_arch)
2356
      unset(ghs_toolset_root)
2357
      unset(ghs_toolset_name)
2358
      unset(ghs_os_root)
2359
      unset(ghs_os_dir)
2360
      unset(ghs_target_platform)
2361
      unset(ghs_bsp_name)
2362
      unset(ghs_toolset_extra)
2363
    endforeach()
2364
  endif()
2365

2366
  macro(add_test_VSAndroid name generator platform)
2367
    add_test(NAME "VSAndroid.${name}.${platform}" COMMAND ${CMAKE_CTEST_COMMAND}
2368
      --build-and-test
2369
      "${CMake_SOURCE_DIR}/Tests/VSAndroid"
2370
      "${CMake_BINARY_DIR}/Tests/VSAndroid/${name}/${platform}"
2371
      --build-generator "${generator}"
2372
      --build-project VSAndroid
2373
      --build-config $<CONFIGURATION>
2374
      --build-options -DCMAKE_SYSTEM_NAME=Android "-A${platform}"
2375
      )
2376
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSAndroid/${name}")
2377
  endmacro()
2378
  if(tegra AND NOT "${CMake_SOURCE_DIR};${CMake_BINARY_DIR}" MATCHES " ")
2379
    if(vs14)
2380
      add_test_VSAndroid(vs14 "Visual Studio 14 2015" "Tegra-Android")
2381
    endif()
2382
  endif()
2383
  if(vs14 AND CMake_TEST_ANDROID_VS14)
2384
    add_test_VSAndroid(vs14 "Visual Studio 14 2015" "ARM")
2385
  endif()
2386
  if(vs15 AND CMake_TEST_ANDROID_VS15)
2387
    add_test_VSAndroid(vs15 "Visual Studio 15 2017" "ARM")
2388
  endif()
2389
  if(vs16 AND CMake_TEST_ANDROID_VS16)
2390
    add_test_VSAndroid(vs16 "Visual Studio 16 2019" "ARM")
2391
  endif()
2392
  if(vs17 AND CMake_TEST_ANDROID_VS17)
2393
    add_test_VSAndroid(vs17 "Visual Studio 17 2022" "ARM")
2394
  endif()
2395
  if(vs18 AND CMake_TEST_ANDROID_VS18)
2396
    add_test_VSAndroid(vs18 "Visual Studio 18 2026" "ARM")
2397
  endif()
2398

2399
  if(APPLE)
2400
    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
2401
      set(BundleTestInstallDir
2402
        "${CMake_BINARY_DIR}/Tests/BundleTest/InstallDirectory")
2403
      add_test(BundleTest ${CMAKE_CTEST_COMMAND}
2404
        --build-and-test
2405
        "${CMake_SOURCE_DIR}/Tests/BundleTest"
2406
        "${CMake_BINARY_DIR}/Tests/BundleTest"
2407
        --build-two-config
2408
        ${build_generator_args}
2409
        --build-project BundleTest
2410
        --build-target install
2411
#       --build-target package
2412
        --build-options
2413
        "-DCMAKE_INSTALL_PREFIX:PATH=${BundleTestInstallDir}"
2414
        "-DCMake_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}"
2415
        --test-command
2416
        ${BundleTestInstallDir}/Applications/SecondBundleExe.app/Contents/MacOS/SecondBundleExe)
2417
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleTest")
2418

2419
      add_test(NAME CFBundleTest COMMAND ${CMAKE_CTEST_COMMAND}
2420
        --build-and-test
2421
        "${CMake_SOURCE_DIR}/Tests/CFBundleTest"
2422
        "${CMake_BINARY_DIR}/Tests/CFBundleTest"
2423
        --build-two-config
2424
        ${build_generator_args}
2425
        --build-project CFBundleTest
2426
        --build-config $<CONFIGURATION>
2427
        --test-command
2428
        ${CMAKE_CMAKE_COMMAND} -DCTEST_CONFIGURATION_TYPE=$<CONFIGURATION>
2429
        -Ddir=${CMake_BINARY_DIR}/Tests/CFBundleTest
2430
        -Dgen=${CMAKE_GENERATOR}
2431
        -P ${CMake_SOURCE_DIR}/Tests/CFBundleTest/VerifyResult.cmake)
2432
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CFBundleTest")
2433
    endif()
2434
  endif()
2435

2436
  if(APPLE AND CTEST_TEST_CPACK)
2437
    add_test(BundleGeneratorTest ${CMAKE_CTEST_COMMAND}
2438
      --build-and-test
2439
      "${CMake_SOURCE_DIR}/Tests/BundleGeneratorTest"
2440
      "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest"
2441
      --build-two-config
2442
      ${build_generator_args}
2443
      --build-project BundleGeneratorTest
2444
      --build-target package
2445
      --build-options
2446
        "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/BundleGeneratorTest/InstallDirectory"
2447
      )
2448
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest")
2449
  endif()
2450

2451
  add_test(WarnUnusedCliUnused ${CMAKE_CTEST_COMMAND}
2452
    --build-and-test
2453
    "${CMake_SOURCE_DIR}/Tests/WarnUnusedCliUnused"
2454
    "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused"
2455
    ${build_generator_args}
2456
    --build-project WarnUnusedCliUnused
2457
    --build-options
2458
      "-DUNUSED_CLI_VARIABLE=Unused")
2459
  set_tests_properties(WarnUnusedCliUnused PROPERTIES
2460
    PASS_REGULAR_EXPRESSION "CMake Warning:.*Manually-specified variables were not used by the project:.*  UNUSED_CLI_VARIABLE")
2461
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused")
2462

2463
  add_test(WarnUnusedCliUsed ${CMAKE_CTEST_COMMAND}
2464
    --build-and-test
2465
    "${CMake_SOURCE_DIR}/Tests/VariableUsage"
2466
    "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed"
2467
    ${build_generator_args}
2468
    --build-noclean
2469
    --build-project WarnUnusedCliUsed
2470
    --build-options
2471
      "-DUSED_VARIABLE=Usage proven")
2472
  set_tests_properties(WarnUnusedCliUsed PROPERTIES
2473
    PASS_REGULAR_EXPRESSION "Usage proven")
2474
  set_tests_properties(WarnUnusedCliUsed PROPERTIES
2475
    FAIL_REGULAR_EXPRESSION "CMake Warning: The variable, 'USED_VARIABLE'")
2476
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed")
2477

2478
  add_test(WarnUninitialized ${CMAKE_CTEST_COMMAND}
2479
    --build-and-test
2480
    "${CMake_SOURCE_DIR}/Tests/VariableUsage"
2481
    "${CMake_BINARY_DIR}/Tests/WarnUninitialized"
2482
    ${build_generator_args}
2483
    --build-noclean
2484
    --build-project WarnUninitialized
2485
    --build-options
2486
      "--warn-uninitialized")
2487
  set_tests_properties(WarnUninitialized PROPERTIES
2488
    PASS_REGULAR_EXPRESSION "uninitialized variable 'USED_VARIABLE'")
2489
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUninitialized")
2490

2491
  add_test(TestsWorkingDirectory
2492
    ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
2493
    --build-and-test
2494
    "${CMake_SOURCE_DIR}/Tests/TestsWorkingDirectory"
2495
    "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
2496
    ${build_generator_args}
2497
    --build-project TestsWorkingDirectoryProj
2498
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
2499
    --test-command ${CMAKE_CTEST_COMMAND} -V -C \${CTEST_CONFIGURATION_TYPE}
2500
    )
2501
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory")
2502

2503
  # Make sure CTest can handle a test with no newline in output.
2504
  add_test(CTest.NoNewline
2505
    ${CMAKE_CMAKE_COMMAND} -E echo_append "This line has no newline!")
2506

2507
  # A simple test for ctest in script mode
2508
  configure_file("${CMake_SOURCE_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake.in"
2509
          "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake" @ONLY)
2510
  add_test(CTest.ScriptMode ${CMAKE_CTEST_COMMAND}
2511
    -S "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake"
2512
    )
2513

2514
  # Test CTest Update with Subversion
2515
  if(NOT DEFINED CMake_TEST_CTestUpdate_SVN OR CMake_TEST_CTestUpdate_SVN)
2516
    find_package(Subversion QUIET)
2517
    if(Subversion_FOUND)
2518
      get_filename_component(_Subversion_BIN_DIR
2519
        ${Subversion_SVN_EXECUTABLE} PATH)
2520
      find_program(Subversion_SVNADMIN_EXECUTABLE svnadmin
2521
        HINTS ${_Subversion_BIN_DIR}
2522
        )
2523
      mark_as_advanced(Subversion_SVNADMIN_EXECUTABLE)
2524
      if(NOT Subversion_SVNADMIN_EXECUTABLE)
2525
        set(Subversion_FOUND FALSE)
2526
      endif()
2527
    endif()
2528
  endif()
2529
  if(NOT DEFINED CMake_TEST_CTestUpdate_SVN AND Subversion_FOUND)
2530
    set(CMake_TEST_CTestUpdate_SVN 1)
2531
  endif()
2532
  if(CMake_TEST_CTestUpdate_SVN)
2533
    if(NOT Subversion_FOUND)
2534
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_SVN enabled but Subversion is not found.")
2535
    endif()
2536
    set(CTestUpdateSVN_DIR "CTest UpdateSVN")
2537
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateSVN.cmake.in"
2538
      "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake" @ONLY)
2539
    add_test(CTest.UpdateSVN ${CMAKE_CMAKE_COMMAND}
2540
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake"
2541
      )
2542
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateSVN_DIR}")
2543
  endif()
2544

2545
  # Test CTest Update with CVS
2546
  if(NOT DEFINED CMake_TEST_CTestUpdate_CVS OR CMake_TEST_CTestUpdate_CVS)
2547
    find_program(CVS_EXECUTABLE NAMES cvs)
2548
    mark_as_advanced(CVS_EXECUTABLE)
2549
  endif()
2550
  if(NOT DEFINED CMake_TEST_CTestUpdate_CVS AND CVS_EXECUTABLE
2551
      AND (UNIX OR NOT "${CVS_EXECUTABLE}" MATCHES "cygwin"))
2552
    set(CMake_TEST_CTestUpdate_CVS 1)
2553
  endif()
2554
  if(CMake_TEST_CTestUpdate_CVS)
2555
    if(NOT CVS_EXECUTABLE)
2556
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_CVS enabled but CVS_EXECUTABLE is not found.")
2557
    endif()
2558
    set(CTestUpdateCVS_DIR "CTest UpdateCVS")
2559
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateCVS.cmake.in"
2560
      "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake" @ONLY)
2561
    add_test(CTest.UpdateCVS ${CMAKE_CMAKE_COMMAND}
2562
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake"
2563
      )
2564
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateCVS_DIR}")
2565
  endif()
2566

2567
  # Test CTest Update with BZR
2568
  if(CMake_TEST_CTestUpdate_BZR)
2569
    if(TEST_HOME)
2570
      file(MAKE_DIRECTORY "${TEST_HOME}/.bazaar")
2571
    endif()
2572
    find_program(BZR_EXECUTABLE NAMES bzr)
2573
    mark_as_advanced(BZR_EXECUTABLE)
2574
    if(NOT BZR_EXECUTABLE)
2575
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_BZR enabled but BZR_EXECUTABLE is not found.")
2576
    endif()
2577
    set(CTestUpdateBZR_DIR "CTest UpdateBZR")
2578
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
2579
      "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake" @ONLY)
2580
    add_test(CTest.UpdateBZR ${CMAKE_CMAKE_COMMAND}
2581
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake"
2582
      )
2583
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
2584
    set(CTestUpdateBZR_DIR "CTest UpdateBZR_CLocale")
2585
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
2586
      "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake" @ONLY)
2587
    add_test(CTest.UpdateBZR.CLocale ${CMAKE_CMAKE_COMMAND}
2588
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake"
2589
      )
2590
    set_tests_properties(CTest.UpdateBZR.CLocale PROPERTIES ENVIRONMENT LC_ALL=C)
2591
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
2592
  endif()
2593

2594
  # Test CTest Update with GIT
2595
  if(NOT DEFINED CMake_TEST_CTestUpdate_GIT AND GIT_EXECUTABLE
2596
      AND (UNIX OR NOT "${GIT_EXECUTABLE}" MATCHES "cygwin"))
2597
    set(CMake_TEST_CTestUpdate_GIT 1)
2598
  endif()
2599
  if(CMake_TEST_CTestUpdate_GIT)
2600
    if(NOT GIT_EXECUTABLE)
2601
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_GIT enabled but GIT_EXECUTABLE is not found.")
2602
    endif()
2603
    set(CTestUpdateGIT_DIR "CTest UpdateGIT")
2604
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateGIT.cmake.in"
2605
      "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake" @ONLY)
2606
    add_test(CTest.UpdateGIT ${CMAKE_CMAKE_COMMAND}
2607
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake"
2608
      )
2609
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateGIT_DIR}")
2610
    set_property(TEST CTest.UpdateGIT PROPERTY ENVIRONMENT GIT_ALLOW_PROTOCOL=file)
2611
  endif()
2612

2613
  # Test CTest Update with HG
2614
  if(NOT DEFINED CMake_TEST_CTestUpdate_HG OR CMake_TEST_CTestUpdate_HG)
2615
    find_program(HG_EXECUTABLE NAMES hg)
2616
    mark_as_advanced(HG_EXECUTABLE)
2617
  endif()
2618
  if(NOT DEFINED CMake_TEST_CTestUpdate_HG AND HG_EXECUTABLE
2619
      AND (UNIX OR NOT "${HG_EXECUTABLE}" MATCHES "cygwin"))
2620
    execute_process(COMMAND "${HG_EXECUTABLE}" --version OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE HG_RV)
2621
    if(HG_RV EQUAL 0)
2622
      set(CMake_TEST_CTestUpdate_HG 1)
2623
    endif()
2624
  endif()
2625
  if(CMake_TEST_CTestUpdate_HG)
2626
    if(NOT HG_EXECUTABLE)
2627
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_HG enabled but HG_EXECUTABLE is not found.")
2628
    endif()
2629
    set(CTestUpdateHG_DIR "CTest UpdateHG")
2630
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateHG.cmake.in"
2631
      "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake" @ONLY)
2632
    add_test(CTest.UpdateHG ${CMAKE_CMAKE_COMMAND}
2633
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake"
2634
      )
2635
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateHG_DIR}")
2636
  endif()
2637

2638
  # Test CTest Update with P4
2639
  if(CMake_TEST_CTestUpdate_P4)
2640
    find_program(P4_EXECUTABLE NAMES p4)
2641
    find_program(P4D_EXECUTABLE NAMES p4d)
2642
    mark_as_advanced(P4_EXECUTABLE P4D_EXECUTABLE)
2643
    if(NOT P4_EXECUTABLE OR NOT P4D_EXECUTABLE)
2644
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_HG enabled but P4_EXECUTABLE and P4D_EXECUTABLE are not both not found.")
2645
    endif()
2646
    set(CTestUpdateP4_DIR "CTest UpdateP4")
2647
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateP4.cmake.in"
2648
      "${CMake_BINARY_DIR}/Tests/CTestUpdateP4.cmake" @ONLY)
2649
    add_test(CTest.UpdateP4 ${CMAKE_CMAKE_COMMAND}
2650
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateP4.cmake"
2651
      )
2652
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateP4_DIR}")
2653
  endif()
2654

2655
  if(NOT CMake_TEST_NO_NETWORK)
2656
    configure_file(
2657
      "${CMake_SOURCE_DIR}/Tests/CTestTestUpload/test.cmake.in"
2658
      "${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake"
2659
      @ONLY ESCAPE_QUOTES)
2660
    add_test(CTestTestUpload ${CMAKE_CTEST_COMMAND}
2661
      -S "${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake" -V
2662
      --output-log "${CMake_BINARY_DIR}/Tests/CTestTestUpload/testOut.log"
2663
      )
2664
    set_tests_properties(CTestTestUpload PROPERTIES
2665
      PASS_REGULAR_EXPRESSION "Upload\\.xml")
2666
  endif()
2667

2668
  configure_file(
2669
    "${CMake_SOURCE_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake.in"
2670
    "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake"
2671
    @ONLY ESCAPE_QUOTES)
2672
  add_test(CTestCoverageCollectGCOV ${CMAKE_CTEST_COMMAND}
2673
    -C \${CTEST_CONFIGURATION_TYPE}
2674
    -S "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake" -VV
2675
    --output-log "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/testOut.log"
2676
    )
2677

2678
  configure_file(
2679
    "${CMake_SOURCE_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake.in"
2680
    "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake"
2681
    @ONLY ESCAPE_QUOTES)
2682
  add_test(CTestTestEmptyBinaryDirectory ${CMAKE_CTEST_COMMAND}
2683
    -S "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake" -V
2684
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/testOut.log"
2685
    )
2686
  set_tests_properties(CTestTestEmptyBinaryDirectory PROPERTIES
2687
    PASS_REGULAR_EXPRESSION "TEST_SUCCESS")
2688

2689
  # test coverage for mumps
2690
  # create a MumpsCoverage dir in the binary tree under Testing to
2691
  # avoid the .NoDartCoverage files in the cmake testing tree
2692
  configure_file(
2693
     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.tcl.in"
2694
     "${CMake_BINARY_DIR}/Testing/MumpsCoverage/DartConfiguration.tcl")
2695
  configure_file(
2696
     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/gtm_coverage.mcov.in"
2697
     "${CMake_BINARY_DIR}/Testing/MumpsCoverage/gtm_coverage.mcov")
2698
  file(REMOVE_RECURSE "${CMake_BINARY_DIR}/Testing/MumpsCoverage/VistA-FOIA")
2699
  file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
2700
    DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCoverage")
2701
  add_test(NAME CTestGTMCoverage
2702
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2703
    ${CMake_BINARY_DIR}/Testing/MumpsCoverage
2704
    $<TARGET_FILE:ctest> -T Coverage --debug)
2705
  set_tests_properties(CTestGTMCoverage PROPERTIES
2706
      PASS_REGULAR_EXPRESSION
2707
      "Process file.*ZZCOVTST.m.*Total LOC:.*32.*Percentage Coverage: 81.25*"
2708
      ENVIRONMENT COVFILE=)
2709

2710
  configure_file(
2711
     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.cache.tcl.in"
2712
     "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/DartConfiguration.tcl")
2713
  configure_file(
2714
    "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/cache_coverage.cmcov.in"
2715
    "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/cache_coverage.cmcov")
2716
  file(REMOVE_RECURSE "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/VistA-FOIA")
2717
  file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
2718
    DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage")
2719
  add_test(NAME CTestCacheCoverage
2720
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2721
    ${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage
2722
    $<TARGET_FILE:ctest> -T Coverage --debug)
2723
  set_tests_properties(CTestCacheCoverage PROPERTIES
2724
      PASS_REGULAR_EXPRESSION
2725
      "Process file.*ZZCOVTST.m.*Total LOC:.*32.*Percentage Coverage: 87.50.*"
2726
      ENVIRONMENT COVFILE=)
2727

2728
  # Adding a test case for Python Coverage
2729
  configure_file(
2730
     "${CMake_SOURCE_DIR}/Tests/PythonCoverage/coverage.xml.in"
2731
     "${CMake_BINARY_DIR}/Testing/PythonCoverage/coverage.xml")
2732
  configure_file(
2733
     "${CMake_SOURCE_DIR}/Tests/PythonCoverage/DartConfiguration.tcl.in"
2734
     "${CMake_BINARY_DIR}/Testing/PythonCoverage/DartConfiguration.tcl")
2735
  file(COPY "${CMake_SOURCE_DIR}/Tests/PythonCoverage/coveragetest"
2736
    DESTINATION "${CMake_BINARY_DIR}/Testing/PythonCoverage")
2737
  add_test(NAME CTestPythonCoverage
2738
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2739
    ${CMake_BINARY_DIR}/Testing/PythonCoverage
2740
    $<TARGET_FILE:ctest> -T Coverage --debug)
2741
  set_tests_properties(CTestPythonCoverage PROPERTIES
2742
      PASS_REGULAR_EXPRESSION
2743
      "Process file.*foo.py.*Total LOC:.*13.*Percentage Coverage: 84.62.*"
2744
      ENVIRONMENT COVFILE=)
2745

2746
  # Adding a test case for non-python Cobertura Coverage
2747
  configure_file(
2748
     "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/DartConfiguration.tcl.in"
2749
     "${CMake_BINARY_DIR}/Testing/CoberturaCoverage/DartConfiguration.tcl")
2750
  configure_file(
2751
     "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/coverage.xml.in"
2752
     "${CMake_BINARY_DIR}/Testing/CoberturaCoverage/coverage.xml")
2753
  file(COPY "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/src"
2754
    DESTINATION "${CMake_BINARY_DIR}/Testing/CoberturaCoverage")
2755
  add_test(NAME CTestCoberturaCoverage
2756
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2757
    ${CMake_BINARY_DIR}/Testing/CoberturaCoverage
2758
    $<TARGET_FILE:ctest> -T Coverage --debug)
2759
  set_tests_properties(CTestCoberturaCoverage PROPERTIES
2760
      PASS_REGULAR_EXPRESSION
2761
      "Process file.*CoverageTest.java.*Total LOC:.*18.*Percentage Coverage: 72.22.*"
2762
      ENVIRONMENT COBERTURADIR=${CMake_BINARY_DIR}/Testing/CoberturaCoverage
2763
      ENVIRONMENT COVFILE=)
2764

2765

2766
  # Adding a test case for JaCoCo Coverage
2767
  configure_file(
2768
     "${CMake_SOURCE_DIR}/Tests/JacocoCoverage/DartConfiguration.tcl.in"
2769
     "${CMake_BINARY_DIR}/Testing/JacocoCoverage/DartConfiguration.tcl")
2770
  file(COPY "${CMake_SOURCE_DIR}/Tests/JacocoCoverage/Coverage"
2771
    DESTINATION "${CMake_BINARY_DIR}/Testing/JacocoCoverage")
2772
  configure_file("${CMake_BINARY_DIR}/Testing/JacocoCoverage/Coverage/target/site/jacoco.xml.in"
2773
    "${CMake_BINARY_DIR}/Testing/JacocoCoverage/Coverage/target/site/jacoco.xml")
2774
  add_test(NAME CTestJacocoCoverage
2775
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2776
    ${CMake_BINARY_DIR}/Testing/JacocoCoverage
2777
    $<TARGET_FILE:ctest> -T Coverage --debug)
2778
  set_tests_properties(CTestJacocoCoverage PROPERTIES
2779
      PASS_REGULAR_EXPRESSION
2780
      "Process file.*CoverageTest.java.*Total LOC:.*17.*Percentage Coverage: 76.47*"
2781
      ENVIRONMENT COVFILE=)
2782

2783
  # Adding a test case for Javascript Coverage
2784
  configure_file(
2785
     "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/DartConfiguration.tcl.in"
2786
     "${CMake_BINARY_DIR}/Testing/JavascriptCoverage/DartConfiguration.tcl")
2787
  configure_file(
2788
     "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/output.json.in"
2789
     "${CMake_BINARY_DIR}/Testing/JavascriptCoverage/output.json")
2790
  file(COPY "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/"
2791
    DESTINATION "${CMake_BINARY_DIR}/Testing/JavascriptCoverage"
2792
    FILES_MATCHING PATTERN "*.js")
2793
  add_test(NAME CTestJavascriptCoverage
2794
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2795
    ${CMake_BINARY_DIR}/Testing/JavascriptCoverage
2796
    $<TARGET_FILE:ctest> -T Coverage --debug)
2797
  set_tests_properties(CTestJavascriptCoverage PROPERTIES
2798
      PASS_REGULAR_EXPRESSION
2799
      "Process file.*test3.js.*Total LOC:.*49.*Percentage Coverage: 79.59*"
2800
      ENVIRONMENT COVFILE=)
2801

2802
  # test coverage for Delphi-code-Coverage
2803
  configure_file(
2804
     "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/DartConfiguration.tcl.in"
2805
     "${CMake_BINARY_DIR}/Testing/DelphiCoverage/DartConfiguration.tcl")
2806
  file(COPY "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/src"
2807
    DESTINATION "${CMake_BINARY_DIR}/Testing/DelphiCoverage")
2808
  configure_file(
2809
    "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html.in"
2810
    "${CMake_BINARY_DIR}/Testing/DelphiCoverage/UTCovTest(UTCovTest.pas).html")
2811
  add_test(NAME CTestDelphiCoverage
2812
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2813
    ${CMake_BINARY_DIR}/Testing/DelphiCoverage
2814
    $<TARGET_FILE:ctest> -T Coverage --debug)
2815
  set_tests_properties(CTestDelphiCoverage PROPERTIES
2816
      PASS_REGULAR_EXPRESSION
2817
      "Process file.*UTCovTest.pas.*Total LOC:.*20.*Percentage Coverage: 95.*"
2818
      ENVIRONMENT COVFILE=)
2819

2820
  function(add_config_tests cfg)
2821
    set(base "${CMake_BINARY_DIR}/Tests/CTestConfig")
2822

2823
    # Test -S script with a -C config arg to ctest:
2824
    configure_file(
2825
      "${CMake_SOURCE_DIR}/Tests/CTestConfig/script.cmake.in"
2826
      "${base}/${cfg}-script.cmake"
2827
      @ONLY ESCAPE_QUOTES)
2828
    add_test(CTestConfig.Script.${cfg} ${CMAKE_CTEST_COMMAND}
2829
      -C ${cfg}
2830
      -S "${base}/${cfg}-script.cmake" -VV
2831
      --output-log "${base}/${cfg}-script.log"
2832
      )
2833

2834
    # Test -D dashboard with a -C config arg to ctest.
2835
    # (Actual commands inside a cmake -P script because we need to be able to set
2836
    #  the working directory reliably...)
2837
    configure_file(
2838
      "${CMake_SOURCE_DIR}/Tests/CTestConfig/dashboard.cmake.in"
2839
      "${base}/${cfg}-dashboard.cmake"
2840
      @ONLY ESCAPE_QUOTES)
2841
    add_test(CTestConfig.Dashboard.${cfg} ${CMAKE_CMAKE_COMMAND}
2842
      -P "${base}/${cfg}-dashboard.cmake" -VV
2843
      )
2844
  endfunction()
2845

2846
  add_config_tests(Debug)
2847
  add_config_tests(MinSizeRel)
2848
  add_config_tests(Release)
2849
  add_config_tests(RelWithDebInfo)
2850

2851
  # Test -S script with some -D variable definition args to ctest:
2852
  add_test(CTestConfig.ScriptWithArgs ${CMAKE_CTEST_COMMAND}
2853
    -C "Release"
2854
    -D arg1=this
2855
    -D arg2=that
2856
    -D "arg3=the other"
2857
    "-Darg4=this is the fourth"
2858
    -Darg5=the_fifth
2859
    -Darg6:STRING=value-with-type
2860
    -S "${CMake_SOURCE_DIR}/Tests/CTestConfig/ScriptWithArgs.cmake" -VV
2861
    --output-log "${CMake_BINARY_DIR}/Tests/CTestConfig/ScriptWithArgs.log"
2862
    )
2863

2864
  ADD_TEST_MACRO(CMakeCommands.add_compile_definitions add_compile_definitions)
2865
  ADD_TEST_MACRO(CMakeCommands.add_compile_options add_compile_options)
2866
  ADD_TEST_MACRO(CMakeCommands.target_link_libraries target_link_libraries)
2867
  ADD_TEST_MACRO(CMakeCommands.target_include_directories target_include_directories)
2868
  ADD_TEST_MACRO(CMakeCommands.target_compile_definitions target_compile_definitions)
2869
  ADD_TEST_MACRO(CMakeCommands.target_compile_options target_compile_options)
2870
  ADD_TEST_MACRO(CMakeCommands.target_sources target_sources)
2871

2872
  ADD_TEST_MACRO(CMakeCommands.add_link_options)
2873
  ADD_TEST_MACRO(CMakeCommands.target_link_options)
2874
  ADD_TEST_MACRO(CMakeCommands.link_directories)
2875
  ADD_TEST_MACRO(CMakeCommands.target_link_directories)
2876

2877
  configure_file(
2878
    "${CMake_SOURCE_DIR}/Tests/CTestTestCrash/test.cmake.in"
2879
    "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake"
2880
    @ONLY ESCAPE_QUOTES)
2881
  add_test(CTestTestCrash ${CMAKE_CTEST_COMMAND}
2882
    -S "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake" -V
2883
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCrash/testOutput.log"
2884
    )
2885
  # With Watcom and OrangeC the SEGFAULT is not found, it just fails
2886
  if(CMAKE_GENERATOR MATCHES "Watcom WMake" OR CMAKE_C_COMPILER_ID STREQUAL "OrangeC")
2887
    set_tests_properties(CTestTestCrash PROPERTIES
2888
      PASS_REGULAR_EXPRESSION "Failed")
2889
  else()
2890
    set_tests_properties(CTestTestCrash PROPERTIES
2891
      PASS_REGULAR_EXPRESSION "(Illegal|SegFault|Subprocess aborted|SIGTRAP)")
2892
  endif()
2893

2894
  configure_file(
2895
    "${CMake_SOURCE_DIR}/Tests/CTestTestBadExe/test.cmake.in"
2896
    "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake"
2897
    @ONLY ESCAPE_QUOTES)
2898
  add_test(CTestTestBadExe ${CMAKE_CTEST_COMMAND}
2899
    -S "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake" -V
2900
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/testOutput.log"
2901
    )
2902
  set(CTestTestBadExe_REGEX "BAD_COMMAND")
2903
  # some cygwin can not be made to produce a BAD_COMMAND error
2904
  # the best we can get from it is a failed test
2905
  if(CYGWIN)
2906
    set(CTestTestBadExe_REGEX "(\\*\\*\\*Failed)|BAD_COMMAND")
2907
  endif()
2908
  set_tests_properties(CTestTestBadExe PROPERTIES
2909
    PASS_REGULAR_EXPRESSION "${CTestTestBadExe_REGEX}")
2910

2911
  configure_file(
2912
    "${CMake_SOURCE_DIR}/Tests/CTestTestBadGenerator/test.cmake.in"
2913
    "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/test.cmake"
2914
    @ONLY ESCAPE_QUOTES)
2915
  add_test(CTestTestBadGenerator ${CMAKE_CTEST_COMMAND}
2916
    -C "\${CTestTest_CONFIG}"
2917
    -S "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/test.cmake" -V
2918
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/testOutput.log"
2919
    )
2920
  set_property(TEST CTestTestBadGenerator PROPERTY
2921
    PASS_REGULAR_EXPRESSION "could not create generator named \"Bad Generator\"")
2922

2923
  configure_file(
2924
    "${CMake_SOURCE_DIR}/Tests/CTestTestParallel/test.cmake.in"
2925
    "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake"
2926
    @ONLY ESCAPE_QUOTES)
2927
  add_test(CTestTestParallel ${CMAKE_CTEST_COMMAND}
2928
    -S "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake" -V
2929
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestParallel/testOutput.log"
2930
    )
2931

2932
  configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestVerboseOutput/test.cmake.in"
2933
    "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/test.cmake" @ONLY ESCAPE_QUOTES)
2934
  add_test(CTestTestVerboseOutput ${CMAKE_CTEST_COMMAND}
2935
    -S "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/test.cmake" -VV
2936
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/testOutput.log"
2937
    -C "\${CTestTest_CONFIG}"
2938
    )
2939
  set_property(TEST CTestTestVerboseOutput PROPERTY PASS_REGULAR_EXPRESSION
2940
    "Test command:.*Working Directory:.*Environment variables:.*foo=bar.*this=that"
2941
  )
2942

2943
  ADD_TEST_MACRO(CTestTestSerialInDepends ${CMAKE_CTEST_COMMAND} -j 4
2944
    --output-on-failure -C "\${CTestTest_CONFIG}")
2945

2946
  ADD_TEST_MACRO(CTestTestMissingDependsExe ${CMAKE_CTEST_COMMAND}
2947
    --output-on-failure -C "\${CTestTest_CONFIG}")
2948
  set_tests_properties(CTestTestMissingDependsExe PROPERTIES
2949
    PASS_REGULAR_EXPRESSION "\\*\\*\\*Not Run"
2950
  )
2951

2952
  if(NOT BORLAND)
2953
    add_test_macro(CTestLimitDashJ ${CMAKE_CTEST_COMMAND} -j 4
2954
      --output-on-failure -C "\${CTestTest_CONFIG}")
2955
  endif()
2956

2957
  configure_file(
2958
    "${CMake_SOURCE_DIR}/Tests/CTestTestLabelRegExp/test.cmake.in"
2959
    "${CMake_BINARY_DIR}/Tests/CTestTestLabelRegExp/test.cmake"
2960
    @ONLY ESCAPE_QUOTES)
2961
  add_test(NAME CTestTestLabelRegExp
2962
    COMMAND ${CMAKE_CMAKE_COMMAND}
2963
      -DSOURCE_DIR=${CMAKE_SOURCE_DIR}/Tests/CTestTestLabelRegExp
2964
      -P ${CMAKE_BINARY_DIR}/Tests/CTestTestLabelRegExp/test.cmake
2965
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Tests/CTestTestLabelRegExp
2966
  )
2967

2968
  configure_file(
2969
    "${CMake_SOURCE_DIR}/Tests/CTestTestScheduler/test.cmake.in"
2970
    "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/test.cmake"
2971
    @ONLY ESCAPE_QUOTES)
2972
  add_test(CTestTestScheduler ${CMAKE_CTEST_COMMAND}
2973
    -S "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/test.cmake" -V
2974
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/testOutput.log"
2975
    )
2976
  set_tests_properties(CTestTestScheduler PROPERTIES
2977
    PASS_REGULAR_EXPRESSION "Start 1.*Start 2.*Start 3.*Start 4.*Start 4.*Start 3.*Start 2.*Start 1"
2978
    RESOURCE_LOCK "CostData")
2979

2980
  configure_file(
2981
    "${CMake_SOURCE_DIR}/Tests/CTestTestCostSerial/test.cmake.in"
2982
    "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake"
2983
    @ONLY ESCAPE_QUOTES)
2984
  add_test(CTestTestCostSerial ${CMAKE_CTEST_COMMAND}
2985
    -S "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake" -V
2986
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/testOutput.log"
2987
    )
2988
  set_tests_properties(CTestTestCostSerial PROPERTIES
2989
    PASS_REGULAR_EXPRESSION "Start 2.*Start 3.*Start 1.*Start 2.*Start 3.*Start 1"
2990
    RESOURCE_LOCK "CostData")
2991

2992
  configure_file(
2993
    "${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/test.cmake.in"
2994
    "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake"
2995
    @ONLY ESCAPE_QUOTES)
2996
  configure_file(
2997
    "${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
2998
    "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
2999
    COPYONLY)
3000
  add_test(CTestTestStopTime ${CMAKE_CTEST_COMMAND}
3001
    -S "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake" -V
3002
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/testOutput.log"
3003
    )
3004
  set_tests_properties(CTestTestStopTime PROPERTIES
3005
    PASS_REGULAR_EXPRESSION "The stop time has been passed")
3006

3007
  configure_file(
3008
    "${CMake_SOURCE_DIR}/Tests/CTestTestSubdir/test.cmake.in"
3009
    "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake"
3010
    @ONLY ESCAPE_QUOTES)
3011
  add_test(CTestTestSubdir ${CMAKE_CTEST_COMMAND}
3012
    -S "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake" -V
3013
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/testOutput.log"
3014
    )
3015
  #make sure all 3 subdirs were added
3016
  set_tests_properties(CTestTestSubdir PROPERTIES
3017
    PASS_REGULAR_EXPRESSION "0 tests failed out of 3")
3018

3019
  configure_file(
3020
    "${CMake_SOURCE_DIR}/Tests/CTestTestDepends/test.cmake.in"
3021
    "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake"
3022
    @ONLY ESCAPE_QUOTES)
3023
  add_test(CTestTestDepends ${CMAKE_CTEST_COMMAND}
3024
    -C "\${CTestTest_CONFIG}"
3025
    -S "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake" -V
3026
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestDepends/testOutput.log"
3027
    )
3028

3029
  configure_file(
3030
    "${CMake_SOURCE_DIR}/Tests/CTestTestCycle/test.cmake.in"
3031
    "${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake"
3032
    @ONLY ESCAPE_QUOTES)
3033
  add_test(CTestTestCycle ${CMAKE_CTEST_COMMAND}
3034
    -C "\${CTestTest_CONFIG}"
3035
    -S "${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake" -V
3036
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCycle/testOutput.log"
3037
    )
3038
  set_tests_properties(CTestTestCycle PROPERTIES
3039
    PASS_REGULAR_EXPRESSION "a cycle exists in the test dependency graph")
3040

3041
  configure_file(
3042
    "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/test.cmake.in"
3043
    "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake"
3044
    @ONLY ESCAPE_QUOTES)
3045
  configure_file(
3046
    "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/hello.cmake.in"
3047
    "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/hello.cmake"
3048
    @ONLY ESCAPE_QUOTES)
3049
  add_test(CTestTestRunScript ${CMAKE_CTEST_COMMAND}
3050
    -S "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake" -V
3051
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/testOutput.log"
3052
    )
3053

3054
  add_test(CTestTestShowOnly ${CMAKE_CTEST_COMMAND} -N)
3055

3056
  configure_file(
3057
    "${CMake_SOURCE_DIR}/Tests/CTestTestFdSetSize/test.cmake.in"
3058
    "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake"
3059
    @ONLY ESCAPE_QUOTES)
3060
  add_test(CTestTestFdSetSize ${CMAKE_CTEST_COMMAND}
3061
    -S "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake" -j20 -V --timeout 120
3062
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/testOutput.log"
3063
    )
3064

3065
  if(CMAKE_TESTS_CDASH_SERVER)
3066
    set(regex "^([^:]+)://([^/]+)(.*)$")
3067

3068
    if("${CMAKE_TESTS_CDASH_SERVER}" MATCHES "${regex}")
3069
      set(protocol "${CMAKE_MATCH_1}")
3070
      set(server "${CMAKE_MATCH_2}")
3071
      set(path "${CMAKE_MATCH_3}")
3072
    else()
3073
      set(protocol "http")
3074
      set(server "open.cdash.org")
3075
      set(path "")
3076
      message("warning: CMAKE_TESTS_CDASH_SERVER does not match expected regex...")
3077
      message("         ...using default url='${protocol}://${server}${path}' for CTestTest[23]")
3078
    endif()
3079
  endif()
3080

3081

3082
  if(CTEST_TEST_CTEST AND CMAKE_RUN_LONG_TESTS AND CMAKE_TESTS_CDASH_SERVER)
3083
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest/test.cmake.in"
3084
      "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" @ONLY ESCAPE_QUOTES)
3085
    add_test(CTestTest ${CMAKE_CTEST_COMMAND}
3086
      -S "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" -V
3087
      --output-log "${CMake_BINARY_DIR}/Tests/CTestTest/testOutput.log"
3088
      )
3089

3090
    if(NOT CMake_TEST_EXTERNAL_CMAKE)
3091
      configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest2/test.cmake.in"
3092
        "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" @ONLY ESCAPE_QUOTES)
3093
      add_test(NAME CTestTest2 COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3094
        -S "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" -V
3095
        --output-log "${CMake_BINARY_DIR}/Tests/CTestTest2/testOutput.log"
3096
        )
3097
    endif()
3098

3099
    if("${CMAKE_GENERATOR}" MATCHES "Makefiles|Ninja|FASTBuild")
3100
      configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestLaunchers/test.cmake.in"
3101
        "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/test.cmake" @ONLY ESCAPE_QUOTES)
3102
      add_test(CTestTestLaunchers ${CMAKE_CTEST_COMMAND}
3103
        -S "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/test.cmake" -V
3104
        --output-log "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/testOutput.log"
3105
        )
3106
      set_tests_properties(CTestTestLaunchers PROPERTIES
3107
        PASS_REGULAR_EXPRESSION "CTEST_TEST_LAUNCHER_SUCCESS")
3108
    endif()
3109

3110
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestChecksum/test.cmake.in"
3111
      "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" @ONLY
3112
      ESCAPE_QUOTES)
3113
    add_test(CTestTestChecksum ${CMAKE_CTEST_COMMAND}
3114
      -S "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" -V
3115
      --output-log
3116
      "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/testOutput.log"
3117
      )
3118
    set_tests_properties(CTestTestChecksum PROPERTIES PASS_REGULAR_EXPRESSION
3119
      "md5 mismatch")
3120

3121
    # these tests take a long time, make sure they have it
3122
    # if timeouts have not already been set
3123
    get_test_property(CTestTest TIMEOUT PREVIOUS_TIMEOUT)
3124
    if("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
3125
      set_tests_properties(CTestTest
3126
        PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
3127
    endif()
3128

3129
    if(NOT CMake_TEST_EXTERNAL_CMAKE)
3130
      get_test_property(CTestTest2 TIMEOUT PREVIOUS_TIMEOUT)
3131
      if("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
3132
        set_tests_properties(CTestTest2
3133
          PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
3134
      endif()
3135
    endif()
3136
  endif()
3137

3138
  if(NOT DEFINED CMake_TEST_BOOTSTRAP)
3139
    if(CMAKE_RUN_LONG_TESTS
3140
        AND NOT CMAKE_SKIP_BOOTSTRAP_TEST
3141
        AND NOT CMake_TEST_EXTERNAL_CMAKE
3142
        AND NOT CMAKE_GENERATOR MATCHES "Xcode"
3143
        AND NOT EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt"
3144
        )
3145
      set(CMake_TEST_BOOTSTRAP 1)
3146
    else()
3147
      set(CMake_TEST_BOOTSTRAP 0)
3148
    endif()
3149
  endif()
3150
  set(bootstrap "")
3151
  if(CMake_TEST_BOOTSTRAP)
3152
    if(UNIX)
3153
      set(bootstrap ${CMake_SOURCE_DIR}/bootstrap)
3154
    elseif(MSYS)
3155
      configure_file(${CMAKE_CURRENT_SOURCE_DIR}/bootstrap.bat.in
3156
                     ${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat @ONLY)
3157
      set(bootstrap ${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat)
3158
    endif()
3159
  endif()
3160
  if(bootstrap)
3161
    add_test(NAME BootstrapTest
3162
      COMMAND ${CMAKE_CMAKE_COMMAND}
3163
        -D "bootstrap=${bootstrap}"
3164
        -D "bin_dir=${CMake_BINARY_DIR}/Tests/BootstrapTest"
3165
        -D "generator=${CMAKE_GENERATOR}"
3166
        -P ${CMAKE_CURRENT_SOURCE_DIR}/BootstrapTest.cmake
3167
      )
3168
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BootstrapTest")
3169
    # This test will use all processors.
3170
    set_property(TEST BootstrapTest PROPERTY RUN_SERIAL 1)
3171
    # This test may take a long time.
3172
    if(NOT DEFINED CMake_TEST_BOOTSTRAP_TIMEOUT)
3173
      set(CMake_TEST_BOOTSTRAP_TIMEOUT 5400)
3174
    endif()
3175
    set_property(TEST BootstrapTest PROPERTY TIMEOUT "${CMake_TEST_BOOTSTRAP_TIMEOUT}")
3176
  endif()
3177

3178
  if(CMAKE_Fortran_COMPILER)
3179
    add_test(Fortran ${CMAKE_CTEST_COMMAND}
3180
      --build-and-test
3181
      "${CMake_SOURCE_DIR}/Tests/Fortran"
3182
      "${CMake_BINARY_DIR}/Tests/Fortran"
3183
      ${build_generator_args}
3184
      --build-project testf
3185
      --build-two-config
3186
      --test-command testf)
3187
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Fortran")
3188
    set_property(TEST Fortran APPEND PROPERTY LABELS "Fortran")
3189

3190
    if(CMAKE_Fortran_COMPILER_SUPPORTS_F90
3191
        # FIXME(lfortran): The compiler fails on the test's modules.
3192
        AND NOT CMAKE_Fortran_COMPILER_ID STREQUAL "LFortran"
3193
        )
3194
      if(DEFINED CMake_TEST_Fortran_SUBMODULES)
3195
        list(PREPEND CMake_TEST_FortranModules_BUILD_OPTIONS -DCMake_TEST_Fortran_SUBMODULES:BOOL=${CMake_TEST_Fortran_SUBMODULES})
3196
      endif()
3197
      add_test(FortranModules ${CMAKE_CTEST_COMMAND}
3198
        --build-and-test
3199
        "${CMake_SOURCE_DIR}/Tests/FortranModules"
3200
        "${CMake_BINARY_DIR}/Tests/FortranModules"
3201
        ${build_generator_args}
3202
        --build-project FortranModules
3203
        --build-options
3204
          -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
3205
          ${CMake_TEST_FortranModules_BUILD_OPTIONS}
3206
        )
3207
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranModules")
3208
      set_property(TEST FortranModules APPEND PROPERTY LABELS "Fortran")
3209
    endif()
3210

3211
    # FortranCInterface tests.
3212
    if(UNIX)
3213
      configure_file(${CMAKE_CURRENT_SOURCE_DIR}/FortranC/Flags.cmake.in
3214
        ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake @ONLY)
3215
      add_test(FortranC.Flags ${CMAKE_CMAKE_COMMAND} -P
3216
        ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake)
3217
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC/Flags")
3218
      set_property(TEST FortranC.Flags APPEND PROPERTY LABELS "Fortran")
3219
    else()
3220
      add_test(FortranC ${CMAKE_CTEST_COMMAND}
3221
        --build-and-test
3222
        "${CMake_SOURCE_DIR}/Tests/FortranC"
3223
        "${CMake_BINARY_DIR}/Tests/FortranC"
3224
        ${build_generator_args}
3225
        --build-project FortranC
3226
        --build-two-config
3227
        --test-command CMakeFiles/FortranCInterface/FortranCInterface)
3228
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC")
3229
      set_property(TEST FortranC APPEND PROPERTY LABELS "Fortran")
3230
    endif()
3231
  endif()
3232

3233
  if(NOT DEFINED CMake_TEST_Java)
3234
    if(APPLE OR MINGW)
3235
      set(CMake_TEST_Java 0)
3236
    else()
3237
      set(CMake_TEST_Java 1)
3238
    endif()
3239
  endif()
3240
  if(CMake_TEST_Java)
3241
    find_package(Java COMPONENTS Development QUIET)
3242
  endif()
3243
  if(Java_JAVA_EXECUTABLE AND Java_JAVAC_EXECUTABLE AND Java_JAR_EXECUTABLE)
3244

3245
    set(JavaExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM})
3246
    ADD_TEST_MACRO(JavaExportImport JavaExportImport)
3247

3248
    if("${Java_VERSION}" VERSION_GREATER_EQUAL 9)
3249
      set(JavaModExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM})
3250
      ADD_TEST_MACRO(JavaModExportImport JavaModExportImport)
3251
    endif()
3252

3253
    get_filename_component(JAVACPATH ${Java_JAVAC_EXECUTABLE} REALPATH)
3254
    get_filename_component(JNIPATH ${JAVACPATH} PATH)
3255
    find_file(JNI_H jni.h
3256
      "${JNIPATH}/../include"
3257
      "${JNIPATH}/../java/include")
3258
    if(JNI_H AND EXISTS "${JNI_H}") # in case jni.h is a broken symlink
3259
      file(READ "${JNI_H}" JNI_FILE)
3260
      if("${JNI_FILE}" MATCHES "JDK1_2")
3261

3262
        execute_process(
3263
          COMMAND "${Java_JAVA_EXECUTABLE}" -version
3264
          OUTPUT_VARIABLE _version ERROR_VARIABLE _version RESULT_VARIABLE _result
3265
          )
3266

3267
        # E2K has broken Java RVM before 3.5.2
3268
        if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "e2k" AND _result EQUAL 0)
3269
          string(REGEX MATCH "RVM ([0-9.]+)" RVMVER "${_version}")
3270
          # Consider empty match a broken version too
3271
          if("${CMAKE_MATCH_1}" VERSION_LESS "3.5.2")
3272
            set(BROKEN_RVM TRUE)
3273
          endif()
3274
        endif()
3275

3276
        if(NOT BROKEN_RVM)
3277
          add_test(NAME Java.Jar COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3278
            --build-and-test
3279
            "${CMake_SOURCE_DIR}/Tests/Java"
3280
            "${CMake_BINARY_DIR}/Tests/JavaJar"
3281
            ${build_generator_args}
3282
            --build-project hello
3283
            --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaJar/"
3284
            --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
3285
          list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaJar")
3286

3287
          # For next tests, java tool must have same architecture as toolchain
3288
          math(EXPR _object_mode "${CMAKE_SIZEOF_VOID_P} * 8")
3289
          if(_result EQUAL 0 AND _version MATCHES "${_object_mode}-Bit")
3290
            ## next test is valid only if Java version is less than 1.10
3291
            if("${Java_VERSION}" VERSION_LESS 1.10)
3292
              add_test(NAME Java.Javah COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3293
                --build-and-test
3294
                "${CMake_SOURCE_DIR}/Tests/JavaJavah"
3295
                "${CMake_BINARY_DIR}/Tests/JavaJavah"
3296
                ${build_generator_args}
3297
                --build-project helloJavah
3298
                --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaJavah/"
3299
                --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
3300
              list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaJavah")
3301
            endif()
3302
            ## next test is valid only if Java is, at least, version 1.8
3303
            if(NOT "${Java_VERSION}" VERSION_LESS 1.8)
3304
              add_test(NAME Java.NativeHeaders COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3305
                --build-and-test
3306
                "${CMake_SOURCE_DIR}/Tests/JavaNativeHeaders"
3307
                "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders"
3308
                ${build_generator_args}
3309
                --build-project helloJavaNativeHeaders
3310
                --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders/"
3311
                --build-target install
3312
                --build-options
3313
                "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/JavaNativeHeaders/Install"
3314
                --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
3315
              list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders")
3316
            endif()
3317
          endif()
3318
        endif()
3319
      endif()
3320
    endif()
3321
  endif()
3322

3323
  # Define a set of "contract" tests, each activated by a cache entry
3324
  # named "CMake_TEST_CONTRACT_<project>".  For each Contract test,
3325
  # the project should provide a directory with a CMakeLists.txt file
3326
  # that uses ExternalProject to download and configure the project.
3327
  # The directory should also contain a Configure.cmake file that
3328
  # sets "CMake_TEST_CONTRACT_<project>_<var>" variables to configure
3329
  # the code below.
3330
  foreach(project IN ITEMS PLplot Trilinos VTK)
3331
    if(CMake_TEST_CONTRACT_${project})
3332
      include(Contracts/${project}/Configure.cmake)
3333
      ADD_TEST_MACRO(Contracts.${project} ${CMake_TEST_CONTRACT_${project}_RUN_TEST})
3334
      # The external projects may take a long time to build.
3335
      if(DEFINED CMake_TEST_CONTRACT_${project}_TIMEOUT)
3336
        set(timeout ${CMake_TEST_CONTRACT_${project}_TIMEOUT})
3337
      elseif(CMake_TEST_CONTRACT_DEFAULT_TIMEOUT)
3338
        set(timeout ${CMake_TEST_CONTRACT_DEFAULT_TIMEOUT})
3339
      else()
3340
        set(timeout 21600)
3341
      endif()
3342
      set_property(TEST Contracts.${project} PROPERTY TIMEOUT "${timeout}")
3343
    endif()
3344
  endforeach()
3345

3346
  if(TEST_CompileCommandOutput)
3347
    set(CompileCommandOutput_BUILD_OPTIONS
3348
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES})
3349
    ADD_TEST_MACRO(CompileCommandOutput
3350
      "${CMake_BINARY_DIR}/Tests/CMakeLib/runcompilecommands")
3351
  endif()
3352

3353
  add_test(IncludeDirectories ${CMAKE_CTEST_COMMAND}
3354
    --build-and-test
3355
    "${CMake_SOURCE_DIR}/Tests/IncludeDirectories"
3356
    "${CMake_BINARY_DIR}/Tests/IncludeDirectories"
3357
    --build-two-config
3358
    ${build_generator_args}
3359
    --build-project IncludeDirectories
3360
    --build-options
3361
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
3362
    --test-command IncludeDirectories)
3363
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/IncludeDirectories")
3364

3365
  if(CMAKE_GENERATOR MATCHES "^((Unix|MSYS) Makefiles|Ninja|FASTBuild)$" AND
3366
     ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.4)
3367
      OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
3368
      OR (CMAKE_CXX_COMPILER_ID STREQUAL "LCC")
3369
      OR (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")))
3370
    add_test(IncludeDirectoriesCPATH ${CMAKE_CTEST_COMMAND}
3371
      --build-and-test
3372
      "${CMake_SOURCE_DIR}/Tests/IncludeDirectoriesCPATH"
3373
      "${CMake_BINARY_DIR}/Tests/IncludeDirectoriesCPATH"
3374
      --build-two-config
3375
      ${build_generator_args}
3376
      --build-project IncludeDirectoriesCPATH)
3377
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/IncludeDirectoriesCPATH")
3378
    set_tests_properties(IncludeDirectoriesCPATH
3379
      PROPERTIES
3380
        ENVIRONMENT "CPATH=${CMAKE_CURRENT_SOURCE_DIR}/IncludeDirectoriesCPATH/viacpath")
3381
  endif()
3382

3383
  add_test(InterfaceLinkLibraries ${CMAKE_CTEST_COMMAND}
3384
    --build-and-test
3385
    "${CMake_SOURCE_DIR}/Tests/InterfaceLinkLibraries"
3386
    "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries"
3387
    --build-two-config
3388
    ${build_generator_args}
3389
    --build-project InterfaceLinkLibraries
3390
    --test-command InterfaceLinkLibraries)
3391
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries")
3392

3393
  ADD_TEST_MACRO(InterfaceLinkLibrariesDirect)
3394

3395
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
3396
    add_subdirectory(CMakeTests)
3397
  endif()
3398

3399
  if(BUILD_QtDialog AND CMake_TEST_GUI AND NOT CMake_TEST_EXTERNAL_CMAKE)
3400
    add_subdirectory(CMakeGUI)
3401
  endif()
3402

3403
  # Run CheckSourceTree as the very last test in the CMake/CTest/CPack test
3404
  # suite. It detects if any changes have been made to the CMake source tree
3405
  # by any previous configure, build or test steps.
3406
  if(GIT_EXECUTABLE AND EXISTS "${CMake_SOURCE_DIR}/.git"
3407
      AND NOT "${CMake_SOURCE_DIR}" STREQUAL "${CMake_BINARY_DIR}")
3408
    add_subdirectory(CheckSourceTree)
3409
  endif()
3410

3411
  # If this is not an in-source build, provide a target to wipe out
3412
  # all the test build directories. This must come at the end after
3413
  # all the above logic has finished adding to TEST_BUILD_DIRS
3414
  if(NOT EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt")
3415
    configure_file(${CMake_SOURCE_DIR}/Tests/test_clean.cmake.in
3416
                   ${CMake_BINARY_DIR}/Tests/test_clean.cmake @ONLY)
3417
    add_custom_target(test_clean
3418
      COMMAND ${CMAKE_COMMAND} -P ${CMake_BINARY_DIR}/Tests/test_clean.cmake
3419
      COMMENT "Removing test build directories."
3420
      )
3421
  endif()
3422
endif()
3423

3424
Product

Resources

Company
