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
# Testing
84
if(BUILD_TESTING)
85
  set(CMake_TEST_DEVENV "")
86
  if(CMAKE_VS_DEVENV_COMMAND)
87
    set(CMake_TEST_DEVENV "${CMAKE_VS_DEVENV_COMMAND}")
88
  endif()
89

90
  if(CMAKE_GENERATOR MATCHES "Visual Studio|Xcode")
91
    set(CMake_TEST_EXPLICIT_MAKE_PROGRAM "")
92
  else()
93
    set(CMake_TEST_EXPLICIT_MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM}")
94
  endif()
95

96
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
97
    if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles" OR ("${CMAKE_GENERATOR}" MATCHES Ninja AND NOT WIN32))
98
      set(TEST_CompileCommandOutput 1)
99
    endif()
100
  endif()
101

102
  set(MAKE_IS_GNU)
103
  if(CMAKE_MAKE_PROGRAM MATCHES make)
104
    execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} no_such_target --version
105
      RESULT_VARIABLE res OUTPUT_VARIABLE out ERROR_VARIABLE out)
106
    if("${res}" STREQUAL "0")
107
      if("${out}" MATCHES "GNU")
108
        set(MAKE_IS_GNU 1)
109
      endif()
110
    endif()
111
  endif()
112

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

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

133
  set(build_generator_args
134
    --build-generator ${CMAKE_GENERATOR}
135
    )
136
  if(CMAKE_GENERATOR_PLATFORM)
137
    list(APPEND build_generator_args
138
      --build-generator-platform ${CMAKE_GENERATOR_PLATFORM}
139
      )
140
  endif()
141
  if(CMAKE_GENERATOR_TOOLSET)
142
    list(APPEND build_generator_args
143
      --build-generator-toolset ${CMAKE_GENERATOR_TOOLSET}
144
      )
145
  endif()
146

147
  if(CMake_TEST_EXPLICIT_MAKE_PROGRAM)
