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_Fortran_COMPILER)
465
    ADD_TEST_MACRO(FortranOnly FortranOnly)
466
    set_property(TEST FortranOnly APPEND PROPERTY LABELS "Fortran")
467
  endif()
468
  # test Visual Studio GNU Fortran mixing with cmake_add_fortran_subdirectory
469
  # run this project if we have a working fortran compiler or
470
  # the test is enabled with CMAKE_TEST_CMAKE_ADD_FORTRAN cache variable.
471
  # If you enable the test, CMake should find the MinGW fortran install,
472
  # or in some cases you might need to set the PATH so that cmake can find
473
  # the gfortran from mingw.
474
  if(CMAKE_Fortran_COMPILER OR CMAKE_TEST_CMAKE_ADD_FORTRAN)
475
    set(CMAKE_SKIP_VSGNUFortran FALSE)
476
    # disable test for apple builds using ifort if they are building
477
    # more than one architecture, as ifort does not support that.
478
    if(APPLE AND (CMAKE_Fortran_COMPILER MATCHES ifort))
479
      list(LENGTH CMAKE_OSX_ARCHITECTURES len)
480
      if("${len}" GREATER 1)
481
        message(STATUS "Skip VSGNUFortran for ifort dual cpu mac build")
482
        set(CMAKE_SKIP_VSGNUFortran TRUE)
483
      endif()
484
    endif()
485
    if(CMAKE_Fortran_COMPILER_ID STREQUAL LLVMFlang)
486
      # No DLLEXPORT for 'Tests/VSGNUFortran/subdir/fortran/world.f'.
487
      set(CMAKE_SKIP_VSGNUFortran TRUE)
488
    endif()
489
    if(CMAKE_Fortran_COMPILER_ID STREQUAL IntelLLVM)
490
      message(STATUS "Skip VSGNUFortran for ifx until DLLEXPORT support is implemented")
491
      set(CMAKE_SKIP_VSGNUFortran TRUE)
492
    endif()
493
    if((CMAKE_C_COMPILER MATCHES lsb)
494
        AND (CMAKE_Fortran_COMPILER MATCHES ifort))
495
      message(STATUS "Skip VSGNUFortran for ifort and lsb compilers")
496
      set(CMAKE_SKIP_VSGNUFortran TRUE)
497
    endif()
498
    if(NOT CMAKE_SKIP_VSGNUFortran)
499
      ADD_TEST_MACRO(VSGNUFortran ${CMAKE_CMAKE_COMMAND} -P runtest.cmake)
500
      set_property(TEST VSGNUFortran APPEND PROPERTY LABELS "Fortran")
501
    endif()
502
  endif()
503

504
  if(CMake_TEST_OBJC)
505
    add_subdirectory(ObjC)
506
    add_subdirectory(ObjCXX)
507
  endif()
508

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

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

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

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

615
  list(APPEND TEST_BUILD_DIRS ${CMake_TEST_INSTALL_PREFIX})
616

617
  if(NOT DEFINED CMake_TEST_Qt4)
618
    set(CMake_TEST_Qt4 1)
619
  endif()
620
  if(CMake_TEST_Qt4 AND NOT Qt4_FOUND)
621
    find_package(Qt4 QUIET)
622
  endif()
623

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

633
    set(CMAKE_REQUIRED_INCLUDES ${QT_INCLUDES})
634
    set(CMAKE_REQUIRED_LIBRARIES ${QT_QTCORE_LIBRARIES})
635

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

639
    set(CMAKE_REQUIRED_INCLUDES "${_save_CMAKE_REQUIRED_INCLUDES}")
640
    set(CMAKE_REQUIRED_LIBRARIES "${_save_CMAKE_REQUIRED_LIBRARIES}")
641
  endif()
642

643
  # run test for BundleUtilities on supported platforms/compilers
644
  if((MSVC OR
645
      MINGW OR
646
      CMAKE_SYSTEM_NAME MATCHES "Linux" OR
647
      CMAKE_SYSTEM_NAME MATCHES "Darwin")
648
    AND NOT CMAKE_GENERATOR STREQUAL "Watcom WMake")
649

650
    add_test(BundleUtilities ${CMAKE_CTEST_COMMAND}
651
      --build-and-test
652
      "${CMake_SOURCE_DIR}/Tests/BundleUtilities"
653
      "${CMake_BINARY_DIR}/Tests/BundleUtilities"
654
      ${build_generator_args}
655
      --build-project BundleUtilities
656
      )
