mirror of
https://github.com/Kitware/CMake.git
synced 2026-03-09 01:09:30 -05:00
6eea123e3a
Since commit 84036d30d4 (IntelLLVM: Fix C/C++ standard level flags on
Windows, 2021-07-07, v3.21.0-rc3~8^2~1) we activate C/C++ standard level
logic for IntelLLVM when targeting the MSVC ABI. Update the
`RunCMake.try_compile` test to be aware of this even when CMake is
itself configured by an older CMake that does not know this.
888 lines
32 KiB
CMake
888 lines
32 KiB
CMake
# See adjacent README.rst for documentation of this test infrastructure.
|
|
|
|
# Note that the _isMultiConfig variable is set in the parent directory's
|
|
# CMakeLists.txt (slightly complex logic to support CMake versions before 3.9)
|
|
|
|
macro(add_RunCMake_test test)
|
|
set(TEST_ARGS ${ARGN})
|
|
if ("${ARGV1}" STREQUAL "TEST_DIR")
|
|
if ("${ARGV2}" STREQUAL "")
|
|
message(FATAL_ERROR "Invalid args")
|
|
endif()
|
|
set(Test_Dir ${ARGV2})
|
|
list(REMOVE_AT TEST_ARGS 0)
|
|
list(REMOVE_AT TEST_ARGS 0)
|
|
else()
|
|
set(Test_Dir ${test})
|
|
endif()
|
|
add_test(NAME RunCMake.${test} COMMAND ${CMAKE_CMAKE_COMMAND}
|
|
-DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}
|
|
-DRunCMake_GENERATOR_IS_MULTI_CONFIG=${_isMultiConfig}
|
|
-DRunCMake_GENERATOR=${CMAKE_GENERATOR}
|
|
-DRunCMake_GENERATOR_INSTANCE=${CMAKE_GENERATOR_INSTANCE}
|
|
-DRunCMake_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
|
|
-DRunCMake_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
|
|
-DRunCMake_MAKE_PROGRAM=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
|
|
-DRunCMake_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${Test_Dir}
|
|
-DRunCMake_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/${test}
|
|
${${test}_ARGS}
|
|
${TEST_ARGS}
|
|
-P "${CMAKE_CURRENT_SOURCE_DIR}/${Test_Dir}/RunCMakeTest.cmake"
|
|
)
|
|
set_tests_properties("RunCMake.${test}" PROPERTIES LABELS "CMake;run")
|
|
if(${test} MATCHES ^CMP)
|
|
set_property(TEST "RunCMake.${test}" APPEND PROPERTY LABELS "policy")
|
|
endif()
|
|
endmacro()
|
|
|
|
function(add_RunCMake_test_group test types)
|
|
# create directory for common content
|
|
set(TEST_CONFIG_DIR "${CMAKE_CURRENT_BINARY_DIR}/${test}/conf")
|
|
file(REMOVE_RECURSE "${TEST_CONFIG_DIR}")
|
|
file(MAKE_DIRECTORY "${TEST_CONFIG_DIR}")
|
|
|
|
foreach(type IN LISTS types)
|
|
# generate prerequirements config file in cmake as ctest doesn't have as
|
|
# much system information so it is easier to set programs and environment
|
|
# values here
|
|
unset(${test}_${type}_FOUND_PREREQUIREMENTS)
|
|
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/${test}/${type}/Prerequirements.cmake")
|
|
include("${CMAKE_CURRENT_SOURCE_DIR}/${test}/${type}/Prerequirements.cmake")
|
|
else()
|
|
string(REGEX MATCH "^[^.]*" main_type "${type}")
|
|
include("${CMAKE_CURRENT_SOURCE_DIR}/${test}/${main_type}/Prerequirements.cmake")
|
|
endif()
|
|
get_test_prerequirements("${test}_${type}_FOUND_PREREQUIREMENTS"
|
|
"${TEST_CONFIG_DIR}/${type}_config.cmake")
|
|
|
|
# only add the test if prerequirements are met
|
|
if(${test}_${type}_FOUND_PREREQUIREMENTS)
|
|
add_test(NAME RunCMake.${test}_${type} COMMAND ${CMAKE_CMAKE_COMMAND}
|
|
-DTEST_TYPE=${type}
|
|
-DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}
|
|
-DRunCMake_GENERATOR_IS_MULTI_CONFIG=${_isMultiConfig}
|
|
-DRunCMake_GENERATOR=${CMAKE_GENERATOR}
|
|
-DRunCMake_GENERATOR_INSTANCE=${CMAKE_GENERATOR_INSTANCE}
|
|
-DRunCMake_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
|
|
-DRunCMake_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
|
|
-DRunCMake_MAKE_PROGRAM=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
|
|
-DRunCMake_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${test}
|
|
-DRunCMake_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/${type}/${test}
|
|
-Dconfig_file=${TEST_CONFIG_DIR}/${type}_config.cmake
|
|
-P "${CMAKE_CURRENT_SOURCE_DIR}/${test}/RunCMakeTest.cmake"
|
|
)
|
|
endif()
|
|
endforeach()
|
|
endfunction()
|
|
|
|
# Some tests use python for extra checks.
|
|
find_package(PythonInterp QUIET)
|
|
|
|
if(XCODE_VERSION AND "${XCODE_VERSION}" VERSION_LESS 6.1)
|
|
set(Swift_ARGS -DXCODE_BELOW_6_1=1)
|
|
endif()
|
|
|
|
# Test MSVC for older host CMake versions, and test
|
|
# WIN32/CMAKE_C_COMPILER_ID to fix check on Intel for Windows.
|
|
if(MSVC OR (WIN32 AND CMAKE_C_COMPILER_ID MATCHES "MSVC|Intel"))
|
|
set(LINKER_SUPPORTS_PDB 1)
|
|
else()
|
|
set(LINKER_SUPPORTS_PDB 0)
|
|
endif()
|
|
|
|
add_RunCMake_test(CMP0019)
|
|
add_RunCMake_test(CMP0022)
|
|
add_RunCMake_test(CMP0026)
|
|
add_RunCMake_test(CMP0027)
|
|
add_RunCMake_test(CMP0028)
|
|
add_RunCMake_test(CMP0037)
|
|
add_RunCMake_test(CMP0038)
|
|
add_RunCMake_test(CMP0039)
|
|
add_RunCMake_test(CMP0040)
|
|
add_RunCMake_test(CMP0041)
|
|
if(CMAKE_SYSTEM_NAME MATCHES Darwin AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
|
|
add_RunCMake_test(CMP0042)
|
|
endif()
|
|
add_RunCMake_test(CMP0043)
|
|
add_RunCMake_test(CMP0045)
|
|
add_RunCMake_test(CMP0046)
|
|
add_RunCMake_test(CMP0049)
|
|
add_RunCMake_test(CMP0050)
|
|
add_RunCMake_test(CMP0051)
|
|
add_RunCMake_test(CMP0053)
|
|
add_RunCMake_test(CMP0054)
|
|
add_RunCMake_test(CMP0055)
|
|
add_RunCMake_test(CMP0057)
|
|
add_RunCMake_test(CMP0059)
|
|
add_RunCMake_test(CMP0060)
|
|
add_RunCMake_test(CMP0064)
|
|
if(CMAKE_SYSTEM_NAME MATCHES Darwin AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
|
|
add_RunCMake_test(CMP0068)
|
|
endif()
|
|
add_RunCMake_test(CMP0069)
|
|
add_RunCMake_test(CMP0081)
|
|
add_RunCMake_test(CMP0102)
|
|
if(CMake_TEST_CUDA)
|
|
add_RunCMake_test(CMP0104)
|
|
set_property(TEST RunCMake.CMP0104 APPEND
|
|
PROPERTY LABELS "CUDA")
|
|
endif()
|
|
add_RunCMake_test(CMP0106)
|
|
add_RunCMake_test(CMP0111)
|
|
add_RunCMake_test(CMP0115)
|
|
if(CMAKE_GENERATOR MATCHES "Ninja")
|
|
add_RunCMake_test(CMP0116)
|
|
endif()
|
|
add_RunCMake_test(CMP0118)
|
|
add_RunCMake_test(CMP0119 -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
|
|
add_RunCMake_test(CMP0121)
|
|
if (CMAKE_SYSTEM_NAME MATCHES "(Linux|Darwin)")
|
|
add_RunCMake_test(CMP0125 -DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
|
|
-DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX})
|
|
endif()
|
|
add_RunCMake_test(CMP0126)
|
|
|
|
# The test for Policy 65 requires the use of the
|
|
# CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS variable, which both the VS and Xcode
|
|
# generators ignore. The policy will have no effect on those generators.
|
|
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio|Xcode")
|
|
add_RunCMake_test(CMP0065 -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
|
|
endif()
|
|
if(CMAKE_GENERATOR MATCHES "Make")
|
|
add_RunCMake_test(Make -DMAKE_IS_GNU=${MAKE_IS_GNU})
|
|
endif()
|
|
if(CMake_TEST_Qt5)
|
|
find_package(Qt5Widgets QUIET NO_MODULE)
|
|
endif()
|
|
if(CMAKE_GENERATOR MATCHES "Ninja")
|
|
set(Ninja_ARGS
|
|
-DCMAKE_C_OUTPUT_EXTENSION=${CMAKE_C_OUTPUT_EXTENSION}
|
|
-DCMAKE_SHARED_LIBRARY_PREFIX=${CMAKE_SHARED_LIBRARY_PREFIX}
|
|
-DCMAKE_SHARED_LIBRARY_SUFFIX=${CMAKE_SHARED_LIBRARY_SUFFIX})
|
|
if(CMAKE_Fortran_COMPILER)
|
|
list(APPEND Ninja_ARGS -DTEST_Fortran=1)
|
|
endif()
|
|
if(CMake_TEST_Qt5 AND Qt5Core_FOUND)
|
|
list(APPEND Ninja_ARGS -DCMake_TEST_Qt5=1 -DQt5Core_DIR=${Qt5Core_DIR} -DCMAKE_TEST_Qt5Core_Version=${Qt5Core_VERSION})
|
|
if(Qt5Widgets_FOUND)
|
|
list(APPEND Ninja_ARGS -DQt5Widgets_DIR=${Qt5Widgets_DIR})
|
|
endif()
|
|
endif()
|
|
add_RunCMake_test(Ninja)
|
|
set(NinjaMultiConfig_ARGS
|
|
-DCYGWIN=${CYGWIN} -DMSYS=${MSYS}
|
|
)
|
|
if(CMake_TEST_Qt5 AND Qt5Core_FOUND)
|
|
list(APPEND NinjaMultiConfig_ARGS -DCMake_TEST_Qt5=1 -DQt5Core_DIR=${Qt5Core_DIR} -DCMAKE_TEST_Qt5Core_Version=${Qt5Core_VERSION})
|
|
endif()
|
|
if(DEFINED CMake_TEST_CUDA)
|
|
list(APPEND NinjaMultiConfig_ARGS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
|
|
endif()
|
|
add_RunCMake_test(NinjaMultiConfig)
|
|
set_property(TEST RunCMake.NinjaMultiConfig APPEND
|
|
PROPERTY LABELS "CUDA")
|
|
endif()
|
|
add_RunCMake_test(CTest)
|
|
|
|
if(NOT CMake_TEST_EXTERNAL_CMAKE)
|
|
add_RunCMake_test(ctest_memcheck
|
|
-DPSEUDO_BC=$<TARGET_FILE:pseudo_BC>
|
|
-DPSEUDO_PURIFY=$<TARGET_FILE:pseudo_purify>
|
|
-DPSEUDO_VALGRIND=$<TARGET_FILE:pseudo_valgrind>
|
|
-DPSEUDO_CUDA_SANITIZER=$<TARGET_FILE:pseudo_cuda-memcheck>
|
|
-DPSEUDO_BC_NOLOG=$<TARGET_FILE:pseudonl_BC>
|
|
-DPSEUDO_PURIFY_NOLOG=$<TARGET_FILE:pseudonl_purify>
|
|
-DPSEUDO_VALGRIND_NOLOG=$<TARGET_FILE:pseudonl_valgrind>
|
|
-DMEMCHECK_FAIL=$<TARGET_FILE:memcheck_fail>
|
|
)
|
|
endif()
|
|
|
|
add_RunCMake_test(ABI -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
|
|
set_property(TEST RunCMake.ABI APPEND
|
|
PROPERTY LABELS "CUDA")
|
|
|
|
add_RunCMake_test(AndroidTestUtilities)
|
|
if(CMake_TEST_APPLE_SILICON)
|
|
add_RunCMake_test(AppleSilicon)
|
|
endif()
|
|
set(autogen_with_qt5 FALSE)
|
|
if(CMake_TEST_Qt5 AND Qt5Widgets_FOUND)
|
|
set(autogen_with_qt5 TRUE)
|
|
endif ()
|
|
add_RunCMake_test(Autogen -Dwith_qt5=${autogen_with_qt5})
|
|
|
|
add_RunCMake_test(ArtifactOutputDirs)
|
|
|
|
if(NOT DEFINED CMake_TEST_BuildDepends_GNU_AS
|
|
AND CMAKE_C_COMPILER_ID STREQUAL "GNU"
|
|
AND CMAKE_GENERATOR MATCHES "^Ninja"
|
|
)
|
|
execute_process(COMMAND "${CMAKE_C_COMPILER}" -print-prog-name=as
|
|
RESULT_VARIABLE _gnu_res
|
|
OUTPUT_VARIABLE _gnu_as OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_QUIET)
|
|
if(_gnu_res EQUAL 0 AND _gnu_as)
|
|
set(CMake_TEST_BuildDepends_GNU_AS "${_gnu_as}")
|
|
endif()
|
|
endif()
|
|
|
|
add_RunCMake_test(BuildDepends
|
|
-DMSVC_VERSION=${MSVC_VERSION}
|
|
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
|
|
-DCMake_TEST_BuildDepends_GNU_AS=${CMake_TEST_BuildDepends_GNU_AS}
|
|
)
|
|
if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
|
|
add_RunCMake_test(Byproducts)
|
|
endif()
|
|
add_RunCMake_test(CMakeDependentOption)
|
|
add_RunCMake_test(CMakeRoleGlobalProperty)
|
|
add_RunCMake_test(CMakeRelease -DCMake_TEST_JQ=${CMake_TEST_JQ})
|
|
if(UNIX AND "${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
|
|
add_RunCMake_test(CompilerChange)
|
|
endif()
|
|
add_RunCMake_test(CompilerNotFound)
|
|
add_RunCMake_test(Configure -DMSVC_IDE=${MSVC_IDE})
|
|
add_RunCMake_test(DisallowedCommands)
|
|
if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles|Ninja")
|
|
add_RunCMake_test(ExportCompileCommands)
|
|
endif()
|
|
add_RunCMake_test(ExcludeFromAll)
|
|
add_RunCMake_test(ExternalData)
|
|
add_RunCMake_test(FeatureSummary)
|
|
add_RunCMake_test(FPHSA)
|
|
add_RunCMake_test(FileAPI -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
|
|
-DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID})
|
|
add_RunCMake_test(FindBoost)
|
|
add_RunCMake_test(FindLua)
|
|
add_RunCMake_test(FindOpenGL)
|
|
add_RunCMake_test(InitialFlags)
|
|
if(CMake_TEST_FindOpenSSL)
|
|
add_RunCMake_test(FindOpenSSL)
|
|
endif()
|
|
if(CMake_TEST_UseSWIG)
|
|
add_RunCMake_test(FindSWIG)
|
|
add_RunCMake_test(UseSWIG -DCMake_TEST_FindPython=${CMake_TEST_FindPython})
|
|
endif()
|
|
if(NOT CMAKE_C_COMPILER_ID MATCHES "Watcom")
|
|
add_RunCMake_test(GenerateExportHeader)
|
|
endif()
|
|
add_RunCMake_test(GenEx-COMPILE_LANGUAGE)
|
|
add_RunCMake_test(GenEx-COMPILE_LANG_AND_ID)
|
|
add_RunCMake_test(GenEx-LINK_LANGUAGE)
|
|
add_RunCMake_test(GenEx-LINK_LANG_AND_ID)
|
|
add_RunCMake_test(GenEx-HOST_LINK)
|
|
add_RunCMake_test(GenEx-DEVICE_LINK)
|
|
add_RunCMake_test(GenEx-TARGET_FILE -DLINKER_SUPPORTS_PDB=${LINKER_SUPPORTS_PDB})
|
|
add_RunCMake_test(GenEx-GENEX_EVAL)
|
|
add_RunCMake_test(GenEx-TARGET_RUNTIME_DLLS)
|
|
add_RunCMake_test(GeneratorExpression)
|
|
add_RunCMake_test(GeneratorInstance)
|
|
add_RunCMake_test(GeneratorPlatform)
|
|
if(XCODE_VERSION)
|
|
set(GeneratorToolset_ARGS -DXCODE_VERSION=${XCODE_VERSION})
|
|
endif()
|
|
add_RunCMake_test(GeneratorToolset)
|
|
add_RunCMake_test(GetPrerequisites)
|
|
add_RunCMake_test(GNUInstallDirs -DSYSTEM_NAME=${CMAKE_SYSTEM_NAME})
|
|
add_RunCMake_test(GoogleTest) # Note: does not actually depend on Google Test
|
|
add_RunCMake_test(Graphviz)
|
|
add_RunCMake_test(TargetPropertyGeneratorExpressions)
|
|
add_RunCMake_test(Languages)
|
|
add_RunCMake_test(LinkStatic)
|
|
if(CMAKE_CXX_COMPILER_ID MATCHES "^(Cray|PGI|NVHPC|XL|XLClang|Fujitsu|FujitsuClang)$")
|
|
add_RunCMake_test(MetaCompileFeatures)
|
|
endif()
|
|
if(MSVC)
|
|
add_RunCMake_test(MSVCRuntimeLibrary)
|
|
add_RunCMake_test(MSVCRuntimeTypeInfo)
|
|
add_RunCMake_test(MSVCWarningFlags)
|
|
endif()
|
|
add_RunCMake_test(ObjectLibrary)
|
|
add_RunCMake_test(ParseImplicitIncludeInfo)
|
|
add_RunCMake_test(ParseImplicitLinkInfo)
|
|
if(UNIX AND CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG AND CMAKE_EXECUTABLE_FORMAT STREQUAL "ELF")
|
|
add_RunCMake_test(RuntimePath)
|
|
endif()
|
|
add_RunCMake_test(ScriptMode)
|
|
add_RunCMake_test(Swift -DCMAKE_Swift_COMPILER=${CMAKE_Swift_COMPILER})
|
|
add_RunCMake_test(TargetObjects)
|
|
add_RunCMake_test(TargetSources)
|
|
add_RunCMake_test(TargetProperties)
|
|
add_RunCMake_test(ToolchainFile)
|
|
add_RunCMake_test(find_dependency)
|
|
add_RunCMake_test(CompileDefinitions)
|
|
add_RunCMake_test(CompileFeatures)
|
|
add_RunCMake_test(Policy)
|
|
add_RunCMake_test(PolicyScope)
|
|
add_RunCMake_test(WriteBasicConfigVersionFile)
|
|
add_RunCMake_test(WriteCompilerDetectionHeader)
|
|
add_RunCMake_test(SourceProperties)
|
|
if(NOT WIN32)
|
|
add_RunCMake_test(PositionIndependentCode -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
|
|
-DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID})
|
|
endif()
|
|
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio")
|
|
add_RunCMake_test(VisibilityPreset)
|
|
endif()
|
|
if (QT4_FOUND)
|
|
set(CompatibleInterface_ARGS -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE})
|
|
endif()
|
|
add_RunCMake_test(CompatibleInterface)
|
|
add_RunCMake_test(Syntax)
|
|
add_RunCMake_test(WorkingDirectory)
|
|
add_RunCMake_test(MaxRecursionDepth)
|
|
|
|
add_RunCMake_test(add_custom_command)
|
|
add_RunCMake_test(add_custom_target)
|
|
add_RunCMake_test(add_dependencies)
|
|
add_RunCMake_test(add_executable)
|
|
add_RunCMake_test(add_library)
|
|
add_RunCMake_test(add_subdirectory)
|
|
add_RunCMake_test(add_test)
|
|
add_RunCMake_test(build_command)
|
|
add_executable(exit_code exit_code.c)
|
|
set(execute_process_ARGS
|
|
-DEXIT_CODE_EXE=$<TARGET_FILE:exit_code>
|
|
-DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
|
|
)
|
|
if(NOT CMake_TEST_EXTERNAL_CMAKE)
|
|
list(APPEND execute_process_ARGS -DTEST_ENCODING_EXE=$<TARGET_FILE:testEncoding>)
|
|
endif()
|
|
add_RunCMake_test(execute_process)
|
|
add_RunCMake_test(export)
|
|
add_RunCMake_test(cmake_language)
|
|
add_RunCMake_test(cmake_minimum_required)
|
|
add_RunCMake_test(cmake_parse_arguments)
|
|
add_RunCMake_test(cmake_path -DMSYS=${MSYS})
|
|
add_RunCMake_test(continue)
|
|
add_executable(color_warning color_warning.c)
|
|
add_executable(fake_build_command fake_build_command.c)
|
|
add_RunCMake_test(ctest_build
|
|
-DCOLOR_WARNING=$<TARGET_FILE:color_warning>
|
|
-DFAKE_BUILD_COMMAND_EXE=$<TARGET_FILE:fake_build_command>
|
|
)
|
|
add_RunCMake_test(ctest_cmake_error)
|
|
add_RunCMake_test(ctest_configure)
|
|
if(COVERAGE_COMMAND)
|
|
add_RunCMake_test(ctest_coverage -DCOVERAGE_COMMAND=${COVERAGE_COMMAND})
|
|
endif()
|
|
add_RunCMake_test(ctest_start)
|
|
add_RunCMake_test(ctest_submit)
|
|
add_RunCMake_test(ctest_test
|
|
-DIMAGE_DIR=${CMAKE_SOURCE_DIR}/Utilities/Sphinx/static
|
|
)
|
|
add_RunCMake_test(ctest_disabled_test)
|
|
add_RunCMake_test(ctest_skipped_test)
|
|
add_RunCMake_test(ctest_update)
|
|
add_RunCMake_test(ctest_upload)
|
|
add_RunCMake_test(ctest_fixtures)
|
|
add_RunCMake_test(file -DMSYS=${MSYS})
|
|
add_RunCMake_test(file-CHMOD -DMSYS=${MSYS})
|
|
if(HAVE_ELF_H OR CMAKE_SYSTEM_NAME STREQUAL "AIX")
|
|
add_RunCMake_test(file-RPATH -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME} -DHAVE_ELF_H=${HAVE_ELF_H})
|
|
endif()
|
|
add_RunCMake_test(find_file)
|
|
add_RunCMake_test(find_library -DCYGWIN=${CYGWIN} -DMSYS=${MSYS})
|
|
add_RunCMake_test(find_package -DMSYS=${MSYS})
|
|
add_RunCMake_test(find_path)
|
|
add_RunCMake_test(find_program -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME})
|
|
add_RunCMake_test(foreach)
|
|
add_RunCMake_test(function)
|
|
add_RunCMake_test(get_filename_component)
|
|
add_RunCMake_test(get_property)
|
|
add_RunCMake_test(if)
|
|
add_RunCMake_test(include)
|
|
add_RunCMake_test(include_directories)
|
|
add_RunCMake_test(include_guard)
|
|
add_RunCMake_test(list)
|
|
add_RunCMake_test(load_cache)
|
|
add_RunCMake_test(math)
|
|
add_RunCMake_test(message)
|
|
add_RunCMake_test(option)
|
|
add_RunCMake_test(project -DCMake_TEST_RESOURCES=${CMake_TEST_RESOURCES})
|
|
add_RunCMake_test(project_injected)
|
|
add_RunCMake_test(return)
|
|
add_RunCMake_test(separate_arguments)
|
|
add_RunCMake_test(set_property)
|
|
add_RunCMake_test(string)
|
|
add_RunCMake_test(test_include_dirs)
|
|
add_RunCMake_test(BundleUtilities)
|
|
if(APPLE)
|
|
add_RunCMake_test(INSTALL_NAME_DIR)
|
|
add_RunCMake_test(MacOSVersions)
|
|
endif()
|
|
|
|
function(add_RunCMake_test_try_compile)
|
|
if(CMAKE_VERSION VERSION_LESS 3.9.20170907 AND "x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC")
|
|
# Older CMake versions do not know about MSVC language standards.
|
|
# Approximate our logic from MSVC-CXX.cmake.
|
|
if ((NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.0.24215.1 AND
|
|
CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10) OR
|
|
NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 19.10.25017)
|
|
set(CMAKE_CXX_STANDARD_DEFAULT 14)
|
|
elseif (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 16.0)
|
|
set(CMAKE_CXX_STANDARD_DEFAULT "")
|
|
else()
|
|
unset(CMAKE_CXX_STANDARD_DEFAULT)
|
|
endif()
|
|
endif()
|
|
if(CMAKE_VERSION VERSION_LESS 3.18.20200813 AND "x${CMAKE_C_COMPILER_ID}" STREQUAL "xMSVC")
|
|
# Older CMake versions do not know about MSVC language standards.
|
|
# Approximate our logic from MSVC-C.cmake.
|
|
if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 19.27)
|
|
set(CMAKE_C_STANDARD_DEFAULT 99)
|
|
else()
|
|
set(CMAKE_C_STANDARD_DEFAULT "")
|
|
endif()
|
|
endif()
|
|
if(CMAKE_VERSION VERSION_LESS 3.20.20210225 AND "x${CMAKE_C_COMPILER_ID}" STREQUAL "xClang")
|
|
# Older CMake versions do not know about Clang MSVC compatibility mode
|
|
# standards. Approximate the logic from Clang-C.cmake.
|
|
if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 11.0)
|
|
set(CMAKE_C_STANDARD_DEFAULT 17)
|
|
elseif(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 3.5.2)
|
|
set(CMAKE_C_STANDARD_DEFAULT 11)
|
|
endif()
|
|
endif()
|
|
if(CMAKE_VERSION VERSION_LESS 3.20.6 AND "x${CMAKE_C_COMPILER_ID}" STREQUAL "xIntelLLVM" AND "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")
|
|
# Older CMake versions accidentally set the default standards to empty when
|
|
# IntelLLVM targets the MSVC ABI, thus not activating standard selection.
|
|
# Approximate the logic from IntelLLVM-{C,CXX}.cmake.
|
|
if(DEFINED CMAKE_C_STANDARD_DEFAULT AND "${CMAKE_C_STANDARD_DEFAULT}" STREQUAL "")
|
|
set(CMAKE_C_STANDARD_DEFAULT 17)
|
|
endif()
|
|
if(DEFINED CMAKE_CXX_STANDARD_DEFAULT AND "${CMAKE_CXX_STANDARD_DEFAULT}" STREQUAL "")
|
|
set(CMAKE_CXX_STANDARD_DEFAULT 14)
|
|
endif()
|
|
endif()
|
|
foreach(var
|
|
CMAKE_SYSTEM_NAME
|
|
CMAKE_C_COMPILER_ID
|
|
CMAKE_C_COMPILER_VERSION
|
|
CMAKE_C_STANDARD_DEFAULT
|
|
CMAKE_CXX_COMPILER_ID
|
|
CMAKE_CXX_COMPILER_VERSION
|
|
CMAKE_CXX_STANDARD_DEFAULT
|
|
CMake_TEST_CUDA
|
|
CMake_TEST_ISPC
|
|
CMake_TEST_HIP
|
|
CMake_TEST_FILESYSTEM_1S
|
|
CMAKE_OBJC_STANDARD_DEFAULT
|
|
CMAKE_OBJCXX_STANDARD_DEFAULT
|
|
)
|
|
if(DEFINED ${var})
|
|
list(APPEND try_compile_ARGS -D${var}=${${var}})
|
|
endif()
|
|
endforeach()
|
|
add_RunCMake_test(try_compile)
|
|
set_property(TEST RunCMake.try_compile APPEND
|
|
PROPERTY LABELS "CUDA;ISPC")
|
|
endfunction()
|
|
add_RunCMake_test_try_compile()
|
|
|
|
add_RunCMake_test(try_run -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
|
|
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
|
|
add_RunCMake_test(set)
|
|
add_RunCMake_test(variable_watch)
|
|
add_RunCMake_test(while)
|
|
add_RunCMake_test(CMP0004)
|
|
add_RunCMake_test(TargetPolicies)
|
|
add_RunCMake_test(alias_targets)
|
|
add_RunCMake_test(InterfaceLibrary)
|
|
add_RunCMake_test(no_install_prefix)
|
|
add_RunCMake_test(configure_file)
|
|
add_RunCMake_test(CTestTimeout -DTIMEOUT=${CTestTestTimeout_TIME})
|
|
add_RunCMake_test(CTestTimeoutAfterMatch)
|
|
add_RunCMake_test(DependencyGraph -DCMAKE_Fortran_COMPILER=${CMAKE_Fortran_COMPILER})
|
|
|
|
# ctresalloc links against CMakeLib and CTestLib, which means it can't be built
|
|
# if CMake_TEST_EXTERNAL_CMAKE is activated (the compiler might be different.)
|
|
# So, it has to be provided in the original build tree.
|
|
if(CMake_TEST_EXTERNAL_CMAKE)
|
|
set(no_package_root_path)
|
|
if(NOT CMAKE_VERSION VERSION_LESS 3.12)
|
|
set(no_package_root_path NO_PACKAGE_ROOT_PATH)
|
|
endif()
|
|
find_program(ctresalloc ctresalloc PATHS ${CMake_TEST_EXTERNAL_CMAKE}
|
|
NO_DEFAULT_PATH
|
|
${no_package_root_path}
|
|
NO_CMAKE_PATH
|
|
NO_CMAKE_ENVIRONMENT_PATH
|
|
NO_SYSTEM_ENVIRONMENT_PATH
|
|
NO_CMAKE_SYSTEM_PATH
|
|
NO_CMAKE_FIND_ROOT_PATH
|
|
)
|
|
if(ctresalloc)
|
|
add_executable(ctresalloc IMPORTED)
|
|
set_property(TARGET ctresalloc PROPERTY IMPORTED_LOCATION ${ctresalloc})
|
|
endif()
|
|
else()
|
|
add_executable(ctresalloc CTestResourceAllocation/ctresalloc.cxx)
|
|
target_link_libraries(ctresalloc CTestLib)
|
|
target_include_directories(ctresalloc PRIVATE
|
|
${CMake_BINARY_DIR}/Source
|
|
${CMake_SOURCE_DIR}/Source
|
|
${CMake_SOURCE_DIR}/Source/CTest
|
|
)
|
|
set_property(TARGET ctresalloc PROPERTY RUNTIME_OUTPUT_DIRECTORY ${CMake_BIN_DIR})
|
|
endif()
|
|
|
|
if(TARGET ctresalloc)
|
|
add_RunCMake_test(CTestResourceAllocation -DCTRESALLOC_COMMAND=$<TARGET_FILE:ctresalloc>)
|
|
else()
|
|
message(STATUS "Could not find ctresalloc")
|
|
endif()
|
|
|
|
if(NOT WIN32
|
|
AND NOT MSYS # FIXME: This works on CYGWIN but not on MSYS
|
|
)
|
|
add_RunCMake_test(SymlinkTrees)
|
|
endif ()
|
|
|
|
find_package(Qt4 QUIET)
|
|
find_package(Qt5Core QUIET)
|
|
if (QT4_FOUND AND Qt5Core_FOUND AND NOT Qt5Core_VERSION VERSION_LESS 5.1.0)
|
|
add_RunCMake_test(IncompatibleQt)
|
|
endif()
|
|
if (QT4_FOUND)
|
|
add_RunCMake_test(ObsoleteQtMacros -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE})
|
|
endif()
|
|
|
|
find_package(PkgConfig QUIET)
|
|
if(PKG_CONFIG_FOUND)
|
|
add_RunCMake_test(FindPkgConfig)
|
|
endif()
|
|
|
|
if(CMake_TEST_FindGTK2)
|
|
add_RunCMake_test(FindGTK2)
|
|
endif()
|
|
|
|
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio")
|
|
add_RunCMake_test(include_external_msproject -DVS_PLATFORM_NAME=${CMAKE_VS_PLATFORM_NAME})
|
|
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio (9|10)" AND NOT CMAKE_VS_DEVENV_COMMAND)
|
|
set(NO_USE_FOLDERS 1)
|
|
endif()
|
|
add_RunCMake_test(VSSolution -DNO_USE_FOLDERS=${NO_USE_FOLDERS})
|
|
endif()
|
|
|
|
if("${CMAKE_GENERATOR}" MATCHES "Visual Studio ([^9]|9[0-9])")
|
|
add_RunCMake_test(VS10Project
|
|
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
|
|
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION}
|
|
)
|
|
if( vs12 AND wince )
|
|
add_RunCMake_test( VS10ProjectWinCE "-DRunCMake_GENERATOR_PLATFORM=${wince_sdk}")
|
|
endif()
|
|
endif()
|
|
|
|
if(XCODE_VERSION)
|
|
add_RunCMake_test(XcodeProject -DXCODE_VERSION=${XCODE_VERSION})
|
|
add_RunCMake_test(XcodeProject-Embed -DXCODE_VERSION=${XCODE_VERSION})
|
|
|
|
# This test can take a very long time due to lots of combinations.
|
|
# Use a long default timeout and provide an option to customize it.
|
|
if(NOT DEFINED CMake_TEST_XcodeProject_TIMEOUT)
|
|
set(CMake_TEST_XcodeProject_TIMEOUT 2000)
|
|
endif()
|
|
set_property(TEST RunCMake.XcodeProject PROPERTY TIMEOUT ${CMake_TEST_XcodeProject_TIMEOUT})
|
|
endif()
|
|
|
|
if(CMAKE_C_COMPILER_ID STREQUAL "AppleClang"
|
|
AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 6.0)
|
|
add_RunCMake_test(Framework)
|
|
endif()
|
|
|
|
add_RunCMake_test(File_Archive)
|
|
add_RunCMake_test(File_Configure)
|
|
add_RunCMake_test(File_Generate)
|
|
add_RunCMake_test(ExportWithoutLanguage)
|
|
add_RunCMake_test(target_link_directories)
|
|
add_RunCMake_test(target_link_libraries)
|
|
add_RunCMake_test(target_link_libraries-ALIAS)
|
|
add_RunCMake_test(target_link_libraries-LINK_LANGUAGE)
|
|
add_RunCMake_test(target_link_libraries-LINK_LANG_AND_ID)
|
|
add_RunCMake_test(add_link_options -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID})
|
|
add_RunCMake_test(target_link_options -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
|
|
-DCMake_TEST_CUDA=${CMake_TEST_CUDA})
|
|
set_property(TEST RunCMake.target_link_options APPEND
|
|
PROPERTY LABELS "CUDA")
|
|
|
|
add_RunCMake_test(target_compile_definitions)
|
|
add_RunCMake_test(target_compile_features)
|
|
add_RunCMake_test(target_compile_options
|
|
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
|
|
-DCMAKE_C_SIMULATE_ID=${CMAKE_C_SIMULATE_ID}
|
|
)
|
|
add_RunCMake_test(target_include_directories)
|
|
add_RunCMake_test(target_sources)
|
|
add_RunCMake_test(CheckCompilerFlag -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
|
|
-DCMake_TEST_ISPC=${CMake_TEST_ISPC}
|
|
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
|
|
-DCMake_TEST_HIP=${CMake_TEST_HIP})
|
|
add_RunCMake_test(CheckSourceCompiles -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
|
|
-DCMake_TEST_ISPC=${CMake_TEST_ISPC}
|
|
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
|
|
-DCMake_TEST_HIP=${CMake_TEST_HIP})
|
|
add_RunCMake_test(CheckSourceRuns -DCMake_TEST_CUDA=${CMake_TEST_CUDA}
|
|
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
|
|
-DCMake_TEST_HIP=${CMake_TEST_HIP})
|
|
set_property(TEST RunCMake.CheckCompilerFlag
|
|
RunCMake.CheckSourceCompiles
|
|
RunCMake.CheckSourceRuns
|
|
APPEND PROPERTY LABELS "CUDA")
|
|
set_property(TEST RunCMake.CheckSourceCompiles
|
|
RunCMake.CheckCompilerFlag
|
|
APPEND PROPERTY LABELS "ISPC")
|
|
set_property(TEST RunCMake.CheckCompilerFlag
|
|
RunCMake.CheckSourceCompiles
|
|
RunCMake.CheckSourceRuns
|
|
APPEND PROPERTY LABELS "HIP")
|
|
add_RunCMake_test(CheckModules)
|
|
add_RunCMake_test(CheckIPOSupported)
|
|
if (CMAKE_SYSTEM_NAME MATCHES "(Linux|Darwin)"
|
|
AND (CMAKE_C_COMPILER_ID MATCHES "Clang|GNU" OR CMAKE_Fortran_COMPILER_ID MATCHES "GNU"))
|
|
add_RunCMake_test(CheckLinkerFlag -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
|
|
-DCMAKE_Fortran_COMPILER_ID=${CMAKE_Fortran_COMPILER_ID}
|
|
-DCMake_TEST_CUDA=${CMake_TEST_CUDA}
|
|
-DCMake_TEST_HIP=${CMake_TEST_HIP})
|
|
set_property(TEST RunCMake.CheckLinkerFlag APPEND PROPERTY LABELS "CUDA")
|
|
set_property(TEST RunCMake.CheckLinkerFlag APPEND PROPERTY LABELS "HIP")
|
|
endif()
|
|
|
|
|
|
add_executable(pseudo_llvm-rc pseudo_llvm-rc.c)
|
|
add_RunCMake_test(CommandLine -DLLVM_RC=$<TARGET_FILE:pseudo_llvm-rc> -DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
|
|
-DCYGWIN=${CYGWIN} -DMSYS=${MSYS} -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE})
|
|
add_RunCMake_test(CommandLineTar)
|
|
|
|
if(CMAKE_PLATFORM_NO_VERSIONED_SONAME OR (NOT CMAKE_SHARED_LIBRARY_SONAME_FLAG AND NOT CMAKE_SHARED_LIBRARY_SONAME_C_FLAG))
|
|
set(NO_NAMELINK 1)
|
|
else()
|
|
set(NO_NAMELINK 0)
|
|
endif()
|
|
|
|
add_RunCMake_test(install -DNO_NAMELINK=${NO_NAMELINK} -DCYGWIN=${CYGWIN} -DMSYS=${MSYS}
|
|
-DCMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN=${CMAKE_SHARED_LIBRARY_RPATH_ORIGIN_TOKEN}
|
|
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
|
|
-DCMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG=${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG}
|
|
-DCMAKE_EXECUTABLE_FORMAT=${CMAKE_EXECUTABLE_FORMAT}
|
|
-DCMake_TEST_ISPC=${CMake_TEST_ISPC}
|
|
)
|
|
set_property(TEST RunCMake.install APPEND
|
|
PROPERTY LABELS "ISPC")
|
|
|
|
add_RunCMake_test(file-GET_RUNTIME_DEPENDENCIES
|
|
-DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
|
|
-DCMake_INSTALL_NAME_TOOL_BUG=${CMake_INSTALL_NAME_TOOL_BUG}
|
|
)
|
|
|
|
add_RunCMake_test(CPackCommandLine)
|
|
add_RunCMake_test(CPackConfig)
|
|
add_RunCMake_test(CPackInstallProperties)
|
|
if(XCODE_VERSION)
|
|
set(ExternalProject_ARGS -DXCODE_VERSION=${XCODE_VERSION})
|
|
endif()
|
|
add_RunCMake_test(ExternalProject)
|
|
add_RunCMake_test(FetchContent)
|
|
set(CTestCommandLine_ARGS -DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE})
|
|
if(NOT CMake_TEST_EXTERNAL_CMAKE)
|
|
list(APPEND CTestCommandLine_ARGS -DTEST_AFFINITY=$<TARGET_FILE:testAffinity>)
|
|
endif()
|
|
add_executable(print_stdin print_stdin.c)
|
|
add_RunCMake_test(CTestCommandLine -DTEST_PRINT_STDIN=$<TARGET_FILE:print_stdin>)
|
|
add_RunCMake_test(CacheNewline)
|
|
# Only run this test on unix platforms that support
|
|
# symbolic links
|
|
if(UNIX)
|
|
add_RunCMake_test(CPackSymlinks)
|
|
endif()
|
|
|
|
set(IfacePaths_INCDIRS_ARGS -DTEST_PROP=INCLUDE_DIRECTORIES)
|
|
add_RunCMake_test(IfacePaths_INCDIRS TEST_DIR IfacePaths)
|
|
|
|
set(IfacePaths_SOURCES_ARGS -DTEST_PROP=SOURCES)
|
|
add_RunCMake_test(IfacePaths_SOURCES TEST_DIR IfacePaths)
|
|
|
|
# Matlab module related tests
|
|
if(CMake_TEST_FindMatlab OR CMake_TEST_FindMatlab_MCR OR (NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL ""))
|
|
set(FindMatlab_additional_test_options )
|
|
if(CMake_TEST_FindMatlab_MCR OR NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL "")
|
|
set(FindMatlab_additional_test_options -DIS_MCR=TRUE)
|
|
endif()
|
|
if(NOT "${CMake_TEST_FindMatlab_MCR_ROOT_DIR}" STREQUAL "")
|
|
set(FindMatlab_additional_test_options ${FindMatlab_additional_test_options} "-DMCR_ROOT:FILEPATH=${CMake_TEST_FindMatlab_MCR_ROOT_DIR}")
|
|
endif()
|
|
|
|
add_RunCMake_test(FindMatlab ${FindMatlab_additional_test_options})
|
|
endif()
|
|
|
|
add_executable(pseudo_emulator pseudo_emulator.c)
|
|
add_executable(pseudo_emulator_custom_command pseudo_emulator_custom_command.c)
|
|
add_executable(pseudo_emulator_custom_command_arg pseudo_emulator_custom_command_arg.c)
|
|
add_RunCMake_test(CrosscompilingEmulator
|
|
-DPSEUDO_EMULATOR=$<TARGET_FILE:pseudo_emulator>
|
|
-DPSEUDO_EMULATOR_CUSTOM_COMMAND=$<TARGET_FILE:pseudo_emulator_custom_command>
|
|
-DPSEUDO_EMULATOR_CUSTOM_COMMAND_ARG=$<TARGET_FILE:pseudo_emulator_custom_command_arg>)
|
|
if("${CMAKE_GENERATOR}" MATCHES "Make|Ninja")
|
|
if(UNIX AND NOT CYGWIN)
|
|
execute_process(COMMAND ldd --help
|
|
OUTPUT_VARIABLE LDD_HELP
|
|
ERROR_VARIABLE LDD_ERR)
|
|
if("${LDD_HELP}" MATCHES
|
|
"(-r, --function-relocs.*process data and function relocations.*-u, --unused.*print unused direct dependencies)")
|
|
add_RunCMake_test(LinkWhatYouUse)
|
|
endif()
|
|
endif()
|
|
add_executable(pseudo_tidy pseudo_tidy.c)
|
|
add_executable(pseudo_iwyu pseudo_iwyu.c)
|
|
add_executable(pseudo_cpplint pseudo_cpplint.c)
|
|
add_executable(pseudo_cppcheck pseudo_cppcheck.c)
|
|
add_RunCMake_test(ClangTidy -DPSEUDO_TIDY=$<TARGET_FILE:pseudo_tidy>)
|
|
add_RunCMake_test(IncludeWhatYouUse -DPSEUDO_IWYU=$<TARGET_FILE:pseudo_iwyu>)
|
|
add_RunCMake_test(Cpplint -DPSEUDO_CPPLINT=$<TARGET_FILE:pseudo_cpplint>)
|
|
add_RunCMake_test(Cppcheck -DPSEUDO_CPPCHECK=$<TARGET_FILE:pseudo_cppcheck>)
|
|
add_RunCMake_test(MultiLint
|
|
-DPSEUDO_TIDY=$<TARGET_FILE:pseudo_tidy>
|
|
-DPSEUDO_IWYU=$<TARGET_FILE:pseudo_iwyu>
|
|
-DPSEUDO_CPPLINT=$<TARGET_FILE:pseudo_cpplint>
|
|
-DPSEUDO_CPPCHECK=$<TARGET_FILE:pseudo_cppcheck>
|
|
)
|
|
if(DEFINED CMake_TEST_CUDA)
|
|
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_CUDA=${CMake_TEST_CUDA})
|
|
endif()
|
|
if(DEFINED CMake_TEST_HIP)
|
|
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_HIP=${CMake_TEST_HIP})
|
|
endif()
|
|
if(DEFINED CMake_TEST_ISPC)
|
|
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_ISPC=${CMake_TEST_ISPC})
|
|
endif()
|
|
if(CMAKE_Fortran_COMPILER)
|
|
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_Fortran=1)
|
|
endif()
|
|
if (APPLE AND CMAKE_C_COMPILER_ID MATCHES "Clang|GNU")
|
|
list(APPEND CompilerLauncher_ARGS -DCMake_TEST_OBJC=1)
|
|
list(APPEND LinkerLauncher_ARGS -DCMake_TEST_OBJC=1)
|
|
endif()
|
|
add_RunCMake_test(CompilerLauncher)
|
|
set_property(TEST RunCMake.CompilerLauncher APPEND
|
|
PROPERTY LABELS "CUDA;HIP;ISPC")
|
|
add_RunCMake_test(ctest_labels_for_subprojects)
|
|
add_RunCMake_test(CompilerArgs)
|
|
add_RunCMake_test(LinkerLauncher)
|
|
endif()
|
|
|
|
set(cpack_tests
|
|
DEB.CUSTOM_NAMES
|
|
DEB.DEBUGINFO
|
|
DEB.DEFAULT_PERMISSIONS
|
|
DEB.DEPENDENCIES
|
|
DEB.EMPTY_DIR
|
|
DEB.VERSION
|
|
DEB.EXTRA
|
|
DEB.GENERATE_SHLIBS
|
|
DEB.GENERATE_SHLIBS_LDCONFIG
|
|
DEB.LONG_FILENAMES
|
|
DEB.MINIMAL
|
|
DEB.PER_COMPONENT_FIELDS
|
|
DEB.TIMESTAMPS
|
|
DEB.MD5SUMS
|
|
DEB.DEB_PACKAGE_VERSION_BACK_COMPATIBILITY
|
|
DEB.DEB_DESCRIPTION
|
|
DEB.PROJECT_META
|
|
|
|
RPM.CUSTOM_BINARY_SPEC_FILE
|
|
RPM.CUSTOM_NAMES
|
|
RPM.DEBUGINFO
|
|
RPM.DEFAULT_PERMISSIONS
|
|
RPM.DEPENDENCIES
|
|
RPM.DIST
|
|
RPM.EMPTY_DIR
|
|
RPM.VERSION
|
|
RPM.INSTALL_SCRIPTS
|
|
RPM.MAIN_COMPONENT
|
|
RPM.MINIMAL
|
|
RPM.PARTIALLY_RELOCATABLE_WARNING
|
|
RPM.PER_COMPONENT_FIELDS
|
|
RPM.SINGLE_DEBUGINFO
|
|
RPM.EXTRA_SLASH_IN_PATH
|
|
RPM.SOURCE_PACKAGE
|
|
RPM.SUGGESTS
|
|
RPM.SYMLINKS
|
|
RPM.USER_FILELIST
|
|
RPM.PROJECT_META
|
|
|
|
7Z
|
|
TBZ2
|
|
TGZ
|
|
TXZ
|
|
TZ
|
|
ZIP
|
|
STGZ
|
|
External
|
|
)
|
|
if(APPLE)
|
|
list(APPEND cpack_tests DragNDrop)
|
|
endif()
|
|
add_RunCMake_test_group(CPack "${cpack_tests}")
|
|
# add a test to make sure symbols are exported from a shared library
|
|
# for MSVC compilers CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS property is used
|
|
add_RunCMake_test(AutoExportDll
|
|
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
|
|
-DCMAKE_CXX_COMPILER_ID=${CMAKE_CXX_COMPILER_ID}
|
|
)
|
|
|
|
add_RunCMake_test(AndroidMK)
|
|
|
|
if(CMake_TEST_ANDROID_NDK OR CMake_TEST_ANDROID_STANDALONE_TOOLCHAIN)
|
|
if(NOT "${CMAKE_GENERATOR}" MATCHES "Make|Ninja|Visual Studio 1[456]")
|
|
message(FATAL_ERROR "Android tests supported only by Makefile, Ninja, and Visual Studio >= 14 generators")
|
|
endif()
|
|
foreach(v TEST_ANDROID_NDK TEST_ANDROID_STANDALONE_TOOLCHAIN)
|
|
if(CMake_${v})
|
|
string(REPLACE ";" "|" ${v} "${CMake_${v}}")
|
|
list(APPEND Android_ARGS "-D${v}=${${v}}")
|
|
endif()
|
|
endforeach()
|
|
|
|
add_RunCMake_test(Android)
|
|
|
|
# This test can take a very long time due to lots of combinations.
|
|
# Use a long default timeout and provide an option to customize it.
|
|
if(NOT DEFINED CMake_TEST_ANDROID_TIMEOUT)
|
|
set(CMake_TEST_ANDROID_TIMEOUT 3000)
|
|
endif()
|
|
set_property(TEST RunCMake.Android PROPERTY TIMEOUT ${CMake_TEST_ANDROID_TIMEOUT})
|
|
endif()
|
|
|
|
if(${CMAKE_GENERATOR} MATCHES "Visual Studio ([^9]|9[0-9])")
|
|
add_RunCMake_test(CSharpCustomCommand)
|
|
add_RunCMake_test(CSharpReferenceImport)
|
|
endif()
|
|
|
|
add_RunCMake_test("CTestCommandExpandLists")
|
|
|
|
add_RunCMake_test(PrecompileHeaders -DCMAKE_C_COMPILER_ID=${CMAKE_C_COMPILER_ID}
|
|
-DCMAKE_C_COMPILER_VERSION=${CMAKE_C_COMPILER_VERSION})
|
|
|
|
add_RunCMake_test("UnityBuild")
|
|
add_RunCMake_test(CMakePresets
|
|
-DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
|
|
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
|
|
)
|
|
add_RunCMake_test(CMakePresetsBuild
|
|
-DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
|
|
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
|
|
-DCMAKE_SYSTEM_NAME=${CMAKE_SYSTEM_NAME}
|
|
)
|
|
add_RunCMake_test(CMakePresetsTest
|
|
-DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}
|
|
-DCMake_TEST_JSON_SCHEMA=${CMake_TEST_JSON_SCHEMA}
|
|
)
|
|
|
|
if(${CMAKE_GENERATOR} MATCHES "Make|Ninja")
|
|
add_RunCMake_test(TransformDepfile)
|
|
endif()
|
|
|
|
if(WIN32)
|
|
add_RunCMake_test(Win32GenEx)
|
|
endif()
|