148
    list(APPEND build_generator_args
149
      --build-makeprogram ${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
150
      )
151
  endif()
152

153
  if(_isMultiConfig)
154
    set(test_options -C Debug)
155
  endif()
156

157
  # Look for git to use for tests.
158
  find_program(GIT_EXECUTABLE NAMES git)
159

160
  # Look for rpmbuild to use for tests.
161
  # The tool does not work with spaces in the path.
162
  if(NOT CMAKE_CURRENT_BINARY_DIR MATCHES " ")
163
    find_program(RPMBUILD_EXECUTABLE NAMES rpmbuild)
164
  else()
165
    set(RPMBUILD_EXECUTABLE "RPMBUILD_EXECUTABLE-NOTFOUND")
166
  endif()
167

168
  if(RPMBUILD_EXECUTABLE)
169
    set(CPACK_BINARY_RPM ON)
170
  else()
171
    set(CPACK_BINARY_RPM OFF)
172
  endif()
173

174
  # Look for dpkg to use for tests.
175
  find_program(DPKG_EXECUTABLE NAMES dpkg)
176

177
  if(DPKG_EXECUTABLE)
178
    set(CPACK_BINARY_DEB ON)
179
  else()
180
    set(CPACK_BINARY_DEB OFF)
181
  endif()
182

183
  if(CMake_TEST_CPACK_NUGET)
184
    set(CPACK_BINARY_NUGET ON)
185
  else()
186
    set(CPACK_BINARY_NUGET OFF)
187
  endif()
188

189
  if(WIN32)
190
    set(reg_vs14 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\14.0;InstallDir]")
191
    set(reg_ws10_0 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\14.0\\Setup\\Build Tools for Windows 10;srcPath]")
192
    set(reg_tegra "[HKEY_LOCAL_MACHINE\\SOFTWARE\\NVIDIA Corporation\\Nsight Tegra;sdkRoot]")
193
    set(reg_nasm "[HKEY_CURRENT_USER\\SOFTWARE\\nasm]")
194
    foreach(reg IN ITEMS vs14 ws10_0 tegra nasm)
195
      get_filename_component(r "${reg_${reg}}" ABSOLUTE)
196
      if(IS_DIRECTORY "${r}" AND NOT "${r}" STREQUAL "/registry")
197
        set(${reg} 1)
198
      else()
199
        set(${reg} 0)
200
      endif()
201
    endforeach()
202
    if(CMAKE_HOST_WIN32 AND COMMAND cmake_host_system_information)
203
      set(info_vs15 "VS_15_DIR")
204
      set(info_vs16 "VS_16_DIR")
205
      set(info_vs17 "VS_17_DIR")
206
      set(vs_versions)
207
      if(WIN32)
208
        if(NOT CMAKE_VERSION VERSION_LESS 3.21.20210624)
209
          set(vs_versions vs15 vs16 vs17)
210
        elseif(NOT CMAKE_VERSION VERSION_LESS 3.14)
211
          set(vs_versions vs15 vs16)
212
        elseif(NOT CMAKE_VERSION VERSION_LESS 3.8)
213
          set(vs_versions vs15)
214
        endif()
215
      endif()
216
      foreach(info IN LISTS vs_versions)
217
        cmake_host_system_information(RESULT found QUERY "${info_${info}}")
218
        if(found)
219
          set(${info} 1)
220
        else()
221
          set(${info} 0)
222
        endif()
223
      endforeach()
224
    endif()
225
  endif()
226

227
  if(CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND NOT DEFINED CMake_TEST_APPLE_SILICON)
228
    execute_process(COMMAND sysctl -q hw.optional.arm64
229
      OUTPUT_VARIABLE _sysctl_stdout
230
      ERROR_VARIABLE  _sysctl_stderr
231
      RESULT_VARIABLE _sysctl_result
232
      )
233
    if(_sysctl_result EQUAL 0 AND _sysctl_stdout MATCHES "hw.optional.arm64: 1")
234
      set(CMake_TEST_APPLE_SILICON 1)
235
    else()
236
      set(CMake_TEST_APPLE_SILICON 0)
237
    endif()
238
    unset(_sysctl_result)
239
    unset(_sysctl_stderr)
240
    unset(_sysctl_stdout)
241
  endif()
242

243
  #---------------------------------------------------------------------------
244
  # Add tests below here.
245

246
  if(NOT DEFINED CMake_TEST_Qt6)
247
    set(CMake_TEST_Qt6 1)
248
  endif()
249
  if(CMake_TEST_Qt6)
250
    find_package(Qt6 COMPONENTS Core Widgets QUIET NO_MODULE)
251
  endif()
252

253
  if(NOT DEFINED CMake_TEST_Qt5)
254
    set(CMake_TEST_Qt5 1)
255
  endif()
256
  if(CMake_TEST_Qt5)
257
    find_package(Qt5Widgets QUIET NO_MODULE)
258
  endif()
259

260
  # Collect a list of all test build directories.
261
  set(TEST_BUILD_DIRS)
262

263
  # Should the long tests be run?
264
  option(CMAKE_RUN_LONG_TESTS
265
    "Should the long tests be run (such as Bootstrap)." ON)
266
  mark_as_advanced(CMAKE_RUN_LONG_TESTS)
267

268
  if(CMAKE_RUN_LONG_TESTS)
269
    option(CTEST_TEST_CTEST
270
      "Should the tests that run a full sub ctest process be run?"
271
      OFF)
272
    mark_as_advanced(CTEST_TEST_CTEST)
273
  endif()
274

275
  option(CTEST_TEST_CPACK
276
    "Should the tests that use '--build-target package' be run?"
277
    ON)
278
  mark_as_advanced(CTEST_TEST_CPACK)
279
  set(CMake_TEST_XCODE_VERSION 0)
280
  if(APPLE)
281
    if(XCODE_VERSION)
282
      set(CMake_TEST_XCODE_VERSION "${XCODE_VERSION}")
283
    else()
284
      execute_process(
285
        COMMAND xcodebuild -version
286
        OUTPUT_VARIABLE _version
287
        ERROR_VARIABLE _stderr
288
        RESULT_VARIABLE _failed
289
        )
290
      if(NOT _failed AND _version MATCHES "^Xcode ([0-9]+(\\.[0-9]+)*)")
291
        set(CMake_TEST_XCODE_VERSION "${CMAKE_MATCH_1}")
292
      endif()
293
    endif()
294
    if(CMAKE_OSX_SYSROOT)
295
      execute_process(
296
        COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version ProductName
297
        OUTPUT_VARIABLE _stdout
298
        OUTPUT_STRIP_TRAILING_WHITESPACE
299
        ERROR_VARIABLE _stderr
300
        RESULT_VARIABLE _failed
301
        )
302
      if(NOT _failed)
303
        set(CMAKE_OSX_SDKPRODUCT "${_stdout}")
304
      endif()
305

306
      execute_process(
307
        COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version SDKVersion
308
        OUTPUT_VARIABLE _stdout
309
        OUTPUT_STRIP_TRAILING_WHITESPACE
310
        ERROR_VARIABLE _stderr
311
        RESULT_VARIABLE _failed
312
        )
313
      if(NOT _failed)
314
        set(CMAKE_OSX_SDKVERSION "${_stdout}")
315
      endif()
316
    endif()
317
  endif()
318

319
  if(CMake_TEST_XCODE_VERSION AND CMAKE_OSX_SDKVERSION AND CMAKE_OSX_SDKPRODUCT)
320
    if((NOT CMake_TEST_XCODE_VERSION VERSION_LESS 6.1) AND
321
      ((NOT CMAKE_OSX_SDKPRODUCT STREQUAL "Mac OS X") OR
322
      (NOT CMAKE_OSX_SDKVERSION VERSION_LESS 10.10)))
323
      if(CMAKE_GENERATOR STREQUAL "Xcode")
324
        set(CMake_TEST_XCODE_SWIFT 1)
325
      endif()
326
    endif()
327
  endif()
328
  if(NOT DEFINED CMake_TEST_Swift)
329
    if(CMAKE_Swift_COMPILER OR CMake_TEST_XCODE_SWIFT)
330
      set(CMake_TEST_Swift 1)
331
    endif()
332
  endif()
333

334
  if(NOT DEFINED CMake_TEST_OBJC)
335
    if(APPLE AND CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
336
      set(CMake_TEST_OBJC 1)
337
    endif()
338
  endif()
339

340
  if(CMake_TEST_FindPython)
341
    set(CMake_TEST_FindPython2 TRUE)
342
    set(CMake_TEST_FindPython3 TRUE)
343
  endif()
344
  if(CMake_TEST_FindPython_SABIModule)
345
    set(CMake_TEST_FindPython2_SABIModule TRUE)
346
    set(CMake_TEST_FindPython3_SABIModule TRUE)
347
  endif()
348
  if(CMake_TEST_FindPython_NumPy)
349
    set(CMake_TEST_FindPython2_NumPy TRUE)
350
    set(CMake_TEST_FindPython3_NumPy TRUE)
351
  endif()
352
  if(CMake_TEST_FindPython_Conda)
353
    set(CMake_TEST_FindPython3_Conda TRUE)
354
  endif()
355
  if(CMake_TEST_FindPython_IronPython)
356
    set(CMake_TEST_FindPython2_IronPython TRUE)
357
    set(CMake_TEST_FindPython3_IronPython TRUE)
358
  endif()
359
  if(CMake_TEST_FindPython_PyPy)
360
    set(CMake_TEST_FindPython2_PyPy TRUE)
361
    set(CMake_TEST_FindPython3_PyPy TRUE)
362
  endif()
363
  if (CMake_TEST_FindPython2 AND CMAKE_SYSTEM_NAME MATCHES "Linux|Darwin")
364
    set(CMake_TEST_FindPython2_SABIModule TRUE)
365
  endif()
366
  if (CMake_TEST_FindPython3 AND CMAKE_SYSTEM_NAME MATCHES "Linux|Darwin")
367
    set(CMake_TEST_FindPython3_SABIModule TRUE)
368
  endif()
369

370
  # Use 1500 or CTEST_TEST_TIMEOUT for long test timeout value,
371
  # whichever is greater.
372
  set(CMAKE_LONG_TEST_TIMEOUT 1500)
373
  if(CTEST_TEST_TIMEOUT)
374
    set(CMAKE_LONG_TEST_TIMEOUT ${CTEST_TEST_TIMEOUT})
375
  endif()
376
  if(CMAKE_LONG_TEST_TIMEOUT LESS 1500)
377
    set(CMAKE_LONG_TEST_TIMEOUT 1500)
378
  endif()
379

380
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
381
    add_subdirectory(CMakeLib)
382
  endif()
383
  add_subdirectory(CMakeOnly)
384
  add_subdirectory(RunCMake)
385

386
  add_subdirectory(FindPackageModeMakefileTest)
387

388
  add_test(NAME CMake.Copyright
389
    COMMAND ${CMAKE_CMAKE_COMMAND} -P ${CMAKE_CURRENT_SOURCE_DIR}/CMakeCopyright.cmake)
390

391
  # add a bunch of standard build-and-test style tests
392
  ADD_TEST_MACRO(CommandLineTest CommandLineTest)
393
  ADD_TEST_MACRO(FindPackageCMakeTest FindPackageCMakeTest)
394
  ADD_TEST_MACRO(FindPackageCpsTest FindPackageCpsTest)
395
  ADD_TEST_MACRO(StringFileTest StringFileTest)
396
  ADD_TEST_MACRO(TryCompile TryCompile)
397
  ADD_TEST_MACRO(SystemInformation SystemInformation)
398
  ADD_TEST_MACRO(MathTest MathTest)
399

400
  string(REPLACE ";" "$<SEMICOLON>" TEST_STDS_C "${CMake_TEST_C_STANDARDS}")
401
  string(REPLACE ";" "$<SEMICOLON>" TEST_STDS_CXX "${CMake_TEST_CXX_STANDARDS}")
402
  string(REPLACE ";" "$<SEMICOLON>" TEST_STDS_CUDA "${CMake_TEST_CUDA_STANDARDS}")
403
  string(REPLACE ";" "$<SEMICOLON>" TEST_STDS_HIP "${CMake_TEST_HIP_STANDARDS}")
404
  set(CompileFeatures_BUILD_OPTIONS
405
    -DCMake_TEST_C_STANDARDS=${TEST_STDS_C}
406
    -DCMake_TEST_CXX_STANDARDS=${TEST_STDS_CXX}
407
    -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
408
    -DCMake_TEST_CUDA_STANDARDS=${TEST_STDS_CUDA}
409
    -DCMake_TEST_HIP=${CMake_TEST_HIP}
410
    -DCMake_TEST_HIP_STANDARDS=${TEST_STDS_HIP}
411
    )
412
  ADD_TEST_MACRO(CompileFeatures CompileFeatures)
413
  set_property(TEST CompileFeatures APPEND PROPERTY LABELS "CUDA" "HIP")
414

415
  ADD_TEST_MACRO(CMakeCommands.target_compile_features)
416

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

482
  if(CMake_TEST_OBJC)
483
    add_subdirectory(ObjC)
484
    add_subdirectory(ObjCXX)
485
  endif()
486

487
  if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
488
    ADD_TEST_MACRO(CSharpOnly CSharpOnly)
489
    if(NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
490
      ADD_TEST_MACRO(CSharpLinkToCxx CSharpLinkToCxx)
491
      ADD_TEST_MACRO(CSharpLinkFromCxx CSharpLinkFromCxx)
492
    endif()
493
    ADD_TEST_MACRO(CSharpWin32GenEx CSharpWin32GenEx)
494
    set_tests_properties(CSharpWin32GenEx PROPERTIES
495
      PASS_REGULAR_EXPRESSION "Target \"CSharpWin32GenEx\" has a generator expression in its\n  WIN32_EXECUTABLE property\\.  This is not supported on managed executables\\."
496
      )
497
  endif()
498

499
  ADD_TEST_MACRO(COnly COnly)
500
  ADD_TEST_MACRO(CxxOnly CxxOnly)
501
  ADD_TEST_MACRO(CxxSubdirC CxxSubdirC)
502
  ADD_TEST_MACRO(OutDir runtime/OutDir)
503
  ADD_TEST_MACRO(OutName exe.OutName.exe)
504
  ADD_TEST_MACRO(ObjectLibrary UseCshared)
505
  ADD_TEST_MACRO(SharedLibraryArchive UseSLA)
506
  ADD_TEST_MACRO(NewlineArgs NewlineArgs)
507
  ADD_TEST_MACRO(SetLang SetLangX)
508
  ADD_TEST_MACRO(EmptyProperty EmptyProperty)
509
  ADD_TEST_MACRO(ExternalOBJ ExternalOBJ)
510
  ADD_TEST_MACRO(LinkDirectory bin/LinkDirectory)
511
  ADD_TEST_MACRO(LinkLanguage LinkLanguage)
512
  ADD_TEST_MACRO(LinkLine LinkLine)
513
  ADD_TEST_MACRO(MacroTest miniMacroTest)
514
  ADD_TEST_MACRO(FunctionTest miniFunctionTest)
515
  ADD_TEST_MACRO(ReturnTest ReturnTest)
516
  ADD_TEST_MACRO(Properties Properties)
517
  ADD_TEST_MACRO(Assembler HelloAsm)
518
  # relies on Linux syscall interface
519
  if(CMake_TEST_ASM_NASM AND CMAKE_SYSTEM_NAME MATCHES "Linux" AND CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64")
520
    ADD_TEST_MACRO(NasmOnly NasmOnly)
521
  endif()
522
  ADD_TEST_MACRO(SourceGroups SourceGroups)
523
  ADD_TEST_MACRO(Preprocess Preprocess)
524
  set(ExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
525
                                 -DCMake_TEST_CUDA:BOOL=${CMake_TEST_CUDA}
526
                                 -DCMake_INSTALL_NAME_TOOL_BUG:BOOL=${CMake_INSTALL_NAME_TOOL_BUG}
527
                                 )
528
  ADD_TEST_MACRO(ExportImport ExportImport)
529
  set_property(TEST ExportImport APPEND
530
    PROPERTY LABELS "CUDA")
531
  ADD_TEST_MACRO(Unset Unset)
532
  ADD_TEST_MACRO(PolicyScope PolicyScope)
533
  ADD_TEST_MACRO(EmptyLibrary EmptyLibrary)
534
  ADD_TEST_MACRO(CompileDefinitions CompileDefinitions)
535

536
  if(_isMultiConfig)
537
    set(CompileOptions_CTEST_OPTIONS --build-config $<CONFIGURATION>)
538
  else()
539
    set(CompileOptions_BUILD_OPTIONS -DCMAKE_BUILD_TYPE=$<CONFIGURATION>)
540
  endif()
541
  if(CMAKE_Fortran_COMPILER)
542
    list(APPEND CompileOptions_BUILD_OPTIONS -DTEST_FORTRAN=1)
543
  endif()
544
  ADD_TEST_MACRO(CompileOptions CompileOptions)
545
  set_property(TEST CompileOptions APPEND PROPERTY LABELS "Fortran")
546

547
  ADD_TEST_MACRO(CompatibleInterface CompatibleInterface)
548
  ADD_TEST_MACRO(CustomTransitiveProperties CustomTransitiveProperties)
549
  ADD_TEST_MACRO(AliasTarget AliasTarget)
550
  ADD_TEST_MACRO(StagingPrefix StagingPrefix)
551
  ADD_TEST_MACRO(ImportedSameName ImportedSameName)
552
  ADD_TEST_MACRO(InterfaceLibrary InterfaceLibrary)
553
  if(NOT CMAKE_GENERATOR STREQUAL "Xcode")
554
    if(_isMultiConfig)
555
      set(ConfigSources_CTEST_OPTIONS --build-config $<CONFIGURATION>)
556
    else()
557
      set(ConfigSources_BUILD_OPTIONS -DCMAKE_BUILD_TYPE=$<CONFIGURATION>)
558
    endif()
559
    ADD_TEST_MACRO(ConfigSources ConfigSources)
560
  endif()
561
  ADD_TEST_MACRO(SourcesProperty SourcesProperty)
562
  ADD_TEST_MACRO(SourceFileProperty SourceFileProperty)
563
  if(NOT CMAKE_GENERATOR STREQUAL "Xcode")
564
    ADD_TEST_MACRO(SourceFileIncludeDirProperty SourceFileIncludeDirProperty)
565
  endif()
566
  if(CMAKE_CXX_COMPILER_ID STREQUAL "LCC" OR (CMAKE_CXX_COMPILER_ID STREQUAL "GNU"
567
      AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7))
568
    set(runCxxDialectTest 1)
569
  endif()
570
  if(CMAKE_CXX_COMPILER_ID STREQUAL Clang
571
        AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4 AND NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
572
    if(NOT APPLE OR POLICY CMP0025)
573
      set(runCxxDialectTest 1)
574
    endif()
575
  endif()
576
  if(runCxxDialectTest)
577
    ADD_TEST_MACRO(CxxDialect CxxDialect)
578
  endif()
579
  set_tests_properties(EmptyLibrary PROPERTIES
580
    PASS_REGULAR_EXPRESSION "CMake Error: CMake can not determine linker language for target: test")
581
  ADD_TEST_MACRO(CrossCompile CrossCompile)
582
  set_tests_properties(CrossCompile PROPERTIES
583
    PASS_REGULAR_EXPRESSION "try_run.. invoked in cross-compiling mode")
584
  if(CMake_TEST_XCODE_VERSION)
585
    set(Architecture_BUILD_OPTIONS -DCMake_TEST_XCODE_VERSION=${CMake_TEST_XCODE_VERSION})
586
    ADD_TEST_MACRO(Architecture Architecture)
587
    set_tests_properties(Architecture PROPERTIES
588
      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)")
589
    set_property(TEST Architecture APPEND PROPERTY
590
      PASS_REGULAR_EXPRESSION "Skip test x86_64 only|found architecture '.*', required architecture '.*'")
591
  endif()
592

593
  list(APPEND TEST_BUILD_DIRS ${CMake_TEST_INSTALL_PREFIX})
594

595
  if(NOT DEFINED CMake_TEST_Qt4)
596
    set(CMake_TEST_Qt4 1)
597
  endif()
598
  if(CMake_TEST_Qt4 AND NOT Qt4_FOUND)
599
    find_package(Qt4 QUIET)
600
  endif()
601

602
  if(CMake_TEST_Qt4 AND Qt4_FOUND)
603
    # test whether the Qt4 which has been found works, on some machines
604
    # which run nightly builds there were errors like "wrong file format"
605
    # for libQtCore.so. So first check it works, and only if it does add
606
    # the automoc test.
607
    include(CheckCXXSourceCompiles)
608
    set(_save_CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}")
609
    set(_save_CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}")
610

611
    set(CMAKE_REQUIRED_INCLUDES ${QT_INCLUDES})
612
    set(CMAKE_REQUIRED_LIBRARIES ${QT_QTCORE_LIBRARIES})
613

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

617
    set(CMAKE_REQUIRED_INCLUDES "${_save_CMAKE_REQUIRED_INCLUDES}")
618
    set(CMAKE_REQUIRED_LIBRARIES "${_save_CMAKE_REQUIRED_LIBRARIES}")
619
  endif()
620

621
  # run test for BundleUtilities on supported platforms/compilers
622
  if((MSVC OR
623
      MINGW OR
624
      CMAKE_SYSTEM_NAME MATCHES "Linux" OR
625
      CMAKE_SYSTEM_NAME MATCHES "Darwin")
626
    AND NOT CMAKE_GENERATOR STREQUAL "Watcom WMake")
627

628
    add_test(BundleUtilities ${CMAKE_CTEST_COMMAND}
629
      --build-and-test
630
      "${CMake_SOURCE_DIR}/Tests/BundleUtilities"
631
      "${CMake_BINARY_DIR}/Tests/BundleUtilities"
632
      ${build_generator_args}
633
      --build-project BundleUtilities
634
      )
635
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleUtilities")
636

637
    # run test for DeployQt4 on supported platforms/compilers (which depends on BundleUtilities)
638
    # this test also depends on the existence of the standard qtiff plugin
639
    if(QT4_WORKS AND QT_QTSQL_FOUND)
640
      add_test(Qt4Deploy ${CMAKE_CTEST_COMMAND}
641
        --build-and-test
642
        "${CMake_SOURCE_DIR}/Tests/Qt4Deploy"
643
        "${CMake_BINARY_DIR}/Tests/Qt4Deploy"
644
        ${build_generator_args}
645
        --build-project Qt4Deploy
646
        --build-options
647
          -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
648
          -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
649
        )
650
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Deploy")
651
    endif()
652

653
  endif()
654

655
  set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/COnly")
656
  set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/CMakeBuildCOnly")
657
  set(CMAKE_BUILD_TEST_EXE COnly)
658
  configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
659
    "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake" @ONLY)
660
  add_test(CMakeBuildTest ${CMAKE_CMAKE_COMMAND} -P
661
    "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake")
662
  list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
663
  # now do it again for a project that has two project commands
664
  set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/DoubleProject")
665
  set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/DoubleProject")
666
  set(CMAKE_BUILD_TEST_EXE just_silly)
667
  configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
668
    "${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake" @ONLY)
669
  add_test(CMakeDoubleProject ${CMAKE_CMAKE_COMMAND} -P
670
    "${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake")
671
  list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
672

673
  ADD_TEST_MACRO(Module.CheckTypeSize CheckTypeSize)
674

675
  set(Module.CheckIPOSupported-C_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_C=${CMake_TEST_IPO_WORKS_C})
676
  ADD_TEST_MACRO(Module.CheckIPOSupported-C CheckIPOSupported-C)
677

678
  set(Module.CheckIPOSupported-CXX_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_CXX=${CMake_TEST_IPO_WORKS_CXX})
679
  ADD_TEST_MACRO(Module.CheckIPOSupported-CXX CheckIPOSupported-CXX)
680

681
  if(CMake_TEST_CUDA)
682
    ADD_TEST_MACRO(Module.CheckIPOSupported-CUDA CheckIPOSupported-CUDA)
683
    set_property(TEST Module.CheckIPOSupported-CUDA APPEND PROPERTY LABELS "CUDA")
684
  endif()
685

686
  if(CMAKE_Fortran_COMPILER)
687
    set(Module.CheckIPOSupported-Fortran_BUILD_OPTIONS -DCMake_TEST_IPO_WORKS_Fortran=${CMake_TEST_IPO_WORKS_Fortran})
688
    ADD_TEST_MACRO(Module.CheckIPOSupported-Fortran CheckIPOSupported-Fortran)
689
    set_property(TEST Module.CheckIPOSupported-Fortran APPEND PROPERTY LABELS "Fortran")
690
  endif()
691

692
  add_test(Module.ExternalData ${CMAKE_CTEST_COMMAND}
693
    --build-and-test
694
    "${CMake_SOURCE_DIR}/Tests/Module/ExternalData"
695
    "${CMake_BINARY_DIR}/Tests/Module/ExternalData"
696
    ${build_generator_args}
697
    --build-project ExternalDataTest
698
    --build-noclean
699
    --build-options
700
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
701
    --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} -V
702
    )
703
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Module/ExternalData")
704

705
  ADD_TEST_MACRO(Module.FindDependency FindDependency)
706

707
  ADD_TEST_MACRO(Module.WriteCompilerDetectionHeader WriteCompilerDetectionHeader)
708

709
  if(APPLE OR CMAKE_CXX_COMPILER_ID MATCHES "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "LCC")
710
    include(CheckCXXCompilerFlag)
711
    check_cxx_compiler_flag(-fPIE run_pic_test)
712
  else()
713
    if(CMAKE_CXX_COMPILER_ID MATCHES "PGI"
714
        OR CMAKE_CXX_COMPILER_ID MATCHES "PathScale"
715
        OR CMAKE_CXX_COMPILER_ID MATCHES "Intel")
716
      set(run_pic_test 0)
717
    else()
718
      set(run_pic_test 1)
719
    endif()
720
  endif()
721

722
  if(run_pic_test)
723
    ADD_TEST_MACRO(PositionIndependentTargets PositionIndependentTargets)
724
  endif()
725

726
  if(CMAKE_CXX_COMPILER_ID MATCHES "LCC" OR
727
    ((CMAKE_CXX_COMPILER_ID MATCHES "GNU") AND
728
    (NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 4.2) AND
729
    (CMAKE_SYSTEM_NAME MATCHES "Linux")))
730

731
    include(CheckCXXCompilerFlag)
732
    check_cxx_compiler_flag(
733
      -fvisibility-inlines-hidden run_inlines_hidden_test)
734
  endif()
735

736
  if(run_inlines_hidden_test)
737
    add_test(Visibility ${CMAKE_CTEST_COMMAND}
738
      --build-and-test
739
      "${CMake_SOURCE_DIR}/Tests/Visibility"
740
      "${CMake_BINARY_DIR}/Tests/Visibility"
741
      ${build_generator_args}
742
      --build-project Visibility
743
    )
744
    list(APPEND TEST_BUILD_DIRS
745
      "${CMake_BINARY_DIR}/Tests/Visibility"
746
    )
747
  endif()
748

749
  add_test(LinkFlags-prepare
750
    ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
751
    --build-and-test
752
    "${CMake_SOURCE_DIR}/Tests/LinkFlags"
753
    "${CMake_BINARY_DIR}/Tests/LinkFlags"
754
    ${build_generator_args}
755
    --build-project LinkFlags
756
    --build-target LinkFlags
757
    --build-options
758
      -DTEST_CONFIG=\${CTEST_CONFIGURATION_TYPE}
759
    )
760
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkFlags")
761

762
  macro(ADD_LINK_FLAGS_TEST name depends)
763
    add_test(LinkFlags-${name}
764
      ${CMAKE_CMAKE_COMMAND} --build "${CMake_BINARY_DIR}/Tests/LinkFlags"
765
      --target LinkFlags_${name} --config \${CTEST_CONFIGURATION_TYPE}
766
      )
767
    set_tests_properties(LinkFlags-${name} PROPERTIES
768
      PASS_REGULAR_EXPRESSION "BADFLAG" DEPENDS LinkFlags-${depends})
769
  endmacro()
770
  ADD_LINK_FLAGS_TEST(lib prepare)
771
  ADD_LINK_FLAGS_TEST(dll lib)
772
  ADD_LINK_FLAGS_TEST(mod dll)
773
  ADD_LINK_FLAGS_TEST(exe mod)
774
  ADD_LINK_FLAGS_TEST(lib_config exe)
775
  ADD_LINK_FLAGS_TEST(dll_config lib_config)
776
  ADD_LINK_FLAGS_TEST(mod_config dll_config)
777
  ADD_LINK_FLAGS_TEST(exe_config mod_config)
778
  ADD_LINK_FLAGS_TEST(lib_flags exe_config)
779
  ADD_LINK_FLAGS_TEST(dll_flags lib_flags)
780
  ADD_LINK_FLAGS_TEST(mod_flags dll_flags)
781
  ADD_LINK_FLAGS_TEST(exe_flags mod_flags)
782
  ADD_LINK_FLAGS_TEST(lib_flags_config exe_flags)
783
  ADD_LINK_FLAGS_TEST(dll_flags_config lib_flags_config)
784
  ADD_LINK_FLAGS_TEST(mod_flags_config dll_flags_config)
785
  ADD_LINK_FLAGS_TEST(exe_flags_config mod_flags_config)
786

787
  # test for correct sub-project generation
788
  # not implemented in Xcode or Ninja
789
  if(NOT CMAKE_GENERATOR MATCHES "Xcode|Ninja|FASTBuild")
790
    # run cmake and configure all of SubProject
791
    # but only build the independent executable car
792
    add_test(SubProject ${CMAKE_CTEST_COMMAND}
793
      --build-and-test
794
      "${CMake_SOURCE_DIR}/Tests/SubProject"
795
      "${CMake_BINARY_DIR}/Tests/SubProject"
796
      --build-project SubProject
797
      ${build_generator_args}
798
      --build-target car
799
      --test-command car
800
      )
801

802
    # For stage 2, do not run cmake again.
803
    # Then build the foo sub project which should build
804
    # the bar library which should be referenced because
805
    # foo links to the static library bar, but bar is not
806
    # directly in the foo sub project
807
    if(CMake_TEST_EXPLICIT_MAKE_PROGRAM)
808
      set(SubProject-Stage2_BUILD_MAKEPROGRAM
809
        --build-makeprogram ${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
810
        )
811
    endif()
812
    add_test(SubProject-Stage2  ${CMAKE_CTEST_COMMAND}
813
      --build-and-test
814
      "${CMake_SOURCE_DIR}/Tests/SubProject/foo"
815
      "${CMake_BINARY_DIR}/Tests/SubProject/foo"
816
      --build-generator ${CMAKE_GENERATOR}
817
      --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
818
      --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
819
      ${SubProject-Stage2_BUILD_MAKEPROGRAM}
820
      --build-nocmake
821
      --build-project foo
822
      --build-target foo
823
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubProject/foo"
824
      --test-command foo
825
      )
826
    set_tests_properties(SubProject-Stage2 PROPERTIES DEPENDS SubProject)
827
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubProject")
828
  endif()
829

830
  # add tests with more complex invocations
831
  add_test(Framework ${CMAKE_CTEST_COMMAND}
832
    --build-and-test
833
    "${CMake_SOURCE_DIR}/Tests/Framework"
834
    "${CMake_BINARY_DIR}/Tests/Framework"
835
    --build-two-config
836
    ${build_generator_args}
837
    --build-project Framework
838
    --build-options
839
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
840
    "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/Framework/Install"
841
    --test-command bar)
842
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Framework")
843

844
  add_test(TargetName ${CMAKE_CTEST_COMMAND}
845
    --build-and-test
846
    "${CMake_SOURCE_DIR}/Tests/TargetName"
847
    "${CMake_BINARY_DIR}/Tests/TargetName"
848
    --build-two-config
849
    ${build_generator_args}
850
    --build-project TargetName
851
    --test-command ${CMAKE_CMAKE_COMMAND} -E compare_files
852
    ${CMake_SOURCE_DIR}/Tests/TargetName/scripts/hello_world
853
    ${CMake_BINARY_DIR}/Tests/TargetName/scripts/hello_world)
854
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TargetName")
855

856
  add_test(LibName ${CMAKE_CTEST_COMMAND}
857
    --build-and-test
858
    "${CMake_SOURCE_DIR}/Tests/LibName"
859
    "${CMake_BINARY_DIR}/Tests/LibName"
860
    --build-two-config
861
    ${build_generator_args}
862
    --build-project LibName
863
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/LibName/lib"
864
    --build-options
865
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
866
    --test-command foobar
867
    )
868
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LibName")
869

870
  add_test(CustComDepend ${CMAKE_CTEST_COMMAND}
871
    --build-and-test
872
    "${CMake_SOURCE_DIR}/Tests/CustComDepend"
873
    "${CMake_BINARY_DIR}/Tests/CustComDepend"
874
    --build-two-config
875
    ${build_generator_args}
876
    --build-project CustComDepend
877
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustComDepend/bin"
878
    --test-command foo bar.c
879
    )
880
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustComDepend")
881

882
  add_test(ArgumentExpansion  ${CMAKE_CTEST_COMMAND}
883
    --build-and-test
884
    "${CMake_SOURCE_DIR}/Tests/ArgumentExpansion"
885
    "${CMake_BINARY_DIR}/Tests/ArgumentExpansion"
886
    ${build_generator_args}
887
    --build-project ArgumentExpansion
888
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ArgumentExpansion/bin"
889
    )
890
  set_tests_properties(ArgumentExpansion PROPERTIES
891
    FAIL_REGULAR_EXPRESSION "Unexpected: ")
892
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ArgumentExpansion")
893

894
  add_test(GeneratorExpression
895
    ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
896
    --build-and-test
897
    "${CMake_SOURCE_DIR}/Tests/GeneratorExpression"
898
    "${CMake_BINARY_DIR}/Tests/GeneratorExpression"
899
    ${build_generator_args}
900
    --build-project GeneratorExpression
901
    --build-options
902
      -DCMAKE_BUILD_TYPE=\${CTEST_CONFIGURATION_TYPE}
903
    --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} -V
904
    )
905
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/GeneratorExpression")
906

907
  add_test(CustomCommand  ${CMAKE_CTEST_COMMAND}
908
    --build-and-test
909
    "${CMake_SOURCE_DIR}/Tests/CustomCommand"
910
    "${CMake_BINARY_DIR}/Tests/CustomCommand"
911
    --build-two-config
912
    ${build_generator_args}
913
    --build-project CustomCommand
914
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustomCommand/bin"
915
    --build-options
916
    --test-command CustomCommand
917
    )
918
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommand")
919

920
  ADD_TEST_MACRO(CustomCommandByproducts CustomCommandByproducts)
921

922
  ADD_TEST_MACRO(CommandLength CommandLength)
923

924
  ADD_TEST_MACRO(EmptyDepends ${CMAKE_CTEST_COMMAND})
925

926
  add_test(CustomCommandWorkingDirectory  ${CMAKE_CTEST_COMMAND}
927
    --build-and-test
928
    "${CMake_SOURCE_DIR}/Tests/CustomCommandWorkingDirectory"
929
    "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory"
930
    --build-two-config
931
    ${build_generator_args}
932
    --build-project TestWorkingDir
933
    --test-command working
934
    )
935
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory")
936

937
  add_test(OutOfSource ${CMAKE_CTEST_COMMAND}
938
    --build-and-test
939
    "${CMake_SOURCE_DIR}/Tests/OutOfSource"
940
    "${CMake_BINARY_DIR}/Tests/OutOfSource"
941
    ${build_generator_args}
942
    --build-project OutOfSource
943
    --build-two-config
944
    --test-command
945
    "${CMake_BINARY_DIR}/Tests/OutOfSource/SubDir/OutOfSourceSubdir/simple")
946
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSource")
947
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSourceDeep")
948
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfBinary")
949

950
  add_test(BuildDepends ${CMAKE_CTEST_COMMAND}
951
    --build-and-test
952
    "${CMake_SOURCE_DIR}/Tests/BuildDepends"
953
    "${CMake_BINARY_DIR}/Tests/BuildDepends"
954
    ${build_generator_args}
955
    --build-project BuildDepends
956
    --build-options
957
    "-DCMake_TEST_XCODE_VERSION=${CMake_TEST_XCODE_VERSION}"
958
    )
959
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BuildDepends")
960

961
  set(MissingInstallInstallDir
962
    "${CMake_BINARY_DIR}/Tests/MissingInstall/InstallDirectory")
963
  add_test(MissingInstall ${CMAKE_CTEST_COMMAND}
964
    --build-and-test
965
    "${CMake_SOURCE_DIR}/Tests/MissingInstall"
966
    "${CMake_BINARY_DIR}/Tests/MissingInstall"
967
    ${build_generator_args}
968
    --build-project TestMissingInstall
969
    --build-two-config
970
    --build-options
971
    "-DCMAKE_INSTALL_PREFIX:PATH=${MissingInstallInstallDir}")
972
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MissingInstall")
973

974
  # By default, run the CPackComponents test if the CTEST_TEST_CPACK
975
  # option is ON:
976
  #
977
  set(CTEST_RUN_CPackComponents ${CTEST_TEST_CPACK})
978
  set(CTEST_package_X11_TEST ${CTEST_TEST_CPACK})
979
  set(CTEST_RUN_CPackComponentsForAll ${CTEST_TEST_CPACK})
980
  set(CTEST_RUN_CPackComponentsPrefix ${CTEST_TEST_CPACK})
981

982
  find_program(NSIS_MAKENSIS_EXECUTABLE NAMES makensis
983
    PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
984
    DOC "makensis program location"
985
    )
986

987
  # But on Windows, only run the CPackComponents test if the NSIS
988
  # installer builder is available:
989
  #
990
  if(WIN32)
991
    if(NSIS_MAKENSIS_EXECUTABLE)
992
      set(CTEST_RUN_CPackComponents ON)
993
    else()
994
      set(CTEST_RUN_CPackComponents OFF)
995
      set(CTEST_package_X11_TEST OFF)
996
    endif()
997
  endif()
998

999
  # On Windows run the CPackInnoSetupGenerator test
1000
  if(WIN32 AND CMake_TEST_CPACK_INNOSETUP)
1001
    add_test(CPackInnoSetupGenerator ${CMAKE_CTEST_COMMAND}
1002
      -C \${CTEST_CONFIGURATION_TYPE}
1003
      --build-and-test
1004
      "${CMake_SOURCE_DIR}/Tests/CPackInnoSetupGenerator"
1005
      "${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator"
1006
      ${build_generator_args}
1007
      --build-project CPackInnoSetupGenerator
1008
      --build-options
1009
      --test-command ${CMAKE_CMAKE_COMMAND}
1010
      "-DCPackInnoSetupGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator"
1011
      "-Dconfig=\${CTEST_CONFIGURATION_TYPE}"
1012
      -P "${CMake_SOURCE_DIR}/Tests/CPackInnoSetupGenerator/RunCPackVerifyResult.cmake")
1013

1014
    set_property(TEST CPackInnoSetupGenerator PROPERTY
1015
      ATTACHED_FILES_ON_FAIL
1016
      "${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator/_CPack_Packages/win32/INNOSETUP/ISCCOutput.log")
1017

1018
    set_property(TEST CPackInnoSetupGenerator PROPERTY
1019
      ATTACHED_FILES
1020
      "${CMake_BINARY_DIR}/Tests/CPackInnoSetupGenerator/_CPack_Packages/win32/INNOSETUP/ISScript.iss")
1021
  endif()
1022

1023
  # On Windows run the CPackNSISGenerator test
1024
  # if the nsis is available
1025
  if(WIN32 AND NSIS_MAKENSIS_EXECUTABLE)
1026
    add_test(CPackNSISGenerator ${CMAKE_CTEST_COMMAND}
1027
      -C \${CTEST_CONFIGURATION_TYPE}
1028
      --build-and-test
1029
      "${CMake_SOURCE_DIR}/Tests/CPackNSISGenerator"
1030
      "${CMake_BINARY_DIR}/Tests/CPackNSISGenerator"
1031
      ${build_generator_args}
1032
      --build-project CPackNSISGenerator
1033
      --build-options
1034
      --test-command ${CMAKE_CMAKE_COMMAND}
1035
        "-DCPackNSISGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackNSISGenerator"
1036
        "-Dconfig=\${CTEST_CONFIGURATION_TYPE}"
1037
        -P "${CMake_SOURCE_DIR}/Tests/CPackNSISGenerator/RunCPackVerifyResult.cmake")
1038

1039
    set_property(TEST CPackNSISGenerator PROPERTY
1040
      ATTACHED_FILES_ON_FAIL
1041
      "${CMake_BINARY_DIR}/Tests/CPackNSISGenerator/_CPack_Packages/win32/NSIS/NSISOutput.log")
1042
  endif()
1043

1044
  find_program(IFW_BINARYCREATOR_EXECUTABLE NAMES binarycreator
1045
    DOC "IFW binarycreator program location"
1046
  )
1047

1048
  if(IFW_BINARYCREATOR_EXECUTABLE)
1049
    add_test(CPackIFWGenerator ${CMAKE_CTEST_COMMAND}
1050
      -C \${CTEST_CONFIGURATION_TYPE}
1051
      --build-and-test
1052
      "${CMake_SOURCE_DIR}/Tests/CPackIFWGenerator"
1053
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator"
1054
      ${build_generator_args}
1055
      --build-project CPackIFWGenerator
1056
      --build-options
1057
      --test-command ${CMAKE_CMAKE_COMMAND}
1058
      "-DCPackIFWGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackIFWGenerator"
1059
      "-Dconfig=\${CTEST_CONFIGURATION_TYPE}"
1060
      -P "${CMake_SOURCE_DIR}/Tests/CPackIFWGenerator/RunCPackVerifyResult.cmake")
1061

1062
    set_property(TEST CPackIFWGenerator PROPERTY
1063
      ATTACHED_FILES_ON_FAIL
1064
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator/_CPack_Packages/Linux/IFW/IFWOutput.log"
1065
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator/_CPack_Packages/Darwin/IFW/IFWOutput.log"
1066
      "${CMake_BINARY_DIR}/Tests/CPackIFWGenerator/_CPack_Packages/win32/IFW/IFWOutput.log"
1067
    )
1068
  endif()
1069

1070
  if(CTEST_TEST_CPACK)
1071
    add_test(CPackUseDefaultVersion ${CMAKE_CTEST_COMMAND}
1072
      --build-and-test
1073
      "${CMake_SOURCE_DIR}/Tests/CPackUseDefaultVersion"
1074
      "${CMake_BINARY_DIR}/Tests/CPackUseDefaultVersion"
1075
      ${build_generator_args}
1076
      --build-project CPackUseDefaultVersion
1077
      --build-two-config
1078
      --build-options
1079
        ${CPackUseDefaultVersion_BUILD_OPTIONS})
1080
    set_tests_properties(CPackUseDefaultVersion PROPERTIES PASS_REGULAR_EXPRESSION "CPACK_PACKAGE_VERSION=0\\.1\\.1")
1081
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackUseDefaultVersion")
1082

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

1095
    add_test(CPackUseShortProjectVersion ${CMAKE_CTEST_COMMAND}
1096
      --build-and-test
1097
      "${CMake_SOURCE_DIR}/Tests/CPackUseShortProjectVersion"
1098
      "${CMake_BINARY_DIR}/Tests/CPackUseShortProjectVersion"
1099
      ${build_generator_args}
1100
      --build-project CPackUseShortProjectVersion
1101
      --build-two-config
1102
      --build-options
1103
        ${CPackUseProjectVersion_BUILD_OPTIONS})
1104
    set_tests_properties(CPackUseShortProjectVersion PROPERTIES PASS_REGULAR_EXPRESSION "CPACK_PACKAGE_VERSION=2")
1105
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackUseShortProjectVersion")
1106
  endif()
1107

1108
  if(CTEST_RUN_CPackComponents)
1109
    set(CPackComponents_BUILD_OPTIONS)
1110
    if(APPLE)
1111
      set(CPackComponents_BUILD_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
1112
      if(CMake_TEST_XCODE_VERSION VERSION_GREATER "4.6")
1113
        set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1114
          -DCPACK_BINARY_PRODUCTBUILD:BOOL=ON)
1115
      endif()
1116
    endif()
1117
    if(NSIS_MAKENSIS_EXECUTABLE)
1118
      execute_process(COMMAND ${NSIS_MAKENSIS_EXECUTABLE} "-VERSION" ERROR_QUIET OUTPUT_QUIET RESULT_VARIABLE NSIS_OK)
1119
      if("${NSIS_OK}" STREQUAL "0")
1120
        set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1121
          -DCPACK_BINARY_NSIS:BOOL=ON)
1122
      endif()
1123
    endif()
1124

1125
    add_test(CPackComponents ${CMAKE_CTEST_COMMAND}
1126
      --build-and-test
1127
      "${CMake_SOURCE_DIR}/Tests/CPackComponents"
1128
      "${CMake_BINARY_DIR}/Tests/CPackComponents"
1129
      ${build_generator_args}
1130
      --build-project CPackComponents
1131
      --build-two-config
1132
      --build-target package
1133
      --build-options
1134
        -DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
1135
        -DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
1136
        ${CPackComponents_BUILD_OPTIONS}
1137
        --graphviz=CPackComponents.dot
1138
      --test-command ${CMAKE_CMAKE_COMMAND}
1139
        "-DCPackComponents_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponents"
1140
        -P "${CMake_SOURCE_DIR}/Tests/CPackComponents/VerifyResult.cmake")
1141
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponents")
1142
  endif()
1143

1144
  if(CTEST_RUN_CPackComponentsForAll)
1145
    # Check whether if rpmbuild command is found
1146
    # before adding RPM tests
1147
    if(CPACK_BINARY_RPM)
1148
      list(APPEND ACTIVE_CPACK_GENERATORS RPM)
1149
    endif()
1150
    # Check whether if dpkg command is found
1151
    # before adding DEB tests
1152
    if(CPACK_BINARY_DEB)
1153
      list(APPEND ACTIVE_CPACK_GENERATORS DEB)
1154
    endif()
1155
    if(CMake_TEST_CPACK_NUGET)
1156
      list(APPEND ACTIVE_CPACK_GENERATORS NUGET)
1157
      set(CPACK_GENERATOR_STRING_NUGET NuGet)
1158
    endif()
1159

1160
    # ACTIVE_CPACK_GENERATORS variable
1161
    # now contains the list of 'active generators'
1162
    set(CPackComponentsForAll_BUILD_OPTIONS)
1163
    # set up list of CPack generators
1164
    list(APPEND ACTIVE_CPACK_GENERATORS "ZIP")
1165
    if(APPLE)
1166
      list(APPEND ACTIVE_CPACK_GENERATORS "DragNDrop")
1167
      if(CMake_TEST_XCODE_VERSION VERSION_GREATER "4.6")
1168
        list(APPEND ACTIVE_CPACK_GENERATORS "productbuild")
1169
      endif()
1170
    endif()
1171

1172
    # set up list of component packaging ways
1173
    list(APPEND CWAYLST "default")
1174
    list(APPEND CWAYLST "OnePackPerGroup")
1175
    list(APPEND CWAYLST "IgnoreGroup")
1176
    list(APPEND CWAYLST "AllInOne")
1177
    foreach(CPackGen IN LISTS ACTIVE_CPACK_GENERATORS)
1178
      if(NOT DEFINED CPACK_GENERATOR_STRING_${CPackGen})
1179
        set(CPACK_GENERATOR_STRING_${CPackGen} ${CPackGen})
1180
      endif()
1181
      set(CPackRun_CPackGen  "-DCPackGen=${CPACK_GENERATOR_STRING_${CPackGen}}")
1182
      foreach(CPackComponentWay IN LISTS CWAYLST)
1183
        set(CPackRun_CPackComponentWay "-DCPackComponentWay=${CPackComponentWay}")
1184
        add_test(CPackComponentsForAll-${CPackGen}-${CPackComponentWay}
1185
          ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
1186
          --build-and-test
1187
          "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll"
1188
          "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
1189
          ${build_generator_args}
1190
          --build-project CPackComponentsForAll
1191
          --build-options
1192
             -DCPACK_GENERATOR:STRING=${CPACK_GENERATOR_STRING_${CPackGen}}
1193
             -DCPACK_BINARY_${CPackGen}:BOOL=ON
1194
             ${CPackRun_CPackComponentWay}
1195
             ${CPackComponentsForAll_BUILD_OPTIONS}
1196
             --graphviz=CPackComponentsForAll.dot
1197
          --test-command ${CMAKE_CMAKE_COMMAND}
1198
            "-DCPackComponentsForAll_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
1199
            "${CPackRun_CPackGen}"
1200
            "${CPackRun_CPackComponentWay}"
1201
            -P "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll/RunCPackVerifyResult.cmake")
1202
        list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}")
1203
      endforeach()
1204
    endforeach()
1205

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

1246
      set(CPackGen "DEB")
1247
      set(CPackRun_CPackGen "-DCPackGen=${CPackGen}")
1248

1249
      foreach(CPackDEBConfiguration IN LISTS DEB_CONFIGURATIONS_TO_TEST)
1250
        set(CPackRun_CPackDEBConfiguration "-DCPackDEBConfiguration=${CPackDEBConfiguration}")
1251
        add_test(NAME ${DEB_TEST_NAMES}-${CPackDEBConfiguration} COMMAND
1252
          ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
1253
          --build-and-test
1254
              "${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}"
1255
              "${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}"
1256
              ${build_generator_args}
1257
          --build-project CPackComponentsDEB
1258
          --build-options
1259
              -DCPACK_GENERATOR:STRING=${CPackGen}
1260
              -DCPACK_BINARY_${CPackGen}:BOOL=ON
1261
              ${CPackRun_CPackDEBConfiguration}
1262
              ${CPackRun_CPackDEBConfiguration_ALL_CONFIGS}
1263
          --graphviz=${DEB_TEST_NAMES}.dot
1264
          --test-command ${CMAKE_CMAKE_COMMAND}
1265
              "-D${DEB_TEST_NAMES}_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}"
1266
              "-D${DEB_TEST_NAMES}_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}"
1267
              "${CPackRun_CPackGen}"
1268
              "${CPackRun_CPackDEBConfiguration}"
1269
              "-DCONFIG=$<CONFIG>"
1270
              -P "${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}/RunCPackVerifyResult-${CPackDEBConfiguration}.cmake")
1271
          list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}")
1272
      endforeach()
1273
    endif()
1274

1275
  endif()
1276

1277
  # By default, turn this test off (because it takes a long time...)
1278
  #
1279
  if(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
1280
    set(CTEST_RUN_CPackTestAllGenerators OFF)
1281

1282
    # ...but: if it appears to be a coverage dashboard, or long tests are
1283
    # on, then set it to the generic CTEST_TEST_CPACK setting.
1284
    #
1285
    if(CMAKE_CXX_FLAGS MATCHES "-ftest-coverage" OR
1286
      NOT "$ENV{COVFILE}" STREQUAL "" OR
1287
      CMAKE_RUN_LONG_TESTS)
1288
      set(CTEST_RUN_CPackTestAllGenerators ${CTEST_TEST_CPACK})
1289
    endif()
1290
  endif()
1291

1292
  if(CTEST_RUN_CPackTestAllGenerators)
1293
    add_test(CPackTestAllGenerators ${CMAKE_CTEST_COMMAND}
1294
      --build-and-test
1295
      "${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators"
1296
      "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators"
1297
      ${build_generator_args}
1298
      --build-project CPackTestAllGenerators
1299
      --test-command
1300
      ${CMAKE_CMAKE_COMMAND}
1301
        -D dir=${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators
1302
        -P ${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators/RunCPack.cmake
1303
      )
1304
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators")
1305
  endif()
1306

1307
  if(CTEST_RUN_CPackComponentsPrefix)
1308
    set(CPackComponents_BUILD_OPTIONS)
1309
    if(APPLE)
1310
      set(CPackComponents_BUILD_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
1311
      if(CMake_TEST_XCODE_VERSION VERSION_GREATER "4.6")
1312
        set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1313
          -DCPACK_BINARY_PRODUCTBUILD:BOOL=ON)
1314
      endif()
1315
    endif()
1316
    if(NOT NSIS_MAKENSIS_EXECUTABLE)
1317
      set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
1318
        -DCPACK_BINARY_NSIS:BOOL=OFF)
1319
    endif()
1320

1321
    add_test(CPackComponentsPrefix ${CMAKE_CTEST_COMMAND}
1322
      --build-and-test
1323
      "${CMake_SOURCE_DIR}/Tests/CPackComponentsPrefix"
1324
      "${CMake_BINARY_DIR}/Tests/CPackComponentsPrefix"
1325
      ${build_generator_args}
1326
      --build-project CPackComponentsPrefix
1327
      --build-two-config
1328
      --build-target package
1329
      --build-options
1330
        -DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
1331
        -DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
1332
        -DCPACK_BINARY_ZIP:BOOL=ON
1333
        ${CPackComponents_BUILD_OPTIONS}
1334
        )
1335
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsPrefix")
1336
  endif()
1337

1338
  if(CTEST_package_X11_TEST)
1339
    set(X11_build_target_arg --build-target package)
1340
  else()
1341
    set(X11_build_target_arg)
1342
  endif()
1343

1344
  add_test(X11 ${CMAKE_CTEST_COMMAND}
1345
    --build-and-test
1346
    "${CMake_SOURCE_DIR}/Tests/X11"
1347
    "${CMake_BINARY_DIR}/Tests/X11"
1348
    ${build_generator_args}
1349
    --build-project UseX11
1350
    --build-two-config
1351
    ${X11_build_target_arg}
1352
    --test-command  UseX11)
1353
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/X11")
1354

1355
  if(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
1356
    set(CTEST_RUN_CMakeTestAllGenerators ON)
1357
  endif()
1358

1359
  if(CTEST_RUN_CMakeTestAllGenerators)
1360
    add_test(CMakeTestAllGenerators ${CMAKE_CMAKE_COMMAND}
1361
        -D dir=${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators
1362
        -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
1363
        -P ${CMake_SOURCE_DIR}/Tests/CMakeTestAllGenerators/RunCMake.cmake
1364
      )
1365
    list(APPEND TEST_BUILD_DIRS
1366
      "${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators")
1367
    # This test runs a lot of processes.  Do not make them compete
1368
    # for resources with other tests.
1369
    set_property(TEST CMakeTestAllGenerators PROPERTY RUN_SERIAL 1)
1370
  endif()
1371

1372
  add_test(complex  ${CMAKE_CTEST_COMMAND}
1373
    --build-and-test
1374
    "${CMake_SOURCE_DIR}/Tests/Complex"
1375
    "${CMake_BINARY_DIR}/Tests/Complex"
1376
    --build-two-config
1377
    --build-config-sample "${CMAKE_CTEST_COMMAND}"
1378
    ${build_generator_args}
1379
    --build-project Complex
1380
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Complex/bin"
1381
    -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
1382
    --test-command complex
1383
    )
1384
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Complex")
1385

1386
  add_test(complexOneConfig  ${CMAKE_CTEST_COMMAND}
1387
    --build-and-test
1388
    "${CMake_SOURCE_DIR}/Tests/ComplexOneConfig"
1389
    "${CMake_BINARY_DIR}/Tests/ComplexOneConfig"
1390
    ${build_generator_args}
1391
    --build-project Complex
1392
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ComplexOneConfig/bin"
1393
    -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
1394
    --test-command complex)
1395
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ComplexOneConfig")
1396
  # because of the registry write these tests depend on each other
1397
  set_tests_properties(complex PROPERTIES DEPENDS complexOneConfig)
1398

1399
  add_test(Environment ${CMAKE_CTEST_COMMAND}
1400
    --build-and-test
1401
    "${CMake_SOURCE_DIR}/Tests/Environment"
1402
    "${CMake_BINARY_DIR}/Tests/Environment"
1403
    ${build_generator_args}
1404
    --build-project EnvironmentProj
1405
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Environment"
1406
    --test-command ${CMAKE_CTEST_COMMAND} -V
1407
    )
1408
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Environment")
1409
  set_property(TEST Environment APPEND
1410
    PROPERTY ENVIRONMENT
1411
      "SET_FROM_AMBIENT_unset=base"
1412
      "SET_FROM_AMBIENT_replace=base"
1413
      "SET_FROM_AMBIENT_string=base"
1414
      "SET_FROM_AMBIENT_path=base"
1415
      "SET_FROM_AMBIENT_list=base")
1416

1417
  add_test(QtAutomocNoQt  ${CMAKE_CTEST_COMMAND}
1418
    --build-and-test
1419
    "${CMake_SOURCE_DIR}/Tests/QtAutomocNoQt"
1420
    "${CMake_BINARY_DIR}/Tests/QtAutomocNoQt"
1421
    ${build_generator_args}
1422
    --build-project QtAutomocNoQt
1423
    --build-options
1424
      -DCMAKE_BUILD_TYPE=\${CTEST_CONFIGURATION_TYPE}
1425
    )
1426
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/QtAutomocNoQt")
1427

1428
  if(CMake_TEST_Qt6 AND Qt6Widgets_FOUND)
1429
    add_subdirectory(Qt6Autogen)
1430
  endif()
1431
  if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND)
1432
    add_subdirectory(Qt5Autogen)
1433
  endif()
1434
  if(QT4_WORKS AND QT_QTGUI_FOUND)
1435
    add_subdirectory(Qt4Autogen)
1436

1437
    add_test(Qt4Targets ${CMAKE_CTEST_COMMAND}
1438
      --build-and-test
1439
      "${CMake_SOURCE_DIR}/Tests/Qt4Targets"
1440
      "${CMake_BINARY_DIR}/Tests/Qt4Targets"
1441
      ${build_generator_args}
1442
      --build-project Qt4Targets
1443
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4Targets"
1444
      --build-options
1445
        -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
1446
      --test-command ${CMAKE_CTEST_COMMAND} -V
1447
      )
1448
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Targets")
1449

1450
    if(Qt5Widgets_FOUND AND NOT Qt5Widgets_VERSION VERSION_LESS 5.1.0)
1451
      add_test(Qt4And5AutomocForward ${CMAKE_CTEST_COMMAND}
1452
        --build-and-test
1453
        "${CMake_SOURCE_DIR}/Tests/Qt4And5Automoc"
1454
        "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocForward"
1455
        ${build_generator_args}
1456
        --build-project Qt4And5Automoc
1457
        --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocForward"
1458
        --test-command ${CMAKE_CTEST_COMMAND} -V
1459
        )
1460
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocForward")
1461
      add_test(Qt4And5AutomocReverse ${CMAKE_CTEST_COMMAND}
1462
        --build-and-test
1463
        "${CMake_SOURCE_DIR}/Tests/Qt4And5Automoc"
1464
        "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse"
1465
        ${build_generator_args}
1466
        --build-project Qt4And5Automoc
1467
        --build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse"
1468
        --build-options -DQT_REVERSE_FIND_ORDER=1
1469
        --test-command ${CMAKE_CTEST_COMMAND} -V
1470
        )
1471
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse")
1472
    endif()
1473
  endif()
1474

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

1546
  if(CMake_TEST_CUDA)
1547
    add_subdirectory(Cuda)
1548
    add_subdirectory(CudaOnly)
1549
  endif()
1550

1551
  if(CMake_TEST_HIP)
1552
    add_subdirectory(HIP)
1553
  endif()
1554

1555
  if(CMake_TEST_ISPC)
1556
    add_subdirectory(ISPC)
1557
  endif()
1558

1559
  if(CMake_TEST_FindGTest)
1560
    add_subdirectory(FindGTest)
1561
    add_subdirectory(GoogleTest)
1562
  endif()
1563

1564
  if(CMake_TEST_UseSWIG)
1565
    add_subdirectory(UseSWIG)
1566
  endif()
1567

1568
  if(CMake_TEST_FindRuby)
1569
    add_subdirectory(FindRuby)
1570
  endif()
1571

1572
  add_subdirectory(FindThreads)
1573

1574
  # Matlab module
1575
  # CMake_TEST_FindMatlab: indicates to look for Matlab (from PATH for Linux)
1576
  # CMake_TEST_FindMatlab_ROOT_DIR: indicates an optional root directory for Matlab, allows to select a version.
1577
  # CMake_TEST_FindMatlab_MCR: indicates the MCR is installed
1578
  # CMake_TEST_FindMatlab_MCR_ROOT_DIR: indicates an optional root directory for the MCR, required on Linux
1579
  if(CMake_TEST_FindMatlab OR CMake_TEST_FindMatlab_ROOT_DIR OR
1580
     CMake_TEST_FindMatlab_MCR OR CMake_TEST_FindMatlab_MCR_ROOT_DIR)
1581
    set(FindMatlab_additional_test_options)
1582
    if(CMake_TEST_FindMatlab_MCR OR CMake_TEST_FindMatlab_MCR_ROOT_DIR)
1583
      set(FindMatlab_additional_test_options -DIS_MCR=TRUE)
1584
    endif()
1585
    if(CMake_TEST_FindMatlab_ROOT_DIR)
1586
      set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMatlab_ROOT_DIR=${CMake_TEST_FindMatlab_ROOT_DIR}")
1587
    endif()
1588
    if(CMake_TEST_FindMatlab_MCR_ROOT_DIR)
1589
      set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMCR_ROOT:FILEPATH=${CMake_TEST_FindMatlab_MCR_ROOT_DIR}")
1590
    endif()
1591
    set(FindMatlab.basic_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1592
    ADD_TEST_MACRO(FindMatlab.basic_checks      ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1593
    set_property(TEST FindMatlab.basic_checks APPEND PROPERTY LABELS "Matlab")
1594
    set(FindMatlab.versions_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1595
    ADD_TEST_MACRO(FindMatlab.versions_checks   ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1596
    set_property(TEST FindMatlab.versions_checks APPEND PROPERTY LABELS "Matlab")
1597
    set(FindMatlab.components_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1598
    ADD_TEST_MACRO(FindMatlab.components_checks ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1599
    set_property(TEST FindMatlab.components_checks APPEND PROPERTY LABELS "Matlab")
1600
    set(FindMatlab.failure_reports_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1601
    ADD_TEST_MACRO(FindMatlab.failure_reports   ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1602
    set_property(TEST FindMatlab.failure_reports APPEND PROPERTY LABELS "Matlab")
1603
    set(FindMatlab.r2018a_check_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1604
    ADD_TEST_MACRO(FindMatlab.r2018a_check   ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1605
    set_property(TEST FindMatlab.r2018a_check APPEND PROPERTY LABELS "Matlab")
1606
    set(FindMatlab.targets_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1607
    ADD_TEST_MACRO(FindMatlab.targets_checks      ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1608
    set_property(TEST FindMatlab.targets_checks APPEND PROPERTY LABELS "Matlab")
1609
    set(FindMatlab.no_implicit_link_checks_BUILD_OPTIONS ${FindMatlab_additional_test_options})
1610
    ADD_TEST_MACRO(FindMatlab.no_implicit_link_checks      ${CMAKE_CTEST_COMMAND} -V -C $<CONFIGURATION>)
1611
    set_property(TEST FindMatlab.no_implicit_link_checks APPEND PROPERTY LABELS "Matlab")
1612
  endif()
1613

1614
  set(ExternalProject_BUILD_OPTIONS "")
1615
  foreach(vcs IN ITEMS CVS SVN GIT HG)
1616
    if(DEFINED CMake_TEST_ExternalProject_${vcs})
1617
      list(APPEND ExternalProject_BUILD_OPTIONS -DEP_TEST_${vcs}=${CMake_TEST_ExternalProject_${vcs}})
1618
    endif()
1619
  endforeach()
1620
  add_test(ExternalProject ${CMAKE_CTEST_COMMAND}
1621
    --build-and-test
1622
    "${CMake_SOURCE_DIR}/Tests/ExternalProject"
1623
    "${CMake_BINARY_DIR}/Tests/ExternalProject"
1624
    ${build_generator_args}
1625
    --build-project ExternalProjectTest
1626
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProject"
1627
    --build-options ${ExternalProject_BUILD_OPTIONS}
1628
    --test-command ${CMAKE_CTEST_COMMAND} -V
1629
    )
1630
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProject")
1631
  set_tests_properties(ExternalProject PROPERTIES
1632
    ENVIRONMENT GIT_ALLOW_PROTOCOL=file
1633
    RUN_SERIAL 1
1634
    TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
1635

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

1646
  add_test(NAME ExternalProjectSourceSubdir
1647
    COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
1648
    --build-and-test
1649
    "${CMake_SOURCE_DIR}/Tests/ExternalProjectSourceSubdir"
1650
    "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdir"
1651
    ${build_generator_args}
1652
    --build-project ExternalProjectSourceSubdir
1653
    )
1654
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdir")
1655

1656
  add_test(NAME ExternalProjectSourceSubdirNotCMake
1657
    COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
1658
    --build-and-test
1659
    "${CMake_SOURCE_DIR}/Tests/ExternalProjectSourceSubdirNotCMake"
1660
    "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdirNotCMake"
1661
    ${build_generator_args}
1662
    --build-project ExternalProjectSourceSubdirNotCMake
1663
    )
1664
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectSourceSubdirNotCMake")
1665

1666
  add_test(ExternalProjectLocal ${CMAKE_CTEST_COMMAND}
1667
    --build-and-test
1668
    "${CMake_SOURCE_DIR}/Tests/ExternalProjectLocal"
1669
    "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal"
1670
    ${build_generator_args}
1671
    --build-project ExternalProjectLocalTest
1672
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal"
1673
    --test-command ${CMAKE_CTEST_COMMAND} -V
1674
    )
1675
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal")
1676
  set_tests_properties(ExternalProjectLocal PROPERTIES
1677
    RUN_SERIAL 1
1678
    TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
1679

1680
  add_test(ExternalProjectUpdateSetup ${CMAKE_CTEST_COMMAND}
1681
    --build-and-test
1682
    "${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate"
1683
    "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
1684
    ${build_generator_args}
1685
    --build-project ExternalProjectUpdateTest
1686
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
1687
    --test-command ${CMAKE_CTEST_COMMAND} -V
1688
    )
1689
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
1690
  set_tests_properties(ExternalProjectUpdateSetup PROPERTIES
1691
    RUN_SERIAL 1
1692
    TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
1693

1694
  add_test(NAME ExternalProjectUpdate
1695
    COMMAND ${CMAKE_CMAKE_COMMAND}
1696
    -DExternalProjectUpdate_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
1697
    -DExternalProjectUpdate_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate
1698
    -DCMAKE_GENERATOR=${CMAKE_GENERATOR}
1699
    -DCMAKE_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
1700
    -DCMAKE_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
1701
    -DCMAKE_CTEST_COMMAND=${CMAKE_CTEST_COMMAND}
1702
    -P ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate/ExternalProjectUpdateTest.cmake
1703
    )
1704
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
1705
  set_tests_properties(ExternalProjectUpdate PROPERTIES
1706
    RUN_SERIAL 1
1707
    TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT}
1708
    WORKING_DIRECTORY ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
1709
    DEPENDS ExternalProjectUpdateSetup
1710
    )
1711

1712
  execute_process(
1713
    COMMAND ${CMAKE_COMMAND}
1714
    "-E" create_symlink
1715
    "${CMake_SOURCE_DIR}/Tests/CMakeLists.txt"        # random source file that exists
1716
    "${CMake_BINARY_DIR}/Tests/try_to_create_symlink" # random target file in existing directory
1717
    RESULT_VARIABLE _symlink_result
1718
    OUTPUT_VARIABLE _symlink_stdout
1719
    ERROR_VARIABLE _symlink_stderr
1720
    )
1721
  if(_symlink_result EQUAL 0)
1722
    file(REMOVE "${CMake_BINARY_DIR}/Tests/try_to_create_symlink")
1723
    function(add_installmode_test _mode)
1724
      set(ENV{CMAKE_INSTALL_MODE} _mode)
1725
      set(_maybe_InstallMode_CTEST_OPTIONS)
1726
      set(_maybe_BUILD_OPTIONS)
1727
      if(_isMultiConfig)
1728
        set(_maybe_CTEST_OPTIONS -C $<CONFIGURATION>)
1729
      else()
1730
        set(_maybe_BUILD_OPTIONS "-DCMAKE_BUILD_TYPE=$<CONFIGURATION>")
1731
      endif()
1732
      add_test(
1733
        NAME "InstallMode-${_mode}"
1734
        COMMAND
1735
          ${CMAKE_CTEST_COMMAND} -V ${_maybe_CTEST_OPTIONS}
1736
        --build-and-test
1737
          "${CMake_SOURCE_DIR}/Tests/InstallMode"
1738
          "${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}"
1739
        ${build_generator_args}
1740
        --build-project superpro
1741
        --build-exe-dir "${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}"
1742
        --build-options
1743
          ${_maybe_BUILD_OPTIONS}
1744
          "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}/install"
1745
        )
1746
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/InstallMode-${_mode}")
1747
      unset(ENV{CMAKE_INSTALL_MODE})
1748
    endfunction()
1749

1750
    add_installmode_test(COPY)
1751
    add_installmode_test(REL_SYMLINK)
1752
    add_installmode_test(REL_SYMLINK_OR_COPY)
1753
    add_installmode_test(ABS_SYMLINK)
1754
    add_installmode_test(ABS_SYMLINK_OR_COPY)
1755
    add_installmode_test(SYMLINK)
1756
    add_installmode_test(SYMLINK_OR_COPY)
1757
  endif()
1758

1759
  function(add_importexport_test export_name import_name)
1760
    set(install_dir
1761
      "${CMake_BINARY_DIR}/Tests/ImportExport/Install${export_name}")
1762
    set(export_build_dir "${CMake_BINARY_DIR}/Tests/ImportExport/${export_name}Build")
1763
    set(export_test_name "Guide.ImportExport.${export_name}")
1764
    add_test(${export_test_name} ${CMAKE_CTEST_COMMAND}
1765
      -C "Release"
1766
      --build-and-test
1767
      "${CMake_SOURCE_DIR}/Help/guide/importing-exporting/${export_name}"
1768
      "${export_build_dir}"
1769
      ${build_generator_args}
1770
      --build-project ${export_name}
1771
      --build-target install
1772
      --build-options
1773
      "-DCMAKE_INSTALL_PREFIX:PATH=${install_dir}")
1774
    list(APPEND TEST_BUILD_DIRS "${export_build_dir}")
1775

1776
    set(import_build_dir "${CMake_BINARY_DIR}/Tests/ImportExport/${import_name}Build")
1777
    set(import_test_name "Guide.ImportExport.${import_name}")
1778
    add_test(${import_test_name} ${CMAKE_CTEST_COMMAND}
1779
      -C "Release"
1780
      --build-and-test
1781
      "${CMake_SOURCE_DIR}/Help/guide/importing-exporting/${import_name}"
1782
      "${import_build_dir}"
1783
      ${build_generator_args}
1784
      --build-project ${import_name}
1785
      --build-options
1786
      "-DCMAKE_PREFIX_PATH:PATH=${install_dir}")
1787
    set_tests_properties(${import_test_name} PROPERTIES DEPENDS ${export_test_name})
1788
    list(APPEND TEST_BUILD_DIRS "${import_build_dir}")
1789
  endfunction()
1790

1791
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
1792
    add_importexport_test("MyExe" "Importing")
1793
    add_importexport_test("MathFunctions" "Downstream")
1794
    add_importexport_test("MathFunctionsComponents" "DownstreamComponents")
1795
  endif()
1796

1797
  add_test(testing ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
1798
    --build-and-test
1799
    "${CMake_SOURCE_DIR}/Tests/Testing"
1800
    "${CMake_BINARY_DIR}/Tests/Testing"
1801
    ${build_generator_args}
1802
    --build-project Testing
1803
    --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
1804
    )
1805
  set_tests_properties(testing PROPERTIES PASS_REGULAR_EXPRESSION "Passed")
1806
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Testing")
1807

1808
  add_test(wrapping  ${CMAKE_CTEST_COMMAND}
1809
    --build-and-test
1810
    "${CMake_SOURCE_DIR}/Tests/Wrapping"
1811
    "${CMake_BINARY_DIR}/Tests/Wrapping"
1812
    ${build_generator_args}
1813
    --build-project Wrapping
1814
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1815
    --test-command wrapping
1816
    )
1817
  add_test(qtwrapping  ${CMAKE_CTEST_COMMAND}
1818
    --build-and-test
1819
    "${CMake_SOURCE_DIR}/Tests/Wrapping"
1820
    "${CMake_BINARY_DIR}/Tests/Wrapping"
1821
    ${build_generator_args}
1822
    --build-project Wrapping
1823
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1824
      --test-command qtwrapping
1825
      )
1826
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Wrapping")
1827

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

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

1850
  add_test(testdriver3  ${CMAKE_CTEST_COMMAND}
1851
    --build-and-test
1852
    "${CMake_SOURCE_DIR}/Tests/TestDriver"
1853
    "${CMake_BINARY_DIR}/Tests/TestDriver3"
1854
    ${build_generator_args}
1855
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1856
    --build-project TestDriverTest
1857
    --test-command TestDriverTest subdir/test3
1858
    )
1859
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver3")
1860

1861
  add_test(testdriver4  ${CMAKE_CTEST_COMMAND}
1862
    --build-and-test
1863
    "${CMake_SOURCE_DIR}/Tests/TestDriver"
1864
    "${CMake_BINARY_DIR}/Tests/TestDriver4"
1865
    ${build_generator_args}
1866
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1867
    --build-project TestDriverTest
1868
    --test-command TestDriverTest -A test2
1869
    )
1870
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver4")
1871

1872
  add_test(testdriver5  ${CMAKE_CTEST_COMMAND}
1873
    --build-and-test
1874
    "${CMake_SOURCE_DIR}/Tests/TestDriver"
1875
    "${CMake_BINARY_DIR}/Tests/TestDriver5"
1876
    ${build_generator_args}
1877
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
1878
    --build-project TestDriverTest
1879
    --test-command TestDriverTest -A test2
1880
    )
1881
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver5")
1882
  set_tests_properties(testdriver5 PROPERTIES
1883
    PASS_REGULAR_EXPRESSION
1884
    "TAP version 13\n1\\.\\.3.+ok 1 test1 # [0-9]+\\.[0-9]+.*All tests finished."
1885
    )
1886

1887
  add_test(Dependency ${CMAKE_CTEST_COMMAND}
1888
    --build-and-test
1889
    "${CMake_SOURCE_DIR}/Tests/Dependency"
1890
    "${CMake_BINARY_DIR}/Tests/Dependency"
1891
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/Dependency/Exec"
1892
    ${build_generator_args}
1893
    --build-project Dependency
1894
    --test-command exec
1895
    )
1896
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Dependency")
1897

1898
  if(CMAKE_SYSTEM_NAME MATCHES syllable)
1899

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

1906
    set(_DLL_PATH "$ENV{DLL_PATH}")
1907
    if(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.(:.*)?$")
1908
      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")
1909
    endif()
1910
    if(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.\\./lib(:.*)?$")
1911
      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")
1912
    endif()
1913

1914
  else()
1915

1916
    add_test(JumpWithLibOut  ${CMAKE_CTEST_COMMAND}
1917
      --build-and-test
1918
      "${CMake_SOURCE_DIR}/Tests/Jump"
1919
      "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut"
1920
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Executable"
1921
      --build-project Jump
1922
      ${build_generator_args}
1923
      --build-options
1924
        -DLIBRARY_OUTPUT_PATH:PATH=${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Lib
1925
      --test-command jumpExecutable
1926
      )
1927

1928
    add_test(JumpNoLibOut  ${CMAKE_CTEST_COMMAND}
1929
      --build-and-test
1930
      "${CMake_SOURCE_DIR}/Tests/Jump"
1931
      "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut"
1932
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
1933
      --build-run-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
1934
      --build-project Jump
1935
      ${build_generator_args}
1936
      --test-command jumpExecutable
1937
      )
1938
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Jump")
1939

1940
    add_test(Plugin ${CMAKE_CTEST_COMMAND}
1941
      --build-and-test
1942
      "${CMake_SOURCE_DIR}/Tests/Plugin"
1943
      "${CMake_BINARY_DIR}/Tests/Plugin"
1944
      ${build_generator_args}
1945
      --build-project Plugin
1946
      --build-two-config
1947
      --test-command bin/example)
1948
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Plugin")
1949

1950
    if(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
1951
      ADD_TEST_MACRO(RuntimePath RuntimePath)
1952
    endif()
1953
  endif()
1954

1955
  if(APPLE AND "${DARWIN_MAJOR_VERSION}" GREATER 9)
1956
    add_test(MacRuntimePath ${CMAKE_CTEST_COMMAND}
1957
      --build-and-test
1958
      "${CMake_SOURCE_DIR}/Tests/MacRuntimePath"
1959
      "${CMake_BINARY_DIR}/Tests/MacRuntimePath"
1960
      ${build_generator_args}
1961
      --build-project MacRuntimePath
1962
      --build-options
1963
        -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
1964
      )
1965
  endif()
1966

1967
  if(CMake_TEST_XCODE_VERSION AND NOT CMake_TEST_XCODE_VERSION VERSION_LESS 5)
1968
    if(NOT CMake_TEST_XCTest_DEPLOYMENT_TARGET)
1969
      execute_process(
1970
        COMMAND sw_vers -productVersion
1971
        OUTPUT_VARIABLE OSX_VERSION
1972
        OUTPUT_STRIP_TRAILING_WHITESPACE
1973
        )
1974
      if(OSX_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
1975
        set(CMake_TEST_XCTest_DEPLOYMENT_TARGET "${CMAKE_MATCH_1}")
1976
      endif()
1977
    endif()
1978
    if(CMake_TEST_XCTest_DEPLOYMENT_TARGET)
1979
      set(XCTest_CTEST_OPTIONS --build-config $<CONFIGURATION>)
1980
      set(XCTest_BUILD_OPTIONS -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMake_TEST_XCTest_DEPLOYMENT_TARGET} -DCMAKE_OSX_SYSROOT=macosx)
1981
      ADD_TEST_MACRO(XCTest ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION> -V)
1982
    endif()
1983
  endif()
1984

1985
  add_test(linkorder1 ${CMAKE_CTEST_COMMAND}
1986
    --build-and-test
1987
    "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
1988
    "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
1989
    ${build_generator_args}
1990
    --build-project LinkLineOrder
1991
    --test-command Exec1
1992
    )
1993

1994
  add_test(linkorder2  ${CMAKE_CTEST_COMMAND}
1995
    --build-and-test
1996
    "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
1997
    "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
1998
    ${build_generator_args}
1999
    --build-project LinkLineOrder
2000
    --test-command Exec2
2001
    )
2002
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkLineOrder")
2003
  set_tests_properties(qtwrapping PROPERTIES DEPENDS wrapping)
2004
  set_tests_properties(testdriver1 PROPERTIES DEPENDS qtwrapping)
2005
  set_tests_properties(testdriver2 PROPERTIES DEPENDS testdriver1)
2006
  set_tests_properties(testdriver3 PROPERTIES DEPENDS testdriver2)
2007
  set_tests_properties(linkorder2 PROPERTIES DEPENDS linkorder1)
2008

2009
  # Test static linking on toolchains known to support it.
2010
  if((CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "LCC")
2011
      AND NOT APPLE AND NOT WIN32 AND NOT CYGWIN
2012
      AND EXISTS "/usr/lib/libm.a")
2013
    add_test(LinkStatic  ${CMAKE_CTEST_COMMAND}
2014
      --build-and-test
2015
      "${CMake_SOURCE_DIR}/Tests/LinkStatic"
2016
      "${CMake_BINARY_DIR}/Tests/LinkStatic"
2017
      ${build_generator_args}
2018
      --build-project LinkStatic
2019
      --build-options
2020
        -DMATH_LIBRARY:FILEPATH=/usr/lib/libm.a
2021
      --test-command LinkStatic
2022
      )
2023
  endif()
2024

2025
  if(MAKE_SUPPORTS_SPACES
2026
      AND NOT CMAKE_GENERATOR STREQUAL "Xcode"
2027
      AND NOT CMAKE_GENERATOR STREQUAL "Watcom WMake"
2028
      )
2029
    add_test(SubDirSpaces ${CMAKE_CTEST_COMMAND}
2030
      --build-and-test
2031
      "${CMake_SOURCE_DIR}/Tests/SubDirSpaces"
2032
      "${CMake_BINARY_DIR}/Tests/SubDirSpaces"
2033
      --build-exe-dir
2034
      "${CMake_BINARY_DIR}/Tests/SubDirSpaces/Executable Sources"
2035
      ${build_generator_args}
2036
      --build-project SUBDIR
2037
      --test-command test
2038
      "${CMake_BINARY_DIR}/Tests/SubDirSpaces/ShouldBeHere"
2039
      "${CMake_BINARY_DIR}/Tests/SubDirSpaces/testfromsubdir.obj"
2040
      )
2041
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDirSpaces")
2042
  endif()
2043

2044
  if(WIN32)
2045
    add_test(SubDir ${CMAKE_CTEST_COMMAND}
2046
      --build-and-test
2047
      "${CMake_SOURCE_DIR}/Tests/SubDir"
2048
      "${CMake_BINARY_DIR}/Tests/SubDir"
2049
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
2050
      ${build_generator_args}
2051
      --build-project SUBDIR
2052
      --test-command test
2053
      "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
2054
      "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.obj"
2055
      )
2056
  else()
2057
    add_test(SubDir ${CMAKE_CTEST_COMMAND}
2058
      --build-and-test
2059
      "${CMake_SOURCE_DIR}/Tests/SubDir"
2060
      "${CMake_BINARY_DIR}/Tests/SubDir"
2061
      --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
2062
      ${build_generator_args}
2063
      --build-project SUBDIR
2064
      --test-command test
2065
      "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
2066
      "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.o"
2067
      )
2068
  endif()
2069
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDir")
2070

2071
  if(MSVC OR (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND CMAKE_C_SIMULATE_ID STREQUAL "MSVC"))
2072
    ADD_TEST_MACRO(PDBDirectoryAndName myexe)
2073
    if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" OR NOT "x${CMAKE_C_COMPILER_FRONTEND_VARIANT}" STREQUAL "xGNU")
2074
      ADD_TEST_MACRO(ForceInclude foo)
2075
    endif()
2076
    if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang" AND NOT CMAKE_C_COMPILER_ID STREQUAL "IntelLLVM")
2077
      ADD_TEST_MACRO(PrecompiledHeader foo)
2078
    endif()
2079

2080
    set(MSVCDebugInformationFormat_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2081
    if(CMAKE_Fortran_COMPILER)
2082
      list(APPEND MSVCDebugInformationFormat_BUILD_OPTIONS -DCMake_TEST_Fortran=1)
2083
    endif()
2084
    ADD_TEST_MACRO(MSVCDebugInformationFormat)
2085
    set_property(TEST MSVCDebugInformationFormat APPEND
2086
      PROPERTY LABELS "CUDA" "Fortran")
2087

2088
    set(MSVCRuntimeChecks_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2089
    if(CMAKE_Fortran_COMPILER)
2090
      list(APPEND MSVCRuntimeChecks_BUILD_OPTIONS -DCMake_TEST_Fortran=1)
2091
    endif()
2092
    ADD_TEST_MACRO(MSVCRuntimeChecks)
2093
    set_property(TEST MSVCRuntimeChecks APPEND
2094
      PROPERTY LABELS "CUDA" "Fortran")
2095

2096
    set(MSVCRuntimeLibrary_BUILD_OPTIONS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
2097
    ADD_TEST_MACRO(MSVCRuntimeLibrary)
2098
    set_property(TEST MSVCRuntimeLibrary APPEND
2099
      PROPERTY LABELS "CUDA")
2100
    if(CMAKE_Fortran_COMPILER)
2101
      ADD_TEST_MACRO(MSVCRuntimeLibrary.Fortran)
2102
      set_property(TEST MSVCRuntimeLibrary.Fortran APPEND PROPERTY LABELS "Fortran")
2103
    endif()
2104
  endif()
2105
  if(MSVC OR
2106
      "${CMAKE_GENERATOR}" MATCHES "(MSYS|MinGW) Makefiles")
2107
    ADD_TEST_MACRO(ModuleDefinition example_exe)
2108
  endif()
2109

2110
  if(CMAKE_C_COMPILER_ID MATCHES "Watcom" AND WIN32)
2111
    ADD_TEST_MACRO(WatcomRuntimeLibrary)
2112
  endif()
2113

2114
  ADD_TEST_MACRO(CheckCompilerRelatedVariables CheckCompilerRelatedVariables)
2115

2116
  if("${CMAKE_GENERATOR}" MATCHES "^Ninja$|Makefile|FASTBuild")
2117
    add_test(MakeClean ${CMAKE_CTEST_COMMAND}
2118
      --build-and-test
2119
      "${CMake_SOURCE_DIR}/Tests/MakeClean"
2120
      "${CMake_BINARY_DIR}/Tests/MakeClean"
2121
      ${build_generator_args}
2122
      --build-project MakeClean
2123
      --build-exe-dir "${CMake_BINARY_DIR}/MakeClean"
2124
      --test-command check_clean
2125
      )
2126
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MakeClean")
2127
  endif()
2128

2129
  if(CMake_TEST_MFC)
2130
    add_test(MFC ${CMAKE_CTEST_COMMAND}
2131
      --build-and-test
2132
      "${CMake_SOURCE_DIR}/Tests/MFC"
2133
      "${CMake_BINARY_DIR}/Tests/MFC"
2134
      --build-two-config
2135
      ${build_generator_args}
2136
      --build-project mfc_driver
2137
      --test-command ${CMAKE_CTEST_COMMAND}
2138
        -C \${CTEST_CONFIGURATION_TYPE} -VV)
2139
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MFC")
2140
  endif()
2141

2142
  if(MSVC AND NOT MSVC_VERSION LESS 1700
2143
     AND (CMAKE_C_COMPILER_ARCHITECTURE_ID STREQUAL "ARM64")
2144
      )
2145
    ADD_TEST_MACRO(VSMARMASM VSMARMASM)
2146
  endif()
2147

2148
  if(MSVC AND NOT MSVC_VERSION LESS 1310
2149
     AND (NOT CMAKE_C_COMPILER_ARCHITECTURE_ID STREQUAL "ARM64")
2150
      )
2151
    ADD_TEST_MACRO(VSMASM VSMASM)
2152
  endif()
2153

2154
  if(CMAKE_GENERATOR MATCHES "Visual Studio")
2155
    if(NOT MSVC60)
2156
      ADD_TEST_MACRO(SBCS SBCS)
2157
    endif()
2158

2159
    if(NOT CMAKE_GENERATOR_TOOLSET STREQUAL "v90"
2160
        AND NOT CMAKE_VS_PLATFORM_NAME STREQUAL "ARM64")
2161
      ADD_TEST_MACRO(VSWindowsFormsResx VSWindowsFormsResx)
2162
      ADD_TEST_MACRO(VSManagedCustomCommand)
2163
    endif()
2164

2165
    add_test(VSExternalInclude ${CMAKE_CTEST_COMMAND}
2166
      --build-and-test
2167
      "${CMake_SOURCE_DIR}/Tests/VSExternalInclude"
2168
      "${CMake_BINARY_DIR}/Tests/VSExternalInclude"
2169
      --build-two-config
2170
      ${build_generator_args}
2171
      --build-project VSExternalInclude
2172
      --test-command VSExternalInclude)
2173
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExternalInclude")
2174

2175
    add_test(VSMidl ${CMAKE_CTEST_COMMAND}
2176
      --build-and-test
2177
      "${CMake_SOURCE_DIR}/Tests/VSMidl"
2178
      "${CMake_BINARY_DIR}/Tests/VSMidl"
2179
      --build-two-config
2180
      ${build_generator_args}
2181
      --build-project VSMidl
2182
      --test-command VSMidl)
2183
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSMidl")
2184

2185
    if(CMake_TEST_DEVENV)
2186
      # The test (and tested property) works with .sln files, so it's skipped when:
2187
      # * cmake --build is set up to use MSBuild, since the MSBuild invocation does not use the .sln file
2188
      set(_last_test "")
2189
      foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES)
2190
        add_test(NAME VSExcludeFromDefaultBuild-${config} COMMAND ${CMAKE_CTEST_COMMAND}
2191
          --build-and-test
2192
          "${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild"
2193
          "${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
2194
          --build-config ${config}
2195
          --build-two-config
2196
          --build-generator ${CMAKE_GENERATOR}
2197
          --build-makeprogram ${CMake_TEST_DEVENV}
2198
          --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
2199
          --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
2200
          --build-project VSExcludeFromDefaultBuild
2201
          --build-target install
2202
          --test-command ${CMAKE_COMMAND}
2203
             -D "activeConfig=${config}"
2204
             -D "allConfigs=${CMAKE_CONFIGURATION_TYPES}"
2205
             -D "dir=${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
2206
             -P "${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild/ResultTest.cmake")
2207
        if(_last_test)
2208
          set_property(TEST VSExcludeFromDefaultBuild-${config} PROPERTY DEPENDS ${_last_test})
2209
        endif()
2210
        set(_last_test "VSExcludeFromDefaultBuild-${config}")
2211
      endforeach()
2212
      unset(_last_test)
2213
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild")
2214
    endif()
2215

2216
    add_test(NAME VSProjectInSubdir COMMAND ${CMAKE_CTEST_COMMAND}
2217
      --build-and-test
2218
      "${CMake_SOURCE_DIR}/Tests/VSProjectInSubdir"
2219
      "${CMake_BINARY_DIR}/Tests/VSProjectInSubdir"
2220
      --build-two-config
2221
      --build-generator ${CMAKE_GENERATOR}
2222
      --build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
2223
      --build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
2224
      --build-project VSProjectInSubdir
2225
      --build-target test)
2226
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSProjectInSubdir")
2227
  endif()
2228

2229
  get_filename_component(ntver "[HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows NT\\CurrentVersion;CurrentVersion]" NAME)
2230
  if(WIN32 AND ntver VERSION_GREATER 6.1) # Windows >= 8.0
2231
    macro(add_test_VSWinStorePhone name generator systemName systemVersion architecture)
2232
      add_test(NAME VSWinStorePhone.${name} COMMAND ${CMAKE_CTEST_COMMAND}
2233
        --build-and-test
2234
        "${CMake_SOURCE_DIR}/Tests/VSWinStorePhone"
2235
        "${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}"
2236
        --build-generator "${generator}"
2237
        --build-generator-platform "${architecture}"
2238
        --build-project VSWinStorePhone
2239
        --build-config $<CONFIGURATION>
2240
        --build-options -DCMAKE_SYSTEM_NAME=${systemName}
2241
                        -DCMAKE_SYSTEM_VERSION=${systemVersion}
2242
        --test-command
2243
          ${CMAKE_CMAKE_COMMAND} -DAPP_PACKAGE_DIR="${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}"
2244
                                 -P "${CMake_SOURCE_DIR}/Tests/VSWinStorePhone/VerifyAppPackage.cmake"
2245
        )
2246
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}")
2247
    endmacro()
2248

2249
    # FIXME(#26248): Update this test to work with newer VS and Win 10.0.
2250
    # It previously ran with Visual Studio 12 2013 targeting Win 8.1.
2251
    if(FALSE AND CMAKE_GENERATOR MATCHES "Visual Studio")
2252
      add_test(NAME VSXaml COMMAND ${CMAKE_CTEST_COMMAND}
2253
        --build-and-test
2254
          "${CMake_SOURCE_DIR}/Tests/VSXaml"
2255
          "${CMake_BINARY_DIR}/Tests/VSXaml"
2256
          --build-generator "${CMAKE_GENERATOR}"
2257
          --build-project VSXaml
2258
          --build-config $<CONFIGURATION>
2259
          --build-options -DCMAKE_SYSTEM_NAME=WindowsStore
2260
                          -DCMAKE_SYSTEM_VERSION=10.0
2261
        )
2262
    endif()
2263

2264
    if(CMake_TEST_VSWinStorePhone_VS_2017 AND ws10_0)
2265
      add_test_VSWinStorePhone(vs15-store10_0-X86 "Visual Studio 15 2017" WindowsStore 10.0 Win32)
2266
      add_test_VSWinStorePhone(vs15-store10_0-ARM "Visual Studio 15 2017" WindowsStore 10.0 ARM)
2267
      add_test_VSWinStorePhone(vs15-store10_0-X64 "Visual Studio 15 2017" WindowsStore 10.0 x64)
2268
      add_test_VSWinStorePhone(vs15-store10_0-ARM64 "Visual Studio 15 2017" WindowsStore 10.0 ARM64)
2269
    endif()
2270
    if(vs14 AND ws10_0)
2271
      add_test_VSWinStorePhone(vs14-store10_0-X86 "Visual Studio 14 2015" WindowsStore 10.0 Win32)
2272
      add_test_VSWinStorePhone(vs14-store10_0-ARM "Visual Studio 14 2015" WindowsStore 10.0 ARM)
2273
      add_test_VSWinStorePhone(vs14-store10_0-X64 "Visual Studio 14 2015" WindowsStore 10.0 x64)
2274
    endif()
2275
  endif()
2276

2277
  if(CMAKE_GENERATOR MATCHES "Visual Studio" AND nasm)
2278
    ADD_TEST_MACRO(VSNASM VSNASM)
2279
  endif()
2280

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

2384
  macro(add_test_VSAndroid name generator platform)
2385
    add_test(NAME "VSAndroid.${name}.${platform}" COMMAND ${CMAKE_CTEST_COMMAND}
2386
      --build-and-test
2387
      "${CMake_SOURCE_DIR}/Tests/VSAndroid"
2388
      "${CMake_BINARY_DIR}/Tests/VSAndroid/${name}/${platform}"
2389
      --build-generator "${generator}"
2390
      --build-project VSAndroid
2391
      --build-config $<CONFIGURATION>
2392
      --build-options -DCMAKE_SYSTEM_NAME=Android "-A${platform}"
2393
      )
2394
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSAndroid/${name}")
2395
  endmacro()
2396
  if(tegra AND NOT "${CMake_SOURCE_DIR};${CMake_BINARY_DIR}" MATCHES " ")
2397
    if(vs14)
2398
      add_test_VSAndroid(vs14 "Visual Studio 14 2015" "Tegra-Android")
2399
    endif()
2400
  endif()
2401
  if(vs14 AND CMake_TEST_ANDROID_VS14)
2402
    add_test_VSAndroid(vs14 "Visual Studio 14 2015" "ARM")
2403
  endif()
2404
  if(vs15 AND CMake_TEST_ANDROID_VS15)
2405
    add_test_VSAndroid(vs15 "Visual Studio 15 2017" "ARM")
2406
  endif()
2407
  if(vs16 AND CMake_TEST_ANDROID_VS16)
2408
    add_test_VSAndroid(vs16 "Visual Studio 16 2019" "ARM")
2409
  endif()
2410
  if(vs17 AND CMake_TEST_ANDROID_VS17)
2411
    add_test_VSAndroid(vs17 "Visual Studio 17 2022" "ARM")
2412
  endif()
2413

2414
  if(APPLE)
2415
    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
2416
      set(BundleTestInstallDir
2417
        "${CMake_BINARY_DIR}/Tests/BundleTest/InstallDirectory")
2418
      add_test(BundleTest ${CMAKE_CTEST_COMMAND}
2419
        --build-and-test
2420
        "${CMake_SOURCE_DIR}/Tests/BundleTest"
2421
        "${CMake_BINARY_DIR}/Tests/BundleTest"
2422
        --build-two-config
2423
        ${build_generator_args}
2424
        --build-project BundleTest
2425
        --build-target install
2426
#       --build-target package
2427
        --build-options
2428
        "-DCMAKE_INSTALL_PREFIX:PATH=${BundleTestInstallDir}"
2429
        "-DCMake_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}"
2430
        --test-command
2431
        ${BundleTestInstallDir}/Applications/SecondBundleExe.app/Contents/MacOS/SecondBundleExe)
2432
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleTest")
2433

2434
      add_test(NAME CFBundleTest COMMAND ${CMAKE_CTEST_COMMAND}
2435
        --build-and-test
2436
        "${CMake_SOURCE_DIR}/Tests/CFBundleTest"
2437
        "${CMake_BINARY_DIR}/Tests/CFBundleTest"
2438
        --build-two-config
2439
        ${build_generator_args}
2440
        --build-project CFBundleTest
2441
        --build-config $<CONFIGURATION>
2442
        --test-command
2443
        ${CMAKE_CMAKE_COMMAND} -DCTEST_CONFIGURATION_TYPE=$<CONFIGURATION>
2444
        -Ddir=${CMake_BINARY_DIR}/Tests/CFBundleTest
2445
        -Dgen=${CMAKE_GENERATOR}
2446
        -P ${CMake_SOURCE_DIR}/Tests/CFBundleTest/VerifyResult.cmake)
2447
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CFBundleTest")
2448
    endif()
2449
  endif()
2450

2451
  if(APPLE AND CTEST_TEST_CPACK)
2452
    add_test(BundleGeneratorTest ${CMAKE_CTEST_COMMAND}
2453
      --build-and-test
2454
      "${CMake_SOURCE_DIR}/Tests/BundleGeneratorTest"
2455
      "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest"
2456
      --build-two-config
2457
      ${build_generator_args}
2458
      --build-project BundleGeneratorTest
2459
      --build-target package
2460
      --build-options
2461
        "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/BundleGeneratorTest/InstallDirectory"
2462
      )
2463
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest")
2464
  endif()
2465

2466
  add_test(WarnUnusedCliUnused ${CMAKE_CTEST_COMMAND}
2467
    --build-and-test
2468
    "${CMake_SOURCE_DIR}/Tests/WarnUnusedCliUnused"
2469
    "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused"
2470
    ${build_generator_args}
2471
    --build-project WarnUnusedCliUnused
2472
    --build-options
2473
      "-DUNUSED_CLI_VARIABLE=Unused")
2474
  set_tests_properties(WarnUnusedCliUnused PROPERTIES
2475
    PASS_REGULAR_EXPRESSION "CMake Warning:.*Manually-specified variables were not used by the project:.*  UNUSED_CLI_VARIABLE")
2476
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused")
2477

2478
  add_test(WarnUnusedCliUsed ${CMAKE_CTEST_COMMAND}
2479
    --build-and-test
2480
    "${CMake_SOURCE_DIR}/Tests/VariableUsage"
2481
    "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed"
2482
    ${build_generator_args}
2483
    --build-noclean
2484
    --build-project WarnUnusedCliUsed
2485
    --build-options
2486
      "-DUSED_VARIABLE=Usage proven")
2487
  set_tests_properties(WarnUnusedCliUsed PROPERTIES
2488
    PASS_REGULAR_EXPRESSION "Usage proven")
2489
  set_tests_properties(WarnUnusedCliUsed PROPERTIES
2490
    FAIL_REGULAR_EXPRESSION "CMake Warning: The variable, 'USED_VARIABLE'")
2491
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed")
2492

2493
  add_test(WarnUninitialized ${CMAKE_CTEST_COMMAND}
2494
    --build-and-test
2495
    "${CMake_SOURCE_DIR}/Tests/VariableUsage"
2496
    "${CMake_BINARY_DIR}/Tests/WarnUninitialized"
2497
    ${build_generator_args}
2498
    --build-noclean
2499
    --build-project WarnUninitialized
2500
    --build-options
2501
      "--warn-uninitialized")
2502
  set_tests_properties(WarnUninitialized PROPERTIES
2503
    PASS_REGULAR_EXPRESSION "uninitialized variable 'USED_VARIABLE'")
2504
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUninitialized")
2505

2506
  add_test(TestsWorkingDirectory
2507
    ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
2508
    --build-and-test
2509
    "${CMake_SOURCE_DIR}/Tests/TestsWorkingDirectory"
2510
    "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
2511
    ${build_generator_args}
2512
    --build-project TestsWorkingDirectoryProj
2513
    --build-exe-dir "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
2514
    --test-command ${CMAKE_CTEST_COMMAND} -V -C \${CTEST_CONFIGURATION_TYPE}
2515
    )
2516
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory")
2517

2518
  # Make sure CTest can handle a test with no newline in output.
2519
  add_test(CTest.NoNewline
2520
    ${CMAKE_CMAKE_COMMAND} -E echo_append "This line has no newline!")
2521

2522
  # A simple test for ctest in script mode
2523
  configure_file("${CMake_SOURCE_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake.in"
2524
          "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake" @ONLY)
2525
  add_test(CTest.ScriptMode ${CMAKE_CTEST_COMMAND}
2526
    -S "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake"
2527
    )
2528

2529
  # Test CTest Update with Subversion
2530
  if(NOT DEFINED CMake_TEST_CTestUpdate_SVN OR CMake_TEST_CTestUpdate_SVN)
2531
    find_package(Subversion QUIET)
2532
    if(Subversion_FOUND)
2533
      get_filename_component(_Subversion_BIN_DIR
2534
        ${Subversion_SVN_EXECUTABLE} PATH)
2535
      find_program(Subversion_SVNADMIN_EXECUTABLE svnadmin
2536
        HINTS ${_Subversion_BIN_DIR}
2537
        )
2538
      mark_as_advanced(Subversion_SVNADMIN_EXECUTABLE)
2539
      if(NOT Subversion_SVNADMIN_EXECUTABLE)
2540
        set(Subversion_FOUND FALSE)
2541
      endif()
2542
    endif()
2543
  endif()
2544
  if(NOT DEFINED CMake_TEST_CTestUpdate_SVN AND Subversion_FOUND)
2545
    set(CMake_TEST_CTestUpdate_SVN 1)
2546
  endif()
2547
  if(CMake_TEST_CTestUpdate_SVN)
2548
    if(NOT Subversion_FOUND)
2549
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_SVN enabled but Subversion is not found.")
2550
    endif()
2551
    set(CTestUpdateSVN_DIR "CTest UpdateSVN")
2552
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateSVN.cmake.in"
2553
      "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake" @ONLY)
2554
    add_test(CTest.UpdateSVN ${CMAKE_CMAKE_COMMAND}
2555
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake"
2556
      )
2557
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateSVN_DIR}")
2558
  endif()
2559

2560
  # Test CTest Update with CVS
2561
  if(NOT DEFINED CMake_TEST_CTestUpdate_CVS OR CMake_TEST_CTestUpdate_CVS)
2562
    find_program(CVS_EXECUTABLE NAMES cvs)
2563
    mark_as_advanced(CVS_EXECUTABLE)
2564
  endif()
2565
  if(NOT DEFINED CMake_TEST_CTestUpdate_CVS AND CVS_EXECUTABLE
2566
      AND (UNIX OR NOT "${CVS_EXECUTABLE}" MATCHES "cygwin"))
2567
    set(CMake_TEST_CTestUpdate_CVS 1)
2568
  endif()
2569
  if(CMake_TEST_CTestUpdate_CVS)
2570
    if(NOT CVS_EXECUTABLE)
2571
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_CVS enabled but CVS_EXECUTABLE is not found.")
2572
    endif()
2573
    set(CTestUpdateCVS_DIR "CTest UpdateCVS")
2574
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateCVS.cmake.in"
2575
      "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake" @ONLY)
2576
    add_test(CTest.UpdateCVS ${CMAKE_CMAKE_COMMAND}
2577
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake"
2578
      )
2579
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateCVS_DIR}")
2580
  endif()
2581

2582
  # Test CTest Update with BZR
2583
  if(CMake_TEST_CTestUpdate_BZR)
2584
    if(TEST_HOME)
2585
      file(MAKE_DIRECTORY "${TEST_HOME}/.bazaar")
2586
    endif()
2587
    find_program(BZR_EXECUTABLE NAMES bzr)
2588
    mark_as_advanced(BZR_EXECUTABLE)
2589
    if(NOT BZR_EXECUTABLE)
2590
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_BZR enabled but BZR_EXECUTABLE is not found.")
2591
    endif()
2592
    set(CTestUpdateBZR_DIR "CTest UpdateBZR")
2593
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
2594
      "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake" @ONLY)
2595
    add_test(CTest.UpdateBZR ${CMAKE_CMAKE_COMMAND}
2596
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake"
2597
      )
2598
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
2599
    set(CTestUpdateBZR_DIR "CTest UpdateBZR_CLocale")
2600
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
2601
      "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake" @ONLY)
2602
    add_test(CTest.UpdateBZR.CLocale ${CMAKE_CMAKE_COMMAND}
2603
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake"
2604
      )
2605
    set_tests_properties(CTest.UpdateBZR.CLocale PROPERTIES ENVIRONMENT LC_ALL=C)
2606
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
2607
  endif()
2608

2609
  # Test CTest Update with GIT
2610
  if(NOT DEFINED CMake_TEST_CTestUpdate_GIT AND GIT_EXECUTABLE
2611
      AND (UNIX OR NOT "${GIT_EXECUTABLE}" MATCHES "cygwin"))
2612
    set(CMake_TEST_CTestUpdate_GIT 1)
2613
  endif()
2614
  if(CMake_TEST_CTestUpdate_GIT)
2615
    if(NOT GIT_EXECUTABLE)
2616
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_GIT enabled but GIT_EXECUTABLE is not found.")
2617
    endif()
2618
    set(CTestUpdateGIT_DIR "CTest UpdateGIT")
2619
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateGIT.cmake.in"
2620
      "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake" @ONLY)
2621
    add_test(CTest.UpdateGIT ${CMAKE_CMAKE_COMMAND}
2622
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake"
2623
      )
2624
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateGIT_DIR}")
2625
    set_property(TEST CTest.UpdateGIT PROPERTY ENVIRONMENT GIT_ALLOW_PROTOCOL=file)
2626
  endif()
2627

2628
  # Test CTest Update with HG
2629
  if(NOT DEFINED CMake_TEST_CTestUpdate_HG OR CMake_TEST_CTestUpdate_HG)
2630
    find_program(HG_EXECUTABLE NAMES hg)
2631
    mark_as_advanced(HG_EXECUTABLE)
2632
  endif()
2633
  if(NOT DEFINED CMake_TEST_CTestUpdate_HG AND HG_EXECUTABLE
2634
      AND (UNIX OR NOT "${HG_EXECUTABLE}" MATCHES "cygwin"))
2635
    execute_process(COMMAND "${HG_EXECUTABLE}" --version OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE HG_RV)
2636
    if(HG_RV EQUAL 0)
2637
      set(CMake_TEST_CTestUpdate_HG 1)
2638
    endif()
2639
  endif()
2640
  if(CMake_TEST_CTestUpdate_HG)
2641
    if(NOT HG_EXECUTABLE)
2642
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_HG enabled but HG_EXECUTABLE is not found.")
2643
    endif()
2644
    set(CTestUpdateHG_DIR "CTest UpdateHG")
2645
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateHG.cmake.in"
2646
      "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake" @ONLY)
2647
    add_test(CTest.UpdateHG ${CMAKE_CMAKE_COMMAND}
2648
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake"
2649
      )
2650
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateHG_DIR}")
2651
  endif()
2652

2653
  # Test CTest Update with P4
2654
  if(CMake_TEST_CTestUpdate_P4)
2655
    find_program(P4_EXECUTABLE NAMES p4)
2656
    find_program(P4D_EXECUTABLE NAMES p4d)
2657
    mark_as_advanced(P4_EXECUTABLE P4D_EXECUTABLE)
2658
    if(NOT P4_EXECUTABLE OR NOT P4D_EXECUTABLE)
2659
      message(FATAL_ERROR "CMake_TEST_CTestUpdate_HG enabled but P4_EXECUTABLE and P4D_EXECUTABLE are not both not found.")
2660
    endif()
2661
    set(CTestUpdateP4_DIR "CTest UpdateP4")
2662
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateP4.cmake.in"
2663
      "${CMake_BINARY_DIR}/Tests/CTestUpdateP4.cmake" @ONLY)
2664
    add_test(CTest.UpdateP4 ${CMAKE_CMAKE_COMMAND}
2665
      -P "${CMake_BINARY_DIR}/Tests/CTestUpdateP4.cmake"
2666
      )
2667
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateP4_DIR}")
2668
  endif()
2669

2670
  if(NOT CMake_TEST_NO_NETWORK)
2671
    configure_file(
2672
      "${CMake_SOURCE_DIR}/Tests/CTestTestUpload/test.cmake.in"
2673
      "${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake"
2674
      @ONLY ESCAPE_QUOTES)
2675
    add_test(CTestTestUpload ${CMAKE_CTEST_COMMAND}
2676
      -S "${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake" -V
2677
      --output-log "${CMake_BINARY_DIR}/Tests/CTestTestUpload/testOut.log"
2678
      )
2679
    set_tests_properties(CTestTestUpload PROPERTIES
2680
      PASS_REGULAR_EXPRESSION "Upload\\.xml")
2681
  endif()
2682

2683
  configure_file(
2684
    "${CMake_SOURCE_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake.in"
2685
    "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake"
2686
    @ONLY ESCAPE_QUOTES)
2687
  add_test(CTestCoverageCollectGCOV ${CMAKE_CTEST_COMMAND}
2688
    -C \${CTEST_CONFIGURATION_TYPE}
2689
    -S "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake" -VV
2690
    --output-log "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/testOut.log"
2691
    )
2692

2693
  configure_file(
2694
    "${CMake_SOURCE_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake.in"
2695
    "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake"
2696
    @ONLY ESCAPE_QUOTES)
2697
  add_test(CTestTestEmptyBinaryDirectory ${CMAKE_CTEST_COMMAND}
2698
    -S "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake" -V
2699
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/testOut.log"
2700
    )
2701
  set_tests_properties(CTestTestEmptyBinaryDirectory PROPERTIES
2702
    PASS_REGULAR_EXPRESSION "TEST_SUCCESS")
2703

2704
  # test coverage for mumps
2705
  # create a MumpsCoverage dir in the binary tree under Testing to
2706
  # avoid the .NoDartCoverage files in the cmake testing tree
2707
  configure_file(
2708
     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.tcl.in"
2709
     "${CMake_BINARY_DIR}/Testing/MumpsCoverage/DartConfiguration.tcl")
2710
  configure_file(
2711
     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/gtm_coverage.mcov.in"
2712
     "${CMake_BINARY_DIR}/Testing/MumpsCoverage/gtm_coverage.mcov")
2713
  file(REMOVE_RECURSE "${CMake_BINARY_DIR}/Testing/MumpsCoverage/VistA-FOIA")
2714
  file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
2715
    DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCoverage")
2716
  add_test(NAME CTestGTMCoverage
2717
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2718
    ${CMake_BINARY_DIR}/Testing/MumpsCoverage
2719
    $<TARGET_FILE:ctest> -T Coverage --debug)
2720
  set_tests_properties(CTestGTMCoverage PROPERTIES
2721
      PASS_REGULAR_EXPRESSION
2722
      "Process file.*ZZCOVTST.m.*Total LOC:.*32.*Percentage Coverage: 81.25*"
2723
      ENVIRONMENT COVFILE=)
2724

2725
  configure_file(
2726
     "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.cache.tcl.in"
2727
     "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/DartConfiguration.tcl")
2728
  configure_file(
2729
    "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/cache_coverage.cmcov.in"
2730
    "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/cache_coverage.cmcov")
2731
  file(REMOVE_RECURSE "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/VistA-FOIA")
2732
  file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
2733
    DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage")
2734
  add_test(NAME CTestCacheCoverage
2735
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2736
    ${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage
2737
    $<TARGET_FILE:ctest> -T Coverage --debug)
2738
  set_tests_properties(CTestCacheCoverage PROPERTIES
2739
      PASS_REGULAR_EXPRESSION
2740
      "Process file.*ZZCOVTST.m.*Total LOC:.*32.*Percentage Coverage: 87.50.*"
2741
      ENVIRONMENT COVFILE=)
2742

2743
  # Adding a test case for Python Coverage
2744
  configure_file(
2745
     "${CMake_SOURCE_DIR}/Tests/PythonCoverage/coverage.xml.in"
2746
     "${CMake_BINARY_DIR}/Testing/PythonCoverage/coverage.xml")
2747
  configure_file(
2748
     "${CMake_SOURCE_DIR}/Tests/PythonCoverage/DartConfiguration.tcl.in"
2749
     "${CMake_BINARY_DIR}/Testing/PythonCoverage/DartConfiguration.tcl")
2750
  file(COPY "${CMake_SOURCE_DIR}/Tests/PythonCoverage/coveragetest"
2751
    DESTINATION "${CMake_BINARY_DIR}/Testing/PythonCoverage")
2752
  add_test(NAME CTestPythonCoverage
2753
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2754
    ${CMake_BINARY_DIR}/Testing/PythonCoverage
2755
    $<TARGET_FILE:ctest> -T Coverage --debug)
2756
  set_tests_properties(CTestPythonCoverage PROPERTIES
2757
      PASS_REGULAR_EXPRESSION
2758
      "Process file.*foo.py.*Total LOC:.*13.*Percentage Coverage: 84.62.*"
2759
      ENVIRONMENT COVFILE=)
2760

2761
  # Adding a test case for non-python Cobertura Coverage
2762
  configure_file(
2763
     "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/DartConfiguration.tcl.in"
2764
     "${CMake_BINARY_DIR}/Testing/CoberturaCoverage/DartConfiguration.tcl")
2765
  configure_file(
2766
     "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/coverage.xml.in"
2767
     "${CMake_BINARY_DIR}/Testing/CoberturaCoverage/coverage.xml")
2768
  file(COPY "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/src"
2769
    DESTINATION "${CMake_BINARY_DIR}/Testing/CoberturaCoverage")
2770
  add_test(NAME CTestCoberturaCoverage
2771
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2772
    ${CMake_BINARY_DIR}/Testing/CoberturaCoverage
2773
    $<TARGET_FILE:ctest> -T Coverage --debug)
2774
  set_tests_properties(CTestCoberturaCoverage PROPERTIES
2775
      PASS_REGULAR_EXPRESSION
2776
      "Process file.*CoverageTest.java.*Total LOC:.*18.*Percentage Coverage: 72.22.*"
2777
      ENVIRONMENT COBERTURADIR=${CMake_BINARY_DIR}/Testing/CoberturaCoverage
2778
      ENVIRONMENT COVFILE=)
2779

2780

2781
  # Adding a test case for JaCoCo Coverage
2782
  configure_file(
2783
     "${CMake_SOURCE_DIR}/Tests/JacocoCoverage/DartConfiguration.tcl.in"
2784
     "${CMake_BINARY_DIR}/Testing/JacocoCoverage/DartConfiguration.tcl")
2785
  file(COPY "${CMake_SOURCE_DIR}/Tests/JacocoCoverage/Coverage"
2786
    DESTINATION "${CMake_BINARY_DIR}/Testing/JacocoCoverage")
2787
  configure_file("${CMake_BINARY_DIR}/Testing/JacocoCoverage/Coverage/target/site/jacoco.xml.in"
2788
    "${CMake_BINARY_DIR}/Testing/JacocoCoverage/Coverage/target/site/jacoco.xml")
2789
  add_test(NAME CTestJacocoCoverage
2790
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2791
    ${CMake_BINARY_DIR}/Testing/JacocoCoverage
2792
    $<TARGET_FILE:ctest> -T Coverage --debug)
2793
  set_tests_properties(CTestJacocoCoverage PROPERTIES
2794
      PASS_REGULAR_EXPRESSION
2795
      "Process file.*CoverageTest.java.*Total LOC:.*17.*Percentage Coverage: 76.47*"
2796
      ENVIRONMENT COVFILE=)
2797

2798
  # Adding a test case for Javascript Coverage
2799
  configure_file(
2800
     "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/DartConfiguration.tcl.in"
2801
     "${CMake_BINARY_DIR}/Testing/JavascriptCoverage/DartConfiguration.tcl")
2802
  configure_file(
2803
     "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/output.json.in"
2804
     "${CMake_BINARY_DIR}/Testing/JavascriptCoverage/output.json")
2805
  file(COPY "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/"
2806
    DESTINATION "${CMake_BINARY_DIR}/Testing/JavascriptCoverage"
2807
    FILES_MATCHING PATTERN "*.js")
2808
  add_test(NAME CTestJavascriptCoverage
2809
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2810
    ${CMake_BINARY_DIR}/Testing/JavascriptCoverage
2811
    $<TARGET_FILE:ctest> -T Coverage --debug)
2812
  set_tests_properties(CTestJavascriptCoverage PROPERTIES
2813
      PASS_REGULAR_EXPRESSION
2814
      "Process file.*test3.js.*Total LOC:.*49.*Percentage Coverage: 79.59*"
2815
      ENVIRONMENT COVFILE=)
2816

2817
  # test coverage for Delphi-code-Coverage
2818
  configure_file(
2819
     "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/DartConfiguration.tcl.in"
2820
     "${CMake_BINARY_DIR}/Testing/DelphiCoverage/DartConfiguration.tcl")
2821
  file(COPY "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/src"
2822
    DESTINATION "${CMake_BINARY_DIR}/Testing/DelphiCoverage")
2823
  configure_file(
2824
    "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html.in"
2825
    "${CMake_BINARY_DIR}/Testing/DelphiCoverage/UTCovTest(UTCovTest.pas).html")
2826
  add_test(NAME CTestDelphiCoverage
2827
    COMMAND ${CMAKE_CMAKE_COMMAND} -E chdir
2828
    ${CMake_BINARY_DIR}/Testing/DelphiCoverage
2829
    $<TARGET_FILE:ctest> -T Coverage --debug)
2830
  set_tests_properties(CTestDelphiCoverage PROPERTIES
2831
      PASS_REGULAR_EXPRESSION
2832
      "Process file.*UTCovTest.pas.*Total LOC:.*20.*Percentage Coverage: 95.*"
2833
      ENVIRONMENT COVFILE=)
2834

2835
  function(add_config_tests cfg)
2836
    set(base "${CMake_BINARY_DIR}/Tests/CTestConfig")
2837

2838
    # Test -S script with a -C config arg to ctest:
2839
    configure_file(
2840
      "${CMake_SOURCE_DIR}/Tests/CTestConfig/script.cmake.in"
2841
      "${base}/${cfg}-script.cmake"
2842
      @ONLY ESCAPE_QUOTES)
2843
    add_test(CTestConfig.Script.${cfg} ${CMAKE_CTEST_COMMAND}
2844
      -C ${cfg}
2845
      -S "${base}/${cfg}-script.cmake" -VV
2846
      --output-log "${base}/${cfg}-script.log"
2847
      )
2848

2849
    # Test -D dashboard with a -C config arg to ctest.
2850
    # (Actual commands inside a cmake -P script because we need to be able to set
2851
    #  the working directory reliably...)
2852
    configure_file(
2853
      "${CMake_SOURCE_DIR}/Tests/CTestConfig/dashboard.cmake.in"
2854
      "${base}/${cfg}-dashboard.cmake"
2855
      @ONLY ESCAPE_QUOTES)
2856
    add_test(CTestConfig.Dashboard.${cfg} ${CMAKE_CMAKE_COMMAND}
2857
      -P "${base}/${cfg}-dashboard.cmake" -VV
2858
      )
2859
  endfunction()
2860

2861
  add_config_tests(Debug)
2862
  add_config_tests(MinSizeRel)
2863
  add_config_tests(Release)
2864
  add_config_tests(RelWithDebInfo)
2865

2866
  # Test -S script with some -D variable definition args to ctest:
2867
  add_test(CTestConfig.ScriptWithArgs ${CMAKE_CTEST_COMMAND}
2868
    -C "Release"
2869
    -D arg1=this
2870
    -D arg2=that
2871
    -D "arg3=the other"
2872
    "-Darg4=this is the fourth"
2873
    -Darg5=the_fifth
2874
    -Darg6:STRING=value-with-type
2875
    -S "${CMake_SOURCE_DIR}/Tests/CTestConfig/ScriptWithArgs.cmake" -VV
2876
    --output-log "${CMake_BINARY_DIR}/Tests/CTestConfig/ScriptWithArgs.log"
2877
    )
2878

2879
  ADD_TEST_MACRO(CMakeCommands.add_compile_definitions add_compile_definitions)
2880
  ADD_TEST_MACRO(CMakeCommands.add_compile_options add_compile_options)
2881
  ADD_TEST_MACRO(CMakeCommands.target_link_libraries target_link_libraries)
2882
  ADD_TEST_MACRO(CMakeCommands.target_include_directories target_include_directories)
2883
  ADD_TEST_MACRO(CMakeCommands.target_compile_definitions target_compile_definitions)
2884
  ADD_TEST_MACRO(CMakeCommands.target_compile_options target_compile_options)
2885
  ADD_TEST_MACRO(CMakeCommands.target_sources target_sources)
2886

2887
  ADD_TEST_MACRO(CMakeCommands.add_link_options)
2888
  ADD_TEST_MACRO(CMakeCommands.target_link_options)
2889
  ADD_TEST_MACRO(CMakeCommands.link_directories)
2890
  ADD_TEST_MACRO(CMakeCommands.target_link_directories)
2891

2892
  configure_file(
2893
    "${CMake_SOURCE_DIR}/Tests/CTestTestCrash/test.cmake.in"
2894
    "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake"
2895
    @ONLY ESCAPE_QUOTES)
2896
  add_test(CTestTestCrash ${CMAKE_CTEST_COMMAND}
2897
    -S "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake" -V
2898
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCrash/testOutput.log"
2899
    )
2900
  # With Watcom and OrangeC the SEGFAULT is not found, it just fails
2901
  if(CMAKE_GENERATOR MATCHES "Watcom WMake" OR CMAKE_C_COMPILER_ID STREQUAL "OrangeC")
2902
    set_tests_properties(CTestTestCrash PROPERTIES
2903
      PASS_REGULAR_EXPRESSION "Failed")
2904
  else()
2905
    set_tests_properties(CTestTestCrash PROPERTIES
2906
      PASS_REGULAR_EXPRESSION "(Illegal|SegFault|Subprocess aborted|SIGTRAP)")
2907
  endif()
2908

2909
  configure_file(
2910
    "${CMake_SOURCE_DIR}/Tests/CTestTestBadExe/test.cmake.in"
2911
    "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake"
2912
    @ONLY ESCAPE_QUOTES)
2913
  add_test(CTestTestBadExe ${CMAKE_CTEST_COMMAND}
2914
    -S "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake" -V
2915
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/testOutput.log"
2916
    )
2917
  set(CTestTestBadExe_REGEX "BAD_COMMAND")
2918
  # some cygwin can not be made to produce a BAD_COMMAND error
2919
  # the best we can get from it is a failed test
2920
  if(CYGWIN)
2921
    set(CTestTestBadExe_REGEX "(\\*\\*\\*Failed)|BAD_COMMAND")
2922
  endif()
2923
  set_tests_properties(CTestTestBadExe PROPERTIES
2924
    PASS_REGULAR_EXPRESSION "${CTestTestBadExe_REGEX}")
2925

2926
  configure_file(
2927
    "${CMake_SOURCE_DIR}/Tests/CTestTestBadGenerator/test.cmake.in"
2928
    "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/test.cmake"
2929
    @ONLY ESCAPE_QUOTES)
2930
  add_test(CTestTestBadGenerator ${CMAKE_CTEST_COMMAND}
2931
    -C "\${CTestTest_CONFIG}"
2932
    -S "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/test.cmake" -V
2933
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/testOutput.log"
2934
    )
2935
  set_property(TEST CTestTestBadGenerator PROPERTY
2936
    PASS_REGULAR_EXPRESSION "could not create generator named \"Bad Generator\"")
2937

2938
  configure_file(
2939
    "${CMake_SOURCE_DIR}/Tests/CTestTestParallel/test.cmake.in"
2940
    "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake"
2941
    @ONLY ESCAPE_QUOTES)
2942
  add_test(CTestTestParallel ${CMAKE_CTEST_COMMAND}
2943
    -S "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake" -V
2944
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestParallel/testOutput.log"
2945
    )
2946

2947
  configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestVerboseOutput/test.cmake.in"
2948
    "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/test.cmake" @ONLY ESCAPE_QUOTES)
2949
  add_test(CTestTestVerboseOutput ${CMAKE_CTEST_COMMAND}
2950
    -S "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/test.cmake" -VV
2951
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/testOutput.log"
2952
    -C "\${CTestTest_CONFIG}"
2953
    )
2954
  set_property(TEST CTestTestVerboseOutput PROPERTY PASS_REGULAR_EXPRESSION
2955
    "Test command:.*Working Directory:.*Environment variables:.*foo=bar.*this=that"
2956
  )
2957

2958
  ADD_TEST_MACRO(CTestTestSerialInDepends ${CMAKE_CTEST_COMMAND} -j 4
2959
    --output-on-failure -C "\${CTestTest_CONFIG}")
2960

2961
  ADD_TEST_MACRO(CTestTestMissingDependsExe ${CMAKE_CTEST_COMMAND}
2962
    --output-on-failure -C "\${CTestTest_CONFIG}")
2963
  set_tests_properties(CTestTestMissingDependsExe PROPERTIES
2964
    PASS_REGULAR_EXPRESSION "\\*\\*\\*Not Run"
2965
  )
2966

2967
  if(NOT BORLAND)
2968
    add_test_macro(CTestLimitDashJ ${CMAKE_CTEST_COMMAND} -j 4
2969
      --output-on-failure -C "\${CTestTest_CONFIG}")
2970
  endif()
2971

2972
  configure_file(
2973
    "${CMake_SOURCE_DIR}/Tests/CTestTestLabelRegExp/test.cmake.in"
2974
    "${CMake_BINARY_DIR}/Tests/CTestTestLabelRegExp/test.cmake"
2975
    @ONLY ESCAPE_QUOTES)
2976
  add_test(NAME CTestTestLabelRegExp
2977
    COMMAND ${CMAKE_CMAKE_COMMAND}
2978
      -DSOURCE_DIR=${CMAKE_SOURCE_DIR}/Tests/CTestTestLabelRegExp
2979
      -P ${CMAKE_BINARY_DIR}/Tests/CTestTestLabelRegExp/test.cmake
2980
    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Tests/CTestTestLabelRegExp
2981
  )
2982

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

2995
  configure_file(
2996
    "${CMake_SOURCE_DIR}/Tests/CTestTestCostSerial/test.cmake.in"
2997
    "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake"
2998
    @ONLY ESCAPE_QUOTES)
2999
  add_test(CTestTestCostSerial ${CMAKE_CTEST_COMMAND}
3000
    -S "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake" -V
3001
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/testOutput.log"
3002
    )
3003
  set_tests_properties(CTestTestCostSerial PROPERTIES
3004
    PASS_REGULAR_EXPRESSION "Start 2.*Start 3.*Start 1.*Start 2.*Start 3.*Start 1"
3005
    RESOURCE_LOCK "CostData")
3006

3007
  configure_file(
3008
    "${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/test.cmake.in"
3009
    "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake"
3010
    @ONLY ESCAPE_QUOTES)
3011
  configure_file(
3012
    "${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
3013
    "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
3014
    COPYONLY)
3015
  add_test(CTestTestStopTime ${CMAKE_CTEST_COMMAND}
3016
    -S "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake" -V
3017
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/testOutput.log"
3018
    )
3019
  set_tests_properties(CTestTestStopTime PROPERTIES
3020
    PASS_REGULAR_EXPRESSION "The stop time has been passed")
3021

3022
  configure_file(
3023
    "${CMake_SOURCE_DIR}/Tests/CTestTestSubdir/test.cmake.in"
3024
    "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake"
3025
    @ONLY ESCAPE_QUOTES)
3026
  add_test(CTestTestSubdir ${CMAKE_CTEST_COMMAND}
3027
    -S "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake" -V
3028
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/testOutput.log"
3029
    )
3030
  #make sure all 3 subdirs were added
3031
  set_tests_properties(CTestTestSubdir PROPERTIES
3032
    PASS_REGULAR_EXPRESSION "0 tests failed out of 3")
3033

3034
  configure_file(
3035
    "${CMake_SOURCE_DIR}/Tests/CTestTestTimeout/test.cmake.in"
3036
    "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake"
3037
    @ONLY ESCAPE_QUOTES)
3038
  add_test(CTestTestTimeout ${CMAKE_CTEST_COMMAND}
3039
    -C "\${CTestTest_CONFIG}"
3040
    -S "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake" -V
3041
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/testOutput.log"
3042
    )
3043
  set_tests_properties(CTestTestTimeout PROPERTIES
3044
    PASS_REGULAR_EXPRESSION "TestTimeout *\\.+ *\\*\\*\\*Timeout.*TestSleep *\\.+ *Passed.*timeout correctly killed child")
3045

3046
  add_test(
3047
    NAME CTestTestRerunFailed
3048
    COMMAND ${CMAKE_CTEST_COMMAND} --rerun-failed)
3049
  set_tests_properties(CTestTestRerunFailed PROPERTIES
3050
    PASS_REGULAR_EXPRESSION "1/1 Test #1: TestTimeout" DEPENDS CTestTestTimeout
3051
    WORKING_DIRECTORY ${CMake_BINARY_DIR}/Tests/CTestTestTimeout)
3052

3053
  configure_file(
3054
    "${CMake_SOURCE_DIR}/Tests/CTestTestDepends/test.cmake.in"
3055
    "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake"
3056
    @ONLY ESCAPE_QUOTES)
3057
  add_test(CTestTestDepends ${CMAKE_CTEST_COMMAND}
3058
    -C "\${CTestTest_CONFIG}"
3059
    -S "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake" -V
3060
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestDepends/testOutput.log"
3061
    )
3062

3063
  configure_file(
3064
    "${CMake_SOURCE_DIR}/Tests/CTestTestCycle/test.cmake.in"
3065
    "${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake"
3066
    @ONLY ESCAPE_QUOTES)
3067
  add_test(CTestTestCycle ${CMAKE_CTEST_COMMAND}
3068
    -C "\${CTestTest_CONFIG}"
3069
    -S "${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake" -V
3070
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCycle/testOutput.log"
3071
    )
3072
  set_tests_properties(CTestTestCycle PROPERTIES
3073
    PASS_REGULAR_EXPRESSION "a cycle exists in the test dependency graph")
3074

3075
  configure_file(
3076
    "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/test.cmake.in"
3077
    "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake"
3078
    @ONLY ESCAPE_QUOTES)
3079
  configure_file(
3080
    "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/hello.cmake.in"
3081
    "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/hello.cmake"
3082
    @ONLY ESCAPE_QUOTES)
3083
  add_test(CTestTestRunScript ${CMAKE_CTEST_COMMAND}
3084
    -S "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake" -V
3085
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/testOutput.log"
3086
    )
3087

3088
  add_test(CTestTestShowOnly ${CMAKE_CTEST_COMMAND} -N)
3089

3090
  configure_file(
3091
    "${CMake_SOURCE_DIR}/Tests/CTestTestFdSetSize/test.cmake.in"
3092
    "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake"
3093
    @ONLY ESCAPE_QUOTES)
3094
  add_test(CTestTestFdSetSize ${CMAKE_CTEST_COMMAND}
3095
    -S "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake" -j20 -V --timeout 120
3096
    --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/testOutput.log"
3097
    )
3098

3099
  if(CMAKE_TESTS_CDASH_SERVER)
3100
    set(regex "^([^:]+)://([^/]+)(.*)$")
3101

3102
    if("${CMAKE_TESTS_CDASH_SERVER}" MATCHES "${regex}")
3103
      set(protocol "${CMAKE_MATCH_1}")
3104
      set(server "${CMAKE_MATCH_2}")
3105
      set(path "${CMAKE_MATCH_3}")
3106
    else()
3107
      set(protocol "http")
3108
      set(server "open.cdash.org")
3109
      set(path "")
3110
      message("warning: CMAKE_TESTS_CDASH_SERVER does not match expected regex...")
3111
      message("         ...using default url='${protocol}://${server}${path}' for CTestTest[23]")
3112
    endif()
3113
  endif()
3114

3115

3116
  if(CTEST_TEST_CTEST AND CMAKE_RUN_LONG_TESTS AND CMAKE_TESTS_CDASH_SERVER)
3117
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest/test.cmake.in"
3118
      "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" @ONLY ESCAPE_QUOTES)
3119
    add_test(CTestTest ${CMAKE_CTEST_COMMAND}
3120
      -S "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" -V
3121
      --output-log "${CMake_BINARY_DIR}/Tests/CTestTest/testOutput.log"
3122
      )
3123

3124
    if(NOT CMake_TEST_EXTERNAL_CMAKE)
3125
      configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest2/test.cmake.in"
3126
        "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" @ONLY ESCAPE_QUOTES)
3127
      add_test(NAME CTestTest2 COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3128
        -S "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" -V
3129
        --output-log "${CMake_BINARY_DIR}/Tests/CTestTest2/testOutput.log"
3130
        )
3131
    endif()
3132

3133
    if("${CMAKE_GENERATOR}" MATCHES "Makefiles|Ninja|FASTBuild")
3134
      configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestLaunchers/test.cmake.in"
3135
        "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/test.cmake" @ONLY ESCAPE_QUOTES)
3136
      add_test(CTestTestLaunchers ${CMAKE_CTEST_COMMAND}
3137
        -S "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/test.cmake" -V
3138
        --output-log "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/testOutput.log"
3139
        )
3140
      set_tests_properties(CTestTestLaunchers PROPERTIES
3141
        PASS_REGULAR_EXPRESSION "CTEST_TEST_LAUNCHER_SUCCESS")
3142
    endif()
3143

3144
    configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestChecksum/test.cmake.in"
3145
      "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" @ONLY
3146
      ESCAPE_QUOTES)
3147
    add_test(CTestTestChecksum ${CMAKE_CTEST_COMMAND}
3148
      -S "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" -V
3149
      --output-log
3150
      "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/testOutput.log"
3151
      )
3152
    set_tests_properties(CTestTestChecksum PROPERTIES PASS_REGULAR_EXPRESSION
3153
      "md5 mismatch")
3154

3155
    # these tests take a long time, make sure they have it
3156
    # if timeouts have not already been set
3157
    get_test_property(CTestTest TIMEOUT PREVIOUS_TIMEOUT)
3158
    if("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
3159
      set_tests_properties(CTestTest
3160
        PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
3161
    endif()
3162

3163
    if(NOT CMake_TEST_EXTERNAL_CMAKE)
3164
      get_test_property(CTestTest2 TIMEOUT PREVIOUS_TIMEOUT)
3165
      if("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
3166
        set_tests_properties(CTestTest2
3167
          PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
3168
      endif()
3169
    endif()
3170
  endif()
3171

3172
  if(NOT DEFINED CMake_TEST_BOOTSTRAP)
3173
    if(CMAKE_RUN_LONG_TESTS
3174
        AND NOT CMAKE_SKIP_BOOTSTRAP_TEST
3175
        AND NOT CMake_TEST_EXTERNAL_CMAKE
3176
        AND NOT CMAKE_GENERATOR MATCHES "Xcode"
3177
        AND NOT EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt"
3178
        )
3179
      set(CMake_TEST_BOOTSTRAP 1)
3180
    else()
3181
      set(CMake_TEST_BOOTSTRAP 0)
3182
    endif()
3183
  endif()
3184
  set(bootstrap "")
3185
  if(CMake_TEST_BOOTSTRAP)
3186
    if(UNIX)
3187
      set(bootstrap ${CMake_SOURCE_DIR}/bootstrap)
3188
    elseif(MSYS)
3189
      configure_file(${CMAKE_CURRENT_SOURCE_DIR}/bootstrap.bat.in
3190
                     ${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat @ONLY)
3191
      set(bootstrap ${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat)
3192
    endif()
3193
  endif()
3194
  if(bootstrap)
3195
    add_test(NAME BootstrapTest
3196
      COMMAND ${CMAKE_CMAKE_COMMAND}
3197
        -D "bootstrap=${bootstrap}"
3198
        -D "bin_dir=${CMake_BINARY_DIR}/Tests/BootstrapTest"
3199
        -D "generator=${CMAKE_GENERATOR}"
3200
        -P ${CMAKE_CURRENT_SOURCE_DIR}/BootstrapTest.cmake
3201
      )
3202
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BootstrapTest")
3203
    # This test will use all processors.
3204
    set_property(TEST BootstrapTest PROPERTY RUN_SERIAL 1)
3205
    # This test may take a long time.
3206
    if(NOT DEFINED CMake_TEST_BOOTSTRAP_TIMEOUT)
3207
      set(CMake_TEST_BOOTSTRAP_TIMEOUT 5400)
3208
    endif()
3209
    set_property(TEST BootstrapTest PROPERTY TIMEOUT "${CMake_TEST_BOOTSTRAP_TIMEOUT}")
3210
  endif()
3211

3212
  if(CMAKE_Fortran_COMPILER)
3213
    add_test(Fortran ${CMAKE_CTEST_COMMAND}
3214
      --build-and-test
3215
      "${CMake_SOURCE_DIR}/Tests/Fortran"
3216
      "${CMake_BINARY_DIR}/Tests/Fortran"
3217
      ${build_generator_args}
3218
      --build-project testf
3219
      --build-two-config
3220
      --test-command testf)
3221
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Fortran")
3222
    set_property(TEST Fortran APPEND PROPERTY LABELS "Fortran")
3223

3224
    if(CMAKE_Fortran_COMPILER_SUPPORTS_F90
3225
        # FIXME(lfortran): The compiler fails on the test's modules.
3226
        AND NOT CMAKE_Fortran_COMPILER_ID STREQUAL "LFortran"
3227
        )
3228
      if(DEFINED CMake_TEST_Fortran_SUBMODULES)
3229
        list(PREPEND CMake_TEST_FortranModules_BUILD_OPTIONS -DCMake_TEST_Fortran_SUBMODULES:BOOL=${CMake_TEST_Fortran_SUBMODULES})
3230
      endif()
3231
      add_test(FortranModules ${CMAKE_CTEST_COMMAND}
3232
        --build-and-test
3233
        "${CMake_SOURCE_DIR}/Tests/FortranModules"
3234
        "${CMake_BINARY_DIR}/Tests/FortranModules"
3235
        ${build_generator_args}
3236
        --build-project FortranModules
3237
        --build-options
3238
          -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
3239
          ${CMake_TEST_FortranModules_BUILD_OPTIONS}
3240
        )
3241
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranModules")
3242
      set_property(TEST FortranModules APPEND PROPERTY LABELS "Fortran")
3243
    endif()
3244

3245
    # FortranCInterface tests.
3246
    if(UNIX)
3247
      configure_file(${CMAKE_CURRENT_SOURCE_DIR}/FortranC/Flags.cmake.in
3248
        ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake @ONLY)
3249
      add_test(FortranC.Flags ${CMAKE_CMAKE_COMMAND} -P
3250
        ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake)
3251
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC/Flags")
3252
      set_property(TEST FortranC.Flags APPEND PROPERTY LABELS "Fortran")
3253
    else()
3254
      add_test(FortranC ${CMAKE_CTEST_COMMAND}
3255
        --build-and-test
3256
        "${CMake_SOURCE_DIR}/Tests/FortranC"
3257
        "${CMake_BINARY_DIR}/Tests/FortranC"
3258
        ${build_generator_args}
3259
        --build-project FortranC
3260
        --build-two-config
3261
        --test-command CMakeFiles/FortranCInterface/FortranCInterface)
3262
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC")
3263
      set_property(TEST FortranC APPEND PROPERTY LABELS "Fortran")
3264
    endif()
3265
  endif()
3266

3267
  if(NOT DEFINED CMake_TEST_Java)
3268
    if(APPLE OR MINGW)
3269
      set(CMake_TEST_Java 0)
3270
    else()
3271
      set(CMake_TEST_Java 1)
3272
    endif()
3273
  endif()
3274
  if(CMake_TEST_Java)
3275
    find_package(Java COMPONENTS Development QUIET)
3276
  endif()
3277
  if(Java_JAVA_EXECUTABLE AND Java_JAVAC_EXECUTABLE AND Java_JAR_EXECUTABLE)
3278

3279
    set(JavaExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM})
3280
    ADD_TEST_MACRO(JavaExportImport JavaExportImport)
3281

3282
    get_filename_component(JAVACPATH ${Java_JAVAC_EXECUTABLE} REALPATH)
3283
    get_filename_component(JNIPATH ${JAVACPATH} PATH)
3284
    find_file(JNI_H jni.h
3285
      "${JNIPATH}/../include"
3286
      "${JNIPATH}/../java/include")
3287
    if(JNI_H AND EXISTS "${JNI_H}") # in case jni.h is a broken symlink
3288
      file(READ "${JNI_H}" JNI_FILE)
3289
      if("${JNI_FILE}" MATCHES "JDK1_2")
3290

3291
        execute_process(
3292
          COMMAND "${Java_JAVA_EXECUTABLE}" -version
3293
          OUTPUT_VARIABLE _version ERROR_VARIABLE _version RESULT_VARIABLE _result
3294
          )
3295

3296
        # E2K has broken Java RVM before 3.5.2
3297
        if(CMAKE_HOST_SYSTEM_PROCESSOR STREQUAL "e2k" AND _result EQUAL 0)
3298
          string(REGEX MATCH "RVM ([0-9.]+)" RVMVER "${_version}")
3299
          # Consider empty match a broken version too
3300
          if("${CMAKE_MATCH_1}" VERSION_LESS "3.5.2")
3301
            set(BROKEN_RVM TRUE)
3302
          endif()
3303
        endif()
3304

3305
        if(NOT BROKEN_RVM)
3306
          add_test(NAME Java.Jar COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3307
            --build-and-test
3308
            "${CMake_SOURCE_DIR}/Tests/Java"
3309
            "${CMake_BINARY_DIR}/Tests/JavaJar"
3310
            ${build_generator_args}
3311
            --build-project hello
3312
            --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaJar/"
3313
            --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
3314
          list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaJar")
3315

3316
          # For next tests, java tool must have same architecture as toolchain
3317
          math(EXPR _object_mode "${CMAKE_SIZEOF_VOID_P} * 8")
3318
          if(_result EQUAL 0 AND _version MATCHES "${_object_mode}-Bit")
3319
            ## next test is valid only if Java version is less than 1.10
3320
            if("${Java_VERSION}" VERSION_LESS 1.10)
3321
              add_test(NAME Java.Javah COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3322
                --build-and-test
3323
                "${CMake_SOURCE_DIR}/Tests/JavaJavah"
3324
                "${CMake_BINARY_DIR}/Tests/JavaJavah"
3325
                ${build_generator_args}
3326
                --build-project helloJavah
3327
                --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaJavah/"
3328
                --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
3329
              list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaJavah")
3330
            endif()
3331
            ## next test is valid only if Java is, at least, version 1.8
3332
            if(NOT "${Java_VERSION}" VERSION_LESS 1.8)
3333
              add_test(NAME Java.NativeHeaders COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIG>
3334
                --build-and-test
3335
                "${CMake_SOURCE_DIR}/Tests/JavaNativeHeaders"
3336
                "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders"
3337
                ${build_generator_args}
3338
                --build-project helloJavaNativeHeaders
3339
                --build-run-dir "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders/"
3340
                --build-target install
3341
                --build-options
3342
                "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/JavaNativeHeaders/Install"
3343
                --test-command ${CMAKE_CTEST_COMMAND} -V -C $<CONFIG>)
3344
              list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaNativeHeaders")
3345
            endif()
3346
          endif()
3347
        endif()
3348
      endif()
3349
    endif()
3350
  endif()
3351

3352
  # add some cross compiler tests, for now only with makefile based generators
3353
  if(CMAKE_GENERATOR MATCHES "Makefiles")
3354

3355
    # if sdcc is found, build the SimpleCOnly project with sdcc
3356
    find_program(SDCC_EXECUTABLE sdcc)
3357
    mark_as_advanced(SDCC_EXECUTABLE)
3358
    if(SDCC_EXECUTABLE)
3359
      add_test(SimpleCOnly_sdcc ${CMAKE_CTEST_COMMAND}
3360
        --build-and-test
3361
        "${CMake_SOURCE_DIR}/Tests/SimpleCOnly"
3362
        "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc"
3363
        ${build_generator_args}
3364
        --build-project SimpleC
3365
        --build-options
3366
          "-DCMAKE_SYSTEM_NAME=Generic"
3367
          "-DCMAKE_C_COMPILER=${SDCC_EXECUTABLE}")
3368
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc")
3369
    endif()
3370

3371
    # If a Linux -> MinGW cross compiler is found then try it
3372
    find_program(MINGW_CC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-gcc)
3373
    find_program(MINGW_CXX_LINUX2WIN_EXECUTABLE i586-mingw32msvc-g++)
3374
    find_program(MINGW_RC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-windres)
3375
    mark_as_advanced(MINGW_CC_LINUX2WIN_EXECUTABLE MINGW_CXX_LINUX2WIN_EXECUTABLE MINGW_RC_LINUX2WIN_EXECUTABLE)
3376
    if(MINGW_CC_LINUX2WIN_EXECUTABLE AND MINGW_CXX_LINUX2WIN_EXECUTABLE AND MINGW_RC_LINUX2WIN_EXECUTABLE)
3377
      add_test(Simple_Mingw_Linux2Win ${CMAKE_CTEST_COMMAND}
3378
        --build-and-test
3379
        "${CMake_SOURCE_DIR}/Tests/Simple"
3380
        "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win"
3381
        ${build_generator_args}
3382
        --build-project Simple
3383
        --build-options
3384
          "-DCMAKE_SYSTEM_NAME=Windows"
3385
          "-DCMAKE_C_COMPILER=${MINGW_CC_LINUX2WIN_EXECUTABLE}"
3386
          "-DCMAKE_CXX_COMPILER=${MINGW_CXX_LINUX2WIN_EXECUTABLE}"
3387
          "-DCMAKE_RC_COMPILER=${MINGW_RC_LINUX2WIN_EXECUTABLE}"
3388
        )
3389
      list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win")
3390
    endif()
3391
  endif()
3392

3393
  if(CMAKE_TEST_PROJECT_CSE_DIR)
3394
    set(script "${CMAKE_TEST_PROJECT_CSE_DIR}/BuildProjectCSE.cmake")
3395
    if(NOT EXISTS "${script}")
3396
      set(script "${CMAKE_TEST_PROJECT_CSE_DIR}/cse_build.cmake")
3397
    endif()
3398
    if(NOT EXISTS "${script}")
3399
      message("warning: CMAKE_TEST_PROJECT_CSE_DIR set, but no build script found...")
3400
    endif()
3401

3402
    add_test(BuildCSE ${CMAKE_CTEST_COMMAND} -V -S "${script}")
3403
    set_tests_properties(BuildCSE PROPERTIES TIMEOUT 5400)
3404
  endif()
3405

3406
  if(CMAKE_TEST_PLPLOT_DIR)
3407
    add_test(plplot ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_PLPLOT_DIR}/../../EasyDashboardScripts/plplot.cmake)
3408
    set_tests_properties ( plplot PROPERTIES TIMEOUT 5400)
3409
  endif()
3410

3411
  if(CMAKE_TEST_CHICKEN_DIR)
3412
    add_test(Chicken ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_CHICKEN_DIR}/../../EasyDashboardScripts/Chicken.cmake)
3413
    set_tests_properties(Chicken PROPERTIES TIMEOUT 5400)
3414
  endif()
3415

3416
  if(CMAKE_TEST_KDELIBS_ALPHA_1_DIR)
3417
    add_test(KDELibsAlpha1 ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_KDELIBS_ALPHA_1_DIR}/../../EasyDashboardScripts/kdelibs.cmake)
3418
    set_tests_properties(KDELibsAlpha1 PROPERTIES TIMEOUT 5400)
3419
  endif()
3420

3421
  # Define a set of "contract" tests, each activated by a cache entry
3422
  # named "CMake_TEST_CONTRACT_<project>".  For each Contract test,
3423
  # the project should provide a directory with a CMakeLists.txt file
3424
  # that uses ExternalProject to download and configure the project.
3425
  # The directory should also contain a Configure.cmake file that
3426
  # sets "CMake_TEST_CONTRACT_<project>_<var>" variables to configure
3427
  # the code below.
3428
  foreach(project IN ITEMS PLplot Trilinos VTK)
3429
    if(CMake_TEST_CONTRACT_${project})
3430
      include(Contracts/${project}/Configure.cmake)
3431
      ADD_TEST_MACRO(Contracts.${project} ${CMake_TEST_CONTRACT_${project}_RUN_TEST})
3432
      # The external projects may take a long time to build.
3433
      if(DEFINED CMake_TEST_CONTRACT_${project}_TIMEOUT)
3434
        set(timeout ${CMake_TEST_CONTRACT_${project}_TIMEOUT})
3435
      elseif(CMake_TEST_CONTRACT_DEFAULT_TIMEOUT)
3436
        set(timeout ${CMake_TEST_CONTRACT_DEFAULT_TIMEOUT})
3437
      else()
3438
        set(timeout 21600)
3439
      endif()
3440
      set_property(TEST Contracts.${project} PROPERTY TIMEOUT "${timeout}")
3441
    endif()
3442
  endforeach()
3443

3444
  if(TEST_CompileCommandOutput)
3445
    set(CompileCommandOutput_BUILD_OPTIONS
3446
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES})
3447
    ADD_TEST_MACRO(CompileCommandOutput
3448
      "${CMake_BINARY_DIR}/Tests/CMakeLib/runcompilecommands")
3449
  endif()
3450

3451
  add_test(IncludeDirectories ${CMAKE_CTEST_COMMAND}
3452
    --build-and-test
3453
    "${CMake_SOURCE_DIR}/Tests/IncludeDirectories"
3454
    "${CMake_BINARY_DIR}/Tests/IncludeDirectories"
3455
    --build-two-config
3456
    ${build_generator_args}
3457
    --build-project IncludeDirectories
3458
    --build-options
3459
      -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
3460
    --test-command IncludeDirectories)
3461
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/IncludeDirectories")
3462

3463
  if(CMAKE_GENERATOR MATCHES "^((Unix|MSYS) Makefiles|Ninja|FASTBuild)$" AND
3464
     ((CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.4)
3465
      OR (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND NOT "x${CMAKE_CXX_SIMULATE_ID}" STREQUAL "xMSVC")
3466
      OR (CMAKE_CXX_COMPILER_ID STREQUAL "LCC")
3467
      OR (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")))
3468
    add_test(IncludeDirectoriesCPATH ${CMAKE_CTEST_COMMAND}
3469
      --build-and-test
3470
      "${CMake_SOURCE_DIR}/Tests/IncludeDirectoriesCPATH"
3471
      "${CMake_BINARY_DIR}/Tests/IncludeDirectoriesCPATH"
3472
      --build-two-config
3473
      ${build_generator_args}
3474
      --build-project IncludeDirectoriesCPATH)
3475
    list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/IncludeDirectoriesCPATH")
3476
    set_tests_properties(IncludeDirectoriesCPATH
3477
      PROPERTIES
3478
        ENVIRONMENT "CPATH=${CMAKE_CURRENT_SOURCE_DIR}/IncludeDirectoriesCPATH/viacpath")
3479
  endif()
3480

3481
  add_test(InterfaceLinkLibraries ${CMAKE_CTEST_COMMAND}
3482
    --build-and-test
3483
    "${CMake_SOURCE_DIR}/Tests/InterfaceLinkLibraries"
3484
    "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries"
3485
    --build-two-config
3486
    ${build_generator_args}
3487
    --build-project InterfaceLinkLibraries
3488
    --test-command InterfaceLinkLibraries)
3489
  list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries")
3490

3491
  ADD_TEST_MACRO(InterfaceLinkLibrariesDirect)
3492

3493
  if(NOT CMake_TEST_EXTERNAL_CMAKE)
3494
    add_subdirectory(CMakeTests)
3495
  endif()
3496

3497
  if(BUILD_QtDialog AND CMake_TEST_GUI AND NOT CMake_TEST_EXTERNAL_CMAKE)
3498
    add_subdirectory(CMakeGUI)
3499
  endif()
3500

3501
  # Run CheckSourceTree as the very last test in the CMake/CTest/CPack test
3502
  # suite. It detects if any changes have been made to the CMake source tree
3503
  # by any previous configure, build or test steps.
3504
  if(GIT_EXECUTABLE AND EXISTS "${CMake_SOURCE_DIR}/.git"
3505
      AND NOT "${CMake_SOURCE_DIR}" STREQUAL "${CMake_BINARY_DIR}")
3506
    add_subdirectory(CheckSourceTree)
3507
  endif()
3508

3509
  # If this is not an in-source build, provide a target to wipe out
3510
  # all the test build directories. This must come at the end after
3511
  # all the above logic has finished adding to TEST_BUILD_DIRS
3512
  if(NOT EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt")
3513
    configure_file(${CMake_SOURCE_DIR}/Tests/test_clean.cmake.in
3514
                   ${CMake_BINARY_DIR}/Tests/test_clean.cmake @ONLY)
3515
    add_custom_target(test_clean
3516
      COMMAND ${CMAKE_COMMAND} -P ${CMake_BINARY_DIR}/Tests/test_clean.cmake
3517
      COMMENT "Removing test build directories."
3518
      )
3519
  endif()
3520
endif()
3521

3522
Product

Resources

Company
