Skip to content

Instantly share code, notes, and snippets.

@waitman

waitman/cmake-2.8.12.2 strip Qt checks and build

Created March 1, 2014 18:38
Show Gist options
  • Save waitman/9294842 to your computer and use it in GitHub Desktop.
Save waitman/9294842 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
cmake-2.8.12.2 strip Qt checks and build
# This is a shell archive. Save it in a file, remove anything before
# this line, and then unpack it by entering "sh file". Note, it may
# create directories; files and directories will be owned by you and
# have default permissions.
#
# This archive contains:
#
# CMakeCPackOptions.cmake
# Tests/CMakeLists.txt
# Tests/RunCMake/CMakeLists.txt
# Source/CMakeLists.txt
#
echo x - CMakeCPackOptions.cmake
sed 's/^X//' >CMakeCPackOptions.cmake << 'f6f6efa4b1f87acfaf08758e3bf52d50 -'
X# This file is configured at cmake time, and loaded at cpack time.
X# To pass variables to cpack from cmake, they must be configured
X# in this file.
X
Xif(CPACK_GENERATOR MATCHES "NSIS")
X set(CPACK_NSIS_INSTALL_ROOT "$PROGRAMFILES")
X
X # set the install/unistall icon used for the installer itself
X # There is a bug in NSI that does not handle full unix paths properly.
X set(CPACK_NSIS_MUI_ICON "/sources/cmake-2.8.12.2/Utilities/Release\\CMakeLogo.ico")
X set(CPACK_NSIS_MUI_UNIICON "/sources/cmake-2.8.12.2/Utilities/Release\\CMakeLogo.ico")
X # set the package header icon for MUI
X set(CPACK_PACKAGE_ICON "/sources/cmake-2.8.12.2/Utilities/Release\\CMakeInstall.bmp")
X # tell cpack to create links to the doc files
X set(CPACK_NSIS_MENU_LINKS
X "doc/cmake-2.8/cmake-gui.html" "cmake-gui Help"
X "doc/cmake-2.8/cmake.html" "CMake Help"
X "doc/cmake-2.8/cmake-properties.html"
X "CMake Properties and Variables Help"
X "doc/cmake-2.8/ctest.html" "CTest Help"
X "doc/cmake-2.8/cmake-modules.html" "CMake Modules Help"
X "doc/cmake-2.8/cmake-commands.html" "CMake Commands Help"
X "doc/cmake-2.8/cpack.html" "CPack Help"
X "http://www.cmake.org" "CMake Web Site"
X )
X # Use the icon from cmake-gui for add-remove programs
X set(CPACK_NSIS_INSTALLED_ICON_NAME "bin\\cmake-gui.exe")
X
X set(CPACK_NSIS_PACKAGE_NAME "CMake 2.8")
X set(CPACK_NSIS_DISPLAY_NAME "CMake 2.8, a cross-platform, open-source build system")
X set(CPACK_NSIS_HELP_LINK "http://www.cmake.org")
X set(CPACK_NSIS_URL_INFO_ABOUT "http://www.kitware.com")
X set(CPACK_NSIS_CONTACT [email protected])
X set(CPACK_NSIS_MODIFY_PATH ON)
Xendif()
X
X# include the cpack options for qt dialog if they exist
X# they might not if qt was not enabled for the build
Xinclude("/sources/cmake-2.8.12.2/Source/QtDialog/QtDialogCPack.cmake" OPTIONAL)
X
Xif(CPACK_GENERATOR MATCHES "CygwinSource")
X # when packaging source make sure the .build directory is not included
X set(CPACK_SOURCE_IGNORE_FILES
X "/CVS/" "/\\.build/" "/\\.svn/" "\\.swp$" "\\.#" "/#" "~$")
Xendif()
X
Xif("${CPACK_GENERATOR}" STREQUAL "PackageMaker")
X if(CMAKE_PACKAGE_QTGUI)
X set(CPACK_PACKAGE_DEFAULT_LOCATION "/Applications")
X else()
X set(CPACK_PACKAGE_DEFAULT_LOCATION "/usr")
X endif()
Xendif()
X
Xif("${CPACK_GENERATOR}" STREQUAL "WIX")
X # Reset CPACK_PACKAGE_VERSION to deal with WiX restriction.
X # But the file names still use the full CMake_VERSION value:
X set(CPACK_PACKAGE_FILE_NAME
X "${CPACK_PACKAGE_NAME}-2.8.12.2-${CPACK_SYSTEM_NAME}")
X set(CPACK_SOURCE_PACKAGE_FILE_NAME
X "${CPACK_PACKAGE_NAME}-2.8.12.2-Source")
X
X if(NOT CPACK_WIX_SIZEOF_VOID_P)
X set(CPACK_WIX_SIZEOF_VOID_P "8")
X endif()
X
X set(CPACK_PACKAGE_VERSION
X "2.8.12")
X # WIX installers require at most a 4 component version number, where
X # each component is an integer between 0 and 65534 inclusive
X set(tweak "2")
X if(tweak MATCHES "^[0-9]+$")
X if(tweak GREATER 0 AND tweak LESS 65535)
X set(CPACK_PACKAGE_VERSION "${CPACK_PACKAGE_VERSION}.${tweak}")
X endif()
X endif()
Xendif()
f6f6efa4b1f87acfaf08758e3bf52d50 -
echo x - Tests/CMakeLists.txt
sed 's/^X//' >Tests/CMakeLists.txt << '74f91ee0c70fa79d4081883c8d574430 -'
X# a macro for tests that have a simple format where the name matches the
X# directory and project
Xmacro(ADD_TEST_MACRO NAME COMMAND)
X string(REPLACE "." "/" dir "${NAME}")
X string(REGEX REPLACE "[^.]*\\." "" proj "${NAME}")
X add_test(${NAME} ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/${dir}"
X "${CMake_BINARY_DIR}/Tests/${dir}"
X --build-two-config
X ${build_generator_args}
X --build-project ${proj}
X ${${NAME}_EXTRA_OPTIONS}
X --test-command ${COMMAND} ${ARGN})
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${dir}")
Xendmacro()
X
Xinclude(${CMAKE_CURRENT_SOURCE_DIR}/RegexEscapeString.cmake)
X
Xinclude(${CMAKE_CURRENT_SOURCE_DIR}/CheckFortran.cmake)
X
X# Fake a user home directory to avoid polluting the real one.
Xif(DEFINED ENV{HOME} AND NOT CTEST_NO_TEST_HOME)
X set(TEST_HOME "${CMake_BINARY_DIR}/Tests/CMakeFiles/TestHome")
X file(MAKE_DIRECTORY "${TEST_HOME}")
X file(WRITE "${TEST_HOME}/.cvspass" ":pserver:[email protected]:/cvsroot/KWSys A\n")
X set(TEST_HOME_ENV_CODE "# Fake a user home directory to avoid polluting the real one.
X# But provide original ENV{HOME} value in ENV{CTEST_REAL_HOME} for tests that
X# need access to the real HOME directory.
Xset(ENV{CTEST_REAL_HOME} \"\$ENV{HOME}\")
Xset(ENV{HOME} \"${TEST_HOME}\")
X")
Xendif()
X
X# Choose a default configuration for CTest tests.
Xset(CTestTest_CONFIG Debug)
Xif(NOT CMAKE_CONFIGURATION_TYPES AND CMAKE_BUILD_TYPE)
X set(CTestTest_CONFIG ${CMAKE_BUILD_TYPE})
Xendif()
X
Xconfigure_file(${CMake_SOURCE_DIR}/Tests/EnforceConfig.cmake.in
X ${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake @ONLY)
X
X# Testing
Xif(BUILD_TESTING)
X if("${CMAKE_TEST_GENERATOR}" MATCHES "Unix Makefiles" OR ("${CMAKE_TEST_GENERATOR}" MATCHES Ninja AND NOT WIN32))
X set(TEST_CompileCommandOutput 1)
X endif()
X
X set(MAKE_IS_GNU )
X if(${CMAKE_TEST_MAKEPROGRAM} MATCHES make)
X execute_process(COMMAND ${CMAKE_TEST_MAKEPROGRAM} no_such_target --version
X RESULT_VARIABLE res OUTPUT_VARIABLE out ERROR_VARIABLE out)
X if("${res}" STREQUAL "0")
X if("${out}" MATCHES "GNU")
X set(MAKE_IS_GNU 1)
X endif()
X endif()
X endif()
X
X # some old versions of make simply cannot handle spaces in paths
X if (MAKE_IS_GNU OR
X "${CMAKE_TEST_MAKEPROGRAM}" MATCHES "nmake|gmake|wmake" OR
X "${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio|XCode|Borland")
X set(MAKE_SUPPORTS_SPACES 1)
X else()
X set(MAKE_SUPPORTS_SPACES 0)
X endif()
X
X set(build_generator_args
X --build-generator ${CMAKE_TEST_GENERATOR}
X --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
X )
X if(CMAKE_TEST_GENERATOR_TOOLSET)
X list(APPEND build_generator_args
X --build-generator-toolset ${CMAKE_TEST_GENERATOR_TOOLSET}
X )
X endif()
X
X add_subdirectory(CMakeLib)
X add_subdirectory(CMakeOnly)
X add_subdirectory(RunCMake)
X
X add_subdirectory(FindPackageModeMakefileTest)
X
X add_subdirectory(CTestTestMemcheck)
X
X # Collect a list of all test build directories.
X set(TEST_BUILD_DIRS)
X
X # Should the long tests be run?
X option(CMAKE_RUN_LONG_TESTS
X "Should the long tests be run (such as Bootstrap)." ON)
X mark_as_advanced(CMAKE_RUN_LONG_TESTS)
X
X if (CMAKE_RUN_LONG_TESTS)
X option(CTEST_TEST_CTEST
X "Should the tests that run a full sub ctest process be run?"
X OFF)
X mark_as_advanced(CTEST_TEST_CTEST)
X endif ()
X
X # Should tests that use CVS be run?
X #
X set(do_cvs_tests 0)
X
X if(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
X find_package(CVS QUIET)
X else()
X find_program(CVS_EXECUTABLE NAMES cvs)
X endif()
X
X if(CVS_EXECUTABLE)
X set(do_cvs_tests 1)
X endif()
X
X if(do_cvs_tests AND NOT UNIX)
X if("${CVS_EXECUTABLE}" MATCHES "cygwin")
X set(do_cvs_tests 0)
X endif()
X endif()
X
X # Should CPack tests be run? By default, yes, but...
X #
X # Disable packaging test on Apple 10.3 and below. PackageMaker starts
X # DiskManagementTool as root and disowns it
X # (http://lists.apple.com/archives/installer-dev/2005/Jul/msg00005.html).
X # It is left holding open pipe handles and preventing ProcessUNIX from
X # detecting end-of-data even after its immediate child exits. Then
X # the test hangs until it times out and is killed. This is a
X # well-known bug in kwsys process execution that I would love to get
X # time to fix.
X #
X option(CTEST_TEST_CPACK
X "Should the tests that use '--build-target package' be run?"
X ON)
X mark_as_advanced(CTEST_TEST_CPACK)
X set(CTEST_TEST_OSX_ARCH 0)
X if(APPLE)
X execute_process(
X COMMAND sw_vers -productVersion
X OUTPUT_VARIABLE OSX_VERSION
X OUTPUT_STRIP_TRAILING_WHITESPACE
X )
X if(OSX_VERSION MATCHES "^10\\.[0123]" OR OSX_VERSION MATCHES "ProductVersion:\t10\\.[0123]")
X message(STATUS "Forcing CTEST_TEST_CPACK=OFF on OSX < 10.4")
X message(STATUS "OSX_VERSION='${OSX_VERSION}'")
X set(CTEST_TEST_CPACK OFF)
X else()
X set(CTEST_TEST_OSX_ARCH 1)
X endif()
X endif()
X
X # Use 1500 or CTEST_TEST_TIMEOUT for long test timeout value,
X # whichever is greater.
X set(CMAKE_LONG_TEST_TIMEOUT 1500)
X if(CTEST_TEST_TIMEOUT)
X set(CMAKE_LONG_TEST_TIMEOUT ${CTEST_TEST_TIMEOUT})
X endif()
X if(CMAKE_LONG_TEST_TIMEOUT LESS 1500)
X set(CMAKE_LONG_TEST_TIMEOUT 1500)
X endif()
X
X # add a bunch of standard build-and-test style tests
X ADD_TEST_MACRO(CommandLineTest CommandLineTest)
X ADD_TEST_MACRO(FindPackageTest FindPackageTest)
X ADD_TEST_MACRO(FindModulesExecuteAll FindModulesExecuteAll)
X ADD_TEST_MACRO(StringFileTest StringFileTest)
X ADD_TEST_MACRO(TryCompile TryCompile)
X ADD_TEST_MACRO(TarTest TarTest)
X ADD_TEST_MACRO(SystemInformation SystemInformation)
X ADD_TEST_MACRO(MathTest MathTest)
X # assume no resources building to test
X set(TEST_RESOURCES FALSE)
X # for windows and cygwin assume we have resources
X if(WIN32 OR CYGWIN)
X set(TEST_RESOURCES TRUE)
X endif()
X # for borland and watcom there is no resource support
X if("${CMAKE_TEST_GENERATOR}" MATCHES "WMake" OR
X "${CMAKE_TEST_GENERATOR}" MATCHES "Borland")
X set(TEST_RESOURCES FALSE)
X endif()
X if(TEST_RESOURCES)
X ADD_TEST_MACRO(VSResource VSResource)
X endif()
X ADD_TEST_MACRO(Simple Simple)
X ADD_TEST_MACRO(PreOrder PreOrder)
X ADD_TEST_MACRO(MissingSourceFile MissingSourceFile)
X set_tests_properties(MissingSourceFile PROPERTIES
X PASS_REGULAR_EXPRESSION "CMake Error at CMakeLists.txt:3 \\(add_executable\\):[ \r\n]*Cannot find source file:[ \r\n]*DoesNotExist/MissingSourceFile.c")
X if(CMAKE_Fortran_COMPILER)
X ADD_TEST_MACRO(FortranOnly FortranOnly)
X endif()
X # test Visual Studio GNU Fortran mixing with cmake_add_fortran_subdirectory
X # run this project if we have a working fortran compiler or
X # the test is enabled with CMAKE_TEST_CMAKE_ADD_FORTRAN cache variable.
X # If you enable the test, CMake should find the MinGW fortran install,
X # or in some cases you might need to set the PATH so that cmake can find
X # the gfortran from mingw.
X if(CMAKE_Fortran_COMPILER OR CMAKE_TEST_CMAKE_ADD_FORTRAN)
X set(CMAKE_SKIP_VSGNUFortran FALSE)
X # disable test for apple builds using ifort if they are building
X # more than one architecture, as ifort does not support that.
X if(APPLE AND (CMAKE_Fortran_COMPILER MATCHES ifort))
X list(LENGTH CMAKE_OSX_ARCHITECTURES len)
X if("${len}" GREATER 1)
X message(STATUS "Skip VSGNUFortran for ifort dual cpu mac build")
X set(CMAKE_SKIP_VSGNUFortran TRUE)
X endif()
X endif()
X if((CMAKE_C_COMPILER MATCHES lsb)
X AND (CMAKE_Fortran_COMPILER MATCHES ifort))
X message(STATUS "Skip VSGNUFortran for ifort and lsb compilers")
X set(CMAKE_SKIP_VSGNUFortran TRUE)
X endif()
X if(NOT CMAKE_SKIP_VSGNUFortran)
X ADD_TEST_MACRO(VSGNUFortran ${CMAKE_COMMAND} -P runtest.cmake)
X endif()
X endif()
X ADD_TEST_MACRO(COnly COnly)
X ADD_TEST_MACRO(CxxOnly CxxOnly)
X ADD_TEST_MACRO(IPO COnly/COnly)
X ADD_TEST_MACRO(OutDir runtime/OutDir)
X ADD_TEST_MACRO(ObjectLibrary UseCshared)
X ADD_TEST_MACRO(NewlineArgs NewlineArgs)
X ADD_TEST_MACRO(SetLang SetLang)
X ADD_TEST_MACRO(EmptyProperty EmptyProperty)
X ADD_TEST_MACRO(ExternalOBJ ExternalOBJ)
X ADD_TEST_MACRO(LoadCommand LoadedCommand)
X ADD_TEST_MACRO(LinkDirectory bin/LinkDirectory)
X ADD_TEST_MACRO(LinkLanguage LinkLanguage)
X ADD_TEST_MACRO(LinkLine LinkLine)
X ADD_TEST_MACRO(MacroTest miniMacroTest)
X ADD_TEST_MACRO(FunctionTest miniFunctionTest)
X ADD_TEST_MACRO(ReturnTest ReturnTest)
X ADD_TEST_MACRO(Properties Properties)
X ADD_TEST_MACRO(Assembler HelloAsm)
X ADD_TEST_MACRO(SourceGroups SourceGroups)
X ADD_TEST_MACRO(Preprocess Preprocess)
X ADD_TEST_MACRO(ExportImport ExportImport)
X ADD_TEST_MACRO(Unset Unset)
X ADD_TEST_MACRO(PolicyScope PolicyScope)
X ADD_TEST_MACRO(EmptyLibrary EmptyLibrary)
X ADD_TEST_MACRO(CompileDefinitions CompileDefinitions)
X ADD_TEST_MACRO(CompileOptions CompileOptions)
X ADD_TEST_MACRO(CompatibleInterface CompatibleInterface)
X ADD_TEST_MACRO(AliasTarget AliasTarget)
X set_tests_properties(EmptyLibrary PROPERTIES
X PASS_REGULAR_EXPRESSION "CMake Error: CMake can not determine linker language for target: test")
X ADD_TEST_MACRO(CrossCompile CrossCompile)
X set_tests_properties(CrossCompile PROPERTIES
X PASS_REGULAR_EXPRESSION "TRY_RUN.. invoked in cross-compiling mode")
X if("${CMAKE_TEST_GENERATOR}" MATCHES "Make")
X ADD_TEST_MACRO(Policy0002 Policy0002)
X endif()
X if(CTEST_TEST_OSX_ARCH)
X ADD_TEST_MACRO(Architecture Architecture)
X set_tests_properties(Architecture PROPERTIES
X PASS_REGULAR_EXPRESSION "(file is not of required architecture|does not match cputype|not the architecture being linked)")
X endif()
X
X list(APPEND TEST_BUILD_DIRS ${CMake_TEST_INSTALL_PREFIX})
X
X # run test for BundleUtilities on supported platforms/compilers
X if(MSVC OR
X MINGW OR
X CMAKE_SYSTEM_NAME MATCHES "Linux" OR
X CMAKE_SYSTEM_NAME MATCHES "Darwin")
X if(NOT "${CMAKE_TEST_GENERATOR}" STREQUAL "Watcom WMake")
X
X add_test(BundleUtilities ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/BundleUtilities"
X "${CMake_BINARY_DIR}/Tests/BundleUtilities"
X ${build_generator_args}
X --build-project BundleUtilities
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleUtilities")
X
X # run test for DeployQt4 on supported platforms/compilers (which depends on BundleUtilities)
X # this test also depends on the existence of the standard qtiff plugin
X if(QT4_WORKS AND QT_QTSQL_FOUND)
X add_test(Qt4Deploy ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Qt4Deploy"
X "${CMake_BINARY_DIR}/Tests/Qt4Deploy"
X ${build_generator_args}
X --build-project Qt4Deploy
X --build-options
X -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
X -DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Deploy")
X endif()
X
X endif()
X endif()
X
X set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/COnly")
X set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/CMakeBuildCOnly")
X set(CMAKE_BUILD_TEST_EXE COnly)
X configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake" @ONLY)
X add_test(CMakeBuildTest ${CMAKE_CMAKE_COMMAND} -P
X "${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake")
X list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
X # now do it again for a project that has two project commands
X set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/DoubleProject")
X set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/DoubleProject")
X set(CMAKE_BUILD_TEST_EXE just_silly)
X configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake" @ONLY)
X add_test(CMakeDoubleProject ${CMAKE_CMAKE_COMMAND} -P
X "${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake")
X list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
X
X ADD_TEST_MACRO(Module.CheckTypeSize CheckTypeSize)
X
X add_test(Module.ExternalData ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Module/ExternalData"
X "${CMake_BINARY_DIR}/Tests/Module/ExternalData"
X ${build_generator_args}
X --build-project ExternalDataTest
X --build-noclean
X --force-new-ctest-process
X --build-options -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
X --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} -V
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Module/ExternalData")
X
X ADD_TEST_MACRO(Module.GenerateExportHeader GenerateExportHeader)
X
X if (APPLE OR CMAKE_CXX_COMPILER_ID MATCHES "GNU")
X include(CheckCXXCompilerFlag)
X check_cxx_compiler_flag(-fPIE run_pic_test)
X else()
X if (CMAKE_CXX_COMPILER_ID MATCHES "PGI"
X OR CMAKE_CXX_COMPILER_ID MATCHES "PathScale"
X OR CMAKE_SYSTEM_NAME MATCHES "IRIX64"
X OR CMAKE_CXX_COMPILER_ID MATCHES "Intel")
X set(run_pic_test 0)
X else()
X set(run_pic_test 1)
X endif()
X endif()
X
X if (run_pic_test)
X ADD_TEST_MACRO(PositionIndependentTargets PositionIndependentTargets)
X endif()
X
X add_test(LinkFlags-prepare
X ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/LinkFlags"
X "${CMake_BINARY_DIR}/Tests/LinkFlags"
X ${build_generator_args}
X --build-project LinkFlags
X --build-target LinkFlags
X --build-options -DTEST_CONFIG=\${CTEST_CONFIGURATION_TYPE}
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkFlags")
X
X macro(ADD_LINK_FLAGS_TEST name depends)
X add_test(LinkFlags-${name}
X ${CMAKE_CMAKE_COMMAND} --build "${CMake_BINARY_DIR}/Tests/LinkFlags"
X --target LinkFlags_${name} --config \${CTEST_CONFIGURATION_TYPE}
X )
X set_tests_properties(LinkFlags-${name} PROPERTIES
X PASS_REGULAR_EXPRESSION "BADFLAG" DEPENDS LinkFlags-${depends})
X endmacro()
X ADD_LINK_FLAGS_TEST(lib prepare)
X ADD_LINK_FLAGS_TEST(dll lib)
X ADD_LINK_FLAGS_TEST(mod dll)
X ADD_LINK_FLAGS_TEST(exe mod)
X ADD_LINK_FLAGS_TEST(lib_config exe)
X ADD_LINK_FLAGS_TEST(dll_config lib_config)
X ADD_LINK_FLAGS_TEST(mod_config dll_config)
X ADD_LINK_FLAGS_TEST(exe_config mod_config)
X ADD_LINK_FLAGS_TEST(lib_flags exe_config)
X ADD_LINK_FLAGS_TEST(dll_flags lib_flags)
X ADD_LINK_FLAGS_TEST(mod_flags dll_flags)
X ADD_LINK_FLAGS_TEST(exe_flags mod_flags)
X ADD_LINK_FLAGS_TEST(lib_flags_config exe_flags)
X ADD_LINK_FLAGS_TEST(dll_flags_config lib_flags_config)
X ADD_LINK_FLAGS_TEST(mod_flags_config dll_flags_config)
X ADD_LINK_FLAGS_TEST(exe_flags_config mod_flags_config)
X
X # If we are running right now with a UnixMakefiles based generator,
X # build the "Simple" test with the ExtraGenerators, if available
X # This doesn't test whether the generated project files work (unfortunately),
X # mainly it tests that cmake doesn't crash when generating these project files.
X if(${CMAKE_TEST_GENERATOR} MATCHES "Unix Makefiles" OR ${CMAKE_TEST_GENERATOR} MATCHES "KDevelop")
X # check which generators we have
X execute_process(COMMAND ${CMAKE_CMAKE_COMMAND} --help
X OUTPUT_VARIABLE cmakeOutput ERROR_VARIABLE cmakeOutput)
X # check for the Eclipse generator
X if ("${cmakeOutput}" MATCHES Eclipse)
X add_test(Simple_EclipseGenerator ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Simple"
X "${CMake_BINARY_DIR}/Tests/Simple_EclipseGenerator"
X --build-two-config
X --build-generator "Eclipse CDT4 - Unix Makefiles"
X --build-generator-toolset "${CMAKE_TEST_GENERATOR_TOOLSET}"
X --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
X --build-project Simple
X --test-command Simple)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_EclipseGenerator")
X endif ()
X
X # check for the CodeBlocks generator
X if ("${cmakeOutput}" MATCHES CodeBlocks)
X add_test(Simple_CodeBlocksGenerator ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Simple"
X "${CMake_BINARY_DIR}/Tests/Simple_CodeBlocksGenerator"
X --build-two-config
X --build-generator "CodeBlocks - Unix Makefiles"
X --build-generator-toolset "${CMAKE_TEST_GENERATOR_TOOLSET}"
X --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
X --build-project Simple
X --test-command Simple)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_CodeBlocksGenerator")
X endif ()
X # check for the KDevelop3 generator
X if ("${cmakeOutput}" MATCHES KDevelop3)
X add_test(Simple_KDevelop3Generator ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Simple"
X "${CMake_BINARY_DIR}/Tests/Simple_KDevelop3Generator"
X --build-two-config
X --build-generator "KDevelop3 - Unix Makefiles"
X --build-generator-toolset "${CMAKE_TEST_GENERATOR_TOOLSET}"
X --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
X --build-project Simple
X --test-command Simple)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_KDevelop3Generator")
X endif ()
X
X endif()
X
X # test for correct sub-project generation
X # not implemented in VS6 or Xcode
X if(NOT MSVC60 AND NOT XCODE AND NOT MSVC70)
X # run cmake and configure all of SubProject
X # but only build the independent executable car
X add_test(SubProject ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/SubProject"
X "${CMake_BINARY_DIR}/Tests/SubProject"
X --build-project SubProject
X ${build_generator_args}
X --build-target car
X --test-command car
X )
X
X if(${CMAKE_TEST_GENERATOR} MATCHES "Ninja")
X # The Ninja generator does not create a recursive build system. Start
X # from the root directory.
X set(SubProject_SUBDIR)
X else()
X set(SubProject_SUBDIR "/foo")
X endif()
X
X # For stage 2, do not run cmake again.
X # Then build the foo sub project which should build
X # the bar library which should be referenced because
X # foo links to the static library bar, but bar is not
X # directly in the foo sub project
X add_test(SubProject-Stage2 ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/SubProject${SubProject_SUBDIR}"
X "${CMake_BINARY_DIR}/Tests/SubProject${SubProject_SUBDIR}"
X ${build_generator_args}
X --build-nocmake
X --build-project foo
X --build-target foo
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubProject/foo"
X --test-command foo
X )
X set_tests_properties ( SubProject-Stage2 PROPERTIES DEPENDS SubProject)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubProject")
X endif()
X
X if (CMAKE_STRICT)
X ADD_TEST_MACRO(DocTest DocTest)
X endif ()
X # macro to add a test that will build a nightly release
X # of CMake for given platform using the release scripts
X macro(ADD_NIGHTLY_BUILD_TEST name script)
X set(_TEST_DIR "${CMake_BINARY_DIR}/Tests/${name}")
X file(MAKE_DIRECTORY "${_TEST_DIR}")
X file(WRITE "${_TEST_DIR}/nightly-cmake.sh"
X "cd ${_TEST_DIR}
X${CMake_BINARY_DIR}/bin/cmake -DCMAKE_CREATE_VERSION=nightly -P ${CMake_SOURCE_DIR}/Utilities/Release/${script}
X${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/Release/upload_release.cmake
X ")
X add_test(${name} /bin/sh ${_TEST_DIR}/nightly-cmake.sh)
X if(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY)
X set_tests_properties (${name} PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
X endif()
X endmacro()
X if(CMAKE_BUILD_NIGHTLY_RELEASES)
X ADD_NIGHTLY_BUILD_TEST(CMakeNightlyWindows
X dash2win64_release.cmake)
X ADD_NIGHTLY_BUILD_TEST(CMakeNightlyMac
X dashmacmini2_release.cmake)
X ADD_NIGHTLY_BUILD_TEST(CMakeNightlyMac64
X dashmacmini5_release.cmake)
X ADD_NIGHTLY_BUILD_TEST(CMakeNightlyLinux
X magrathea_release.cmake)
X endif()
X
X # add tests with more complex invocations
X add_test(Framework ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Framework"
X "${CMake_BINARY_DIR}/Tests/Framework"
X --build-two-config
X ${build_generator_args}
X --build-project Framework
X --build-options
X "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/Framework/Install"
X --test-command bar)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Framework")
X
X add_test(TargetName ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/TargetName"
X "${CMake_BINARY_DIR}/Tests/TargetName"
X --build-two-config
X ${build_generator_args}
X --build-project TargetName
X --test-command ${CMAKE_CMAKE_COMMAND} -E compare_files
X ${CMake_SOURCE_DIR}/Tests/TargetName/scripts/hello_world
X ${CMake_BINARY_DIR}/Tests/TargetName/scripts/hello_world)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TargetName")
X
X add_test(LibName ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/LibName"
X "${CMake_BINARY_DIR}/Tests/LibName"
X --build-two-config
X ${build_generator_args}
X --build-project LibName
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/LibName/lib"
X --test-command foobar
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LibName")
X
X add_test(CustComDepend ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/CustComDepend"
X "${CMake_BINARY_DIR}/Tests/CustComDepend"
X --build-two-config
X ${build_generator_args}
X --build-project CustComDepend
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustComDepend/bin"
X --test-command foo bar.c
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustComDepend")
X
X add_test(ArgumentExpansion ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/ArgumentExpansion"
X "${CMake_BINARY_DIR}/Tests/ArgumentExpansion"
X ${build_generator_args}
X --build-project ArgumentExpansion
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/ArgumentExpansion/bin"
X )
X set_tests_properties(ArgumentExpansion PROPERTIES
X FAIL_REGULAR_EXPRESSION "Unexpected: ")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ArgumentExpansion")
X
X add_test(GeneratorExpression ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/GeneratorExpression"
X "${CMake_BINARY_DIR}/Tests/GeneratorExpression"
X ${build_generator_args}
X --build-project GeneratorExpression
X --build-options -DCMAKE_BUILD_TYPE=\${CTEST_CONFIGURATION_TYPE}
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/GeneratorExpression")
X
X add_test(CustomCommand ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/CustomCommand"
X "${CMake_BINARY_DIR}/Tests/CustomCommand"
X --build-two-config
X ${build_generator_args}
X --build-project CustomCommand
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustomCommand/bin"
X --test-command CustomCommand
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommand")
X
X ADD_TEST_MACRO(EmptyDepends ${CMAKE_CTEST_COMMAND})
X
X add_test(CustomCommandWorkingDirectory ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/CustomCommandWorkingDirectory"
X "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory"
X --build-two-config
X ${build_generator_args}
X --build-project TestWorkingDir
X --test-command working
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory")
X
X #add_test(SimpleExclude ${CMAKE_CTEST_COMMAND}
X # --build-and-test
X # "${CMake_SOURCE_DIR}/Tests/SimpleExclude"
X # "${CMake_BINARY_DIR}/Tests/SimpleExclude"
X # ${build_generator_args}
X # --build-project SimpleExclude
X # --build-two-config
X # --test-command t4
X #--test-command "${CMAKE_COMMAND}"
X #"-DCONFIGURATION=\${CTEST_CONFIGURATION_TYPE}"
X #-P "${CMake_BINARY_DIR}/Tests/SimpleExclude/run.cmake"
X #)
X
X# add_test(SameName ${CMAKE_CTEST_COMMAND}
X# --build-and-test
X# "${CMake_SOURCE_DIR}/Tests/SameName"
X# "${CMake_BINARY_DIR}/Tests/SameName"
X# ${build_generator_args}
X# --build-project SameName
X# --build-two-config
X# --test-command
X# "${CMake_BINARY_DIR}/Tests/SameName/Exe1/mytest2")
X
X add_test(OutOfSource ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/OutOfSource"
X "${CMake_BINARY_DIR}/Tests/OutOfSource"
X ${build_generator_args}
X --build-project OutOfSource
X --build-two-config
X --test-command
X "${CMake_BINARY_DIR}/Tests/OutOfSource/SubDir/OutOfSourceSubdir/simple")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSource")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSourceDeep")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfBinary")
X
X add_test(BuildDepends ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/BuildDepends"
X "${CMake_BINARY_DIR}/Tests/BuildDepends"
X ${build_generator_args}
X --build-project BuildDepends
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BuildDepends")
X
X set(SimpleInstallInstallDir
X "${CMake_BINARY_DIR}/Tests/SimpleInstall/InstallDirectory")
X add_test(SimpleInstall ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/SimpleInstall"
X "${CMake_BINARY_DIR}/Tests/SimpleInstall"
X ${build_generator_args}
X --build-project TestSimpleInstall
X --build-two-config
X --build-options
X "-DCMAKE_INSTALL_PREFIX:PATH=${SimpleInstallInstallDir}"
X "-DCTEST_TEST_CPACK:BOOL=${CTEST_TEST_CPACK}"
X --test-command ${SimpleInstallInstallDir}/MyTest/bin/SimpleInstExe)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleInstall")
X add_test(SimpleInstall-Stage2 ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/SimpleInstallS2"
X "${CMake_BINARY_DIR}/Tests/SimpleInstallS2"
X ${build_generator_args}
X --build-project TestSimpleInstall
X --build-two-config
X --build-options
X "-DCMAKE_INSTALL_PREFIX:PATH=${SimpleInstallInstallDir}"
X "-DSTAGE2:BOOL=1"
X --test-command ${SimpleInstallInstallDir}/MyTest/bin/SimpleInstExeS2)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleInstallS2")
X
X # By default, run the CPackComponents test if the CTEST_TEST_CPACK
X # option is ON:
X #
X set(CTEST_RUN_CPackComponents ${CTEST_TEST_CPACK})
X set(CTEST_package_X11_TEST ${CTEST_TEST_CPACK})
X set(CTEST_RUN_CPackComponentsForAll ${CTEST_TEST_CPACK})
X
X if (CMAKE_SYSTEM_NAME MATCHES "Linux" AND NOT CMAKE_CURRENT_BINARY_DIR MATCHES ".* .*")
X find_program(RPMBUILD NAMES rpmbuild)
X endif()
X # Do not try to build RPM
X if (NOT RPMBUILD)
X set(CPACK_BINARY_RPM OFF)
X endif()
X
X find_program(NSIS_MAKENSIS_EXECUTABLE NAMES makensis
X PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
X DOC "makensis program location"
X )
X
X # But on Windows, only run the CPackComponents test if the NSIS
X # installer builder is available:
X #
X if(WIN32)
X if(NSIS_MAKENSIS_EXECUTABLE)
X set(CTEST_RUN_CPackComponents ON)
X else()
X set(CTEST_RUN_CPackComponents OFF)
X set(CTEST_package_X11_TEST OFF)
X endif()
X endif()
X
X # On Windows run the CPackWiXGenerator test
X # if the WiX Toolset seems to be available
X if(WIN32)
X file(TO_CMAKE_PATH "$ENV{WIX}" WIX_ROOT)
X
X find_program(WIX_LIGHT_EXECUTABLE light
X PATHS "${WIX_ROOT}/bin"
X DOC "WiX Toolset light.exe location")
X
X if(WIX_LIGHT_EXECUTABLE)
X add_test(CPackWiXGenerator ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/CPackWiXGenerator"
X "${CMake_BINARY_DIR}/Tests/CPackWiXGenerator"
X ${build_generator_args}
X --build-project CPackWiXGenerator
X --test-command ${CMAKE_CMAKE_COMMAND}
X "-DCPackWiXGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackWiXGenerator"
X -P "${CMake_SOURCE_DIR}/Tests/CPackWiXGenerator/RunCPackVerifyResult.cmake")
X endif()
X endif()
X
X if(CTEST_RUN_CPackComponents)
X set(CPackComponents_EXTRA_OPTIONS)
X if(APPLE)
X set(CPackComponents_EXTRA_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
X endif()
X if(NSIS_MAKENSIS_EXECUTABLE)
X set(CPackComponents_EXTRA_OPTIONS ${CPackComponents_EXTRA_OPTIONS}
X -DCPACK_BINARY_NSIS:BOOL=ON)
X endif()
X
X add_test(CPackComponents ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/CPackComponents"
X "${CMake_BINARY_DIR}/Tests/CPackComponents"
X ${build_generator_args}
X --build-project CPackComponents
X --build-two-config
X --build-target package
X --build-options
X -DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
X -DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
X ${CPackComponents_EXTRA_OPTIONS}
X --graphviz=CPackComponents.dot
X --test-command ${CMAKE_CMAKE_COMMAND}
X "-DCPackComponents_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponents"
X -P "${CMake_SOURCE_DIR}/Tests/CPackComponents/VerifyResult.cmake")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponents")
X endif()
X
X if(CTEST_RUN_CPackComponentsForAll)
X # Check whether if rpmbuild command is found
X # before adding RPM tests
X find_program(RPMBUILD_EXECUTABLE NAMES rpmbuild)
X if(RPMBUILD_EXECUTABLE)
X list(APPEND ACTIVE_CPACK_GENERATORS RPM)
X endif()
X # Check whether if dpkg command is found
X # before adding DEB tests
X find_program(DPKG_EXECUTABLE NAMES dpkg)
X if(DPKG_EXECUTABLE)
X list(APPEND ACTIVE_CPACK_GENERATORS DEB)
X endif()
X
X # ACTIVE_CPACK_GENERATORS variable
X # now contains the list of 'active generators'
X set(CPackComponentsForAll_EXTRA_OPTIONS)
X # set up list of CPack generators
X list(APPEND GENLST "ZIP")
X if(APPLE)
X list(APPEND GENLST "DragNDrop")
X endif()
X if (NOT CMAKE_CURRENT_BINARY_DIR MATCHES ".* .*")
X list(FIND ACTIVE_CPACK_GENERATORS "RPM" RPM_ACTIVE)
X if (NOT ${RPM_ACTIVE} EQUAL -1)
X list(APPEND GENLST "RPM")
X endif()
X endif()
X list(FIND ACTIVE_CPACK_GENERATORS "DEB" DEB_ACTIVE)
X if (NOT ${DEB_ACTIVE} EQUAL -1)
X list(APPEND GENLST "DEB")
X endif()
X
X # set up list of component packaging ways
X list(APPEND CWAYLST "default")
X list(APPEND CWAYLST "OnePackPerGroup")
X list(APPEND CWAYLST "IgnoreGroup")
X list(APPEND CWAYLST "AllInOne")
X foreach(CPackGen ${GENLST})
X set(CPackRun_CPackGen "-DCPackGen=${CPackGen}")
X foreach(CPackComponentWay ${CWAYLST})
X set(CPackRun_CPackComponentWay "-DCPackComponentWay=${CPackComponentWay}")
X add_test(CPackComponentsForAll-${CPackGen}-${CPackComponentWay} ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll"
X "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
X ${build_generator_args}
X --build-project CPackComponentsForAll
X --build-options
X -DCPACK_BINARY_${CPackGen}:BOOL=ON
X ${CPackRun_CPackComponentWay}
X ${CPackComponentsForAll_EXTRA_OPTIONS}
X --graphviz=CPackComponentsForAll.dot
X --test-command ${CMAKE_CMAKE_COMMAND}
X "-DCPackComponentsForAll_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
X "${CPackRun_CPackGen}"
X "${CPackRun_CPackComponentWay}"
X -P "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll/RunCPackVerifyResult.cmake")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}")
X endforeach()
X endforeach()
X endif()
X
X # By default, turn this test off (because it takes a long time...)
X #
X if(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
X set(CTEST_RUN_CPackTestAllGenerators OFF)
X
X # ...but: if it appears to be a coverage dashboard, or long tests are
X # on, then set it to the generic CTEST_TEST_CPACK setting.
X #
X if(CMAKE_CXX_FLAGS MATCHES "-ftest-coverage" OR
X NOT "$ENV{COVFILE}" STREQUAL "" OR
X CMAKE_RUN_LONG_TESTS)
X set(CTEST_RUN_CPackTestAllGenerators ${CTEST_TEST_CPACK})
X endif()
X endif()
X
X if(CTEST_RUN_CPackTestAllGenerators)
X add_test(CPackTestAllGenerators ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators"
X "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators"
X ${build_generator_args}
X --build-project CPackTestAllGenerators
X --test-command
X ${CMAKE_CMAKE_COMMAND}
X -D dir=${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators
X -P ${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators/RunCPack.cmake
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators")
X endif()
X
X if(CTEST_package_X11_TEST)
X set(X11_build_target_arg --build-target package)
X else()
X set(X11_build_target_arg)
X endif()
X
X add_test(X11 ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/X11"
X "${CMake_BINARY_DIR}/Tests/X11"
X ${build_generator_args}
X --build-project UseX11
X --build-two-config
X ${X11_build_target_arg}
X --test-command UseX11)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/X11")
X
X if(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
X set(CTEST_RUN_CMakeTestAllGenerators ON)
X endif()
X
X if(CTEST_RUN_CMakeTestAllGenerators)
X add_test(CMakeTestAllGenerators ${CMAKE_CMAKE_COMMAND}
X -D dir=${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators
X -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
X -P ${CMake_SOURCE_DIR}/Tests/CMakeTestAllGenerators/RunCMake.cmake
X )
X list(APPEND TEST_BUILD_DIRS
X "${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators")
X endif()
X
X if(NOT DEFINED CTEST_RUN_CMakeTestBadCommandLines)
X set(CTEST_RUN_CMakeTestBadCommandLines ON)
X endif()
X
X if(CTEST_RUN_CMakeTestBadCommandLines)
X add_test(CMakeTestBadCommandLines ${CMAKE_CMAKE_COMMAND}
X -D dir=${CMake_BINARY_DIR}/Tests/CMakeTestBadCommandLines
X -D gen=${CMAKE_TEST_GENERATOR}
X -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
X -P ${CMake_SOURCE_DIR}/Tests/CMakeTestBadCommandLines/RunCMake.cmake
X )
X list(APPEND TEST_BUILD_DIRS
X "${CMake_BINARY_DIR}/Tests/CMakeTestBadCommandLines")
X endif()
X
X if(NOT DEFINED CTEST_RUN_CMakeTestMultipleConfigures)
X set(CTEST_RUN_CMakeTestMultipleConfigures ON)
X endif()
X
X if(CTEST_RUN_CMakeTestMultipleConfigures)
X add_test(CMakeTestMultipleConfigures ${CMAKE_CMAKE_COMMAND}
X -D dir=${CMake_BINARY_DIR}/Tests/CMakeTestMultipleConfigures
X -D gen=${CMAKE_TEST_GENERATOR}
X -D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
X -P ${CMake_SOURCE_DIR}/Tests/CMakeTestMultipleConfigures/RunCMake.cmake
X )
X list(APPEND TEST_BUILD_DIRS
X "${CMake_BINARY_DIR}/Tests/CMakeTestMultipleConfigures")
X endif()
X
X add_test(LoadedCommandOneConfig ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/LoadCommandOneConfig"
X "${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig"
X ${build_generator_args}
X --build-project LoadCommand
X --test-command LoadedCommand
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig")
X
X add_test(complex ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Complex"
X "${CMake_BINARY_DIR}/Tests/Complex"
X --build-two-config
X --build-config-sample "${CMAKE_CTEST_COMMAND}"
X ${build_generator_args}
X --build-project Complex
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Complex/bin"
X --build-options
X -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
X --test-command complex
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Complex")
X
X add_test(complexOneConfig ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/ComplexOneConfig"
X "${CMake_BINARY_DIR}/Tests/ComplexOneConfig"
X ${build_generator_args}
X --build-project Complex
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/ComplexOneConfig/bin"
X --build-options
X -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
X --test-command complex)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ComplexOneConfig")
X # because of the registry write these tests depend on each other
X set_tests_properties ( complex PROPERTIES DEPENDS complexOneConfig)
X
X add_test(Example ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Example"
X "${CMake_BINARY_DIR}/Example"
X ${build_generator_args}
X --build-project HELLO
X --build-exe-dir "${CMake_BINARY_DIR}/Example/Demo"
X --test-command helloDemo
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Example")
X
X add_test(Environment ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Environment"
X "${CMake_BINARY_DIR}/Tests/Environment"
X ${build_generator_args}
X --build-project EnvironmentProj
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Environment"
X --force-new-ctest-process
X --test-command ${CMAKE_CTEST_COMMAND} -V
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Environment")
X
X add_test(ExternalProject ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/ExternalProject"
X "${CMake_BINARY_DIR}/Tests/ExternalProject"
X ${build_generator_args}
X --build-project ExternalProjectTest
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProject"
X --force-new-ctest-process
X --test-command ${CMAKE_CTEST_COMMAND} -V
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProject")
X set_tests_properties(ExternalProject PROPERTIES
X TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
X
X add_test(ExternalProjectUpdateSetup ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate"
X "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
X ${build_generator_args}
X --build-project ExternalProjectUpdateTest
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
X --force-new-ctest-process
X --test-command ${CMAKE_CTEST_COMMAND} -V
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
X set_tests_properties(ExternalProjectUpdateSetup PROPERTIES
X TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
X
X add_test(NAME ExternalProjectUpdate
X COMMAND ${CMAKE_CMAKE_COMMAND}
X -DExternalProjectUpdate_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
X -DExternalProjectUpdate_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate
X -DCMAKE_TEST_GENERATOR=${CMAKE_TEST_GENERATOR}
X -DCMAKE_TEST_GENERATOR_TOOLSET=${CMAKE_TEST_GENERATOR_TOOLSET}
X -DCMAKE_TEST_MAKEPROGRAM=${CMAKE_TEST_MAKEPROGRAM}
X -DCMAKE_CTEST_COMMAND=${CMAKE_CTEST_COMMAND}
X -P ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate/ExternalProjectUpdateTest.cmake
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
X set_tests_properties(ExternalProjectUpdate PROPERTIES
X TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT}
X WORKING_DIRECTORY ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
X DEPENDS ExternalProjectUpdateSetup )
X
X # do each of the tutorial steps
X foreach(STP RANGE 1 7)
X add_test(TutorialStep${STP} ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Tutorial/Step${STP}"
X "${CMake_BINARY_DIR}/Tests/Tutorial/Step${STP}"
X --build-two-config
X ${build_generator_args}
X --build-project Tutorial
X --test-command Tutorial 25.0)
X endforeach()
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Tutorial")
X
X add_test(testing ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Testing"
X "${CMake_BINARY_DIR}/Tests/Testing"
X ${build_generator_args}
X --build-project Testing
X --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
X )
X set_tests_properties(testing PROPERTIES PASS_REGULAR_EXPRESSION "Passed")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Testing")
X
X add_test(wrapping ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Wrapping"
X "${CMake_BINARY_DIR}/Tests/Wrapping"
X ${build_generator_args}
X --build-project Wrapping
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
X --test-command wrapping
X )
X add_test(qtwrapping ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Wrapping"
X "${CMake_BINARY_DIR}/Tests/Wrapping"
X ${build_generator_args}
X --build-project Wrapping
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
X --test-command qtwrapping
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Wrapping")
X
X add_test(testdriver1 ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/TestDriver"
X "${CMake_BINARY_DIR}/Tests/TestDriver"
X ${build_generator_args}
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
X --build-project TestDriverTest
X --test-command TestDriverTest test1
X )
X
X add_test(testdriver2 ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/TestDriver"
X "${CMake_BINARY_DIR}/Tests/TestDriver"
X ${build_generator_args}
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
X --build-project TestDriverTest
X --test-command TestDriverTest test2
X )
X
X add_test(testdriver3 ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/TestDriver"
X "${CMake_BINARY_DIR}/Tests/TestDriver"
X ${build_generator_args}
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
X --build-project TestDriverTest
X --test-command TestDriverTest subdir/test3
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver")
X
X add_test(Dependency ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Dependency"
X "${CMake_BINARY_DIR}/Tests/Dependency"
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Dependency/Exec"
X ${build_generator_args}
X --build-project Dependency
X --test-command exec
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Dependency")
X
X if("${CMAKE_SYSTEM_NAME}" MATCHES syllable)
X
X# RPATH isn't supported under Syllable, so the tests don't
X# find their libraries. In order to fix that LIBRARY_OUTPUT_DIR
X# in the tests would have to be adjusted to ${EXECUTABLE_OUTPUT_DIR}/lib .
X# For now we just require on Syllable that the user adjusts the DLL_PATH
X# environment variable, so except the two tests below all other tests will succeed.
X
X set(_DLL_PATH "$ENV{DLL_PATH}")
X if(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.(:.*)?$")
X 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")
X endif()
X if(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.\\./lib(:.*)?$")
X 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")
X endif()
X
X else()
X
X add_test(JumpWithLibOut ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Jump"
X "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut"
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Executable"
X --build-project Jump
X ${build_generator_args}
X --build-options
X -DLIBRARY_OUTPUT_PATH:PATH=${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Lib
X --test-command jumpExecutable
X )
X
X add_test(JumpNoLibOut ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Jump"
X "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut"
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
X --build-run-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
X --build-project Jump
X ${build_generator_args}
X --test-command jumpExecutable
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Jump")
X
X add_test(Plugin ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Plugin"
X "${CMake_BINARY_DIR}/Tests/Plugin"
X ${build_generator_args}
X --build-project Plugin
X --build-two-config
X --test-command bin/example)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Plugin")
X
X if(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
X ADD_TEST_MACRO(RuntimePath RuntimePath)
X endif()
X endif()
X
X if(APPLE AND "${DARWIN_MAJOR_VERSION}" GREATER 9)
X add_test(MacRuntimePath ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/MacRuntimePath"
X "${CMake_BINARY_DIR}/Tests/MacRuntimePath"
X ${build_generator_args}
X --build-project MacRuntimePath
X )
X endif()
X
X add_test(linkorder1 ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
X "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
X ${build_generator_args}
X --build-project LinkLineOrder
X --test-command Exec1
X )
X
X add_test(linkorder2 ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
X "${CMake_BINARY_DIR}/Tests/LinkLineOrder"
X ${build_generator_args}
X --build-project LinkLineOrder
X --test-command Exec2
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkLineOrder")
X set_tests_properties ( qtwrapping PROPERTIES DEPENDS wrapping)
X set_tests_properties ( testdriver1 PROPERTIES DEPENDS qtwrapping)
X set_tests_properties ( testdriver2 PROPERTIES DEPENDS testdriver1)
X set_tests_properties ( testdriver3 PROPERTIES DEPENDS testdriver2)
X set_tests_properties ( linkorder2 PROPERTIES DEPENDS linkorder1)
X set_tests_properties ( SimpleInstall-Stage2 PROPERTIES DEPENDS SimpleInstall)
X
X # Test static linking on toolchains known to support it.
X if("${CMAKE_C_COMPILER_ID}" MATCHES "^(GNU)$"
X AND NOT APPLE AND NOT WIN32 AND NOT CYGWIN
X AND EXISTS "/usr/lib/libm.a")
X add_test(LinkStatic ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/LinkStatic"
X "${CMake_BINARY_DIR}/Tests/LinkStatic"
X ${build_generator_args}
X --build-project LinkStatic
X --build-options -DMATH_LIBRARY:FILEPATH=/usr/lib/libm.a
X --test-command LinkStatic
X )
X endif()
X
X if(NOT CMAKE_TEST_DIFFERENT_GENERATOR)
X add_test(kwsys ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Source/kwsys"
X "${CMake_BINARY_DIR}/Tests/kwsys"
X ${build_generator_args}
X --build-project kwsys
X --test-command kwsysTestsCxx testIOS
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/kwsys")
X endif()
X
X if(MAKE_SUPPORTS_SPACES)
X add_test(SubDirSpaces ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/SubDirSpaces"
X "${CMake_BINARY_DIR}/Tests/SubDirSpaces"
X --build-exe-dir
X "${CMake_BINARY_DIR}/Tests/SubDirSpaces/Executable Sources"
X ${build_generator_args}
X --build-project SUBDIR
X --test-command test
X "${CMake_BINARY_DIR}/Tests/SubDirSpaces/ShouldBeHere"
X "${CMake_BINARY_DIR}/Tests/SubDirSpaces/testfromsubdir.obj"
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDirSpaces")
X endif ()
X
X if (WIN32)
X add_test(SubDir ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/SubDir"
X "${CMake_BINARY_DIR}/Tests/SubDir"
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
X ${build_generator_args}
X --build-project SUBDIR
X --test-command test
X "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
X "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.obj"
X )
X else ()
X add_test(SubDir ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/SubDir"
X "${CMake_BINARY_DIR}/Tests/SubDir"
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
X ${build_generator_args}
X --build-project SUBDIR
X --test-command test
X "${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
X "${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.o"
X )
X endif ()
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDir")
X
X if(CMAKE_TEST_MSVC)
X ADD_TEST_MACRO(ForceInclude foo)
X ADD_TEST_MACRO(PDBDirectoryAndName myexe)
X ADD_TEST_MACRO(PrecompiledHeader foo)
X endif()
X if(CMAKE_TEST_MSVC OR
X "${CMAKE_TEST_GENERATOR}" MATCHES "(MSYS|MinGW) Makefiles")
X ADD_TEST_MACRO(ModuleDefinition example_exe)
X endif()
X
X ADD_TEST_MACRO(CheckCompilerRelatedVariables CheckCompilerRelatedVariables)
X
X if("${CMAKE_TEST_GENERATOR}" MATCHES "Makefile")
X add_test(MakeClean ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/MakeClean"
X "${CMake_BINARY_DIR}/Tests/MakeClean"
X ${build_generator_args}
X --build-project MakeClean
X --build-exe-dir "${CMake_BINARY_DIR}/MakeClean"
X --test-command check_clean
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MakeClean")
X endif()
X
X if(NOT DEFINED CTEST_RUN_MFC)
X set(CTEST_RUN_MFC OFF)
X
X if(MSVC)
X set(CTEST_RUN_MFC ON)
X
X # Look for evidence that this is a VCExpress build. If so, avoid
X # the MFC test by default.
X string(TOLOWER "${CMAKE_TEST_MAKEPROGRAM}" mkprog)
X if(mkprog MATCHES "vcexpress")
X message(STATUS
X "CMAKE_TEST_MAKEPROGRAM indicates vcexpress, avoiding MFC test")
X set(CTEST_RUN_MFC OFF)
X endif()
X
X # Since MSBuild might also be the "makeprogram" for a VCExpress
X # build tree, use one more heuristic, too. The string representing
X # the .vcproj file type contains "VCExpress" on machines where an
X # express edition of VS was installed last:
X if(CTEST_RUN_MFC)
X execute_process(COMMAND cmd /c assoc .vcproj
X OUTPUT_STRIP_TRAILING_WHITESPACE
X OUTPUT_VARIABLE ov)
X if(ov MATCHES "VCExpress")
X message(STATUS
X ".vcproj file association indicates VCExpress, avoiding MFC test")
X set(CTEST_RUN_MFC OFF)
X endif()
X endif()
X
X # For the Watcom WMake generator, avoid the MFC test by default.
X if(CTEST_RUN_MFC)
X if("${CMAKE_TEST_GENERATOR}" MATCHES "WMake")
X message(STATUS
X "using the Watcom WMake generator, avoiding MFC test")
X set(CTEST_RUN_MFC OFF)
X endif()
X endif()
X
X # Last resort, after quick checks are done. Do a try_compile, and avoid
X # the MFC test if the simplest possible MFC app cannot be compiled.
X if(CTEST_RUN_MFC AND NOT DEFINED HAVE_MFC)
X configure_file(
X ${CMAKE_CURRENT_SOURCE_DIR}/MFC/try_compile/CMakeLists.txt
X ${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile/CMakeLists.txt
X COPYONLY
X )
X configure_file(
X ${CMAKE_CURRENT_SOURCE_DIR}/MFC/mfc1/stdafx.cpp
X ${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile/stdafx.cpp
X COPYONLY
X )
X configure_file(
X ${CMAKE_CURRENT_SOURCE_DIR}/MFC/mfc1/stdafx.h
X ${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile/stdafx.h
X COPYONLY
X )
X
X message(STATUS "Looking for MFC")
X
X try_compile(HAVE_MFC
X ${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile/build
X ${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile
X try_compile_mfc
X OUTPUT_VARIABLE HAVE_MFC_OUTPUT)
X
X if(HAVE_MFC)
X message(STATUS "Looking for MFC - found")
X set(HAVE_MFC 1 CACHE INTERNAL "Have MFC")
X file(APPEND
X ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
X "Determining if MFC exists passed with the following output:\n"
X "${HAVE_MFC_OUTPUT}\n\n")
X else()
X message(STATUS "Looking for MFC - not found")
X set(HAVE_MFC "" CACHE INTERNAL "Have MFC")
X file(APPEND
X ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
X "Determining if MFC exists failed with the following output:\n"
X "${HAVE_MFC_OUTPUT}\n\n")
X endif()
X endif()
X
X if(CTEST_RUN_MFC AND NOT HAVE_MFC)
X message(STATUS
X "cannot compile simplest ever MFC app, avoiding MFC test")
X set(CTEST_RUN_MFC OFF)
X endif()
X endif()
X endif()
X
X if(CTEST_RUN_MFC)
X add_test(MFC ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/MFC"
X "${CMake_BINARY_DIR}/Tests/MFC"
X --build-two-config
X ${build_generator_args}
X --build-project mfc_driver
X --test-command ${CMAKE_CTEST_COMMAND}
X -C \${CTEST_CONFIGURATION_TYPE} -VV)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MFC")
X endif()
X
X if(${CMAKE_TEST_GENERATOR} MATCHES "Visual Studio")
X if(NOT MSVC60)
X ADD_TEST_MACRO(SBCS SBCS)
X endif()
X
X if(NOT "${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio [6789]( |$)"
X AND NOT CMAKE_TEST_GENERATOR_TOOLSET)
X ADD_TEST_MACRO(VSWindowsFormsResx VSWindowsFormsResx)
X endif()
X
X add_test(VSExternalInclude ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/VSExternalInclude"
X "${CMake_BINARY_DIR}/Tests/VSExternalInclude"
X --build-two-config
X ${build_generator_args}
X --build-project VSExternalInclude
X --test-command VSExternalInclude)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExternalInclude")
X
X add_test(VSMidl ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/VSMidl"
X "${CMake_BINARY_DIR}/Tests/VSMidl"
X --build-two-config
X ${build_generator_args}
X --build-project VSMidl
X --test-command VSMidl)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSMidl")
X
X if(NOT MSVC60 AND NOT CMAKE_TEST_MAKEPROGRAM MATCHES "[mM][sS][bB][uU][iI][lL][dD]\\.[eE][xX][eE]")
X # The test (and tested property) works with .sln files, so it's skipped when:
X # * Using VS6, which doesn't use .sln files
X # * cmake --build is set up to use MSBuild, since the MSBuild invocation does not use the .sln file
X set(_last_test "")
X foreach(config ${CMAKE_CONFIGURATION_TYPES})
X add_test(NAME VSExcludeFromDefaultBuild-${config} COMMAND ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild"
X "${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
X --build-config ${config}
X --build-two-config
X ${build_generator_args}
X --build-project VSExcludeFromDefaultBuild
X --test-command ${CMAKE_COMMAND}
X -D "activeConfig=${config}"
X -D "allConfigs=${CMAKE_CONFIGURATION_TYPES}"
X -D "dir=${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
X -P "${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild/ResultTest.cmake")
X if(_last_test)
X set_property(TEST VSExcludeFromDefaultBuild-${config} PROPERTY DEPENDS ${_last_test})
X endif()
X set(_last_test "VSExcludeFromDefaultBuild-${config}")
X endforeach()
X unset(_last_test)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild")
X endif()
X
X if(CMAKE_TEST_GENERATOR MATCHES "Visual Studio ([0-5]|[6-9][0-9])")
X if(CMAKE_TEST_MAKEPROGRAM MATCHES "[mM][sS][bB][uU][iI][lL][dD]\\.[eE][xX][eE]")
X set(MSBUILD_EXECUTABLE "${CMAKE_TEST_MAKEPROGRAM}")
X else()
X if(CMAKE_TEST_GENERATOR MATCHES "Visual Studio (12)")
X set(_msbuild_hints "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\MSBuild\\ToolsVersions\\${CMAKE_MATCH_1}.0;MSBuildToolsPath]")
X else()
X set(_FDIR "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VC7;FrameworkDir32]")
X set(_FVER "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VC7;FrameworkVer32]")
X set(_msbuild_hints ${_FDIR}/${_FVER})
X endif()
X find_program(MSBUILD_EXECUTABLE NAMES msbuild HINTS ${_msbuild_hints})
X endif()
X if(MSBUILD_EXECUTABLE)
X add_test(NAME VSProjectInSubdir COMMAND ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/VSProjectInSubdir"
X "${CMake_BINARY_DIR}/Tests/VSProjectInSubdir"
X --build-two-config
X --build-generator ${CMAKE_TEST_GENERATOR}
X --build-generator-toolset "${CMAKE_TEST_GENERATOR_TOOLSET}"
X --build-makeprogram "${MSBUILD_EXECUTABLE}"
X --build-project VSProjectInSubdir
X --build-target test)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSProjectInSubdir")
X endif()
X endif()
X endif()
X
X if (APPLE)
X if (CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
X set(BundleTestInstallDir
X "${CMake_BINARY_DIR}/Tests/BundleTest/InstallDirectory")
X add_test(BundleTest ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/BundleTest"
X "${CMake_BINARY_DIR}/Tests/BundleTest"
X --build-two-config
X ${build_generator_args}
X --build-project BundleTest
X --build-target install
X# --build-target package
X --build-options "-DCMAKE_INSTALL_PREFIX:PATH=${BundleTestInstallDir}"
X "-DCMake_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}"
X --test-command
X ${BundleTestInstallDir}/Applications/SecondBundleExe.app/Contents/MacOS/SecondBundleExe)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleTest")
X
X add_test(CFBundleTest ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/CFBundleTest"
X "${CMake_BINARY_DIR}/Tests/CFBundleTest"
X --build-two-config
X ${build_generator_args}
X --build-project CFBundleTest
X --test-command
X ${CMAKE_CMAKE_COMMAND} -DCTEST_CONFIGURATION_TYPE=\${CTEST_CONFIGURATION_TYPE}
X -Ddir=${CMake_BINARY_DIR}/Tests/CFBundleTest
X -Dgen=${CMAKE_TEST_GENERATOR}
X -P ${CMake_SOURCE_DIR}/Tests/CFBundleTest/VerifyResult.cmake)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CFBundleTest")
X
X ADD_TEST_MACRO(ObjC++ ObjC++)
X endif ()
X endif ()
X
X if(APPLE AND CTEST_TEST_CPACK)
X add_test(BundleGeneratorTest ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/BundleGeneratorTest"
X "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest"
X --build-two-config
X ${build_generator_args}
X --build-project BundleGeneratorTest
X --build-target package
X --build-options "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/BundleGeneratorTest/InstallDirectory"
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest")
X endif()
X
X add_test(WarnUnusedUnusedViaSet ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/VariableUnusedViaSet"
X "${CMake_BINARY_DIR}/Tests/WarnUnusedUnusedViaSet"
X ${build_generator_args}
X --build-noclean
X --build-project WarnUnusedUnusedViaSet
X --build-options "--warn-unused-vars")
X set_tests_properties(WarnUnusedUnusedViaSet PROPERTIES
X PASS_REGULAR_EXPRESSION "unused variable \\(changing definition\\) 'UNUSED_VARIABLE'")
X set_tests_properties(WarnUnusedUnusedViaSet PROPERTIES
X FAIL_REGULAR_EXPRESSION "unused variable \\(unsetting\\) 'UNUSED_VARIABLE'")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedUnusedViaSet")
X
X add_test(WarnUnusedUnusedViaUnset ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/VariableUnusedViaUnset"
X "${CMake_BINARY_DIR}/Tests/WarnUnusedUnusedViaUnset"
X ${build_generator_args}
X --build-noclean
X --build-project WarnUnusedUnusedViaUnset
X --build-options "--warn-unused-vars")
X set_tests_properties(WarnUnusedUnusedViaUnset PROPERTIES
X PASS_REGULAR_EXPRESSION "CMake Warning .*VariableUnusedViaUnset.CMakeLists.txt:7 \\(set\\):")
X set_tests_properties(WarnUnusedUnusedViaUnset PROPERTIES
X FAIL_REGULAR_EXPRESSION "CMake Warning .*VariableUnusedViaUnset.CMakeLists.txt:5 \\(set\\):")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedUnusedViaUnset")
X
X if("${CMAKE_TEST_GENERATOR}" MATCHES "Makefile" AND NOT WIN32)
X # Ninja does not support ADDITIONAL_MAKE_CLEAN_FILES and therefore fails
X # this test. (See #13371)
X # Apparently Visual Studio does not support it either. As the MakeClean
X # test above is only run with the Makefiles generator, only run this
X # test with the Makefiles generator also.
X add_test(WarnUnusedCliUnused ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/WarnUnusedCliUnused"
X "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused"
X ${build_generator_args}
X --build-project WarnUnusedCliUnused
X --build-options "-DUNUSED_CLI_VARIABLE=Unused")
X set_tests_properties(WarnUnusedCliUnused PROPERTIES
X PASS_REGULAR_EXPRESSION "CMake Warning:.*Manually-specified variables were not used by the project:.* UNUSED_CLI_VARIABLE")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused")
X endif()
X
X add_test(WarnUnusedCliUsed ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/VariableUsage"
X "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed"
X ${build_generator_args}
X --build-noclean
X --build-project WarnUnusedCliUsed
X --build-options "-DUSED_VARIABLE=Usage proven")
X set_tests_properties(WarnUnusedCliUsed PROPERTIES
X PASS_REGULAR_EXPRESSION "Usage proven")
X set_tests_properties(WarnUnusedCliUsed PROPERTIES
X FAIL_REGULAR_EXPRESSION "CMake Warning: The variable, 'USED_VARIABLE'")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed")
X
X add_test(WarnUninitialized ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/VariableUsage"
X "${CMake_BINARY_DIR}/Tests/WarnUninitialized"
X ${build_generator_args}
X --build-noclean
X --build-project WarnUninitialized
X --build-options "--warn-uninitialized")
X set_tests_properties(WarnUninitialized PROPERTIES
X PASS_REGULAR_EXPRESSION "uninitialized variable 'USED_VARIABLE'")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUninitialized")
X
X add_test(TestsWorkingDirectory ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/TestsWorkingDirectory"
X "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
X ${build_generator_args}
X --build-project TestsWorkingDirectoryProj
X --build-exe-dir "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
X --force-new-ctest-process
X --test-command ${CMAKE_CTEST_COMMAND} -V -C \${CTEST_CONFIGURATION_TYPE}
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory")
X
X # Make sure CTest can handle a test with no newline in output.
X add_test(CTest.NoNewline
X ${CMAKE_CMAKE_COMMAND} -E echo_append "This line has no newline!")
X
X # A simple test for ctest in script mode
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake" @ONLY)
X# add_test(CTest.ScriptMode ${CMAKE_CTEST_COMMAND}
X# -S "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake"
X# )
X
X # A test for ctest_build() with targets in subdirectories
X if(CMAKE_TEST_GENERATOR_TOOLSET)
X set(CMAKE_TEST_GENERATOR_TOOLSET_SELECTION "-T;${CMAKE_TEST_GENERATOR_TOOLSET};")
X else()
X set(CMAKE_TEST_GENERATOR_TOOLSET_SELECTION)
X endif()
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestBuildCommandProjectInSubdir/CTestBuildCommandProjectInSubdir.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestBuildCommandProjectInSubdir/CTestBuildCommandProjectInSubdir.cmake" @ONLY)
X unset(CMAKE_TEST_GENERATOR_TOOLSET_SELECTION)
X add_test(CTest.BuildCommand.ProjectInSubdir
X ${CMAKE_CTEST_COMMAND} -S "${CMake_BINARY_DIR}/Tests/CTestBuildCommandProjectInSubdir/CTestBuildCommandProjectInSubdir.cmake"
X -DCMAKE_MAKE_PROGRAM:FILEPATH=${CMAKE_TEST_MAKEPROGRAM})
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CTestBuildCommandProjectInSubdir/Nested")
X
X set(CTEST_TEST_UPDATE 1)
X if(CTEST_TEST_UPDATE)
X # Test CTest Update with Subversion
X find_package(Subversion QUIET)
X if(Subversion_FOUND)
X get_filename_component(_Subversion_BIN_DIR
X ${Subversion_SVN_EXECUTABLE} PATH)
X find_program(Subversion_SVNADMIN_EXECUTABLE svnadmin
X HINTS ${_Subversion_BIN_DIR}
X )
X mark_as_advanced(Subversion_SVNADMIN_EXECUTABLE)
X if(NOT Subversion_SVNADMIN_EXECUTABLE)
X set(Subversion_FOUND FALSE)
X endif()
X endif()
X if(Subversion_FOUND)
X set(CTestUpdateSVN_DIR "CTest UpdateSVN")
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateSVN.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake" @ONLY)
X add_test(CTest.UpdateSVN ${CMAKE_CMAKE_COMMAND}
X -P "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake"
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateSVN_DIR}")
X endif()
X
X # Test CTest Update with CVS
X if(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
X find_package(CVS QUIET)
X else()
X find_program(CVS_EXECUTABLE NAMES cvs)
X set(CVS_FOUND ${CVS_EXECUTABLE})
X endif()
X set(CTEST_TEST_UPDATE_CVS ${CVS_FOUND})
X if(CTEST_TEST_UPDATE_CVS AND NOT UNIX)
X if("${CVS_EXECUTABLE}" MATCHES "cygwin")
X message(STATUS "No CTest.UpdateCVS test with cygwin cvs.exe outside cygwin!")
X set(CTEST_TEST_UPDATE_CVS 0)
X endif()
X endif()
X if(CTEST_TEST_UPDATE_CVS)
X set(CTestUpdateCVS_DIR "CTest UpdateCVS")
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateCVS.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake" @ONLY)
X add_test(CTest.UpdateCVS ${CMAKE_CMAKE_COMMAND}
X -P "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake"
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateCVS_DIR}")
X endif()
X
X # Test CTest Update with BZR
X find_program(BZR_EXECUTABLE NAMES bzr)
X mark_as_advanced(BZR_EXECUTABLE)
X set(CTEST_TEST_UPDATE_BZR 0)
X if(BZR_EXECUTABLE)
X if(NOT "${BZR_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
X set(CTEST_TEST_UPDATE_BZR 1)
X endif()
X endif()
X if(CTEST_TEST_UPDATE_BZR)
X # Check if xmloutput plugin is there
X execute_process(COMMAND ${BZR_EXECUTABLE} xmlplugins RESULT_VARIABLE xmlplugres
X OUTPUT_QUIET ERROR_QUIET)
X if( NOT ${xmlplugres} )
X set(CTestUpdateBZR_DIR "CTest UpdateBZR")
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake" @ONLY)
X add_test(CTest.UpdateBZR ${CMAKE_CMAKE_COMMAND}
X -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake"
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
X set(CTestUpdateBZR_DIR "CTest UpdateBZR_CLocale")
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake" @ONLY)
X add_test(CTest.UpdateBZR.CLocale ${CMAKE_CMAKE_COMMAND}
X -P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake"
X )
X set_tests_properties(CTest.UpdateBZR.CLocale PROPERTIES ENVIRONMENT LC_ALL=C)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
X endif()
X endif()
X
X # Test CTest Update with GIT
X find_program(GIT_EXECUTABLE NAMES git)
X mark_as_advanced(GIT_EXECUTABLE)
X set(CTEST_TEST_UPDATE_GIT 0)
X if(GIT_EXECUTABLE)
X if(NOT "${GIT_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
X set(CTEST_TEST_UPDATE_GIT 1)
X endif()
X endif()
X if(CTEST_TEST_UPDATE_GIT)
X set(CTestUpdateGIT_DIR "CTest UpdateGIT")
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateGIT.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake" @ONLY)
X add_test(CTest.UpdateGIT ${CMAKE_CMAKE_COMMAND}
X -P "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake"
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateGIT_DIR}")
X endif()
X
X # Test CTest Update with HG
X find_program(HG_EXECUTABLE NAMES hg)
X mark_as_advanced(HG_EXECUTABLE)
X set(CTEST_TEST_UPDATE_HG 0)
X if(HG_EXECUTABLE)
X if(NOT "${HG_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
X set(CTEST_TEST_UPDATE_HG 1)
X endif()
X endif()
X if(CTEST_TEST_UPDATE_HG)
X set(CTestUpdateHG_DIR "CTest UpdateHG")
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateHG.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake" @ONLY)
X add_test(CTest.UpdateHG ${CMAKE_CMAKE_COMMAND}
X -P "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake"
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateHG_DIR}")
X endif()
X endif()
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoBuild.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestNoBuild ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut1.log"
X )
X set_tests_properties(CTestTestNoBuild PROPERTIES
X FAIL_REGULAR_EXPRESSION "Error" WILL_FAIL true)
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoExe.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestNoExe ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut2.log"
X )
X set_tests_properties(CTestTestNoExe PROPERTIES DEPENDS CTestTestNoBuild
X PASS_REGULAR_EXPRESSION "Could not find executable"
X FAIL_REGULAR_EXPRESSION "SegFault")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestUpload/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestUpload ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestUpload/testOut.log"
X )
X set_tests_properties(CTestTestUpload PROPERTIES
X PASS_REGULAR_EXPRESSION "Upload\\.xml")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestConfigFileInBuildDir/test1.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestConfigFileInBuildDir1/test1.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestConfigFileInBuildDir1 ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestConfigFileInBuildDir1/test1.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestConfigFileInBuildDir1/testOut1.log"
X )
X REGEX_ESCAPE_STRING(CTEST_TEST_ESCAPED_SOURCE_DIR "${CMake_SOURCE_DIR}")
X set_tests_properties(CTestTestConfigFileInBuildDir1 PROPERTIES DEPENDS CTestTestNoBuild
X PASS_REGULAR_EXPRESSION
X "Reading ctest configuration file: ${CTEST_TEST_ESCAPED_SOURCE_DIR}.Tests.CTestTestConfigFileInBuildDir.CTestConfig.cmake")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestConfigFileInBuildDir/test2.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestConfigFileInBuildDir2/test2.cmake"
X @ONLY ESCAPE_QUOTES)
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestConfigFileInBuildDir/CTestConfig.cmake"
X "${CMake_BINARY_DIR}/Tests/CTestTestConfigFileInBuildDir2/CTestConfig.cmake"
X @ONLY ESCAPE_QUOTES COPYONLY)
X add_test(CTestTestConfigFileInBuildDir2 ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestConfigFileInBuildDir2/test2.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestConfigFileInBuildDir2/testOut2.log"
X )
X REGEX_ESCAPE_STRING(CTEST_TEST_ESCAPED_BINARY_DIR "${CMake_BINARY_DIR}")
X set_tests_properties(CTestTestConfigFileInBuildDir2 PROPERTIES DEPENDS CTestTestNoBuild
X REQUIRED_FILES ${CMake_BINARY_DIR}/Tests/CTestTestConfigFileInBuildDir2/CTestConfig.cmake
X PASS_REGULAR_EXPRESSION
X "Reading ctest configuration file: ${CTEST_TEST_ESCAPED_BINARY_DIR}.Tests.CTestTestConfigFileInBuildDir2.CTestConfig.cmake")
X
X # test coverage for mumps
X # create a MumpsCoverage dir in the binary tree under Testing to
X # avoid the .NoDartCoverage files in the cmake testing tree
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.tcl.in"
X "${CMake_BINARY_DIR}/Testing/MumpsCoverage/DartConfiguration.tcl")
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/gtm_coverage.mcov.in"
X "${CMake_BINARY_DIR}/Testing/MumpsCoverage/gtm_coverage.mcov")
X file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
X DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCoverage")
X add_test(NAME CTestGTMCoverage
X COMMAND cmake -E chdir
X ${CMake_BINARY_DIR}/Testing/MumpsCoverage
X $<TARGET_FILE:ctest> -T Coverage --debug)
X set_tests_properties(CTestGTMCoverage PROPERTIES
X PASS_REGULAR_EXPRESSION
X "Process file.*XINDEX.m.*Total LOC:.*127.*Percentage Coverage: 85.83.*"
X ENVIRONMENT COVFILE=)
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.cache.tcl.in"
X "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/DartConfiguration.tcl")
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/cache_coverage.cmcov.in"
X "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/cache_coverage.cmcov")
X file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
X DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage")
X add_test(NAME CTestCacheCoverage
X COMMAND cmake -E chdir
X ${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage
X $<TARGET_FILE:ctest> -T Coverage --debug)
X set_tests_properties(CTestCacheCoverage PROPERTIES
X PASS_REGULAR_EXPRESSION
X "Process file.*XINDEX.m.*Total LOC:.*125.*Percentage Coverage: 85.60.*"
X ENVIRONMENT COVFILE=)
X # Use macro, not function so that build can still be driven by CMake 2.4.
X # After 2.6 is required, this could be a function without the extra 'set'
X # calls.
X #
X macro(add_config_tests cfg)
X set(cfg "${cfg}")
X set(base "${CMake_BINARY_DIR}/Tests/CTestConfig")
X
X # Test -S script with a -C config arg to ctest:
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestConfig/script.cmake.in"
X "${base}/${cfg}-script.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestConfig.Script.${cfg} ${CMAKE_CTEST_COMMAND}
X -C ${cfg}
X -S "${base}/${cfg}-script.cmake" -VV
X --output-log "${base}/${cfg}-script.log"
X )
X
X # Test -D dashboard with a -C config arg to ctest.
X # (Actual commands inside a cmake -P script because we need to be able to set
X # the working directory reliably...)
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestConfig/dashboard.cmake.in"
X "${base}/${cfg}-dashboard.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestConfig.Dashboard.${cfg} ${CMAKE_CMAKE_COMMAND}
X -P "${base}/${cfg}-dashboard.cmake" -VV
X )
X endmacro()
X
X add_config_tests(Debug)
X add_config_tests(MinSizeRel)
X add_config_tests(Release)
X add_config_tests(RelWithDebInfo)
X
X # Test -S script with some -D variable definition args to ctest:
X add_test(CTestConfig.ScriptWithArgs ${CMAKE_CTEST_COMMAND}
X -C "Release"
X -D arg1=this
X -D arg2=that
X -D "arg3=the other"
X "-Darg4=this is the fourth"
X -Darg5=the_fifth
X -Darg6:STRING=value-with-type
X -S "${CMake_SOURCE_DIR}/Tests/CTestConfig/ScriptWithArgs.cmake" -VV
X --output-log "${CMake_BINARY_DIR}/Tests/CTestConfig/ScriptWithArgs.log"
X )
X
X ADD_TEST_MACRO(CMakeCommands.target_link_libraries target_link_libraries)
X ADD_TEST_MACRO(CMakeCommands.target_include_directories target_include_directories)
X ADD_TEST_MACRO(CMakeCommands.target_compile_definitions target_compile_definitions)
X ADD_TEST_MACRO(CMakeCommands.target_compile_options target_compile_options)
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestCrash/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestCrash ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCrash/testOutput.log"
X )
X # with watcom the SEGFAULT is not found, it just fails
X if(CMAKE_TEST_GENERATOR MATCHES "Watcom WMake")
X set_tests_properties(CTestTestCrash PROPERTIES
X PASS_REGULAR_EXPRESSION "Failed")
X else()
X set_tests_properties(CTestTestCrash PROPERTIES
X PASS_REGULAR_EXPRESSION "(Illegal|SegFault)")
X endif()
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestBadExe/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestBadExe ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/testOutput.log"
X )
X set(CTestTestBadExe_REGEX "BAD_COMMAND")
X # some cygwin can not be made to produce a BAD_COMMAND error
X # the best we can get from it is a failed test
X if(CYGWIN)
X set(CTestTestBadExe_REGEX "(\\*\\*\\*Failed)|BAD_COMMAND")
X endif()
X set_tests_properties(CTestTestBadExe PROPERTIES
X PASS_REGULAR_EXPRESSION "${CTestTestBadExe_REGEX}")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestParallel/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestParallel ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestParallel/testOutput.log"
X )
X
X if(NOT BORLAND)
X set(CTestLimitDashJ_EXTRA_OPTIONS --force-new-ctest-process)
X add_test_macro(CTestLimitDashJ ${CMAKE_CTEST_COMMAND} -j 4
X --output-on-failure -C "\${CTestTest_CONFIG}")
X endif()
X
X add_test(CTestTestPrintLabels ${CMAKE_CTEST_COMMAND} --print-labels)
X set_tests_properties(CTestTestPrintLabels PROPERTIES LABELS "Label1;Label2")
X set_tests_properties(CTestTestPrintLabels PROPERTIES PASS_REGULAR_EXPRESSION
X "All Labels:.* Label1.* Label2")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestResourceLock/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestResourceLock/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestResourceLock ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestResourceLock/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestResourceLock/output.log"
X )
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestScheduler/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestScheduler ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/testOutput.log"
X )
X set_tests_properties(CTestTestScheduler PROPERTIES
X PASS_REGULAR_EXPRESSION "Start 1.*Start 2.*Start 3.*Start 4.*Start 4.*Start 3.*Start 2.*Start 1"
X RESOURCE_LOCK "CostData")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestCostSerial/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestCostSerial ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/testOutput.log"
X )
X set_tests_properties(CTestTestCostSerial PROPERTIES
X PASS_REGULAR_EXPRESSION "Start 2.*Start 3.*Start 1.*Start 2.*Start 3.*Start 1"
X RESOURCE_LOCK "CostData")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake"
X @ONLY ESCAPE_QUOTES)
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
X "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
X COPYONLY)
X add_test(CTestTestStopTime ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/testOutput.log"
X )
X set_tests_properties(CTestTestStopTime PROPERTIES
X PASS_REGULAR_EXPRESSION "The stop time has been passed")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestSubdir/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestSubdir ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/testOutput.log"
X )
X #make sure all 3 subdirs were added
X set_tests_properties(CTestTestSubdir PROPERTIES
X PASS_REGULAR_EXPRESSION "0 tests failed out of 3")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestTimeout/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestTimeout ${CMAKE_CTEST_COMMAND}
X -C "\${CTestTest_CONFIG}"
X -S "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/testOutput.log"
X )
X set_tests_properties(CTestTestTimeout PROPERTIES
X PASS_REGULAR_EXPRESSION "TestTimeout *\\.+ *\\*\\*\\*Timeout.*CheckChild *\\.+ *Passed")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestZeroTimeout/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestZeroTimeout ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/test.cmake" -V
X --output-log
X "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/testOutput.log")
X set_tests_properties(CTestTestZeroTimeout PROPERTIES
X FAIL_REGULAR_EXPRESSION "\\*\\*\\*Timeout")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestDepends/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestDepends ${CMAKE_CTEST_COMMAND}
X -C "\${CTestTest_CONFIG}"
X -S "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestDepends/testOutput.log"
X )
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestCycle/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestCycle ${CMAKE_CTEST_COMMAND}
X -C "\${CTestTest_CONFIG}"
X -S "${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestCycle/testOutput.log"
X )
X set_tests_properties(CTestTestCycle PROPERTIES
X PASS_REGULAR_EXPRESSION "a cycle exists in the test dependency graph")
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake"
X @ONLY ESCAPE_QUOTES)
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/hello.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/hello.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestRunScript ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/testOutput.log"
X )
X
X add_test(CTestTestShowOnly ${CMAKE_CTEST_COMMAND} -N)
X
X add_test(CTestBatchTest ${CMAKE_CTEST_COMMAND} -B)
X
X configure_file(
X "${CMake_SOURCE_DIR}/Tests/CTestTestFdSetSize/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake"
X @ONLY ESCAPE_QUOTES)
X add_test(CTestTestFdSetSize ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake" -j20 -V --timeout 120
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/testOutput.log"
X )
X
X # Use macro, not function so that build can still be driven by CMake 2.4.
X # After 2.6 is required, this could be a function without the extra 'set'
X # calls.
X #
X macro(add_failed_submit_test name source build in out log regex)
X # Have variables named source, build and drop_method because the
X # configure_file call expects those variables to be defined.
X #
X set(source "${source}")
X set(build "${build}")
X configure_file("${in}" "${out}" @ONLY)
X add_test(${name} ${CMAKE_CTEST_COMMAND} -S "${out}" -V --output-log "${log}")
X set_tests_properties(${name} PROPERTIES PASS_REGULAR_EXPRESSION "${regex}")
X endmacro()
X
X set(regex "(Problems when submitting via S*CP")
X set(regex "${regex}|Error message was: ")
X set(regex "${regex}([Cc]ould *n.t resolve host")
X set(regex "${regex}|[Cc]ould *n.t connect to host")
X set(regex "${regex}|Empty reply from server")
X set(regex "${regex}|The requested URL returned error")
X set(regex "${regex}|libcurl was built with SSL disabled. https: not supported)")
X set(regex "${regex}|Submission method .xmlrpc. not compiled into CTest")
X set(regex "${regex}|Submission problem")
X set(regex "${regex}|Submission successful)")
X
X set(ctest_coverage_labels_args "")
X
X foreach(drop_method cp ftp http https scp xmlrpc)
X # Cycle through these values each time through the loop:
X if(ctest_coverage_labels_args STREQUAL "")
X set(ctest_coverage_labels_args "LABELS Everything")
X elseif(ctest_coverage_labels_args STREQUAL "LABELS Everything")
X set(ctest_coverage_labels_args "LABELS 0ArgTest")
X else()
X set(ctest_coverage_labels_args "")
X endif()
X
X add_failed_submit_test(CTestTestFailedSubmit-${drop_method}
X "${CMake_SOURCE_DIR}/Tests/CTestTest/SmallAndFast"
X "${CMake_BINARY_DIR}/Tests/CTestTestFailedSubmits/${drop_method}"
X "${CMake_SOURCE_DIR}/Tests/CTestTestFailedSubmits/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestFailedSubmits/test-${drop_method}.cmake"
X "${CMake_BINARY_DIR}/Tests/CTestTestFailedSubmits/test-${drop_method}.log"
X "${regex}"
X )
X endforeach()
X
X
X if (CMAKE_TESTS_CDASH_SERVER)
X set(regex "^([^:]+)://([^/]+)(/.*)$")
X
X if ("${CMAKE_TESTS_CDASH_SERVER}" MATCHES "${regex}")
X set(protocol "${CMAKE_MATCH_1}")
X set(server "${CMAKE_MATCH_2}")
X set(path "${CMAKE_MATCH_3}")
X else ()
X set(protocol "http")
X set(server "www.cdash.org")
X set(path "/CDash")
X message("warning: CMAKE_TESTS_CDASH_SERVER does not match expected regex...")
X message(" ...using default url='${protocol}://${server}${path}' for CTestTest[23]")
X endif ()
X endif ()
X
X
X if (CTEST_TEST_CTEST AND CMAKE_RUN_LONG_TESTS AND CMAKE_TESTS_CDASH_SERVER)
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" @ONLY ESCAPE_QUOTES)
X add_test(CTestTest ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTest/testOutput.log"
X )
X
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest2/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" @ONLY ESCAPE_QUOTES)
X add_test(CTestTest2 ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" -V
X --output-log "${CMake_BINARY_DIR}/Tests/CTestTest2/testOutput.log"
X )
X
X configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestChecksum/test.cmake.in"
X "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" @ONLY
X ESCAPE_QUOTES)
X add_test(CTestTestChecksum ${CMAKE_CTEST_COMMAND}
X -S "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" -V
X --output-log
X "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/testOutput.log"
X )
X set_tests_properties(CTestTestChecksum PROPERTIES PASS_REGULAR_EXPRESSION
X "Submission failed: Checksum failed for file")
X
X # these tests take a long time, make sure they have it
X # if timeouts have not already been set
X get_test_property(CTestTest TIMEOUT PREVIOUS_TIMEOUT)
X if ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
X set_tests_properties ( CTestTest
X PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
X endif ()
X
X get_test_property(CTestTest2 TIMEOUT PREVIOUS_TIMEOUT)
X if ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
X set_tests_properties ( CTestTest2
X PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
X endif ()
X endif ()
X
X if("${CMAKE_TEST_GENERATOR}" MATCHES Xcode)
X set(CMAKE_SKIP_BOOTSTRAP_TEST 1)
X endif()
X if(EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt")
X # If there is CMakeLists.txt in the binary tree, assume in-source build
X set(CMAKE_SKIP_BOOTSTRAP_TEST 1)
X endif()
X set(bootstrap "")
X if(CMAKE_RUN_LONG_TESTS AND NOT CMAKE_SKIP_BOOTSTRAP_TEST)
X if(UNIX)
X set(bootstrap ${CMake_SOURCE_DIR}/bootstrap)
X elseif(MSYS)
X configure_file(${CMAKE_CURRENT_SOURCE_DIR}/bootstrap.bat.in
X ${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat @ONLY)
X set(bootstrap ${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat)
X endif()
X endif()
X if(bootstrap)
X add_test(BootstrapTest ${CMAKE_CTEST_COMMAND}
X --build-and-test
X ${CMake_SOURCE_DIR}
X ${CMake_BINARY_DIR}/Tests/BootstrapTest
X --build-nocmake
X --build-noclean
X --build-makeprogram ${bootstrap}
X --build-generator "${CMAKE_TEST_GENERATOR}"
X --test-command
X ${CMake_BINARY_DIR}/Tests/BootstrapTest/Bootstrap.cmk/cmake)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BootstrapTest")
X # Make this test run early during parallel execution
X set_tests_properties(BootstrapTest PROPERTIES COST 5000)
X
X # provide more time for the bootstrap test
X get_test_property(BootstrapTest TIMEOUT PREVIOUS_TIMEOUT)
X if ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
X set_tests_properties ( BootstrapTest
X PROPERTIES TIMEOUT 5400)
X endif ()
X endif()
X
X if(CMAKE_Fortran_COMPILER)
X add_test(Fortran ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Fortran"
X "${CMake_BINARY_DIR}/Tests/Fortran"
X ${build_generator_args}
X --build-project testf
X --build-two-config
X --test-command testf)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Fortran")
X
X # FortranCInterface tests.
X if(UNIX)
X configure_file(${CMAKE_CURRENT_SOURCE_DIR}/FortranC/Flags.cmake.in
X ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake @ONLY)
X add_test(FortranC.Flags ${CMAKE_CMAKE_COMMAND} -P
X ${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC/Flags")
X else()
X add_test(FortranC ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/FortranC"
X "${CMake_BINARY_DIR}/Tests/FortranC"
X ${build_generator_args}
X --build-project FortranC
X --build-two-config
X --test-command CMakeFiles/FortranCInterface/FortranCInterface)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC")
X endif()
X endif()
X
X find_package(Java COMPONENTS Development QUIET)
X if(Java_JAVA_EXECUTABLE AND Java_JAVAC_EXECUTABLE AND Java_JAR_EXECUTABLE AND NOT MINGW
X AND NOT "${CMAKE_TEST_GENERATOR}" MATCHES "Xcode")
X get_filename_component(JNIPATH ${JAVA_COMPILE} PATH)
X find_file(JNI_H jni.h
X "${JNIPATH}/../include"
X "${JNIPATH}/../java/include")
X if(JNI_H AND EXISTS "${JNI_H}") # in case jni.h is a broken symlink
X file(READ "${JNI_H}" JNI_FILE)
X if("${JNI_FILE}" MATCHES "JDK1_2")
X add_test(Java ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Java"
X "${CMake_BINARY_DIR}/Tests/Java"
X ${build_generator_args}
X --build-project hello
X --build-two-config
X --build-run-dir "${CMake_BINARY_DIR}/Tests/Java/"
X --test-command ${JAVA_RUNTIME} -classpath hello.jar HelloWorld)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Java")
X endif()
X endif()
X endif()
X
X # add some cross compiler tests, for now only with makefile based generators
X if(CMAKE_TEST_GENERATOR MATCHES "Makefiles" OR CMAKE_TEST_GENERATOR MATCHES "KDevelop")
X
X # if sdcc is found, build the SimpleCOnly project with sdcc
X find_program(SDCC_EXECUTABLE sdcc)
X mark_as_advanced(SDCC_EXECUTABLE)
X if(SDCC_EXECUTABLE)
X add_test(SimpleCOnly_sdcc ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/SimpleCOnly"
X "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc"
X ${build_generator_args}
X --build-project SimpleC
X --build-options
X "-DCMAKE_SYSTEM_NAME=Generic"
X "-DCMAKE_C_COMPILER=${SDCC_EXECUTABLE}")
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc")
X endif()
X
X # If a Linux -> MinGW cross compiler is found then try it
X find_program(MINGW_CC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-gcc)
X find_program(MINGW_CXX_LINUX2WIN_EXECUTABLE i586-mingw32msvc-g++)
X find_program(MINGW_RC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-windres)
X mark_as_advanced(MINGW_CC_LINUX2WIN_EXECUTABLE MINGW_CXX_LINUX2WIN_EXECUTABLE MINGW_RC_LINUX2WIN_EXECUTABLE)
X if(MINGW_CC_LINUX2WIN_EXECUTABLE AND MINGW_CXX_LINUX2WIN_EXECUTABLE AND MINGW_RC_LINUX2WIN_EXECUTABLE)
X add_test(Simple_Mingw_Linux2Win ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/Simple"
X "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win"
X ${build_generator_args}
X --build-project Simple
X --build-options
X "-DCMAKE_SYSTEM_NAME=Windows"
X "-DCMAKE_C_COMPILER=${MINGW_CC_LINUX2WIN_EXECUTABLE}"
X "-DCMAKE_CXX_COMPILER=${MINGW_CXX_LINUX2WIN_EXECUTABLE}"
X "-DCMAKE_RC_COMPILER=${MINGW_RC_LINUX2WIN_EXECUTABLE}"
X )
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win")
X endif()
X endif()
X
X if(UNIX)
X string(COMPARE EQUAL "${CMAKE_INSTALL_PREFIX}" "${CMake_BINARY_DIR}/Tests/TestShellInstall/Prefix"
X PREFIX_IS_FOR_TEST)
X if(PREFIX_IS_FOR_TEST)
X configure_file(
X ${CMake_SOURCE_DIR}/Tests/TestInstall.sh.in
X ${CMake_BINARY_DIR}/Tests/TestShellInstall/TestInstall.sh
X @ONLY IMMEDIATE
X )
X add_test(ShellInstall /bin/sh ${CMake_BINARY_DIR}/Tests/TestShellInstall/TestShellInstall.sh)
X endif()
X endif()
X
X if(CMAKE_TEST_PROJECT_CSE_DIR)
X set(script "${CMAKE_TEST_PROJECT_CSE_DIR}/BuildProjectCSE.cmake")
X if(NOT EXISTS "${script}")
X set(script "${CMAKE_TEST_PROJECT_CSE_DIR}/cse_build.cmake")
X endif()
X if(NOT EXISTS "${script}")
X message("warning: CMAKE_TEST_PROJECT_CSE_DIR set, but no build script found...")
X endif()
X
X add_test(BuildCSE ${CMAKE_CTEST_COMMAND} -V -S "${script}")
X set_tests_properties(BuildCSE PROPERTIES TIMEOUT 5400)
X endif()
X
X if(CMAKE_TEST_PLPLOT_DIR)
X add_test(plplot ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_PLPLOT_DIR}/../../EasyDashboardScripts/plplot.cmake )
X set_tests_properties ( plplot PROPERTIES TIMEOUT 5400)
X endif()
X
X if(CMAKE_TEST_CHICKEN_DIR)
X add_test(Chicken ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_CHICKEN_DIR}/../../EasyDashboardScripts/Chicken.cmake )
X set_tests_properties ( Chicken PROPERTIES TIMEOUT 5400)
X endif()
X
X if(CMAKE_TEST_KDELIBS_ALPHA_1_DIR)
X add_test(KDELibsAlpha1 ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_KDELIBS_ALPHA_1_DIR}/../../EasyDashboardScripts/kdelibs.cmake )
X set_tests_properties ( KDELibsAlpha1 PROPERTIES TIMEOUT 5400)
X endif()
X
X # If this is not an in-source build, provide a target to wipe out
X # all the test build directories.
X if(NOT EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt")
X configure_file(${CMake_SOURCE_DIR}/Tests/test_clean.cmake.in
X ${CMake_BINARY_DIR}/Tests/test_clean.cmake @ONLY)
X add_custom_target(test_clean
X COMMAND ${CMAKE_COMMAND} -P ${CMake_BINARY_DIR}/Tests/test_clean.cmake
X COMMENT "Removing test build directories."
X )
X endif()
X
X add_test(CMakeWizardTest ${CMAKE_CMAKE_COMMAND}
X -D build_dir:STRING=${CMAKE_CURRENT_BINARY_DIR}/CMakeWizardTest
X -D source_dir:STRING=${CMAKE_CURRENT_SOURCE_DIR}/Tutorial/Step3
X -D CMAKE_CTEST_COMMAND:STRING=${CMAKE_CTEST_COMMAND}
X -P ${CMAKE_CURRENT_SOURCE_DIR}/CMakeWizardTest.cmake)
X # If the cache variable CMAKE_CONTRACT_PROJECTS is set
X # then the dashboard will run a contract with CMake test of that
X # name. For example CMAKE_CONTRACT_PROJECTS = vtk542 would run
X # the vtk542 contract test.
X # For each Contract test, the project should provide a directory
X # with at least one CMakeLists.txt file that uses ExternalProject
X # to download and configure the project. The directory should also
X # contain a RunTest.cmake file that has a single set of the format:
X # set(project_RUN_TEST testToRun)
X # The testToRun should be a test executable that can be run to
X # smoke test the build.
X foreach(project ${CMAKE_CONTRACT_PROJECTS})
X include(Contracts/${project}/RunTest.cmake)
X ADD_TEST_MACRO(Contracts.${project}
X ${${project}_RUN_TEST})
X # Contract test timeout in seconds.
X # Default to 6 hours.
X if(DEFINED ${project}_TEST_TIMEOUT)
X set(timeout ${${project}_TEST_TIMEOUT})
X elseif(CMAKE_CONTRACT_TEST_TIMEOUT_DEFAULT)
X set(timeout ${CMAKE_CONTRACT_TEST_TIMEOUT_DEFAULT})
X else()
X set(timeout 21600)
X endif()
X set_tests_properties(Contracts.${project} PROPERTIES TIMEOUT ${timeout})
X endforeach()
X
X if(TEST_CompileCommandOutput)
X set(CompileCommandOutput_EXTRA_OPTIONS
X --build-options -DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES})
X ADD_TEST_MACRO(CompileCommandOutput
X "${CMake_BINARY_DIR}/Tests/CMakeLib/runcompilecommands")
X endif()
X
X add_test(IncludeDirectories ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/IncludeDirectories"
X "${CMake_BINARY_DIR}/Tests/IncludeDirectories"
X --build-two-config
X ${build_generator_args}
X --build-project IncludeDirectories
X --test-command IncludeDirectories)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/IncludeDirectories")
X
X add_test(InterfaceLinkLibraries ${CMAKE_CTEST_COMMAND}
X --build-and-test
X "${CMake_SOURCE_DIR}/Tests/InterfaceLinkLibraries"
X "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries"
X --build-two-config
X ${build_generator_args}
X --build-project InterfaceLinkLibraries
X --test-command InterfaceLinkLibraries)
X list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries")
X
X if(CMAKE_USE_KWSTYLE AND KWSTYLE_EXECUTABLE)
X # The "make StyleCheck" command line as a test. If the test fails, look
X # for lines like "Error #0 (624) Line length exceed 88 (max=79)" in the
X # output to find where the style errors are...
X add_test(KWStyle ${KWSTYLE_EXECUTABLE}
X -xml ${CMake_BINARY_DIR}/CMake.kws.xml
X -o ${CMake_SOURCE_DIR}/Utilities/KWStyle/CMakeOverwrite.txt
X -v
X -D ${CMake_BINARY_DIR}/CMakeKWSFiles.txt
X )
X set_tests_properties(KWStyle PROPERTIES
X WORKING_DIRECTORY ${CMake_BINARY_DIR}/Utilities/KWStyle)
X endif()
X
X add_subdirectory(CMakeTests)
Xendif()
74f91ee0c70fa79d4081883c8d574430 -
echo x - Tests/RunCMake/CMakeLists.txt
sed 's/^X//' >Tests/RunCMake/CMakeLists.txt << '19d8511721b6068546d9087df5277aa2 -'
X# This directory contains tests that run CMake to configure a project
X# but do not actually build anything. To add a test:
X#
X# 1.) Add a subdirectory named for the test.
X#
X# 2.) Call add_RunCMake_test and pass the test directory name.
X#
X# 3.) Create a RunCMakeTest.cmake script in the directory containing
X# include(RunCMake)
X# run_cmake(SubTest1)
X# ...
X# run_cmake(SubTestN)
X# where SubTest1..SubTestN are sub-test names each corresponding to
X# an independent CMake run and project configuration.
X#
X# 3.) Create a CMakeLists.txt file in the directory containing
X# cmake_minimum_required(...)
X# project(${RunCMake_TEST} NONE) # or languages needed
X# include(${RunCMake_TEST}.cmake)
X# where "${RunCMake_TEST}" is literal. A value for RunCMake_TEST
X# will be passed to CMake by the run_cmake macro when running each
X# sub-test.
X#
X# 4.) Create a <SubTest>.cmake file for each sub-test named above
X# containing the actual test code. Optionally create files
X# containing expected test results:
X# <SubTest>-result.txt = Process result expected if not "0"
X# <SubTest>-stdout.txt = Regex matching expected stdout content
X# <SubTest>-stderr.txt = Regex matching expected stderr content
X# <SubTest>-check.cmake = Custom result check
X# Note that trailing newlines will be stripped from actual and expected test
X# output before matching against the stdout and stderr expressions.
X# The code in <SubTest>-check.cmake may use variables
X# RunCMake_TEST_SOURCE_DIR = Top of test source tree
X# RunCMake_TEST_BINARY_DIR = Top of test binary tree
X# and an failure must store a message in RunCMake_TEST_FAILED.
X
Xmacro(add_RunCMake_test test)
X add_test(RunCMake.${test} ${CMAKE_CMAKE_COMMAND}
X -DCMAKE_MODULE_PATH=${CMAKE_CURRENT_SOURCE_DIR}
X -DRunCMake_GENERATOR=${CMAKE_TEST_GENERATOR}
X -DRunCMake_GENERATOR_TOOLSET=${CMAKE_TEST_GENERATOR_TOOLSET}
X -DRunCMake_SOURCE_DIR=${CMAKE_CURRENT_SOURCE_DIR}/${test}
X -DRunCMake_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}/${test}
X ${${test}_ARGS}
X -P "${CMAKE_CURRENT_SOURCE_DIR}/${test}/RunCMakeTest.cmake"
X )
Xendmacro()
X
Xif(XCODE_VERSION AND "${XCODE_VERSION}" VERSION_LESS 3)
X set(GeneratorToolset_ARGS -DXCODE_BELOW_3=1)
Xendif()
X
Xadd_RunCMake_test(CMP0019)
Xadd_RunCMake_test(CMP0022)
Xadd_RunCMake_test(CTest)
Xif(UNIX AND "${CMAKE_TEST_GENERATOR}" MATCHES "Unix Makefiles")
X add_RunCMake_test(CompilerChange)
Xendif()
Xadd_RunCMake_test(Configure)
Xadd_RunCMake_test(ExternalData)
Xadd_RunCMake_test(FPHSA)
Xadd_RunCMake_test(GeneratorExpression)
Xadd_RunCMake_test(GeneratorToolset)
Xadd_RunCMake_test(TargetPropertyGeneratorExpressions)
Xadd_RunCMake_test(Languages)
Xadd_RunCMake_test(ObjectLibrary)
Xif(NOT WIN32)
X add_RunCMake_test(PositionIndependentCode)
X set(SKIP_VISIBILITY 0)
X if("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU" AND "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 4.2)
X set(SKIP_VISIBILITY 1)
X endif()
X
X if (CMAKE_CXX_COMPILER_ID MATCHES Watcom
X OR CMAKE_SYSTEM_NAME MATCHES IRIX64
X OR CMAKE_CXX_COMPILER_ID MATCHES HP
X OR CMAKE_CXX_COMPILER_ID MATCHES XL
X OR CMAKE_CXX_COMPILER_ID MATCHES SunPro)
X set(SKIP_VISIBILITY 1)
X endif()
X
X if (NOT SKIP_VISIBILITY)
X add_RunCMake_test(VisibilityPreset)
X endif()
Xendif()
Xadd_RunCMake_test(CompatibleInterface)
Xadd_RunCMake_test(Syntax)
X
Xadd_RunCMake_test(add_dependencies)
Xadd_RunCMake_test(build_command)
Xadd_RunCMake_test(find_package)
Xadd_RunCMake_test(get_filename_component)
Xadd_RunCMake_test(if)
Xadd_RunCMake_test(include)
Xadd_RunCMake_test(include_directories)
Xadd_RunCMake_test(list)
Xadd_RunCMake_test(try_compile)
Xadd_RunCMake_test(variable_watch)
Xadd_RunCMake_test(CMP0004)
Xadd_RunCMake_test(TargetPolicies)
Xadd_RunCMake_test(alias_targets)
X
Xif("${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio [^6]")
X add_RunCMake_test(include_external_msproject)
X add_RunCMake_test(SolutionGlobalSections)
Xendif()
X
Xadd_RunCMake_test(File_Generate)
Xadd_RunCMake_test(ExportWithoutLanguage)
Xadd_RunCMake_test(target_link_libraries)
19d8511721b6068546d9087df5277aa2 -
echo x - Source/CMakeLists.txt
sed 's/^X//' >Source/CMakeLists.txt << 'c45a2e9f253ef0d9c4a3c90a1306ce5d -'
X#=============================================================================
X# CMake - Cross Platform Makefile Generator
X# Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
X#
X# Distributed under the OSI-approved BSD License (the "License");
X# see accompanying file Copyright.txt for details.
X#
X# This software is distributed WITHOUT ANY WARRANTY; without even the
X# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
X# See the License for more information.
X#=============================================================================
Xinclude(CheckIncludeFile)
X# Check if we can build support for ELF parsing.
Xif(CMAKE_CXX_PLATFORM_ID MATCHES "OpenBSD")
X CHECK_INCLUDE_FILES("stdint.h;elf_abi.h" HAVE_ELF_H)
Xelse()
X CHECK_INCLUDE_FILE("elf.h" HAVE_ELF_H)
Xendif()
Xif(HAVE_ELF_H)
X set(CMAKE_USE_ELF_PARSER 1)
Xelse()
X set(CMAKE_USE_ELF_PARSER)
Xendif()
X
Xset(EXECUTABLE_OUTPUT_PATH ${CMake_BIN_DIR})
X
X# configure the .h file
Xconfigure_file(
X "${CMake_SOURCE_DIR}/Source/cmConfigure.cmake.h.in"
X "${CMake_BINARY_DIR}/Source/cmConfigure.h"
X )
Xconfigure_file(
X "${CMake_SOURCE_DIR}/Source/cmVersionConfig.h.in"
X "${CMake_BINARY_DIR}/Source/cmVersionConfig.h"
X )
Xconfigure_file(
X "${CMake_SOURCE_DIR}/Source/CPack/cmCPackConfigure.h.in"
X "${CMake_BINARY_DIR}/Source/CPack/cmCPackConfigure.h"
X )
X
X# add the include path to find the .h
Xinclude_directories(
X "${CMake_BINARY_DIR}/Source"
X "${CMake_SOURCE_DIR}/Source"
X ${CMAKE_ZLIB_INCLUDES}
X ${CMAKE_EXPAT_INCLUDES}
X ${CMAKE_TAR_INCLUDES}
X ${CMAKE_COMPRESS_INCLUDES}
X )
X
X# let cmake know it is supposed to use it
Xadd_definitions(-DCMAKE_BUILD_WITH_CMAKE)
X
Xoption(CMAKE_REGENERATE_YACCLEX
X "Regenerate YACC and LEXX files" OFF)
Xmark_as_advanced(CMAKE_REGENERATE_YACCLEX)
Xif(CMAKE_REGENERATE_YACCLEX)
X set(parsersLexers cmDependsFortran cmCommandArgument cmExpr)
X find_program(YACC_EXECUTABLE
X NAMES yacc bison
X PATHS /usr/bin
X DOC "Yacc or Bison executable")
X find_program(FLEX_EXECUTABLE
X NAMES flex
X PATHS /usr/bin
X DOC "Flex executable")
X mark_as_advanced(YACC_EXECUTABLE FLEX_EXECUTABLE)
X if(YACC_EXECUTABLE)
X set(BISON_FLAGS)
X if(YACC_EXECUTABLE MATCHES "bison")
X set(BISON_FLAGS "--yacc")
X endif()
X set(yacc_files)
X foreach(name ${parsersLexers})
X set(src "${CMAKE_CURRENT_SOURCE_DIR}/${name}Parser.y")
X set(dst "${CMAKE_CURRENT_BINARY_DIR}/${name}Parser.cxx")
X set(hdr "${CMAKE_CURRENT_BINARY_DIR}/${name}ParserTokens.h")
X add_custom_command(
X OUTPUT "${dst}"
X DEPENDS "${src}"
X COMMAND
X ${YACC_EXECUTABLE}
X --name-prefix=${name}_yy --defines=${hdr} -o${dst} ${src}
X )
X set(yacc_files ${yacc_files} "${dst}")
X endforeach()
X add_custom_target(RerunYacc DEPENDS ${yacc_files})
X endif()
X if(FLEX_EXECUTABLE)
X set(lex_files)
X foreach(name ${parsersLexers})
X set(src "${CMAKE_CURRENT_SOURCE_DIR}/${name}Lexer.in.l")
X set(dst "${CMAKE_CURRENT_BINARY_DIR}/${name}Lexer.cxx")
X set(hdr "${CMAKE_CURRENT_BINARY_DIR}/${name}Lexer.h")
X add_custom_command(
X OUTPUT "${dst}"
X DEPENDS "${src}"
X COMMAND
X ${FLEX_EXECUTABLE}
X --prefix=${name}_yy --header-file=${hdr} -o${dst} ${src}
X )
X set(lex_files ${lex_files} "${dst}")
X endforeach()
X add_custom_target(RerunLex DEPENDS ${lex_files})
X endif()
X
Xendif()
X
X# Check if we can build the ELF parser.
Xif(CMAKE_USE_ELF_PARSER)
X set(ELF_SRCS cmELF.h cmELF.cxx)
Xendif()
X
X#
X# Sources for CMakeLib
X#
Xset(SRCS
X cmStandardIncludes.cxx
X cmArchiveWrite.cxx
X cmBootstrapCommands1.cxx
X cmBootstrapCommands2.cxx
X cmCacheManager.cxx
X cmCacheManager.h
X cmCommands.cxx
X cmCommands.h
X cmCommandArgumentLexer.cxx
X cmCommandArgumentParser.cxx
X cmCommandArgumentParserHelper.cxx
X cmComputeComponentGraph.cxx
X cmComputeComponentGraph.h
X cmComputeLinkDepends.cxx
X cmComputeLinkDepends.h
X cmComputeLinkInformation.cxx
X cmComputeLinkInformation.h
X cmComputeTargetDepends.h
X cmComputeTargetDepends.cxx
X cmCryptoHash.cxx
X cmCryptoHash.h
X cmCustomCommand.cxx
X cmCustomCommand.h
X cmCustomCommandGenerator.cxx
X cmCustomCommandGenerator.h
X cmDefinitions.cxx
X cmDefinitions.h
X cmDepends.cxx
X cmDepends.h
X cmDependsC.cxx
X cmDependsC.h
X cmDependsFortran.cxx
X cmDependsFortran.h
X cmDependsFortranLexer.cxx
X cmDependsFortranParser.cxx
X cmDependsFortranParser.h
X cmDependsJava.cxx
X cmDependsJava.h
X cmDependsJavaLexer.cxx
X cmDependsJavaParser.cxx
X cmDependsJavaParserHelper.cxx
X cmDependsJavaParserHelper.h
X cmDocumentation.cxx
X cmDocumentationFormatter.cxx
X cmDocumentationFormatterHTML.cxx
X cmDocumentationFormatterDocbook.cxx
X cmDocumentationFormatterMan.cxx
X cmDocumentationFormatterText.cxx
X cmDocumentationFormatterUsage.cxx
X cmDocumentationSection.cxx
X cmDocumentCompileDefinitions.h
X cmDocumentGeneratorExpressions.h
X cmDocumentLocationUndefined.h
X cmDocumentVariables.cxx
X cmDynamicLoader.cxx
X cmDynamicLoader.h
X ${ELF_SRCS}
X cmExprLexer.cxx
X cmExprParser.cxx
X cmExprParserHelper.cxx
X cmExportBuildFileGenerator.h
X cmExportBuildFileGenerator.cxx
X cmExportFileGenerator.h
X cmExportFileGenerator.cxx
X cmExportInstallFileGenerator.h
X cmExportInstallFileGenerator.cxx
X cmExportTryCompileFileGenerator.h
X cmExportTryCompileFileGenerator.cxx
X cmExportSet.h
X cmExportSet.cxx
X cmExportSetMap.h
X cmExportSetMap.cxx
X cmExtraCodeBlocksGenerator.cxx
X cmExtraCodeBlocksGenerator.h
X cmExtraEclipseCDT4Generator.cxx
X cmExtraEclipseCDT4Generator.h
X cmExtraSublimeTextGenerator.cxx
X cmExtraSublimeTextGenerator.h
X cmFileTimeComparison.cxx
X cmFileTimeComparison.h
X cmGeneratedFileStream.cxx
X cmGeneratorExpressionDAGChecker.cxx
X cmGeneratorExpressionDAGChecker.h
X cmGeneratorExpressionEvaluator.cxx
X cmGeneratorExpressionEvaluator.h
X cmGeneratorExpressionLexer.cxx
X cmGeneratorExpressionLexer.h
X cmGeneratorExpressionParser.cxx
X cmGeneratorExpressionParser.h
X cmGeneratorExpression.cxx
X cmGeneratorExpression.h
X cmGeneratorTarget.cxx
X cmGeneratorTarget.h
X cmGlobalGenerator.cxx
X cmGlobalGenerator.h
X cmGlobalGeneratorFactory.h
X cmGlobalUnixMakefileGenerator3.cxx
X cmGlobalUnixMakefileGenerator3.h
X cmGraphAdjacencyList.h
X cmGraphVizWriter.cxx
X cmGraphVizWriter.h
X cmInstallGenerator.h
X cmInstallGenerator.cxx
X cmInstallExportGenerator.cxx
X cmInstallFilesGenerator.h
X cmInstallFilesGenerator.cxx
X cmInstallScriptGenerator.h
X cmInstallScriptGenerator.cxx
X cmInstallTargetGenerator.h
X cmInstallTargetGenerator.cxx
X cmInstallDirectoryGenerator.h
X cmInstallDirectoryGenerator.cxx
X cmListFileCache.cxx
X cmListFileCache.h
X cmListFileLexer.c
X cmLocalGenerator.cxx
X cmLocalGenerator.h
X cmLocalUnixMakefileGenerator3.cxx
X cmMakeDepend.cxx
X cmMakeDepend.h
X cmMakefile.cxx
X cmMakefile.h
X cmMakefileTargetGenerator.cxx
X cmMakefileExecutableTargetGenerator.cxx
X cmMakefileLibraryTargetGenerator.cxx
X cmMakefileUtilityTargetGenerator.cxx
X cmOSXBundleGenerator.cxx
X cmOSXBundleGenerator.h
X cmNewLineStyle.h
X cmNewLineStyle.cxx
X cmOrderDirectories.cxx
X cmOrderDirectories.h
X cmPolicies.h
X cmPolicies.cxx
X cmProcessTools.cxx
X cmProcessTools.h
X cmProperty.cxx
X cmProperty.h
X cmPropertyDefinition.cxx
X cmPropertyDefinition.h
X cmPropertyDefinitionMap.cxx
X cmPropertyDefinitionMap.h
X cmPropertyMap.cxx
X cmPropertyMap.h
X cmQtAutomoc.cxx
X cmQtAutomoc.h
X cmScriptGenerator.h
X cmScriptGenerator.cxx
X cmSourceFile.cxx
X cmSourceFile.h
X cmSourceFileLocation.cxx
X cmSourceFileLocation.h
X cmSourceGroup.cxx
X cmSourceGroup.h
X cmSystemTools.cxx
X cmSystemTools.h
X cmTarget.cxx
X cmTarget.h
X cmTargetExport.h
X cmTest.cxx
X cmTest.h
X cmTestGenerator.cxx
X cmTestGenerator.h
X cmVariableWatch.cxx
X cmVariableWatch.h
X cmVersion.cxx
X cmVersion.h
X cmXMLParser.cxx
X cmXMLParser.h
X cmXMLSafe.cxx
X cmXMLSafe.h
X cmake.cxx
X cmake.h
X cmakewizard.cxx
X cmakewizard.h
X
X cm_sha2.h
X cm_sha2.c
X cm_utf8.h
X cm_utf8.c
X )
X
X# Kdevelop only works on UNIX and not windows
Xif(UNIX)
X set(SRCS ${SRCS} cmGlobalKdevelopGenerator.cxx)
Xendif()
X
X# Xcode only works on Apple
Xif(APPLE)
X set(SRCS ${SRCS}
X cmXCodeObject.cxx
X cmXCode21Object.cxx
X cmGlobalXCodeGenerator.cxx
X cmGlobalXCodeGenerator.h
X cmLocalXCodeGenerator.cxx
X cmLocalXCodeGenerator.h)
Xendif()
X
X
Xif (WIN32)
X set(SRCS ${SRCS}
X cmCallVisualStudioMacro.cxx
X cmCallVisualStudioMacro.h
X )
X
X if(NOT UNIX)
X set(SRCS ${SRCS}
X cmGlobalBorlandMakefileGenerator.cxx
X cmGlobalBorlandMakefileGenerator.h
X cmGlobalMSYSMakefileGenerator.cxx
X cmGlobalMinGWMakefileGenerator.cxx
X cmGlobalNMakeMakefileGenerator.cxx
X cmGlobalNMakeMakefileGenerator.h
X cmGlobalJOMMakefileGenerator.cxx
X cmGlobalJOMMakefileGenerator.h
X cmGlobalVisualStudio6Generator.cxx
X cmGlobalVisualStudio6Generator.h
X cmGlobalVisualStudio71Generator.cxx
X cmGlobalVisualStudio71Generator.h
X cmGlobalVisualStudio7Generator.cxx
X cmGlobalVisualStudio7Generator.h
X cmGlobalVisualStudio8Generator.cxx
X cmGlobalVisualStudio8Generator.h
X cmGlobalVisualStudio9Generator.cxx
X cmGlobalVisualStudio9Generator.h
X cmVisualStudioGeneratorOptions.h
X cmVisualStudioGeneratorOptions.cxx
X cmVisualStudio10TargetGenerator.h
X cmVisualStudio10TargetGenerator.cxx
X cmLocalVisualStudio10Generator.cxx
X cmLocalVisualStudio10Generator.h
X cmGlobalVisualStudio10Generator.h
X cmGlobalVisualStudio10Generator.cxx
X cmGlobalVisualStudio11Generator.h
X cmGlobalVisualStudio11Generator.cxx
X cmGlobalVisualStudio12Generator.h
X cmGlobalVisualStudio12Generator.cxx
X cmGlobalVisualStudioGenerator.cxx
X cmGlobalVisualStudioGenerator.h
X cmGlobalWatcomWMakeGenerator.cxx
X cmIDEFlagTable.h
X cmIDEOptions.cxx
X cmIDEOptions.h
X cmLocalVisualStudio6Generator.cxx
X cmLocalVisualStudio6Generator.h
X cmLocalVisualStudio7Generator.cxx
X cmLocalVisualStudio7Generator.h
X cmLocalVisualStudioGenerator.cxx
X cmLocalVisualStudioGenerator.h
X cmVisualStudioSlnData.h
X cmVisualStudioSlnData.cxx
X cmVisualStudioSlnParser.h
X cmVisualStudioSlnParser.cxx
X cmVisualStudioWCEPlatformParser.h
X cmVisualStudioWCEPlatformParser.cxx
X cmWin32ProcessExecution.cxx
X cmWin32ProcessExecution.h
X )
X endif()
Xendif ()
X
X# Ninja support
Xset(SRCS ${SRCS}
X cmGlobalNinjaGenerator.cxx
X cmGlobalNinjaGenerator.h
X cmNinjaTypes.h
X cmLocalNinjaGenerator.cxx
X cmLocalNinjaGenerator.h
X cmNinjaTargetGenerator.cxx
X cmNinjaTargetGenerator.h
X cmNinjaNormalTargetGenerator.cxx
X cmNinjaNormalTargetGenerator.h
X cmNinjaUtilityTargetGenerator.cxx
X cmNinjaUtilityTargetGenerator.h
X )
Xif(WIN32 AND NOT CYGWIN AND NOT BORLAND)
X set_source_files_properties(cmcldeps.cxx PROPERTIES COMPILE_DEFINITIONS _WIN32_WINNT=0x0501)
X add_executable(cmcldeps cmcldeps.cxx)
X target_link_libraries(cmcldeps CMakeLib)
X install(TARGETS cmcldeps DESTINATION bin)
Xendif()
X
X# create a library used by the command line and the GUI
Xadd_library(CMakeLib ${SRCS})
Xtarget_link_libraries(CMakeLib cmsys
X ${CMAKE_EXPAT_LIBRARIES} ${CMAKE_ZLIB_LIBRARIES}
X ${CMAKE_TAR_LIBRARIES} ${CMAKE_COMPRESS_LIBRARIES}
X ${CMAKE_CURL_LIBRARIES} )
X
X# On Apple we need CoreFoundation
Xif(APPLE)
X target_link_libraries(CMakeLib "-framework CoreFoundation")
Xendif()
X
X# On some platforms we need the rpcrt4 library for the VS 7 generators.
Xif(CMAKE_BUILD_ON_VISUAL_STUDIO OR MINGW)
X target_link_libraries(CMakeLib rpcrt4)
Xendif()
X
X#
X# CTestLib
X#
Xinclude_directories(
X "${CMake_SOURCE_DIR}/Source/CTest"
X ${CMAKE_XMLRPC_INCLUDES}
X ${CMAKE_CURL_INCLUDES}
X )
X#
X# Sources for CTestLib
X#
Xset(CTEST_SRCS cmCTest.cxx
X CTest/cmProcess.cxx
X CTest/cmCTestBatchTestHandler.cxx
X CTest/cmCTestBuildAndTestHandler.cxx
X CTest/cmCTestBuildCommand.cxx
X CTest/cmCTestBuildHandler.cxx
X CTest/cmCTestConfigureCommand.cxx
X CTest/cmCTestConfigureHandler.cxx
X CTest/cmCTestCoverageCommand.cxx
X CTest/cmCTestCoverageHandler.cxx
X CTest/cmParseMumpsCoverage.cxx
X CTest/cmParseCacheCoverage.cxx
X CTest/cmParseGTMCoverage.cxx
X CTest/cmParsePHPCoverage.cxx
X CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
X CTest/cmCTestGenericHandler.cxx
X CTest/cmCTestHandlerCommand.cxx
X CTest/cmCTestLaunch.cxx
X CTest/cmCTestMemCheckCommand.cxx
X CTest/cmCTestMemCheckHandler.cxx
X CTest/cmCTestMultiProcessHandler.cxx
X CTest/cmCTestReadCustomFilesCommand.cxx
X CTest/cmCTestRunScriptCommand.cxx
X CTest/cmCTestRunTest.cxx
X CTest/cmCTestScriptHandler.cxx
X CTest/cmCTestSleepCommand.cxx
X CTest/cmCTestStartCommand.cxx
X CTest/cmCTestSubmitCommand.cxx
X CTest/cmCTestSubmitHandler.cxx
X CTest/cmCTestTestCommand.cxx
X CTest/cmCTestTestHandler.cxx
X CTest/cmCTestUpdateCommand.cxx
X CTest/cmCTestUpdateHandler.cxx
X CTest/cmCTestUploadCommand.cxx
X CTest/cmCTestUploadHandler.cxx
X
X CTest/cmCTestVC.cxx
X CTest/cmCTestVC.h
X CTest/cmCTestGlobalVC.cxx
X CTest/cmCTestGlobalVC.h
X CTest/cmCTestCVS.cxx
X CTest/cmCTestCVS.h
X CTest/cmCTestSVN.cxx
X CTest/cmCTestSVN.h
X CTest/cmCTestBZR.cxx
X CTest/cmCTestBZR.h
X CTest/cmCTestGIT.cxx
X CTest/cmCTestGIT.h
X CTest/cmCTestHG.cxx
X CTest/cmCTestHG.h
X )
X
X# Build CTestLib
Xadd_library(CTestLib ${CTEST_SRCS})
Xtarget_link_libraries(CTestLib CMakeLib ${CMAKE_CURL_LIBRARIES} ${CMAKE_XMLRPC_LIBRARIES})
X
X#
X# Sources for CPack
X#
Xset(CPACK_SRCS
X CPack/cmCPackArchiveGenerator.cxx
X CPack/cmCPackComponentGroup.cxx
X CPack/cmCPackGeneratorFactory.cxx
X CPack/cmCPackGenerator.cxx
X CPack/cmCPackLog.cxx
X CPack/cmCPackNSISGenerator.cxx
X CPack/cmCPackSTGZGenerator.cxx
X CPack/cmCPackTGZGenerator.cxx
X CPack/cmCPackTarBZip2Generator.cxx
X CPack/cmCPackTarCompressGenerator.cxx
X CPack/cmCPackZIPGenerator.cxx
X CPack/cmCPackDocumentVariables.cxx
X CPack/cmCPackDocumentMacros.cxx
X )
X
Xif(CYGWIN)
X set(CPACK_SRCS ${CPACK_SRCS}
X CPack/cmCPackCygwinBinaryGenerator.cxx
X CPack/cmCPackCygwinSourceGenerator.cxx
X )
Xendif()
X
Xif(UNIX)
X set(CPACK_SRCS ${CPACK_SRCS}
X CPack/cmCPackDebGenerator.cxx
X CPack/cmCPackRPMGenerator.cxx
X )
Xendif()
X
Xif(WIN32)
X set(CPACK_SRCS ${CPACK_SRCS}
X CPack/WiX/cmCPackWIXGenerator.cxx
X CPack/WiX/cmWIXSourceWriter.cxx
X CPack/WiX/cmWIXRichTextFormatWriter.cxx
X )
Xendif()
X
Xif(APPLE)
X set(CPACK_SRCS ${CPACK_SRCS}
X CPack/cmCPackBundleGenerator.cxx
X CPack/cmCPackDragNDropGenerator.cxx
X CPack/cmCPackOSXX11Generator.cxx
X CPack/cmCPackPackageMakerGenerator.cxx
X )
Xendif()
X
X# Build CPackLib
Xadd_library(CPackLib ${CPACK_SRCS})
Xtarget_link_libraries(CPackLib CMakeLib)
X
Xif(APPLE)
X add_executable(cmakexbuild cmakexbuild.cxx)
X target_link_libraries(cmakexbuild CMakeLib)
X add_executable(OSXScriptLauncher
X CPack/OSXScriptLauncher.cxx)
X target_link_libraries(OSXScriptLauncher cmsys)
X target_link_libraries(OSXScriptLauncher "-framework CoreFoundation")
Xendif()
X
X# Build CMake executable
Xadd_executable(cmake cmakemain.cxx)
Xtarget_link_libraries(cmake CMakeLib)
X
X# Build special executable for running programs on Windows 98.
X# Included on any Windows (unconditional packaging required!).
Xif(WIN32)
X if(NOT UNIX)
X add_executable(cmw9xcom cmw9xcom.cxx)
X target_link_libraries(cmw9xcom CMakeLib)
X install(TARGETS cmw9xcom DESTINATION bin)
X endif()
Xendif()
X
X# Build CTest executable
Xadd_executable(ctest ctest.cxx)
Xtarget_link_libraries(ctest CTestLib)
X
X# Build CPack executable
Xadd_executable(cpack CPack/cpack.cxx)
Xtarget_link_libraries(cpack CPackLib)
X
X# Curses GUI
Xif(BUILD_CursesDialog)
X include(${CMake_SOURCE_DIR}/Source/CursesDialog/CMakeLists.txt)
Xendif()
X
Xinclude (${CMake_BINARY_DIR}/Source/LocalUserOptions.cmake OPTIONAL)
Xinclude (${CMake_SOURCE_DIR}/Source/LocalUserOptions.cmake OPTIONAL)
X
Xinstall(TARGETS cmake ctest cpack DESTINATION bin)
Xif(APPLE)
X install(TARGETS cmakexbuild DESTINATION bin)
Xendif()
X
Xinstall(FILES cmCPluginAPI.h DESTINATION ${CMAKE_DATA_DIR}/include)
c45a2e9f253ef0d9c4a3c90a1306ce5d -
exit
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment