CMake/Tests/CMakeLists.txt

1604 lines
65 KiB
CMake
Raw Normal View History

2007-05-11 18:22:20 +04:00
# a macro for tests that have a simple format where the name matches the
# directory and project
MACRO(ADD_TEST_MACRO NAME COMMAND)
2007-05-11 18:22:20 +04:00
ADD_TEST(${NAME} ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/${NAME}"
"${CMake_BINARY_DIR}/Tests/${NAME}"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project ${NAME}
--test-command ${COMMAND})
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${NAME}")
2007-05-11 18:22:20 +04:00
ENDMACRO(ADD_TEST_MACRO)
# Fake a user home directory to avoid polluting the real one.
IF(DEFINED ENV{HOME} AND NOT CTEST_NO_TEST_HOME)
SET(TEST_HOME "${CMake_BINARY_DIR}/Tests/CMakeFiles/TestHome")
FILE(MAKE_DIRECTORY "${TEST_HOME}")
FILE(WRITE "${TEST_HOME}/.cvspass" ":pserver:anoncvs@www.cmake.org:/cvsroot/KWSys A\n")
SET(TEST_HOME_ENV_CODE "# Fake a user home directory to avoid polluting the real one.
SET(ENV{HOME} \"${TEST_HOME}\")")
ENDIF()
# Choose a default configuration for CTest tests.
SET(CTestTest_CONFIG Debug)
IF(NOT CMAKE_CONFIGURATION_TYPES AND CMAKE_BUILD_TYPE)
SET(CTestTest_CONFIG ${CMAKE_BUILD_TYPE})
ENDIF()
# Make sure the 'testing' test gets a proper configuration.
CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/EnforceConfig.cmake.in
${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake @ONLY)
SET_DIRECTORY_PROPERTIES(PROPERTIES
TEST_INCLUDE_FILE "${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake"
)
# Testing
IF(BUILD_TESTING)
# Collect a list of all test build directories.
SET(TEST_BUILD_DIRS)
# Should the long tests be run?
OPTION(CMAKE_RUN_LONG_TESTS
"Should the long tests be run (such as Bootstrap)." ON)
MARK_AS_ADVANCED(CMAKE_RUN_LONG_TESTS)
IF (CMAKE_RUN_LONG_TESTS)
OPTION(CTEST_TEST_CTEST
"Should the tests that run a full sub ctest process be run?"
OFF)
MARK_AS_ADVANCED(CTEST_TEST_CTEST)
OPTION(TEST_KDE4_STABLE_BRANCH
"Should the KDE4 stable branch test be run?"
OFF)
MARK_AS_ADVANCED(TEST_KDE4_STABLE_BRANCH)
ENDIF (CMAKE_RUN_LONG_TESTS)
# Should tests that use CVS be run?
#
set(do_cvs_tests 0)
if(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
find_package(CVS QUIET)
else(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
find_program(CVS_EXECUTABLE NAMES cvs)
endif(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
if(CVS_EXECUTABLE)
set(do_cvs_tests 1)
endif(CVS_EXECUTABLE)
if(do_cvs_tests AND NOT UNIX)
if("${CVS_EXECUTABLE}" MATCHES "cygwin")
set(do_cvs_tests 0)
endif("${CVS_EXECUTABLE}" MATCHES "cygwin")
endif(do_cvs_tests AND NOT UNIX)
# Should CPack tests be run? By default, yes, but...
#
# Disable packaging test on Apple 10.3 and below. PackageMaker starts
# DiskManagementTool as root and disowns it
# (http://lists.apple.com/archives/installer-dev/2005/Jul/msg00005.html).
# It is left holding open pipe handles and preventing ProcessUNIX from
# detecting end-of-data even after its immediate child exits. Then
# the test hangs until it times out and is killed. This is a
# well-known bug in kwsys process execution that I would love to get
# time to fix.
#
OPTION(CTEST_TEST_CPACK
"Should the tests that use '--build-target package' be run?"
ON)
MARK_AS_ADVANCED(CTEST_TEST_CPACK)
SET(CTEST_TEST_OSX_ARCH 0)
IF(APPLE)
EXECUTE_PROCESS(
COMMAND sw_vers -productVersion
OUTPUT_VARIABLE OSX_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE
)
IF(OSX_VERSION MATCHES "^10\\.[0123]" OR OSX_VERSION MATCHES "ProductVersion:\t10\\.[0123]")
MESSAGE(STATUS "Forcing CTEST_TEST_CPACK=OFF on OSX < 10.4")
MESSAGE(STATUS "OSX_VERSION='${OSX_VERSION}'")
SET(CTEST_TEST_CPACK OFF)
ELSE(OSX_VERSION MATCHES "^10\\.[0123]" OR OSX_VERSION MATCHES "ProductVersion:\t10\\.[0123]")
SET(CTEST_TEST_OSX_ARCH 1)
ENDIF(OSX_VERSION MATCHES "^10\\.[0123]" OR OSX_VERSION MATCHES "ProductVersion:\t10\\.[0123]")
ENDIF(APPLE)
# Use 1500 or CTEST_TEST_TIMEOUT for long test timeout value,
# whichever is greater.
SET(CMAKE_LONG_TEST_TIMEOUT 1500)
IF(CTEST_TEST_TIMEOUT)
SET(CMAKE_LONG_TEST_TIMEOUT ${CTEST_TEST_TIMEOUT})
ENDIF(CTEST_TEST_TIMEOUT)
IF(CMAKE_LONG_TEST_TIMEOUT LESS 1500)
SET(CMAKE_LONG_TEST_TIMEOUT 1500)
ENDIF(CMAKE_LONG_TEST_TIMEOUT LESS 1500)
# add a bunch of standard build-and-test style tests
2007-05-11 18:22:20 +04:00
ADD_TEST_MACRO(CommandLineTest CommandLineTest)
ADD_TEST_MACRO(FindPackageTest FindPackageTest)
2008-06-17 18:51:37 +04:00
ADD_TEST_MACRO(FindModulesExecuteAll FindModulesExecuteAll)
2007-05-11 18:22:20 +04:00
ADD_TEST_MACRO(StringFileTest StringFileTest)
ADD_TEST_MACRO(TryCompile TryCompile)
ADD_TEST_MACRO(TarTest TarTest)
ADD_TEST_MACRO(SystemInformation SystemInformation)
ADD_TEST_MACRO(MathTest MathTest)
ADD_TEST_MACRO(Simple Simple)
ADD_TEST_MACRO(PreOrder PreOrder)
ADD_TEST_MACRO(COnly COnly)
ADD_TEST_MACRO(CxxOnly CxxOnly)
ADD_TEST_MACRO(IPO COnly/COnly)
ADD_TEST_MACRO(OutDir runtime/OutDir)
2007-05-11 18:22:20 +04:00
ADD_TEST_MACRO(NewlineArgs NewlineArgs)
ADD_TEST_MACRO(SetLang SetLang)
ADD_TEST_MACRO(ExternalOBJ ExternalOBJ)
ADD_TEST_MACRO(LoadCommand LoadedCommand)
ADD_TEST_MACRO(LinkDirectory bin/LinkDirectory)
ADD_TEST_MACRO(LinkLanguage LinkLanguage)
ADD_TEST_MACRO(LinkLine LinkLine)
ADD_TEST_MACRO(MacroTest miniMacroTest)
2007-12-03 21:35:41 +03:00
ADD_TEST_MACRO(FunctionTest miniFunctionTest)
ADD_TEST_MACRO(ReturnTest ReturnTest)
ADD_TEST_MACRO(Properties Properties)
2007-07-05 17:05:40 +04:00
ADD_TEST_MACRO(Assembler HelloAsm)
ADD_TEST_MACRO(SourceGroups SourceGroups)
ADD_TEST_MACRO(Preprocess Preprocess)
ADD_TEST_MACRO(ExportImport ExportImport)
ADD_TEST_MACRO(Unset Unset)
ADD_TEST_MACRO(PolicyScope PolicyScope)
ADD_TEST_MACRO(CrossCompile CrossCompile)
SET_TESTS_PROPERTIES(CrossCompile PROPERTIES
PASS_REGULAR_EXPRESSION "TRY_RUN.. invoked in cross-compiling mode")
IF("${CMAKE_TEST_GENERATOR}" MATCHES "Make")
ADD_TEST_MACRO(Policy0002 Policy0002)
ENDIF("${CMAKE_TEST_GENERATOR}" MATCHES "Make")
IF(CTEST_TEST_OSX_ARCH)
ADD_TEST_MACRO(Architecture Architecture)
SET_TESTS_PROPERTIES(Architecture PROPERTIES
PASS_REGULAR_EXPRESSION "(file is not of required architecture|does not match cputype)")
ENDIF(CTEST_TEST_OSX_ARCH)
SET(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/COnly")
SET(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/CMakeBuildCOnly")
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
"${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake" @ONLY)
ADD_TEST(CMakeBuildTest ${CMAKE_CMAKE_COMMAND} -P
"${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake")
LIST(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
# If we are running right now with a UnixMakefiles based generator,
# build the "Simple" test with the ExtraGenerators, if available
# This doesn't test whether the generated project files work (unfortunately),
# mainly it tests that cmake doesn't crash when generating these project files.
IF(${CMAKE_TEST_GENERATOR} MATCHES "Unix Makefiles" OR ${CMAKE_TEST_GENERATOR} MATCHES "KDevelop")
# check which generators we have
EXEC_PROGRAM(${CMAKE_CMAKE_COMMAND} ARGS --help OUTPUT_VARIABLE cmakeOutput )
# check for the Eclipse generator
IF ("${cmakeOutput}" MATCHES Eclipse)
ADD_TEST(Simple_EclipseGenerator ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Simple"
"${CMake_BINARY_DIR}/Tests/Simple_EclipseGenerator"
--build-two-config
--build-generator "Eclipse CDT4 - Unix Makefiles"
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project Simple
--test-command Simple)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_EclipseGenerator")
ENDIF ("${cmakeOutput}" MATCHES Eclipse)
# check for the CodeBlocks generator
IF ("${cmakeOutput}" MATCHES CodeBlocks)
ADD_TEST(Simple_CodeBlocksGenerator ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Simple"
"${CMake_BINARY_DIR}/Tests/Simple_CodeBlocksGenerator"
--build-two-config
--build-generator "CodeBlocks - Unix Makefiles"
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project Simple
--test-command Simple)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_CodeBlocksGenerator")
ENDIF ("${cmakeOutput}" MATCHES CodeBlocks)
# check for the KDevelop3 generator
IF ("${cmakeOutput}" MATCHES KDevelop3)
ADD_TEST(Simple_KDevelop3Generator ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Simple"
"${CMake_BINARY_DIR}/Tests/Simple_KDevelop3Generator"
--build-two-config
--build-generator "KDevelop3 - Unix Makefiles"
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project Simple
--test-command Simple)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_KDevelop3Generator")
2008-08-07 01:43:34 +04:00
ENDIF ("${cmakeOutput}" MATCHES KDevelop3)
ENDIF(${CMAKE_TEST_GENERATOR} MATCHES "Unix Makefiles" OR ${CMAKE_TEST_GENERATOR} MATCHES "KDevelop")
# test for correct sub-project generation
# not implemented in VS6 or Xcode
IF(NOT MSVC60 AND NOT XCODE AND NOT MSVC70)
# run cmake and configure all of SubProject
# but only build the independent executable car
ADD_TEST(SubProject ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SubProject"
"${CMake_BINARY_DIR}/Tests/SubProject"
--build-project SubProject
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-target car
--test-command car
)
# For stage 2, do not run cmake again.
# Then build the foo sub project which should build
# the bar library which should be referenced because
# foo links to the static library bar, but bar is not
# directly in the foo sub project
ADD_TEST(SubProject-Stage2 ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SubProject/foo"
"${CMake_BINARY_DIR}/Tests/SubProject/foo"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-nocmake
--build-project foo
--build-target foo
--test-command foo
)
SET_TESTS_PROPERTIES ( SubProject-Stage2 PROPERTIES DEPENDS SubProject)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubProject")
ENDIF(NOT MSVC60 AND NOT XCODE AND NOT MSVC70)
2007-11-06 22:11:00 +03:00
IF (CMAKE_STRICT)
ADD_TEST_MACRO(DocTest DocTest)
ENDIF (CMAKE_STRICT)
# macro to add a test that will build a nightly release
# of CMake for given platform using the release scripts
MACRO(ADD_NIGHTLY_BUILD_TEST name script)
SET(_TEST_DIR "${CMake_BINARY_DIR}/Tests/${name}")
FILE(MAKE_DIRECTORY "${_TEST_DIR}")
FILE(WRITE "${_TEST_DIR}/nightly-cmake.sh"
"cd ${_TEST_DIR}
${CMake_BINARY_DIR}/bin/cmake -DCMAKE_CREATE_VERSION=CVS -P ${CMake_SOURCE_DIR}/Utilities/Release/${script}
${CMake_BINARY_DIR}/bin/cmake -DVERSION=CVS -P ${CMake_SOURCE_DIR}/Utilities/Release/upload_release.cmake
")
ADD_TEST(${name} /bin/sh ${_TEST_DIR}/nightly-cmake.sh)
IF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY)
SET_TESTS_PROPERTIES (${name} PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
ENDIF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY)
ENDMACRO(ADD_NIGHTLY_BUILD_TEST)
IF(CMAKE_BUILD_NIGHTLY_RELEASES)
ADD_NIGHTLY_BUILD_TEST(CMakeNightlyWindows
dash2win64_release.cmake)
ADD_NIGHTLY_BUILD_TEST(CMakeNightlyMac
dashmacmini2_release.cmake)
ADD_NIGHTLY_BUILD_TEST(CMakeNightlyLinux
magrathea_release.cmake)
ENDIF(CMAKE_BUILD_NIGHTLY_RELEASES)
# add tests with more complex invocations
ADD_TEST(Framework ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Framework"
"${CMake_BINARY_DIR}/Tests/Framework"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project Framework
--build-options
"-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/Framework/Install"
--test-command bar)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Framework")
ADD_TEST(TargetName ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/TargetName"
"${CMake_BINARY_DIR}/Tests/TargetName"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project TargetName
--test-command ${CMAKE_CMAKE_COMMAND} -E compare_files
${CMake_SOURCE_DIR}/Tests/TargetName/scripts/hello_world
${CMake_BINARY_DIR}/Tests/TargetName/scripts/hello_world)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TargetName")
ADD_TEST(LibName ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LibName"
"${CMake_BINARY_DIR}/Tests/LibName"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project LibName
--build-exe-dir "${CMake_BINARY_DIR}/Tests/LibName/lib"
--test-command foobar
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LibName")
ADD_TEST(CustComDepend ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CustComDepend"
"${CMake_BINARY_DIR}/Tests/CustComDepend"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project CustComDepend
--build-exe-dir "${CMake_BINARY_DIR}/Tests/CustComDepend/bin"
--test-command foo bar.c
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustComDepend")
ADD_TEST(CustomCommand ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CustomCommand"
"${CMake_BINARY_DIR}/Tests/CustomCommand"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project CustomCommand
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/CustomCommand/bin"
--test-command CustomCommand
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommand")
ADD_TEST(CustomCommandWorkingDirectory ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CustomCommandWorkingDirectory"
"${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project TestWorkingDir
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--test-command working
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory")
2007-05-11 20:17:27 +04:00
#ADD_TEST(SimpleExclude ${CMAKE_CTEST_COMMAND}
# --build-and-test
# "${CMake_SOURCE_DIR}/Tests/SimpleExclude"
# "${CMake_BINARY_DIR}/Tests/SimpleExclude"
# --build-generator ${CMAKE_TEST_GENERATOR}
# --build-project SimpleExclude
# --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
# --build-two-config
# --test-command t4
#--test-command "${CMAKE_COMMAND}"
#"-DCONFIGURATION=\${CTEST_CONFIGURATION_TYPE}"
#-P "${CMAKE_BINARY_DIR}/Tests/SimpleExclude/run.cmake"
2007-05-11 20:17:27 +04:00
#)
# ADD_TEST(SameName ${CMAKE_CTEST_COMMAND}
# --build-and-test
# "${CMake_SOURCE_DIR}/Tests/SameName"
# "${CMake_BINARY_DIR}/Tests/SameName"
# --build-generator ${CMAKE_TEST_GENERATOR}
# --build-project SameName
# --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
# --build-two-config
# --test-command
# "${CMake_BINARY_DIR}/Tests/SameName/Exe1/mytest2")
ADD_TEST(OutOfSource ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/OutOfSource"
"${CMake_BINARY_DIR}/Tests/OutOfSource"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project OutOfSource
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-two-config
--test-command
"${CMake_BINARY_DIR}/Tests/OutOfSource/SubDir/OutOfSourceSubdir/simple")
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSource")
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfSourceDeep")
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/OutOfBinary")
ADD_TEST(BuildDepends ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/BuildDepends"
"${CMake_BINARY_DIR}/Tests/BuildDepends"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project BuildDepends
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BuildDepends")
SET(SimpleInstallInstallDir
"${CMake_BINARY_DIR}/Tests/SimpleInstall/InstallDirectory")
ADD_TEST(SimpleInstall ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SimpleInstall"
"${CMake_BINARY_DIR}/Tests/SimpleInstall"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project TestSimpleInstall
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-two-config
--build-options
"-DCMAKE_INSTALL_PREFIX:PATH=${SimpleInstallInstallDir}"
"-DCTEST_TEST_CPACK:BOOL=${CTEST_TEST_CPACK}"
--test-command ${SimpleInstallInstallDir}/MyTest/bin/SimpleInstExe)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleInstall")
ADD_TEST(SimpleInstall-Stage2 ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SimpleInstallS2"
"${CMake_BINARY_DIR}/Tests/SimpleInstallS2"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project TestSimpleInstall
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-two-config
--build-options
"-DCMAKE_INSTALL_PREFIX:PATH=${SimpleInstallInstallDir}"
"-DSTAGE2:BOOL=1"
--test-command ${SimpleInstallInstallDir}/MyTest/bin/SimpleInstExeS2)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleInstallS2")
# By default, run the CPackComponents test if the CTEST_TEST_CPACK
# option is ON:
#
set(CTEST_RUN_CPackComponents ${CTEST_TEST_CPACK})
set(CTEST_package_X11_TEST ${CTEST_TEST_CPACK})
find_program(NSIS_MAKENSIS_EXECUTABLE NAMES makensis
PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
DOC "makensis program location"
)
# But on Windows, only run the CPackComponents test if the NSIS
# installer builder is available:
#
if(WIN32)
if(NSIS_MAKENSIS_EXECUTABLE)
set(CTEST_RUN_CPackComponents ON)
else(NSIS_MAKENSIS_EXECUTABLE)
set(CTEST_RUN_CPackComponents OFF)
set(CTEST_package_X11_TEST OFF)
endif(NSIS_MAKENSIS_EXECUTABLE)
endif(WIN32)
IF(CTEST_RUN_CPackComponents)
set(CPackComponents_EXTRA_OPTIONS)
if(APPLE)
set(CPackComponents_EXTRA_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
endif(APPLE)
if(NSIS_MAKENSIS_EXECUTABLE)
set(CPackComponents_EXTRA_OPTIONS ${CPackComponents_EXTRA_OPTIONS}
-DCPACK_BINARY_NSIS:BOOL=ON)
endif(NSIS_MAKENSIS_EXECUTABLE)
ADD_TEST(CPackComponents ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CPackComponents"
"${CMake_BINARY_DIR}/Tests/CPackComponents"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project CPackComponents
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-two-config
--build-target package
--build-options
-DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
-DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
${CPackComponents_EXTRA_OPTIONS}
--graphviz=CPackComponents.dot
--test-command ${CMAKE_CMAKE_COMMAND}
"-DCPackComponents_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponents"
-P "${CMake_SOURCE_DIR}/Tests/CPackComponents/VerifyResult.cmake")
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponents")
ENDIF(CTEST_RUN_CPackComponents)
# By default, turn this test off (because it takes a long time...)
#
if(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
set(CTEST_RUN_CPackTestAllGenerators OFF)
# ...but: if it appears to be a coverage dashboard, or long tests are
# on, then set it to the generic CTEST_TEST_CPACK setting.
#
if(CMAKE_CXX_FLAGS MATCHES "-ftest-coverage" OR
NOT "$ENV{COVFILE}" STREQUAL "" OR
CMAKE_RUN_LONG_TESTS)
set(CTEST_RUN_CPackTestAllGenerators ${CTEST_TEST_CPACK})
endif(CMAKE_CXX_FLAGS MATCHES "-ftest-coverage" OR
NOT "$ENV{COVFILE}" STREQUAL "" OR
CMAKE_RUN_LONG_TESTS)
endif(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
IF(CTEST_RUN_CPackTestAllGenerators)
ADD_TEST(CPackTestAllGenerators ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators"
"${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project CPackTestAllGenerators
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--test-command
${CMAKE_CMAKE_COMMAND}
-D dir=${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators
-D cpack=${CMAKE_CPACK_COMMAND}
-P ${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators/RunCPack.cmake
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators")
ENDIF(CTEST_RUN_CPackTestAllGenerators)
IF(CTEST_package_X11_TEST)
SET(X11_build_target_arg --build-target package)
ELSE(CTEST_package_X11_TEST)
SET(X11_build_target_arg)
ENDIF(CTEST_package_X11_TEST)
ADD_TEST(X11 ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/X11"
"${CMake_BINARY_DIR}/Tests/X11"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project UseX11
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-two-config
${X11_build_target_arg}
--test-command UseX11)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/X11")
if(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
set(CTEST_RUN_CMakeTestAllGenerators ON)
endif(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
IF(CTEST_RUN_CMakeTestAllGenerators)
ADD_TEST(CMakeTestAllGenerators ${CMAKE_CMAKE_COMMAND}
-D dir=${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators
-D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
-P ${CMake_SOURCE_DIR}/Tests/CMakeTestAllGenerators/RunCMake.cmake
)
LIST(APPEND TEST_BUILD_DIRS
"${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators")
ENDIF(CTEST_RUN_CMakeTestAllGenerators)
if(NOT DEFINED CTEST_RUN_CMakeTestBadCommandLines)
set(CTEST_RUN_CMakeTestBadCommandLines ON)
endif(NOT DEFINED CTEST_RUN_CMakeTestBadCommandLines)
IF(CTEST_RUN_CMakeTestBadCommandLines)
ADD_TEST(CMakeTestBadCommandLines ${CMAKE_CMAKE_COMMAND}
-D dir=${CMake_BINARY_DIR}/Tests/CMakeTestBadCommandLines
-D gen=${CMAKE_TEST_GENERATOR}
-D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
-P ${CMake_SOURCE_DIR}/Tests/CMakeTestBadCommandLines/RunCMake.cmake
)
LIST(APPEND TEST_BUILD_DIRS
"${CMake_BINARY_DIR}/Tests/CMakeTestBadCommandLines")
ENDIF(CTEST_RUN_CMakeTestBadCommandLines)
if(NOT DEFINED CTEST_RUN_CMakeTestMultipleConfigures)
set(CTEST_RUN_CMakeTestMultipleConfigures ON)
endif(NOT DEFINED CTEST_RUN_CMakeTestMultipleConfigures)
IF(CTEST_RUN_CMakeTestMultipleConfigures)
ADD_TEST(CMakeTestMultipleConfigures ${CMAKE_CMAKE_COMMAND}
-D dir=${CMake_BINARY_DIR}/Tests/CMakeTestMultipleConfigures
-D gen=${CMAKE_TEST_GENERATOR}
-D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
-P ${CMake_SOURCE_DIR}/Tests/CMakeTestMultipleConfigures/RunCMake.cmake
)
LIST(APPEND TEST_BUILD_DIRS
"${CMake_BINARY_DIR}/Tests/CMakeTestMultipleConfigures")
ENDIF(CTEST_RUN_CMakeTestMultipleConfigures)
ADD_TEST(LoadedCommandOneConfig ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LoadCommandOneConfig"
"${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project LoadCommand
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--test-command LoadedCommand
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig")
# Como does not seem to support shared libraries.
GET_FILENAME_COMPONENT(CMAKE_BASE_NAME ${CMAKE_CXX_COMPILER} NAME_WE)
IF(CMAKE_BASE_NAME MATCHES "^como$")
SET(COMPILER_IS_COMO 1)
ENDIF(CMAKE_BASE_NAME MATCHES "^como$")
IF(NOT COMPILER_IS_COMO)
SET(COMPLEX_TEST_CMAKELIB 1)
IF(CMAKE_TEST_DIFFERENT_GENERATOR OR CMAKE_TEST_SYSTEM_LIBRARIES)
SET(COMPLEX_TEST_CMAKELIB 0)
ENDIF(CMAKE_TEST_DIFFERENT_GENERATOR OR CMAKE_TEST_SYSTEM_LIBRARIES)
IF(BORLAND)
SET(COMPLEX_TEST_CMAKELIB 0)
ENDIF(BORLAND)
ADD_TEST(complex ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Complex"
"${CMake_BINARY_DIR}/Tests/Complex"
--build-two-config
--build-config-sample "${CMAKE_CTEST_COMMAND}"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project Complex
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Complex/bin"
--build-options
-DCOMPLEX_TEST_CMAKELIB:BOOL=${COMPLEX_TEST_CMAKELIB}
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
--test-command complex
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Complex")
ADD_TEST(complexOneConfig ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/ComplexOneConfig"
"${CMake_BINARY_DIR}/Tests/ComplexOneConfig"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project Complex
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/ComplexOneConfig/bin"
--build-options
-DCOMPLEX_TEST_CMAKELIB:BOOL=${COMPLEX_TEST_CMAKELIB}
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
--test-command complex)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ComplexOneConfig")
# because of the registry write these tests depend on each other
SET_TESTS_PROPERTIES ( complex PROPERTIES DEPENDS complexOneConfig)
2007-06-12 01:15:00 +04:00
# This fails on VS 70
# works on Xcode and makefiles
# ADD_TEST(ConvLibrary ${CMAKE_CTEST_COMMAND}
# --build-and-test
# "${CMake_SOURCE_DIR}/Tests/ConvLibrary"
# "${CMake_BINARY_DIR}/Tests/ConvLibrary"
# --build-two-config
# --build-generator ${CMAKE_TEST_GENERATOR}
# --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
# --build-project ConvLibrary
# --test-command bartest)
# ADD_TEST(complexRelativePaths ${CMAKE_CTEST_COMMAND}
# --build-and-test
# "${CMake_SOURCE_DIR}/Tests/ComplexRelativePaths"
# "${CMake_BINARY_DIR}/Tests/ComplexRelativePaths"
# --build-generator ${CMAKE_TEST_GENERATOR}
# --build-project complex
# --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
# --build-exe-dir "${CMake_BINARY_DIR}/Tests/ComplexRelativePaths/bin"
# --build-options -DCMAKE_USE_RELATIVE_PATHS:BOOL=ON
# --test-command complex)
ENDIF(NOT COMPILER_IS_COMO)
ADD_TEST(Example ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Example"
"${CMake_BINARY_DIR}/Example"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project HELLO
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Example/Demo"
--test-command helloDemo
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Example")
ADD_TEST(Environment ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Environment"
"${CMake_BINARY_DIR}/Tests/Environment"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project EnvironmentProj
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Environment"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Environment")
ADD_TEST(ExternalProject ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/ExternalProject"
"${CMake_BINARY_DIR}/Tests/ExternalProject"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project ExternalProjectTest
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProject"
--force-new-ctest-process
--test-command ${CMAKE_CTEST_COMMAND} -V
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProject")
# The ExternalProject test takes 900 seconds on some machines!
GET_TEST_PROPERTY(ExternalProject TIMEOUT PREVIOUS_TIMEOUT)
IF("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
SET_TESTS_PROPERTIES(ExternalProject PROPERTIES TIMEOUT 1000)
ENDIF("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
# do each of the tutorial steps
FOREACH(STP RANGE 1 7)
ADD_TEST(TutorialStep${STP} ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Tutorial/Step${STP}"
"${CMake_BINARY_DIR}/Tests/Tutorial/Step${STP}"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project Tutorial
--test-command Tutorial 25.0)
ENDFOREACH(STP)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Tutorial")
ADD_TEST(testing ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Testing"
"${CMake_BINARY_DIR}/Tests/Testing"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project Testing
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Testing")
ADD_TEST(wrapping ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Wrapping"
"${CMake_BINARY_DIR}/Tests/Wrapping"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project Wrapping
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
--test-command wrapping
)
ADD_TEST(qtwrapping ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Wrapping"
"${CMake_BINARY_DIR}/Tests/Wrapping"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project Wrapping
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
--test-command qtwrapping
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Wrapping")
ADD_TEST(testdriver1 ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/TestDriver"
"${CMake_BINARY_DIR}/Tests/TestDriver"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
--build-project TestDriverTest
--test-command TestDriverTest test1
)
ADD_TEST(testdriver2 ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/TestDriver"
"${CMake_BINARY_DIR}/Tests/TestDriver"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
--build-project TestDriverTest
--test-command TestDriverTest test2
)
ADD_TEST(testdriver3 ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/TestDriver"
"${CMake_BINARY_DIR}/Tests/TestDriver"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
--build-project TestDriverTest
--test-command TestDriverTest subdir/test3
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver")
ADD_TEST(Dependency ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Dependency"
"${CMake_BINARY_DIR}/Tests/Dependency"
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Dependency/Exec"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project Dependency
--test-command exec
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Dependency")
IF("${CMAKE_SYSTEM_NAME}" MATCHES syllable)
# RPATH isn't supported under Syllable, so the tests don't
# find their libraries. In order to fix that LIBRARY_OUTPUT_DIR
# in the tests would have to be adjusted to ${EXECUTABLE_OUTPUT_DIR}/lib .
# For now we just require on Syllable that the user adjusts the DLL_PATH
# environment variable, so except the two tests below all other tests will succeed.
SET(_DLL_PATH "$ENV{DLL_PATH}")
IF(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.(:.*)?$")
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")
ENDIF(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.(:.*)?$")
IF(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.\\./lib(:.*)?$")
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")
ENDIF(NOT "${_DLL_PATH}" MATCHES "^(.*:)?\\@bindir\\@/\\.\\./lib(:.*)?$")
ELSE("${CMAKE_SYSTEM_NAME}" MATCHES syllable)
ADD_TEST(JumpWithLibOut ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Jump"
"${CMake_BINARY_DIR}/Tests/Jump/WithLibOut"
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Executable"
--build-project Jump
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-options
-DLIBRARY_OUTPUT_PATH:PATH=${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Lib
--test-command jumpExecutable
)
ADD_TEST(JumpNoLibOut ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Jump"
"${CMake_BINARY_DIR}/Tests/Jump/NoLibOut"
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
--build-run-dir "${CMake_BINARY_DIR}/Tests/Jump/NoLibOut/Executable"
--build-project Jump
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--test-command jumpExecutable
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Jump")
ADD_TEST(Plugin ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Plugin"
"${CMake_BINARY_DIR}/Tests/Plugin"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project Plugin
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-two-config
--test-command bin/example)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Plugin")
IF(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
ADD_TEST_MACRO(RuntimePath RuntimePath)
ENDIF(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
ENDIF("${CMAKE_SYSTEM_NAME}" MATCHES syllable)
ADD_TEST(linkorder1 ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
"${CMake_BINARY_DIR}/Tests/LinkLineOrder"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project LinkLineOrder
--test-command Exec1
)
ADD_TEST(linkorder2 ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
"${CMake_BINARY_DIR}/Tests/LinkLineOrder"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project LinkLineOrder
--test-command Exec2
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkLineOrder")
SET_TESTS_PROPERTIES ( qtwrapping PROPERTIES DEPENDS wrapping)
SET_TESTS_PROPERTIES ( testdriver1 PROPERTIES DEPENDS qtwrapping)
SET_TESTS_PROPERTIES ( testdriver2 PROPERTIES DEPENDS testdriver1)
SET_TESTS_PROPERTIES ( testdriver3 PROPERTIES DEPENDS testdriver2)
SET_TESTS_PROPERTIES ( linkorder2 PROPERTIES DEPENDS linkorder1)
SET_TESTS_PROPERTIES ( SimpleInstall-Stage2 PROPERTIES DEPENDS SimpleInstall)
IF(NOT CMAKE_TEST_DIFFERENT_GENERATOR)
ADD_TEST(kwsys ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Source/kwsys"
"${CMake_BINARY_DIR}/Tests/kwsys"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project kwsys
--test-command kwsysTestsCxx testIOS
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/kwsys")
ENDIF(NOT CMAKE_TEST_DIFFERENT_GENERATOR)
SET(MAKE_IS_GNU )
IF(${CMAKE_TEST_MAKEPROGRAM} MATCHES make)
EXEC_PROGRAM(
${CMAKE_TEST_MAKEPROGRAM} ARGS no_such_target --version
RETURN_VALUE res OUTPUT_VARIABLE out
)
IF("${res}" EQUAL 0)
IF("${out}" MATCHES "GNU")
SET(MAKE_IS_GNU 1)
ENDIF("${out}" MATCHES "GNU")
ENDIF("${res}" EQUAL 0)
ENDIF(${CMAKE_TEST_MAKEPROGRAM} MATCHES make)
# only add this test on platforms that support it
# some old versions of make simply cannot handle spaces in paths
IF (MAKE_IS_GNU OR
"${CMAKE_TEST_MAKEPROGRAM}" MATCHES "nmake|gmake|wmake" OR
"${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio|XCode|Borland")
ADD_TEST(SubDirSpaces ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SubDirSpaces"
"${CMake_BINARY_DIR}/Tests/SubDirSpaces"
--build-exe-dir
"${CMake_BINARY_DIR}/Tests/SubDirSpaces/Executable Sources"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project SUBDIR
--test-command test
"${CMake_BINARY_DIR}/Tests/SubDirSpaces/ShouldBeHere"
"${CMake_BINARY_DIR}/Tests/SubDirSpaces/testfromsubdir.obj"
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDirSpaces")
ENDIF (MAKE_IS_GNU OR
"${CMAKE_TEST_MAKEPROGRAM}" MATCHES "nmake|gmake|wmake" OR
"${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio|XCode|Borland")
IF (WIN32)
ADD_TEST(SubDir ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SubDir"
"${CMake_BINARY_DIR}/Tests/SubDir"
--build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project SUBDIR
--test-command test
"${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
"${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.obj"
)
ELSE (WIN32)
ADD_TEST(SubDir ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SubDir"
"${CMake_BINARY_DIR}/Tests/SubDir"
--build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project SUBDIR
--test-command test
"${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
"${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.o"
)
ENDIF (WIN32)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDir")
IF(CMAKE_TEST_MSVC)
ADD_TEST_MACRO(PrecompiledHeader foo)
ADD_TEST_MACRO(ModuleDefinition example_exe)
ENDIF(CMAKE_TEST_MSVC)
IF("${CMAKE_TEST_GENERATOR}" MATCHES "Makefile")
ADD_TEST(MakeClean ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/MakeClean"
"${CMake_BINARY_DIR}/Tests/MakeClean"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project MakeClean
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-exe-dir "${CMake_BINARY_DIR}/MakeClean"
--test-command check_clean
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MakeClean")
ENDIF("${CMAKE_TEST_GENERATOR}" MATCHES "Makefile")
IF(${CMAKE_TEST_GENERATOR} MATCHES "Visual Studio")
ADD_TEST(VSExternalInclude ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VSExternalInclude"
"${CMake_BINARY_DIR}/Tests/VSExternalInclude"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project VSExternalInclude
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--test-command VSExternalInclude)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExternalInclude")
ENDIF(${CMAKE_TEST_GENERATOR} MATCHES "Visual Studio")
IF (APPLE AND CMAKE_COMPILER_IS_GNUCXX)
SET(BundleTestInstallDir
"${CMake_BINARY_DIR}/Tests/BundleTest/InstallDirectory")
ADD_TEST(BundleTest ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/BundleTest"
"${CMake_BINARY_DIR}/Tests/BundleTest"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project BundleTest
--build-target install
# --build-target package
--build-options "-DCMAKE_INSTALL_PREFIX:PATH=${BundleTestInstallDir}"
"-DCMake_SOURCE_DIR:PATH=${CMAKE_SOURCE_DIR}"
--test-command
${BundleTestInstallDir}/Applications/SecondBundleExe.app/Contents/MacOS/SecondBundleExe)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleTest")
2007-05-11 18:22:20 +04:00
ADD_TEST_MACRO(ObjC++ ObjC++)
ENDIF (APPLE AND CMAKE_COMPILER_IS_GNUCXX)
IF(APPLE AND CTEST_TEST_CPACK)
ADD_TEST(BundleGeneratorTest ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/BundleGeneratorTest"
"${CMake_BINARY_DIR}/Tests/BundleGeneratorTest"
--build-two-config
--build-generator ${CMAKE_TEST_GENERATOR}
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-project BundleGeneratorTest
--build-target package
--build-options "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/BundleGeneratorTest/InstallDirectory"
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest")
ENDIF(APPLE AND CTEST_TEST_CPACK)
# Make sure CTest can handle a test with no newline in output.
ADD_TEST(CTest.NoNewline
${CMAKE_COMMAND} -E echo_append "This line has no newline!")
# A simple test for ctest in script mode
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake" @ONLY)
# ADD_TEST(CTest.ScriptMode ${CMAKE_CTEST_COMMAND}
# -S "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake"
# )
SET(CTEST_TEST_UPDATE 1)
IF(CTEST_TEST_UPDATE)
# Test CTest Update with Subversion
FIND_PACKAGE(Subversion QUIET)
IF(Subversion_FOUND)
GET_FILENAME_COMPONENT(_Subversion_BIN_DIR
${Subversion_SVN_EXECUTABLE} PATH)
FIND_PROGRAM(Subversion_SVNADMIN_EXECUTABLE svnadmin
HINTS ${_Subversion_BIN_DIR}
)
MARK_AS_ADVANCED(Subversion_SVNADMIN_EXECUTABLE)
IF(NOT Subversion_SVNADMIN_EXECUTABLE)
SET(Subversion_FOUND FALSE)
ENDIF(NOT Subversion_SVNADMIN_EXECUTABLE)
ENDIF(Subversion_FOUND)
IF(Subversion_FOUND)
SET(CTestUpdateSVN_DIR "CTest UpdateSVN")
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateSVN.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake" @ONLY)
ADD_TEST(CTest.UpdateSVN ${CMAKE_CMAKE_COMMAND}
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake"
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateSVN_DIR}")
ENDIF(Subversion_FOUND)
# Test CTest Update with CVS
IF(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
FIND_PACKAGE(CVS QUIET)
ELSE(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
FIND_PROGRAM(CVS_EXECUTABLE NAMES cvs)
SET(CVS_FOUND ${CVS_EXECUTABLE})
ENDIF(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
SET(CTEST_TEST_UPDATE_CVS ${CVS_FOUND})
IF(CTEST_TEST_UPDATE_CVS AND NOT UNIX)
IF("${CVS_EXECUTABLE}" MATCHES "cygwin")
MESSAGE(STATUS "No CTest.UpdateCVS test with cygwin cvs.exe outside cygwin!")
SET(CTEST_TEST_UPDATE_CVS 0)
ENDIF("${CVS_EXECUTABLE}" MATCHES "cygwin")
ENDIF(CTEST_TEST_UPDATE_CVS AND NOT UNIX)
IF(CTEST_TEST_UPDATE_CVS)
SET(CTestUpdateCVS_DIR "CTest UpdateCVS")
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateCVS.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake" @ONLY)
ADD_TEST(CTest.UpdateCVS ${CMAKE_CMAKE_COMMAND}
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake"
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateCVS_DIR}")
ENDIF(CTEST_TEST_UPDATE_CVS)
# Test CTest Update with BZR
FIND_PROGRAM(BZR_EXECUTABLE NAMES bzr)
MARK_AS_ADVANCED(BZR_EXECUTABLE)
SET(CTEST_TEST_UPDATE_BZR 0)
IF(BZR_EXECUTABLE)
IF(NOT "${BZR_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
SET(CTEST_TEST_UPDATE_BZR 1)
ENDIF(NOT "${BZR_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
ENDIF(BZR_EXECUTABLE)
IF(CTEST_TEST_UPDATE_BZR)
# Check if xmloutput plugin is there
EXECUTE_PROCESS(COMMAND ${BZR_EXECUTABLE} xmlplugins RESULT_VARIABLE xmlplugres
OUTPUT_QUIET ERROR_QUIET)
IF( NOT ${xmlplugres} )
SET(CTestUpdateBZR_DIR "CTest UpdateBZR")
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake" @ONLY)
ADD_TEST(CTest.UpdateBZR ${CMAKE_CMAKE_COMMAND}
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake"
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
SET(CTestUpdateBZR_DIR "CTest UpdateBZR_CLocale")
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake" @ONLY)
ADD_TEST(CTest.UpdateBZR.CLocale ${CMAKE_CMAKE_COMMAND}
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake"
)
SET_TESTS_PROPERTIES(CTest.UpdateBZR.CLocale PROPERTIES ENVIRONMENT LC_ALL=C)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
ENDIF( NOT ${xmlplugres} )
ENDIF(CTEST_TEST_UPDATE_BZR)
# Test CTest Update with GIT
FIND_PROGRAM(GIT_EXECUTABLE NAMES git)
MARK_AS_ADVANCED(GIT_EXECUTABLE)
SET(CTEST_TEST_UPDATE_GIT 0)
IF(GIT_EXECUTABLE)
IF(NOT "${GIT_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
SET(CTEST_TEST_UPDATE_GIT 1)
ENDIF(NOT "${GIT_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
ENDIF(GIT_EXECUTABLE)
IF(CTEST_TEST_UPDATE_GIT)
SET(CTestUpdateGIT_DIR "CTest UpdateGIT")
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateGIT.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake" @ONLY)
ADD_TEST(CTest.UpdateGIT ${CMAKE_CMAKE_COMMAND}
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake"
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateGIT_DIR}")
ENDIF(CTEST_TEST_UPDATE_GIT)
# Test CTest Update with HG
FIND_PROGRAM(HG_EXECUTABLE NAMES hg)
MARK_AS_ADVANCED(HG_EXECUTABLE)
SET(CTEST_TEST_UPDATE_HG 0)
IF(HG_EXECUTABLE)
IF(NOT "${HG_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
SET(CTEST_TEST_UPDATE_HG 1)
ENDIF(NOT "${HG_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
ENDIF(HG_EXECUTABLE)
IF(CTEST_TEST_UPDATE_HG)
SET(CTestUpdateHG_DIR "CTest UpdateHG")
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestUpdateHG.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake" @ONLY)
ADD_TEST(CTest.UpdateHG ${CMAKE_CMAKE_COMMAND}
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake"
)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateHG_DIR}")
ENDIF(CTEST_TEST_UPDATE_HG)
ENDIF(CTEST_TEST_UPDATE)
CONFIGURE_FILE(
"${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoBuild.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake"
@ONLY ESCAPE_QUOTES)
ADD_TEST(CTestTestNoBuild ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut1.log"
)
SET_TESTS_PROPERTIES(CTestTestNoBuild PROPERTIES
FAIL_REGULAR_EXPRESSION "Error" WILL_FAIL true)
CONFIGURE_FILE(
"${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoExe.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake"
@ONLY ESCAPE_QUOTES)
ADD_TEST(CTestTestNoExe ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut2.log"
)
SET_TESTS_PROPERTIES(CTestTestNoExe PROPERTIES DEPENDS CTestTestNoBuild
PASS_REGULAR_EXPRESSION "Could not find executable"
FAIL_REGULAR_EXPRESSION "SegFault")
# Use macro, not function so that build can still be driven by CMake 2.4.
# After 2.6 is required, this could be a function without the extra 'set'
# calls.
#
macro(add_config_tests cfg)
set(cfg "${cfg}")
set(base "${CMake_BINARY_DIR}/Tests/CTestConfig")
# Test -S script with a -C config arg to ctest:
configure_file(
"${CMake_SOURCE_DIR}/Tests/CTestConfig/script.cmake.in"
"${base}/${cfg}-script.cmake"
@ONLY ESCAPE_QUOTES)
add_test(CTestConfig.Script.${cfg} ${CMAKE_CTEST_COMMAND}
-C ${cfg}
-S "${base}/${cfg}-script.cmake" -VV
--output-log "${base}/${cfg}-script.log"
)
# Test -D dashboard with a -C config arg to ctest.
# (Actual commands inside a cmake -P script because we need to be able to set
# the working directory reliably...)
configure_file(
"${CMake_SOURCE_DIR}/Tests/CTestConfig/dashboard.cmake.in"
"${base}/${cfg}-dashboard.cmake"
@ONLY ESCAPE_QUOTES)
add_test(CTestConfig.Dashboard.${cfg} ${CMAKE_CMAKE_COMMAND}
-P "${base}/${cfg}-dashboard.cmake" -VV
)
endmacro()
add_config_tests(Debug)
add_config_tests(MinSizeRel)
add_config_tests(Release)
add_config_tests(RelWithDebInfo)
add_test(CMakeCommands.build_command ${CMAKE_CMAKE_COMMAND}
-DCMake_SOURCE_DIR=${CMake_SOURCE_DIR}
-Ddir=${CMake_BINARY_DIR}/Tests/CMakeCommands/build_command
-Dgen=${CMAKE_TEST_GENERATOR}
-P "${CMake_SOURCE_DIR}/Tests/CMakeCommands/build_command/RunCMake.cmake"
)
CONFIGURE_FILE(
"${CMake_SOURCE_DIR}/Tests/CTestTestCrash/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake"
@ONLY ESCAPE_QUOTES)
ADD_TEST(CTestTestCrash ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestCrash/testOutput.log"
)
# with watcom the SEGFAULT is not found, it just fails
IF(CMAKE_TEST_GENERATOR MATCHES "Watcom WMake")
SET_TESTS_PROPERTIES(CTestTestCrash PROPERTIES
PASS_REGULAR_EXPRESSION "Failed")
ELSE(CMAKE_TEST_GENERATOR MATCHES "Watcom WMake")
SET_TESTS_PROPERTIES(CTestTestCrash PROPERTIES
PASS_REGULAR_EXPRESSION "SegFault")
ENDIF(CMAKE_TEST_GENERATOR MATCHES "Watcom WMake")
CONFIGURE_FILE(
"${CMake_SOURCE_DIR}/Tests/CTestTestParallel/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake"
@ONLY ESCAPE_QUOTES)
ADD_TEST(CTestTestParallel ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestParallel/testOutput.log"
)
CONFIGURE_FILE(
"${CMake_SOURCE_DIR}/Tests/CTestTestSubdir/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake"
@ONLY ESCAPE_QUOTES)
ADD_TEST(CTestTestSubdir ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/testOutput.log"
)
#make sure all 3 subdirs were added
SET_TESTS_PROPERTIES(CTestTestSubdir PROPERTIES
PASS_REGULAR_EXPRESSION "0 tests failed out of 3")
CONFIGURE_FILE(
"${CMake_SOURCE_DIR}/Tests/CTestTestTimeout/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake"
@ONLY ESCAPE_QUOTES)
ADD_TEST(CTestTestTimeout ${CMAKE_CTEST_COMMAND}
-C "\${CTestTest_CONFIG}"
-S "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/testOutput.log"
)
SET_TESTS_PROPERTIES(CTestTestTimeout PROPERTIES
PASS_REGULAR_EXPRESSION "TestTimeout *\\.+ *\\*\\*\\*Timeout.*CheckChild *\\.+ *Passed")
CONFIGURE_FILE(
"${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake"
@ONLY ESCAPE_QUOTES)
CONFIGURE_FILE(
"${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/hello.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestRunScript/hello.cmake"
@ONLY ESCAPE_QUOTES)
2009-10-29 19:46:00 +03:00
ADD_TEST(CTestTestRunScript ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/testOutput.log"
)
ADD_TEST(CTestTestShowOnly ${CMAKE_CTEST_COMMAND} -N)
ADD_TEST(CTestBatchTest ${CMAKE_CTEST_COMMAND} -B)
# Use macro, not function so that build can still be driven by CMake 2.4.
# After 2.6 is required, this could be a function without the extra 'set'
# calls.
#
macro(add_failed_submit_test name source build in out log regex)
# Have variables named source, build and drop_method because the
# configure_file call expects those variables to be defined.
#
set(source "${source}")
set(build "${build}")
configure_file("${in}" "${out}" @ONLY)
add_test(${name} ${CMAKE_CTEST_COMMAND} -S "${out}" -V --output-log "${log}")
set_tests_properties(${name} PROPERTIES PASS_REGULAR_EXPRESSION "${regex}")
endmacro()
set(regex "(Problems when submitting via S*CP")
set(regex "${regex}|Error message was: ")
set(regex "${regex}([Cc]ould *n.t resolve host")
set(regex "${regex}|[Cc]ould *n.t connect to host")
set(regex "${regex}|libcurl was built with SSL disabled. https: not supported)")
set(regex "${regex}|Submission method .xmlrpc. not compiled into CTest")
set(regex "${regex}|Submission successful)")
set(ctest_coverage_labels_args "")
foreach(drop_method cp ftp http https scp xmlrpc)
# Cycle through these values each time through the loop:
if(ctest_coverage_labels_args STREQUAL "")
set(ctest_coverage_labels_args "LABELS Everything")
elseif(ctest_coverage_labels_args STREQUAL "LABELS Everything")
set(ctest_coverage_labels_args "LABELS 0ArgTest")
else()
set(ctest_coverage_labels_args "")
endif()
add_failed_submit_test(CTestTestFailedSubmit-${drop_method}
"${CMake_SOURCE_DIR}/Tests/CTestTest/SmallAndFast"
"${CMake_BINARY_DIR}/Tests/CTestTestFailedSubmits/${drop_method}"
"${CMake_SOURCE_DIR}/Tests/CTestTestFailedSubmits/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestFailedSubmits/test-${drop_method}.cmake"
"${CMake_BINARY_DIR}/Tests/CTestTestFailedSubmits/test-${drop_method}.log"
"${regex}"
)
endforeach()
IF (CTEST_TEST_CTEST AND CMAKE_RUN_LONG_TESTS)
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestTest/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" @ONLY ESCAPE_QUOTES)
ADD_TEST(CTestTest ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTest/testOutput.log"
)
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestTest2/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" @ONLY ESCAPE_QUOTES)
ADD_TEST(CTestTest2 ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTest2/testOutput.log"
)
CONFIGURE_FILE("${CMake_SOURCE_DIR}/Tests/CTestTest3/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTest3/test.cmake" @ONLY ESCAPE_QUOTES)
ADD_TEST(CTestTest3 ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTest3/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTest3/testOutput.log"
)
# these tests take a long time, make sure they have it
# if timeouts have not already been set
GET_TEST_PROPERTY(CTestTest TIMEOUT PREVIOUS_TIMEOUT)
IF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
SET_TESTS_PROPERTIES ( CTestTest
PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
ENDIF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
GET_TEST_PROPERTY(CTestTest2 TIMEOUT PREVIOUS_TIMEOUT)
IF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
SET_TESTS_PROPERTIES ( CTestTest2
PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
ENDIF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
GET_TEST_PROPERTY(CTestTest3 TIMEOUT PREVIOUS_TIMEOUT)
IF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
SET_TESTS_PROPERTIES ( CTestTest3
PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
ENDIF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
ENDIF (CTEST_TEST_CTEST AND CMAKE_RUN_LONG_TESTS)
IF (CMAKE_RUN_LONG_TESTS AND TEST_KDE4_STABLE_BRANCH)
IF(UNIX)
IF(NOT QT4_FOUND)
FIND_PACKAGE(Qt4)
ENDIF(NOT QT4_FOUND)
SET(TRY_BUILD_KDE4 TRUE)
IF(QT4_FOUND)
# check whether it's Qt 4.5 in a cmake 2.4. compatible way:
IF(NOT EXISTS "${QT_QTNETWORK_INCLUDE_DIR}/QAbstractNetworkCache")
SET(TRY_BUILD_KDE4 FALSE)
ENDIF(NOT EXISTS "${QT_QTNETWORK_INCLUDE_DIR}/QAbstractNetworkCache")
ELSE(QT4_FOUND)
SET(TRY_BUILD_KDE4 FALSE)
ENDIF(QT4_FOUND)
FIND_PACKAGE(Perl)
IF(NOT PERL_FOUND)
SET(TRY_BUILD_KDE4 FALSE)
ENDIF(NOT PERL_FOUND)
FIND_PACKAGE(ZLIB)
IF(NOT ZLIB_FOUND)
SET(TRY_BUILD_KDE4 FALSE)
ENDIF(NOT ZLIB_FOUND)
IF(TRY_BUILD_KDE4)
FILE(MAKE_DIRECTORY ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest)
SET(TEST_KDE4_BASE_DIR ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest)
CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/KDE4StableBranchTest/test_kde4.sh.in ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest/test_kde4.sh @ONLY)
EXECUTE_PROCESS(COMMAND chmod 755 ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest/test_kde4.sh )
ADD_TEST(KDE4StableBranchTest ${CMake_BINARY_DIR}/Tests/KDE4StableBranchTest/test_kde4.sh)
ENDIF(TRY_BUILD_KDE4)
ENDIF(UNIX)
ENDIF (CMAKE_RUN_LONG_TESTS AND TEST_KDE4_STABLE_BRANCH)
IF("${CMAKE_TEST_GENERATOR}" MATCHES Xcode)
SET(CMAKE_SKIP_BOOTSTRAP_TEST 1)
ENDIF("${CMAKE_TEST_GENERATOR}" MATCHES Xcode)
IF(EXISTS "${CMAKE_BINARY_DIR}/CMakeLists.txt")
# If there is CMakeLists.txt in the binary tree, assume in-source build
SET(CMAKE_SKIP_BOOTSTRAP_TEST 1)
ENDIF(EXISTS "${CMAKE_BINARY_DIR}/CMakeLists.txt")
IF(UNIX AND CMAKE_RUN_LONG_TESTS AND NOT CMAKE_SKIP_BOOTSTRAP_TEST)
ADD_TEST(BootstrapTest ${CMAKE_CTEST_COMMAND}
--build-and-test
${CMake_SOURCE_DIR}
${CMake_BINARY_DIR}/Tests/BootstrapTest
--build-nocmake
--build-noclean
--build-makeprogram ${CMake_SOURCE_DIR}/bootstrap
--build-generator "${CMAKE_TEST_GENERATOR}"
--test-command
${CMake_BINARY_DIR}/Tests/BootstrapTest/Bootstrap.cmk/cmake)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BootstrapTest")
# provide more time for the bootstrap test
GET_TEST_PROPERTY(BootstrapTest TIMEOUT PREVIOUS_TIMEOUT)
IF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
SET_TESTS_PROPERTIES ( BootstrapTest
PROPERTIES TIMEOUT 5400)
ENDIF ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
ENDIF(UNIX AND CMAKE_RUN_LONG_TESTS AND NOT CMAKE_SKIP_BOOTSTRAP_TEST)
# fortran does not work for IDE builds because
# CMAKE_STANDARD_LIBRARIES needs to be per language
IF(CMAKE_TEST_GENERATOR MATCHES "Makefiles"
OR CMAKE_TEST_GENERATOR MATCHES "KDevelop")
# see if we can find a fortran compiler on the machine
# if so, add the fortran test and see if it works.
SET(CMAKE_Fortran_COMPILER_LIST ifort ifc efc f95 pgf95
2008-11-18 17:37:06 +03:00
lf95 xlf95 fort gfortran gfortran-4 f90 pgf90 xlf90
epcf90 f77 fort77 frt pgf77 xlf fl32 af77 g77 )
FIND_PROGRAM(CMAKE_Fortran_COMPILER_FULLPATH NAMES
${CMAKE_Fortran_COMPILER_LIST} )
MARK_AS_ADVANCED(CMAKE_Fortran_COMPILER_FULLPATH)
IF(CMAKE_Fortran_COMPILER_FULLPATH)
ADD_TEST(Fortran ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Fortran"
"${CMake_BINARY_DIR}/Tests/Fortran"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project testf
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-two-config
--test-command testf)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Fortran")
ENDIF(CMAKE_Fortran_COMPILER_FULLPATH)
ENDIF(CMAKE_TEST_GENERATOR MATCHES "Makefiles"
OR CMAKE_TEST_GENERATOR MATCHES "KDevelop")
2007-06-26 23:15:52 +04:00
IF(NOT CMAKE_TEST_GENERATOR MATCHES "Xcode")
INCLUDE(FindJava)
IF(JAVA_COMPILE AND JAVA_RUNTIME AND JAVA_ARCHIVE AND NOT MINGW)
GET_FILENAME_COMPONENT(JNIPATH ${JAVA_COMPILE} PATH)
FIND_FILE(JNI_H jni.h
"${JNIPATH}/../include"
"${JNIPATH}/../java/include")
IF(JNI_H)
FILE(READ "${JNI_H}" JNI_FILE)
IF("${JNI_FILE}" MATCHES "JDK1_2")
ADD_TEST(Java ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Java"
"${CMake_BINARY_DIR}/Tests/Java"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project hello
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-two-config
--build-run-dir "${CMake_BINARY_DIR}/Tests/Java/"
--test-command ${JAVA_RUNTIME} -classpath hello.jar HelloWorld)
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Java")
ENDIF("${JNI_FILE}" MATCHES "JDK1_2")
ENDIF(JNI_H)
ENDIF(JAVA_COMPILE AND JAVA_RUNTIME AND JAVA_ARCHIVE AND NOT MINGW)
ENDIF(NOT CMAKE_TEST_GENERATOR MATCHES "Xcode")
# add some cross compiler tests, for now only with makefile based generators
2007-06-26 23:15:52 +04:00
IF(CMAKE_TEST_GENERATOR MATCHES "Makefiles" OR CMAKE_TEST_GENERATOR MATCHES "KDevelop")
# if sdcc is found, build the SimpleCOnly project with sdcc
2007-06-26 23:15:52 +04:00
FIND_PROGRAM(SDCC_EXECUTABLE sdcc)
MARK_AS_ADVANCED(SDCC_EXECUTABLE)
2007-06-26 23:15:52 +04:00
IF(SDCC_EXECUTABLE)
ADD_TEST(SimpleCOnly_sdcc ${CMAKE_CTEST_COMMAND}
2007-06-26 23:15:52 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SimpleCOnly"
"${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc"
2007-06-26 23:15:52 +04:00
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project SimpleC
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-options
"-DCMAKE_SYSTEM_NAME=Generic"
"-DCMAKE_C_COMPILER=${SDCC_EXECUTABLE}")
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc")
2007-06-26 23:15:52 +04:00
ENDIF(SDCC_EXECUTABLE)
FIND_PROGRAM(MINGW_CC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-gcc)
FIND_PROGRAM(MINGW_CXX_LINUX2WIN_EXECUTABLE i586-mingw32msvc-g++)
MARK_AS_ADVANCED(MINGW_CC_LINUX2WIN_EXECUTABLE MINGW_CXX_LINUX2WIN_EXECUTABLE)
IF(MINGW_CC_LINUX2WIN_EXECUTABLE AND MINGW_CXX_LINUX2WIN_EXECUTABLE)
ADD_TEST(Simple_Mingw_Linux2Win ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Simple"
"${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win"
--build-generator ${CMAKE_TEST_GENERATOR}
--build-project Simple
--build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
--build-options
"-DCMAKE_SYSTEM_NAME=Windows"
"-DCMAKE_C_COMPILER=${MINGW_CC_LINUX2WIN_EXECUTABLE}"
"-DCMAKE_CXX_COMPILER=${MINGW_CXX_LINUX2WIN_EXECUTABLE}")
LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win")
ENDIF(MINGW_CC_LINUX2WIN_EXECUTABLE AND MINGW_CXX_LINUX2WIN_EXECUTABLE)
2007-06-26 23:15:52 +04:00
ENDIF(CMAKE_TEST_GENERATOR MATCHES "Makefiles" OR CMAKE_TEST_GENERATOR MATCHES "KDevelop")
IF(UNIX)
STRING(COMPARE EQUAL "${CMAKE_INSTALL_PREFIX}" "${CMake_BINARY_DIR}/Tests/TestShellInstall/Prefix"
PREFIX_IS_FOR_TEST)
IF(PREFIX_IS_FOR_TEST)
CONFIGURE_FILE(
${CMake_SOURCE_DIR}/Tests/TestInstall.sh.in
${CMake_BINARY_DIR}/Tests/TestShellInstall/TestInstall.sh
@ONLY IMMEDIATE
)
ADD_TEST(ShellInstall /bin/sh ${CMake_BINARY_DIR}/Tests/TestShellInstall/TestShellInstall.sh)
ENDIF(PREFIX_IS_FOR_TEST)
ENDIF(UNIX)
IF(CMAKE_TEST_PLPLOT_DIR)
ADD_TEST(plplot ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_PLPLOT_DIR}/../../EasyDashboardScripts/plplot.cmake )
SET_TESTS_PROPERTIES ( plplot PROPERTIES TIMEOUT 5400)
ENDIF(CMAKE_TEST_PLPLOT_DIR)
IF(CMAKE_TEST_CHICKEN_DIR)
ADD_TEST(Chicken ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_CHICKEN_DIR}/../../EasyDashboardScripts/Chicken.cmake )
SET_TESTS_PROPERTIES ( Chicken PROPERTIES TIMEOUT 5400)
ENDIF(CMAKE_TEST_CHICKEN_DIR)
IF(CMAKE_TEST_KDELIBS_ALPHA_1_DIR)
ADD_TEST(KDELibsAlpha1 ${CMAKE_CTEST_COMMAND} -V -S ${CMAKE_TEST_KDELIBS_ALPHA_1_DIR}/../../EasyDashboardScripts/kdelibs.cmake )
SET_TESTS_PROPERTIES ( KDELibsAlpha1 PROPERTIES TIMEOUT 5400)
ENDIF(CMAKE_TEST_KDELIBS_ALPHA_1_DIR)
# If this is not an in-source build, provide a target to wipe out
# all the test build directories.
IF(NOT EXISTS "${CMAKE_BINARY_DIR}/CMakeLists.txt")
CONFIGURE_FILE(${CMake_SOURCE_DIR}/Tests/test_clean.cmake.in
${CMake_BINARY_DIR}/Tests/test_clean.cmake @ONLY)
ADD_CUSTOM_TARGET(test_clean
COMMAND ${CMAKE_COMMAND} -P ${CMake_BINARY_DIR}/Tests/test_clean.cmake
COMMENT "Removing test build directories."
)
ENDIF(NOT EXISTS "${CMAKE_BINARY_DIR}/CMakeLists.txt")
ADD_TEST(CMakeWizardTest ${CMAKE_CMAKE_COMMAND}
-D build_dir:STRING=${CMAKE_CURRENT_BINARY_DIR}/CMakeWizardTest
-D source_dir:STRING=${CMAKE_CURRENT_SOURCE_DIR}/Tutorial/Step3
-D CMAKE_CTEST_COMMAND:STRING=${CMAKE_CTEST_COMMAND}
-P ${CMAKE_CURRENT_SOURCE_DIR}/CMakeWizardTest.cmake)
ENDIF(BUILD_TESTING)
2007-05-11 18:22:20 +04:00
SUBDIRS(CMakeTests)