657
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleUtilities")
658

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

675
  endif()
676

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

695
  set(Module.CheckIPOSupported-C_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_C=${CMake_TEST_IPO_WORKS_C})
696
  ADD_TEST_MACRO(Module.CheckIPOSupported-C CheckIPOSupported-C)
697

698
  set(Module.CheckIPOSupported-CXX_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_CXX=${CMake_TEST_IPO_WORKS_CXX})
699
  ADD_TEST_MACRO(Module.CheckIPOSupported-CXX CheckIPOSupported-CXX)
700

701
  if(CMake_TEST_CUDA)
702
    ADD_TEST_MACRO(Module.CheckIPOSupported-CUDA CheckIPOSupported-CUDA)
703
    set_property(TEST Module.CheckIPOSupported-CUDA APPEND PROPERTY LABELS "CUDA")
704
  endif()
705

706
  if(CMAKE_Fortran_COMPILER)
707
    set(Module.CheckIPOSupported-Fortran_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_Fortran=${CMake_TEST_IPO_WORKS_Fortran})
708
    ADD_TEST_MACRO(Module.CheckIPOSupported-Fortran CheckIPOSupported-Fortran)
709
    set_property(TEST Module.CheckIPOSupported-Fortran APPEND PROPERTY LABELS "Fortran")
710
  endif()
711

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

725
  ADD_TEST_MACRO(Module.FindDependency FindDependency)
726

727
  ADD_TEST_MACRO(Module.WriteCompilerDetectionHeader WriteCompilerDetectionHeader)
728

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

742
  if(run_pic_test)
743
    ADD_TEST_MACRO(PositionIndependentTargets PositionIndependentTargets)
744
  endif()
745

746
  if(CMAKE_CXX_COMPILER_ID MATCHES "LCC" OR
747
    ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") AND
748
    (NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 4.2) AND
749
    (CMAKE_SYSTEM_NAME MATCHES "Linux")))
750

751
    include(CheckCXXCompilerFlag)
752
    check_cxx_compiler_flag(
753
      -fvisibility-inlines-hidden run_inlines_hidden_test)
754
  endif()
755

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

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

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

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

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

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

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

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

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

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

902
  ADD_TEST_MACRO(CustomCommandByproducts CustomCommandByproducts)
903

904
  ADD_TEST_MACRO(CommandLength CommandLength)
905

906
  ADD_TEST_MACRO(EmptyDepends ${CMAKE_CTEST_COMMAND})
907

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

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

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

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

956
  # By default, run the CPackComponents test if the CTEST_TEST_CPACK
957
  # option is ON:
958
  #
959
  set(CTEST_RUN_CPackComponents ${CTEST_TEST_CPACK})
960
  set(CTEST_package_X11_TEST ${CTEST_TEST_CPACK})
961
  set(CTEST_RUN_CPackComponentsForAll ${CTEST_TEST_CPACK})
962
  set(CTEST_RUN_CPackComponentsPrefix ${CTEST_TEST_CPACK})
963

964
  find_program(NSIS_MAKENSIS_EXECUTABLE NAMES makensis
965
    PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
966
    DOC "makensis program location"
967
    )
968

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

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

996
    set_property(TEST CPackInnoSetupGenerator PROPERTY
997
      ATTACHED_FILES_ON_FAIL
998
      "${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator/_CPack_Packages/win32/INNOSETUP/ISCCOutput.log")
999

1000
    set_property(TEST CPackInnoSetupGenerator PROPERTY
1001
      ATTACHED_FILES
1002
      "${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator/_CPack_Packages/win32/INNOSETUP/ISScript.iss")
1003
  endif()
1004

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

1021
    set_property(TEST CPackNSISGenerator PROPERTY
1022
      ATTACHED_FILES_ON_FAIL
1023
      "${CMake_BINARY_DIR}/Tests/CPackNSISGenerator/_CPack_Packages/win32/NSIS/NSISOutput.log")
1024
  endif()
1025

1026
  find_program(IFW_BINARYCREATOR_EXECUTABLE NAMES binarycreator
1027
    DOC "IFW binarycreator program location"
1028
  )
1029

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

1044
    set_property(TEST CPackIFWGenerator PROPERTY
1045
      ATTACHED_FILES_ON_FAIL
1046
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator/_CPack_Packages/Linux/IFW/IFWOutput.log"
1047
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator/_CPack_Packages/Darwin/IFW/IFWOutput.log"
1048
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator/_CPack_Packages/win32/IFW/IFWOutput.log"
1049
    )
1050
  endif()
1051

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

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

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

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

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

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

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

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

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

1228
      set(CPackGen "DEB")
1229
      set(CPackRun_CPackGen "-DCPackGen=${CPackGen}")
1230

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

1257
  endif()
1258

1259
  # By default, turn this test off (because it takes a long time...)
1260
  #
1261
  if(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
1262
    set(CTEST_RUN_CPackTestAllGenerators OFF)
1263

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

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

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

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

1320
  if(CTEST_package_X11_TEST)
1321
    set(X11_build_target_arg --build-target package)
1322
  else()
1323
    set(X11_build_target_arg)
1324
  endif()
1325

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

1337
  if(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
1338
    set(CTEST_RUN_CMakeTestAllGenerators ON)
1339
  endif()
1340

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

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

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

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

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

1410
  if(CMake_TEST_Qt6 AND Qt6Widgets_FOUND)
1411
    add_subdirectory(Qt6Autogen)
1412
  endif()
1413
  if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND)
1414
    add_subdirectory(Qt5Autogen)
1415
  endif()
1416
  if(QT4_WORKS AND QT_QTGUI_FOUND)
1417
    add_subdirectory(Qt4Autogen)
1418

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

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

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

1528
  if(CMake_TEST_CUDA)
1529
    add_subdirectory(Cuda)
1530
    add_subdirectory(CudaOnly)
1531
  endif()
1532

1533
  if(CMake_TEST_HIP)
1534
    add_subdirectory(HIP)
1535
  endif()
1536

1537
  if(CMake_TEST_ISPC)
1538
    add_subdirectory(ISPC)
1539
  endif()
1540

1541
  if(CMake_TEST_FindGTest)
1542
    add_subdirectory(FindGTest)
1543
    add_subdirectory(GoogleTest)
1544
  endif()
1545

1546
  if(CMake_TEST_UseSWIG)
1547
    add_subdirectory(UseSWIG)
1548
  endif()
1549

1550
  add_subdirectory(FindThreads)
1551

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

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

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

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

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

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

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

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

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

1728
    add_installmode_test(COPY)
1729
    add_installmode_test(REL_SYMLINK)
1730
    add_installmode_test(REL_SYMLINK_OR_COPY)
1731
    add_installmode_test(ABS_SYMLINK)
1732
    add_installmode_test(ABS_SYMLINK_OR_COPY)
1733
    add_installmode_test(SYMLINK)
1734
    add_installmode_test(SYMLINK_OR_COPY)
1735
  endif()
1736

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

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

1769
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
1770
    add_importexport_test("MyExe" "Importing")
1771
    add_importexport_test("MathFunctions" "Downstream")
1772
    add_importexport_test("MathFunctionsComponents" "DownstreamComponents")
1773
  endif()
1774

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

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

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

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

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

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

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

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

1876
  if(CMAKE_SYSTEM_NAME MATCHES syllable)
1877

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

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

1892
  else()
1893

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

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

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

1928
    if(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
1929
      ADD_TEST_MACRO(RuntimePath RuntimePath)
1930
    endif()
1931
  endif()
1932

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

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

1963
  add_test(linkorder1 ${CMAKE_CTEST_COMMAND}
1964
    --build-and-test
1965
    "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
1966
    "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
1967
    ${build_generator_args}
1968
    --build-project LinkLineOrder
1969
    --test-command Exec1
1970
    )
1971

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

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

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

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

2049
  if(MSVC OR (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND CMAKE_C_SIMULATE_ID STREQUAL "MSVC"))
2050
    ADD_TEST_MACRO(PDBDirectoryAndName myexe)
2051
    if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" OR NOT "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
2052
      ADD_TEST_MACRO(ForceInclude foo)
2053
    endif()
2054
    if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" AND NOT CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
2055
      ADD_TEST_MACRO(PrecompiledHeader foo)
2056
    endif()
2057

2058
    set(MSVCDebugInformationFormat_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2059
    if(CMAKE_Fortran_COMPILER)
2060
      list(APPEND MSVCDebugInformationFormat_BUILD_OPTIONS -DCMake_TEST_Fortran=1)
2061
    endif()
2062
    ADD_TEST_MACRO(MSVCDebugInformationFormat)
2063
    set_property(TEST MSVCDebugInformationFormat APPEND
2064
      PROPERTY LABELS "CUDA" "Fortran")
2065

2066
    set(MSVCRuntimeChecks_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2067
    if(CMAKE_Fortran_COMPILER)
2068
      list(APPEND MSVCRuntimeChecks_BUILD_OPTIONS -DCMake_TEST_Fortran=1)
2069
    endif()
2070
    ADD_TEST_MACRO(MSVCRuntimeChecks)
2071
    set_property(TEST MSVCRuntimeChecks APPEND
2072
      PROPERTY LABELS "CUDA" "Fortran")
2073

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

2088
  if(CMAKE_C_COMPILER_ID MATCHES "Watcom" AND WIN32)
2089
    ADD_TEST_MACRO(WatcomRuntimeLibrary)
2090
  endif()
2091

2092
  ADD_TEST_MACRO(CheckCompilerRelatedVariables CheckCompilerRelatedVariables)
2093

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

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

2120
  if(MSVC AND NOT MSVC_VERSION LESS 1700
2121
     AND (CMAKE_C_COMPILER_ARCHITECTURE_ID STREQUAL "ARM64")
2122
      )
2123
    ADD_TEST_MACRO(VSMARMASM VSMARMASM)
2124
  endif()
2125

2126
  if(MSVC AND NOT MSVC_VERSION LESS 1310
2127
     AND (NOT CMAKE_C_COMPILER_ARCHITECTURE_ID STREQUAL "ARM64")
2128
      )
2129
    ADD_TEST_MACRO(VSMASM VSMASM)
2130
  endif()
2131

2132
  if(CMAKE_GENERATOR MATCHES "Visual Studio")
2133
    if(NOT MSVC60)
2134
      ADD_TEST_MACRO(SBCS SBCS)
2135
    endif()
2136

2137
    if(NOT CMAKE_GENERATOR_TOOLSET STREQUAL "v90"
2138
        AND NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
2139
      ADD_TEST_MACRO(VSWindowsFormsResx VSWindowsFormsResx)
2140
      ADD_TEST_MACRO(VSManagedCustomCommand)
2141
    endif()
2142

2143
    add_test(VSExternalInclude ${CMAKE_CTEST_COMMAND}
2144
      --build-and-test
2145
      "${CMake_SOURCE_DIR}/Tests/VSExternalInclude"
2146
      "${CMake_BINARY_DIR}/Tests/VSExternalInclude"
2147
      --build-two-config
2148
      ${build_generator_args}
2149
      --build-project VSExternalInclude
2150
      --test-command VSExternalInclude)
2151
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExternalInclude")
2152

2153
    add_test(VSMidl ${CMAKE_CTEST_COMMAND}
2154
      --build-and-test
2155
      "${CMake_SOURCE_DIR}/Tests/VSMidl"
2156
      "${CMake_BINARY_DIR}/Tests/VSMidl"
2157
      --build-two-config
2158
      ${build_generator_args}
2159
      --build-project VSMidl
2160
      --test-command VSMidl)
2161
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSMidl")
2162

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

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

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

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

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

2255
  if(CMAKE_GENERATOR MATCHES "Visual Studio" AND nasm)
2256
    ADD_TEST_MACRO(VSNASM VSNASM)
2257
  endif()
2258

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

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

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

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

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

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

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

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

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

2499
  # Make sure CTest can handle a test with no newline in output.
2500
  add_test(CTest.NoNewline
2501
    ${CMAKE_CMAKE_COMMAND} -E echo_append "This line has no newline!")
2502

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2761

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

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

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

2816
  function(add_config_tests cfg)
2817
    set(base "${CMake_BINARY_DIR}/Tests/CTestConfig")
2818

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

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

2842
  add_config_tests(Debug)
2843
  add_config_tests(MinSizeRel)
2844
  add_config_tests(Release)
2845
  add_config_tests(RelWithDebInfo)
2846

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

2860
  ADD_TEST_MACRO(CMakeCommands.add_compile_definitions add_compile_definitions)
2861
  ADD_TEST_MACRO(CMakeCommands.add_compile_options add_compile_options)
2862
  ADD_TEST_MACRO(CMakeCommands.target_link_libraries target_link_libraries)
2863
  ADD_TEST_MACRO(CMakeCommands.target_include_directories target_include_directories)
2864
  ADD_TEST_MACRO(CMakeCommands.target_compile_definitions target_compile_definitions)
2865
  ADD_TEST_MACRO(CMakeCommands.target_compile_options target_compile_options)
2866
  ADD_TEST_MACRO(CMakeCommands.target_sources target_sources)
2867

2868
  ADD_TEST_MACRO(CMakeCommands.add_link_options)
2869
  ADD_TEST_MACRO(CMakeCommands.target_link_options)
2870
  ADD_TEST_MACRO(CMakeCommands.link_directories)
2871
  ADD_TEST_MACRO(CMakeCommands.target_link_directories)
2872

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

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

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

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

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

2939
  ADD_TEST_MACRO(CTestTestSerialInDepends ${CMAKE_CTEST_COMMAND} -j 4
2940
    --output-on-failure -C "\${CTestTest_CONFIG}")
2941

2942
  ADD_TEST_MACRO(CTestTestMissingDependsExe ${CMAKE_CTEST_COMMAND}
2943
    --output-on-failure -C "\${CTestTest_CONFIG}")
2944
  set_tests_properties(CTestTestMissingDependsExe PROPERTIES
2945
    PASS_REGULAR_EXPRESSION "\\*\\*\\*Not Run"
2946
  )
2947

2948
  if(NOT BORLAND)
2949
    add_test_macro(CTestLimitDashJ ${CMAKE_CTEST_COMMAND} -j 4
2950
      --output-on-failure -C "\${CTestTest_CONFIG}")
2951
  endif()
2952

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

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

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

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

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

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

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

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

3050
  add_test(CTestTestShowOnly ${CMAKE_CTEST_COMMAND} -N)
3051

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

3061
  if(CMAKE_TESTS_CDASH_SERVER)
3062
    set(regex "^([^:]+)://([^/]+)(.*)$")
3063

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

3077

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

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

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

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

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

3125
    if(NOT CMake_TEST_EXTERNAL_CMAKE)
3126
      get_test_property(CTestTest2 TIMEOUT PREVIOUS_TIMEOUT)
3127
      if("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
3128
        set_tests_properties(CTestTest2
3129
          PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
3130
      endif()
3131
    endif()
3132
  endif()
3133

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

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

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

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

3229
  if(NOT DEFINED CMake_TEST_Java)
3230
    if(APPLE OR MINGW)
3231
      set(CMake_TEST_Java 0)
3232
    else()
3233
      set(CMake_TEST_Java 1)
3234
    endif()
3235
  endif()
3236
  if(CMake_TEST_Java)
3237
    find_package(Java COMPONENTS Development QUIET)
3238
  endif()
3239
  if(Java_JAVA_EXECUTABLE AND Java_JAVAC_EXECUTABLE AND Java_JAR_EXECUTABLE)
3240

3241
    set(JavaExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM})
3242
    ADD_TEST_MACRO(JavaExportImport JavaExportImport)
3243

3244
    if("${Java_VERSION}" VERSION_GREATER_EQUAL 9)
3245
      set(JavaModExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM})
3246
      ADD_TEST_MACRO(JavaModExportImport JavaModExportImport)
3247
    endif()
3248

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

3258
        execute_process(
3259
          COMMAND "${Java_JAVA_EXECUTABLE}" -version
3260
          OUTPUT_VARIABLE _version ERROR_VARIABLE _version RESULT_VARIABLE _result
3261
          )
3262

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

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

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

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

3342
  if(TEST_CompileCommandOutput)
3343
    set(CompileCommandOutput_BUILD_OPTIONS
3344
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES})
3345
    ADD_TEST_MACRO(CompileCommandOutput
3346
      "${CMake_BINARY_DIR}/Tests/CMakeLib/runcompilecommands")
3347
  endif()
3348

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

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

3379
  add_test(InterfaceLinkLibraries ${CMAKE_CTEST_COMMAND}
3380
    --build-and-test
3381
    "${CMake_SOURCE_DIR}/Tests/InterfaceLinkLibraries"
3382
    "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries"
3383
    --build-two-config
3384
    ${build_generator_args}
3385
    --build-project InterfaceLinkLibraries
3386
    --test-command InterfaceLinkLibraries)
3387
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries")
3388

3389
  ADD_TEST_MACRO(InterfaceLinkLibrariesDirect)
3390

3391
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
3392
    add_subdirectory(CMakeTests)
3393
  endif()
3394

3395
  if(BUILD_QtDialog AND CMake_TEST_GUI AND NOT CMake_TEST_EXTERNAL_CMAKE)
3396
    add_subdirectory(CMakeGUI)
3397
  endif()
3398

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

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

3420
Product

Resources

Company
