kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Tests/CMakeLists.txt

3201 lines
126 KiB
CMake
Raw Normal View History

ENH: some more CMakeList cleanups
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
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
macro(ADD_TEST_MACRO NAME COMMAND)
string(REPLACE "." "/" dir "${NAME}")
string(REGEX REPLACE "[^.]*\\." "" proj "${NAME}")
Tests: Use add_test(NAME) signature in add_test_macro This will allow generator expressions to be used in test arguments.
2014-07-01 18:24:47 +04:00
add_test(NAME "${NAME}" COMMAND "${CMAKE_CTEST_COMMAND}"
ENH: some more CMakeList cleanups
2007-05-11 18:22:20 +04:00
--build-and-test
Teach ADD_TEST_MACRO about test namespaces We teach ADD_TEST_MACRO to transform names of the form "Namespace.Name" to the directory "Namespace/Name" and the project name "Name". This will allow new tests to be better organized.
2009-12-17 23:14:14 +03:00
"${CMake_SOURCE_DIR}/Tests/${dir}"
"${CMake_BINARY_DIR}/Tests/${dir}"
ENH: some more CMakeList cleanups
2007-05-11 18:22:20 +04:00
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Teach ADD_TEST_MACRO about test namespaces We teach ADD_TEST_MACRO to transform names of the form "Namespace.Name" to the directory "Namespace/Name" and the project name "Name". This will allow new tests to be better organized.
2009-12-17 23:14:14 +03:00
--build-project ${proj}
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
${${NAME}_CTEST_OPTIONS}
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
${${NAME}_BUILD_OPTIONS}
Add a "Contract" test for VTK. The test downloads and builds VTK. The idea is that we can make sure that CMake is staying backwards compatible by testing projects against CMake as the changes are made in CMake. Because these tests will take a long time to run, they will not be enabled by default. Instead, they will be enabled by putting a cache variable into CMake.
2010-09-21 18:23:09 +04:00
--test-command ${COMMAND} ${ARGN})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${dir}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endmacro()
ENH: some more CMakeList cleanups
2007-05-11 18:22:20 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
include(${CMAKE_CURRENT_SOURCE_DIR}/CheckFortran.cmake)
Fix custom commands in VS2010 Fortran projects using CFG_INTDIR and test. For custom commands in VS2010 Fortran projects the INTDIR variable is different than in the rest of the solution because Intel fortran still uses the old VS project files even in VS2010. So, we replace $(Configuration) directly in the project files. I have also added a FortranOnly test that tests this feature and is run on any generator that has Fortran abilities.
2011-08-04 01:24:43 +04:00
Improve fake $HOME test isolation code The commit "Fake $HOME to isolate tests from user" started setting $HOME in the CTest script environment. On some platforms tests depend on some local configuration in the home directory, such as the "cvs login" for KWSys in CTestTest3. In this commit we now construct a fake home dir during CMake config step and populate it with a .cvspass file needed by the test. We also check CTEST_NO_TEST_HOME to optionally disable the test home. See issue #9949.
2009-11-24 20:15:33 +03:00
# Fake a user home directory to avoid polluting the real one.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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.
Add a contract test for building the CSE. To activate the CSE contract test on a given Linux machine's CMake dashboard, put CMAKE_CONTRACT_PROJECTS:STRING=cse-snapshot in the CMake dashboard's initial cache. The chosen snapshot does not generate subproject dependency info right now. That code was in a previous revision in the CSE's svn repo that apparently has not been merged into the present cse git repository master branch. After that is fixed up in the cse repo, we can update the tag here so that the snapshot built here can run a sub-project based dashboard script. For now, it runs as one big build step, building 'all'.
2010-10-08 23:09:24 +04:00
# But provide original ENV{HOME} value in ENV{CTEST_REAL_HOME} for tests that
# need access to the real HOME directory.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(ENV{CTEST_REAL_HOME} \"\$ENV{HOME}\")
set(ENV{HOME} \"${TEST_HOME}\")
Add a contract test for building the CSE. To activate the CSE contract test on a given Linux machine's CMake dashboard, put CMAKE_CONTRACT_PROJECTS:STRING=cse-snapshot in the CMake dashboard's initial cache. The chosen snapshot does not generate subproject dependency info right now. That code was in a previous revision in the CSE's svn repo that apparently has not been merged into the present cse git repository master branch. After that is fixed up in the cse repo, we can update the tag here so that the snapshot built here can run a sub-project based dashboard script. For now, it runs as one big build step, building 'all'.
2010-10-08 23:09:24 +04:00
")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
Improve fake $HOME test isolation code The commit "Fake $HOME to isolate tests from user" started setting $HOME in the CTest script environment. On some platforms tests depend on some local configuration in the home directory, such as the "cvs login" for KWSys in CTestTest3. In this commit we now construct a fake home dir during CMake config step and populate it with a .cvspass file needed by the test. We also check CTEST_NO_TEST_HOME to optionally disable the test home. See issue #9949.
2009-11-24 20:15:33 +03:00
Always use a configuration for CTestTestTimeout This test requires that the dashboard script it drives be invoked with "ctest -C <config> -S ...". We create a "CTestTest_CONFIG" variable to hold a configuration selected at test time. We use the configuration given to the outer CTest, if any, and then default to either Debug or the CMAKE_BUILD_TYPE.
2009-12-01 17:12:07 +03:00
# Choose a default configuration for CTest tests.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CTestTest_CONFIG Debug)
if(NOT CMAKE_CONFIGURATION_TYPES AND CMAKE_BUILD_TYPE)
set(CTestTest_CONFIG ${CMAKE_BUILD_TYPE})
endif()
Always use a configuration for CTestTestTimeout This test requires that the dashboard script it drives be invoked with "ctest -C <config> -S ...". We create a "CTestTest_CONFIG" variable to hold a configuration selected at test time. We use the configuration given to the outer CTest, if any, and then default to either Debug or the CMAKE_BUILD_TYPE.
2009-12-01 17:12:07 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(${CMake_SOURCE_DIR}/Tests/EnforceConfig.cmake.in
ENH: Re-enable new 'testing' test mode This fixes selection of a configuration when none is specified to find an available configuration of the ctest test-command.
2009-01-05 22:14:25 +03:00
${CMake_BINARY_DIR}/Tests/EnforceConfig.cmake @ONLY)
BUG: Fix new 'testing' test for CMake releases The recent change of the 'testing' test to actually drive the tests within it does not work on Windows with released CMakes 2.6.2 and lower if no configuration is given to ctest with a -C option. This works around the problem by detecting the case and changing the empty configuration to Debug.
2008-12-18 22:26:20 +03:00
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
# Testing
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(BUILD_TESTING)
Tests: Rename CMAKE_TEST_DEVENV -> CMake_TEST_DEVENV Follow the convention of naming variables related to the CMake build itself as "CMake_" rather than "CMAKE_". While at it, consolidate the code computing CMake_TEST_DEVENV to be more localized.
2014-03-03 21:40:58 +04:00
set(CMake_TEST_DEVENV "")
Tests: Enable devenv tests on VS >= 10 The VSExcludeFromDefaultBuild have not been enabled on VS >= 10 since commit v3.0.0-rc1~260^2~9 (Tests: Simplify VSExcludeFromDefaultBuild configuration, 2013-11-14). Since commit v3.0.0-rc1~260^2~2 (VS: Add CMAKE_VS_(DEVENV|MSBUILD|MSDEV)_COMMAND variables, 2013-12-04) we can simply check the CMAKE_VS_DEVENV_COMMAND variable for a devenv tool to use for the test.
2015-05-04 23:03:43 +03:00
if(CMAKE_VS_DEVENV_COMMAND)
set(CMake_TEST_DEVENV "${CMAKE_VS_DEVENV_COMMAND}")
elseif(CMAKE_GENERATOR MATCHES "Visual Studio [7-9] " AND
Tests: Rename CMAKE_TEST_DEVENV -> CMake_TEST_DEVENV Follow the convention of naming variables related to the CMake build itself as "CMake_" rather than "CMAKE_". While at it, consolidate the code computing CMake_TEST_DEVENV to be more localized.
2014-03-03 21:40:58 +04:00
NOT CMAKE_MAKE_PROGRAM MATCHES "[mM][sS][bB][uU][iI][lL][dD]\\.[eE][xX][eE]")
set(CMake_TEST_DEVENV "${CMAKE_MAKE_PROGRAM}")
endif()
Xcode: Switch to internal CMAKE_MAKE_PROGRAM lookup by generator (#15324) The "cmakexbuild" wrapper is not needed for Xcode 4 and above, and the path to it may change when CMake moves. Avoid storing a specific path to a build program in CMakeCache.txt and instead compute the value for CMAKE_MAKE_PROGRAM on demand. However, if a user does set the value explicitly then honor it. This does for Xcode what commit v3.0.0-rc1~260^2~4 (VS: Switch to internal CMAKE_MAKE_PROGRAM lookup by generators, 2013-11-15) did for Visual Studio generators.
2015-01-28 22:00:02 +03:00
if(CMAKE_GENERATOR MATCHES "Visual Studio|Xcode")
Tests: Rename CMAKE_TEST_MAKEPROGRAM uses for explicit make program Rename uses of the variable for specifying the make program used to build test projects to CMake_TEST_EXPLICIT_MAKE_PROGRAM.
2014-03-03 22:58:19 +04:00
set(CMake_TEST_EXPLICIT_MAKE_PROGRAM "")
Tests: Drop CMAKE_TEST_GENERATOR and CMAKE_TEST_MAKEPROGRAM options Drop the option to test with a different generator and make program than was used to build. This was used only to test support for the Open Watcom compiler which at one time could not build CMake. Instead we will allow CMake to be configured to skip building binaries and just run the test suite using an external CMake (in a future change). For now leave the two option variables hard-coded to the old option defaults until code can be updated to stop using them.
2014-03-03 21:39:10 +04:00
else()
Tests: Rename CMAKE_TEST_MAKEPROGRAM uses for explicit make program Rename uses of the variable for specifying the make program used to build test projects to CMake_TEST_EXPLICIT_MAKE_PROGRAM.
2014-03-03 22:58:19 +04:00
set(CMake_TEST_EXPLICIT_MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM}")
Tests: Drop CMAKE_TEST_GENERATOR and CMAKE_TEST_MAKEPROGRAM options Drop the option to test with a different generator and make program than was used to build. This was used only to test support for the Open Watcom compiler which at one time could not build CMake. Instead we will allow CMake to be configured to skip building binaries and just run the test suite using an external CMake (in a future change). For now leave the two option variables hard-coded to the old option defaults until code can be updated to stop using them.
2014-03-03 21:39:10 +04:00
endif()
Tests: Move CMAKE_TEST_MAKEPROGRAM into Tests/CMakeLists.txt Also drop the temporary MAKEPROGRAM variable and the DART_ROOT special case. We never run dashboard clients with Dart anymore.
2013-11-14 18:04:54 +04:00
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
2014-03-04 00:24:03 +04:00
if(NOT CMake_TEST_EXTERNAL_CMAKE)
if("${CMAKE_GENERATOR}" MATCHES "Unix Makefiles" OR ("${CMAKE_GENERATOR}" MATCHES Ninja AND NOT WIN32))
set(TEST_CompileCommandOutput 1)
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
Only offer the compile command output feature on unix systems
2011-04-25 21:16:01 +04:00
Tests: Generalize decision for 'make' tool supporting spaces Some make tools do not support spaces inside the source tree paths. Decide early whether to add tests that depend on support for spaces so we can use the result in a decision for any test.
2013-02-22 17:14:18 +04:00
set(MAKE_IS_GNU )
Tests: Drop CMAKE_TEST_MAKEPROGRAM variable Remaining uses of the variable simply test its value so use CMAKE_MAKE_PROGRAM directly instead.
2014-03-03 22:58:37 +04:00
if(CMAKE_MAKE_PROGRAM MATCHES make)
execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} no_such_target --version
Tests: Generalize decision for 'make' tool supporting spaces Some make tools do not support spaces inside the source tree paths. Decide early whether to add tests that depend on support for spaces so we can use the result in a decision for any test.
2013-02-22 17:14:18 +04:00
RESULT_VARIABLE res OUTPUT_VARIABLE out ERROR_VARIABLE out)
if("${res}" STREQUAL "0")
if("${out}" MATCHES "GNU")
set(MAKE_IS_GNU 1)
endif()
endif()
endif()
# some old versions of make simply cannot handle spaces in paths
if (MAKE_IS_GNU OR
Tests: Drop CMAKE_TEST_MAKEPROGRAM variable Remaining uses of the variable simply test its value so use CMAKE_MAKE_PROGRAM directly instead.
2014-03-03 22:58:37 +04:00
CMAKE_MAKE_PROGRAM MATCHES "nmake|gmake|wmake" OR
Tests: Activate tests accidentally excluded from Xcode The generator name is "Xcode", not "XCode". Fix this typo. Explicitly exclude the SubDirSpaces test on Xcode because it does not work. Also tell the RunCMake.File_Generate test when Xcode is not multi-config so it can exlcude the OutputConflict case. Inspired-by: Daniele E. Domenichelli <daniele.domenichelli@iit.it>
2014-07-17 17:31:53 +04:00
CMAKE_GENERATOR MATCHES "Visual Studio|Xcode|Borland")
Tests: Generalize decision for 'make' tool supporting spaces Some make tools do not support spaces inside the source tree paths. Decide early whether to add tests that depend on support for spaces so we can use the result in a decision for any test.
2013-02-22 17:14:18 +04:00
set(MAKE_SUPPORTS_SPACES 1)
else()
set(MAKE_SUPPORTS_SPACES 0)
endif()
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
set(build_generator_args
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator ${CMAKE_GENERATOR}
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
)
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
if(CMAKE_GENERATOR_PLATFORM)
list(APPEND build_generator_args
--build-generator-platform ${CMAKE_GENERATOR_PLATFORM}
)
endif()
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(CMAKE_GENERATOR_TOOLSET)
Tests: Add generator toolset support Propagate CMAKE_GENERATOR_TOOLSET through the test hierarchy so that all tests can build with the selected generator toolset, if any.
2013-02-06 01:10:36 +04:00
list(APPEND build_generator_args
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator-toolset ${CMAKE_GENERATOR_TOOLSET}
Tests: Add generator toolset support Propagate CMAKE_GENERATOR_TOOLSET through the test hierarchy so that all tests can build with the selected generator toolset, if any.
2013-02-06 01:10:36 +04:00
)
endif()
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
set(build_options)
Tests: Rename CMAKE_TEST_MAKEPROGRAM uses for explicit make program Rename uses of the variable for specifying the make program used to build test projects to CMake_TEST_EXPLICIT_MAKE_PROGRAM.
2014-03-03 22:58:19 +04:00
if(CMake_TEST_EXPLICIT_MAKE_PROGRAM)
list(APPEND build_options -DCMAKE_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM})
Tests: Pass CMAKE_MAKE_PROGRAM instead of --build-makeprogram Pass the CMAKE_TEST_MAKEPROGRAM, if any, to each test at CMake time in the CMAKE_MAKE_PROGRAM cache entry. Pass the CMAKE_TEST_MAKEPROGRAM into the ExportImport, Fortran, and MacRuntimePath tests so that they may do the same for the nested project configurations. Now "ctest --build-and-test" can get the make program from the test build tree cache, so drop the explicit --build-makeprogram.
2013-11-15 18:07:42 +04:00
endif()
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
Tests: Consolidate detection of 'rpmbuild' Several tests use slight variations of the same logic to enable CPack RPM tests. Consolidate this logic into one check before any tests are added. Look for 'rpmbuild' only on Linux and only when the test build tree does not have spaces in the path. In particular, this will make the result available in time for the RunCMake.CPackRPM test to be activated even if CMake is configured exactly once.
2015-02-13 19:47:47 +03:00
# Look for rpmbuild to use for tests.
# The tool does not work with spaces in the path.
CPackRPM: run tests on more platforms than just Linux Lift the restriction that limits use of CPackRPM tests to Linux OS only because RPM can also be used on e.g. AIX which is Unix OS.
2015-02-23 02:43:09 +03:00
if(NOT CMAKE_CURRENT_BINARY_DIR MATCHES " ")
Tests: Consolidate detection of 'rpmbuild' Several tests use slight variations of the same logic to enable CPack RPM tests. Consolidate this logic into one check before any tests are added. Look for 'rpmbuild' only on Linux and only when the test build tree does not have spaces in the path. In particular, this will make the result available in time for the RunCMake.CPackRPM test to be activated even if CMake is configured exactly once.
2015-02-13 19:47:47 +03:00
find_program(RPMBUILD_EXECUTABLE NAMES rpmbuild)
else()
set(RPMBUILD_EXECUTABLE "RPMBUILD_EXECUTABLE-NOTFOUND")
endif()
CPack: Enable DEB and RPM tests more reliably CPack DEB and RPM generators were not used for some tests because CPACK_BINARY_DEB and CPACK_BINARY_RPM variable were not set. Fix this, simplify generator selection in CTEST_RUN_CPackComponentsForAll, and fix bugs that were detected after tests were run.
2015-05-09 01:42:30 +03:00
if(RPMBUILD_EXECUTABLE)
set(CPACK_BINARY_RPM ON)
else()
set(CPACK_BINARY_RPM OFF)
endif()
# Look for rpmbuild to use for tests.
# The tool does not work with spaces in the path.
find_program(DPKG_EXECUTABLE NAMES dpkg)
if(DPKG_EXECUTABLE)
set(CPACK_BINARY_DEB ON)
else()
set(CPACK_BINARY_DEB OFF)
endif()
Tests: Consolidate detection of 'rpmbuild' Several tests use slight variations of the same logic to enable CPack RPM tests. Consolidate this logic into one check before any tests are added. Look for 'rpmbuild' only on Linux and only when the test build tree does not have spaces in the path. In particular, this will make the result available in time for the RunCMake.CPackRPM test to be activated even if CMake is configured exactly once.
2015-02-13 19:47:47 +03:00
#---------------------------------------------------------------------------
# Add tests below here.
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
2014-03-04 00:24:03 +04:00
if(NOT CMake_TEST_EXTERNAL_CMAKE)
add_subdirectory(CMakeLib)
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_subdirectory(CMakeOnly)
add_subdirectory(RunCMake)
Create CMakeLib test driver and test cmXMLParser We create a new CMakeLibTests driver executable in which to writes unit tests for CMakeLib. Our first test is a smoke-test of cmXMLParser.
2009-12-08 19:44:50 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_subdirectory(FindPackageModeMakefileTest)
Add a test for the new --find-package mode Alex
2011-08-12 01:27:19 +04:00
ENH: Add test_clean target to wipe out tests We frequently need to wipe out all the CMake test build directories in order to run tests from scratch. This change adds a test_clean custom target to remove all these directories for out-of-source builds.
2008-08-19 19:43:57 +04:00
# Collect a list of all test build directories.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(TEST_BUILD_DIRS)
ENH: Add test_clean target to wipe out tests We frequently need to wipe out all the CMake test build directories in order to run tests from scratch. This change adds a test_clean custom target to remove all these directories for out-of-source builds.
2008-08-19 19:43:57 +04:00
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
# Should the long tests be run?
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
option(CMAKE_RUN_LONG_TESTS
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
"Should the long tests be run (such as Bootstrap)." ON)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
mark_as_advanced(CMAKE_RUN_LONG_TESTS)
ENH: Add patch for feature request #6847 - CPack components for NSIS and PackageMaker installers. Thanks to Doug Gregor for all the hard work involved with implementing this patch! Also added new test CPackComponents that is conditionally executed only when NSIS or PackageMaker installer builders are available.
2008-06-17 19:39:26 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if (CMAKE_RUN_LONG_TESTS)
option(CTEST_TEST_CTEST
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
"Should the tests that run a full sub ctest process be run?"
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
OFF)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
mark_as_advanced(CTEST_TEST_CTEST)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
ENH: some cleanup, condensing some tests, removing arguments that were not needed but rather were cut and paste copies etc
2007-05-18 23:11:20 +04:00
BUG: Additional fix necessary for issue #8481 so that Xcode builds do not write files into the source tree. Also add a test that runs last to check for local modifications in CMake_SOURCE_DIR based on whether 'cvs -q -n up -dP' output is empty. Test fails on dashboard runs when there are local modifications. Test passes on non-dashboard runs with local modifications so that CMake developers may have mods when running the test locally.
2009-07-24 23:58:23 +04:00
# Should tests that use CVS be run?
#
set(do_cvs_tests 0)
BUG: Close endif statements with same string as if so that it still configures with CMake 2.4 -- also check for existence of FindCVS.cmake before doing find_package(CVS QUIET) also for CMake 2.4 sake...
2009-07-25 00:31:33 +04:00
if(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
find_package(CVS QUIET)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
BUG: One last attempt for today to get the new CheckSourceTree test running on dashboards driven by CMake 2.4... Good night now.
2009-07-25 02:30:00 +04:00
find_program(CVS_EXECUTABLE NAMES cvs)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
BUG: Additional fix necessary for issue #8481 so that Xcode builds do not write files into the source tree. Also add a test that runs last to check for local modifications in CMake_SOURCE_DIR based on whether 'cvs -q -n up -dP' output is empty. Test fails on dashboard runs when there are local modifications. Test passes on non-dashboard runs with local modifications so that CMake developers may have mods when running the test locally.
2009-07-24 23:58:23 +04:00
BUG: One last attempt for today to get the new CheckSourceTree test running on dashboards driven by CMake 2.4... Good night now.
2009-07-25 02:30:00 +04:00
if(CVS_EXECUTABLE)
set(do_cvs_tests 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
BUG: One last attempt for today to get the new CheckSourceTree test running on dashboards driven by CMake 2.4... Good night now.
2009-07-25 02:30:00 +04:00
BUG: Additional fix necessary for issue #8481 so that Xcode builds do not write files into the source tree. Also add a test that runs last to check for local modifications in CMake_SOURCE_DIR based on whether 'cvs -q -n up -dP' output is empty. Test fails on dashboard runs when there are local modifications. Test passes on non-dashboard runs with local modifications so that CMake developers may have mods when running the test locally.
2009-07-24 23:58:23 +04:00
if(do_cvs_tests AND NOT UNIX)
if("${CVS_EXECUTABLE}" MATCHES "cygwin")
set(do_cvs_tests 0)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
BUG: Additional fix necessary for issue #8481 so that Xcode builds do not write files into the source tree. Also add a test that runs last to check for local modifications in CMake_SOURCE_DIR based on whether 'cvs -q -n up -dP' output is empty. Test fails on dashboard runs when there are local modifications. Test passes on non-dashboard runs with local modifications so that CMake developers may have mods when running the test locally.
2009-07-24 23:58:23 +04:00
ENH: Add patch for feature request #6847 - CPack components for NSIS and PackageMaker installers. Thanks to Doug Gregor for all the hard work involved with implementing this patch! Also added new test CPackComponents that is conditionally executed only when NSIS or PackageMaker installer builders are available.
2008-06-17 19:39:26 +04:00
# 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.
#
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
option(CTEST_TEST_CPACK
ENH: Add patch for feature request #6847 - CPack components for NSIS and PackageMaker installers. Thanks to Doug Gregor for all the hard work involved with implementing this patch! Also added new test CPackComponents that is conditionally executed only when NSIS or PackageMaker installer builders are available.
2008-06-17 19:39:26 +04:00
"Should the tests that use '--build-target package' be run?"
ON)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
mark_as_advanced(CTEST_TEST_CPACK)
set(CTEST_TEST_OSX_ARCH 0)
Tests: Compute Xcode version for any generator on OS X Store the version in CMake_TEST_XCODE_VERSION for use by tests that work with any generator on OS X but may depend on the Xcode version providing the tools.
2015-02-27 17:35:50 +03:00
set(CMake_TEST_XCODE_VERSION 0)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(APPLE)
execute_process(
ENH: Add patch for feature request #6847 - CPack components for NSIS and PackageMaker installers. Thanks to Doug Gregor for all the hard work involved with implementing this patch! Also added new test CPackComponents that is conditionally executed only when NSIS or PackageMaker installer builders are available.
2008-06-17 19:39:26 +04:00
COMMAND sw_vers -productVersion
OUTPUT_VARIABLE OSX_VERSION
OUTPUT_STRIP_TRAILING_WHITESPACE
)
Tests: Fix OS X version check to use component-wise test Otherwise 10.10 may be considered to be less than 10.4 and the tests for CPack will not run. Reported-by: Sean McBride <sean@rogue-research.com>
2014-12-12 23:08:00 +03:00
if(OSX_VERSION VERSION_LESS 10.4)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
message(STATUS "Forcing CTEST_TEST_CPACK=OFF on OSX < 10.4")
message(STATUS "OSX_VERSION='${OSX_VERSION}'")
set(CTEST_TEST_CPACK OFF)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CTEST_TEST_OSX_ARCH 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Tests: Compute Xcode version for any generator on OS X Store the version in CMake_TEST_XCODE_VERSION for use by tests that work with any generator on OS X but may depend on the Xcode version providing the tools.
2015-02-27 17:35:50 +03:00
if(XCODE_VERSION)
set(CMake_TEST_XCODE_VERSION "${XCODE_VERSION}")
else()
execute_process(
COMMAND xcodebuild -version
OUTPUT_VARIABLE _version ERROR_VARIABLE _version
)
if(_version MATCHES "^Xcode ([0-9]+(\\.[0-9]+)*)")
set(CMake_TEST_XCODE_VERSION "${CMAKE_MATCH_1}")
endif()
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Add patch for feature request #6847 - CPack components for NSIS and PackageMaker installers. Thanks to Doug Gregor for all the hard work involved with implementing this patch! Also added new test CPackComponents that is conditionally executed only when NSIS or PackageMaker installer builders are available.
2008-06-17 19:39:26 +04:00
BUG: Allow timeouts larger than 1500 for tests that may take longer than 25 minutes on really slow/busy machines. bootstrap has been timing out on tiamat, a very old machine, this should help it...
2008-04-19 21:37:38 +04:00
# Use 1500 or CTEST_TEST_TIMEOUT for long test timeout value,
# whichever is greater.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_LONG_TEST_TIMEOUT 1500)
if(CTEST_TEST_TIMEOUT)
set(CMAKE_LONG_TEST_TIMEOUT ${CTEST_TEST_TIMEOUT})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_LONG_TEST_TIMEOUT LESS 1500)
set(CMAKE_LONG_TEST_TIMEOUT 1500)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
BUG: Allow timeouts larger than 1500 for tests that may take longer than 25 minutes on really slow/busy machines. bootstrap has been timing out on tiamat, a very old machine, this should help it...
2008-04-19 21:37:38 +04:00
Copyright.txt: Add test to check year range Add a CMake.Copyright test that, when the CMake version number knows the year (as it does in development versions), checks that Copyright.txt has been updated with the current version year.
2013-11-13 01:13:02 +04:00
add_test(NAME CMake.Copyright
COMMAND cmake -P ${CMAKE_CURRENT_SOURCE_DIR}/CMakeCopyright.cmake)
ENH: some cleanup, condensing some tests, removing arguments that were not needed but rather were cut and paste copies etc
2007-05-18 23:11:20 +04:00
# add a bunch of standard build-and-test style tests
ENH: some more CMakeList cleanups
2007-05-11 18:22:20 +04:00
ADD_TEST_MACRO(CommandLineTest CommandLineTest)
ADD_TEST_MACRO(FindPackageTest FindPackageTest)
ENH: try turning this on again
2008-06-17 18:51:37 +04:00
ADD_TEST_MACRO(FindModulesExecuteAll FindModulesExecuteAll)
ENH: some more CMakeList cleanups
2007-05-11 18:22:20 +04:00
ADD_TEST_MACRO(StringFileTest StringFileTest)
ADD_TEST_MACRO(TryCompile TryCompile)
ADD_TEST_MACRO(SystemInformation SystemInformation)
ADD_TEST_MACRO(MathTest MathTest)
Tests: Execute compile features tests unconditionally. Conditionally create a dummy test if there are no known features.
2014-04-16 19:22:01 +04:00
ADD_TEST_MACRO(CompileFeatures CompileFeatures)
ADD_TEST_MACRO(CMakeCommands.target_compile_features target_compile_features)
Add testing for windows resources for mingw/msys/cygwin and remove for watcom. This commit should test windows resources on all platforms where they are supported now.
2010-12-28 18:58:20 +03:00
# assume no resources building to test
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(TEST_RESOURCES FALSE)
Add testing for windows resources for mingw/msys/cygwin and remove for watcom. This commit should test windows resources on all platforms where they are supported now.
2010-12-28 18:58:20 +03:00
# for windows and cygwin assume we have resources
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(WIN32 OR CYGWIN)
set(TEST_RESOURCES TRUE)
endif()
Add testing for windows resources for mingw/msys/cygwin and remove for watcom. This commit should test windows resources on all platforms where they are supported now.
2010-12-28 18:58:20 +03:00
# for borland and watcom there is no resource support
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if("${CMAKE_GENERATOR}" MATCHES "WMake" OR
"${CMAKE_GENERATOR}" MATCHES "Borland")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(TEST_RESOURCES FALSE)
endif()
if(TEST_RESOURCES)
Only run resource test for MSVC compilers.
2010-12-23 00:14:37 +03:00
ADD_TEST_MACRO(VSResource VSResource)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
ENH: some more CMakeList cleanups
2007-05-11 18:22:20 +04:00
ADD_TEST_MACRO(Simple Simple)
ADD_TEST_MACRO(PreOrder PreOrder)
Report missing source files with context of target Previously we reported only the CMakeLists.txt file in the directory that adds the target.
2010-09-13 23:56:06 +04:00
ADD_TEST_MACRO(MissingSourceFile MissingSourceFile)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(MissingSourceFile PROPERTIES
Test that missing source mentions directory (#11677) Teach the MissingSourceFile test to verify that the directory portion of a missing source file is mentioned in the error message.
2011-01-15 16:16:50 +03:00
PASS_REGULAR_EXPRESSION "CMake Error at CMakeLists.txt:3 \\(add_executable\\):[ \r\n]*Cannot find source file:[ \r\n]*DoesNotExist/MissingSourceFile.c")
Add rudimentary support for the Apple Swift language with Xcode Allow the `Swift` language to be enabled with the Xcode generator for Xcode >= 6.1. Reject it on other generators and with older Xcode versions. Since Apple is the only vendor implementing the language right now, the compiler id can be just `Apple`.
2015-07-06 23:15:49 +03:00
if(CMake_TEST_XCODE_VERSION AND NOT CMake_TEST_XCODE_VERSION VERSION_LESS 6.1)
if(CMAKE_GENERATOR STREQUAL "Xcode")
ADD_TEST_MACRO(SwiftMix SwiftMix)
ADD_TEST_MACRO(SwiftOnly SwiftOnly)
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_Fortran_COMPILER)
Fix custom commands in VS2010 Fortran projects using CFG_INTDIR and test. For custom commands in VS2010 Fortran projects the INTDIR variable is different than in the rest of the solution because Intel fortran still uses the old VS project files even in VS2010. So, we replace $(Configuration) directly in the project files. I have also added a FortranOnly test that tests this feature and is run on any generator that has Fortran abilities.
2011-08-04 01:24:43 +04:00
ADD_TEST_MACRO(FortranOnly FortranOnly)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
Add CMakeAddFortranSubdirectory to use MinGW gfortran in VS This patch adds a new module that allows for easy integration of MinGW gfortran and the Visual Studio compiler. It is done in a function called cmake_add_fortran_subdirectory. The patch also includes a test for this feature.
2011-12-10 03:04:19 +04:00
# test Visual Studio GNU Fortran mixing with cmake_add_fortran_subdirectory
# run this project if we have a working fortran compiler or
# the test is enabled with CMAKE_TEST_CMAKE_ADD_FORTRAN cache variable.
# If you enable the test, CMake should find the MinGW fortran install,
# or in some cases you might need to set the PATH so that cmake can find
# the gfortran from mingw.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_Fortran_COMPILER OR CMAKE_TEST_CMAKE_ADD_FORTRAN)
set(CMAKE_SKIP_VSGNUFortran FALSE)
VSGNUFortran: Disable test in special cases The ifort compiler found on some test machines does not support Mac universal binaries or the Linux Standard Base.
2011-12-17 03:20:46 +04:00
# disable test for apple builds using ifort if they are building
# more than one architecture, as ifort does not support that.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(APPLE AND (CMAKE_Fortran_COMPILER MATCHES ifort))
list(LENGTH CMAKE_OSX_ARCHITECTURES len)
if("${len}" GREATER 1)
message(STATUS "Skip VSGNUFortran for ifort dual cpu mac build")
set(CMAKE_SKIP_VSGNUFortran TRUE)
endif()
endif()
if((CMAKE_C_COMPILER MATCHES lsb)
VSGNUFortran: Disable test in special cases The ifort compiler found on some test machines does not support Mac universal binaries or the Linux Standard Base.
2011-12-17 03:20:46 +04:00
AND (CMAKE_Fortran_COMPILER MATCHES ifort))
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
message(STATUS "Skip VSGNUFortran for ifort and lsb compilers")
set(CMAKE_SKIP_VSGNUFortran TRUE)
endif()
if(NOT CMAKE_SKIP_VSGNUFortran)
VSGNUFortran: Disable test in special cases The ifort compiler found on some test machines does not support Mac universal binaries or the Linux Standard Base.
2011-12-17 03:20:46 +04:00
ADD_TEST_MACRO(VSGNUFortran ${CMAKE_COMMAND} -P runtest.cmake)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
endif()
ENH: some more CMakeList cleanups
2007-05-11 18:22:20 +04:00
ADD_TEST_MACRO(COnly COnly)
ADD_TEST_MACRO(CxxOnly CxxOnly)
Tests: Test using objects from a language enabled in a subdirectory (#15325) Add a test case that enables CXX in the top level and C in a subdirectory. Create an executable in the top level that uses C objects compiled in the subdirectory. Strictly speaking this is not defined behavior for all language combinations, but happens to work in this case. Test this behavior since projects might try to use it.
2014-12-23 03:55:08 +03:00
ADD_TEST_MACRO(CxxSubdirC CxxSubdirC)
Test INTERPROCEDURAL_OPTIMIZATION build feature This creates an "IPO" test that builds some other tests as subdirectories while enabling INTERPROCEDURAL_OPTIMIZATION. See issue #9615.
2009-10-02 21:52:29 +04:00
ADD_TEST_MACRO(IPO COnly/COnly)
Test per-config OUTPUT_DIRECTORY properties We test (ARCHIVE|LIBRARY|RUNTIME)_OUTPUT_DIRECTORY_<CONFIG> properties by building COnly as a subdirectory and setting the properties to put its files in specific locations. We build an executable that verifies the targets actually appear where expected.
2009-10-28 20:35:53 +03:00
ADD_TEST_MACRO(OutDir runtime/OutDir)
Test OBJECT library success cases Add "ObjectLibrary" test to build and use OBJECT libraries. Build multiple object libraries in separate directories with different flags. Use a custom command to generate a source file in one OBJECT library. Reference the OBJECT libraries for inclusion in a STATIC library, a SHARED library, and an EXECUTABLE target. Use the static and shared libraries each in executables that end up using the object library symbols. Verify that object library symbols are exported from the shared library.
2012-03-12 22:41:34 +04:00
ADD_TEST_MACRO(ObjectLibrary UseCshared)
ENH: some more CMakeList cleanups
2007-05-11 18:22:20 +04:00
ADD_TEST_MACRO(NewlineArgs NewlineArgs)
ADD_TEST_MACRO(SetLang SetLang)
set_property: Do not remove a property when APPENDing nothing
2013-07-23 01:19:55 +04:00
ADD_TEST_MACRO(EmptyProperty EmptyProperty)
ENH: some cleanup, condensing some tests, removing arguments that were not needed but rather were cut and paste copies etc
2007-05-18 23:11:20 +04:00
ADD_TEST_MACRO(ExternalOBJ ExternalOBJ)
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
2014-03-04 00:24:03 +04:00
if(NOT CMake_TEST_EXTERNAL_CMAKE)
ADD_TEST_MACRO(LoadCommand LoadedCommand)
endif()
Test CMP0015 OLD and NEW link_directories behavior We create a LinkDirectory test to check that the policy OLD and NEW behaviors work as documented. See issue #9697.
2009-11-24 19:17:16 +03:00
ADD_TEST_MACRO(LinkDirectory bin/LinkDirectory)
ENH: Test transitive link languages This test creates a C executable that links to a C++ static library. On most platforms the executable will not link unless the C++ linker is chosen correctly.
2009-07-10 21:53:38 +04:00
ADD_TEST_MACRO(LinkLanguage LinkLanguage)
ENH: some cleanup, condensing some tests, removing arguments that were not needed but rather were cut and paste copies etc
2007-05-18 23:11:20 +04:00
ADD_TEST_MACRO(LinkLine LinkLine)
ADD_TEST_MACRO(MacroTest miniMacroTest)
ENH: add functions and raise scope
2007-12-03 21:35:41 +03:00
ADD_TEST_MACRO(FunctionTest miniFunctionTest)
ENH: add testing for return and break commands
2008-01-23 18:29:21 +03:00
ADD_TEST_MACRO(ReturnTest ReturnTest)
ENH: added new test for SourceFile objects and properties
2007-05-31 18:29:13 +04:00
ADD_TEST_MACRO(Properties Properties)
ENH: add a simple assembler test Alex
2007-07-05 17:05:40 +04:00
ADD_TEST_MACRO(Assembler HelloAsm)
ENH: add the source_group() demo to the tests Alex
2007-08-27 22:17:29 +04:00
ADD_TEST_MACRO(SourceGroups SourceGroups)
ENH: Create COMPILE_DEFINITIONS property for targets and source files. Create <config>_COMPILE_DEFINITIONS property as per-configuration version. Add Preprocess test to test the feature. Document limitations on Xcode and VS6 generators.
2008-01-14 17:20:58 +03:00
ADD_TEST_MACRO(Preprocess Preprocess)
Tests: Rename CMAKE_TEST_MAKEPROGRAM uses for explicit make program Rename uses of the variable for specifying the make program used to build test projects to CMake_TEST_EXPLICIT_MAKE_PROGRAM.
2014-03-03 22:58:19 +04:00
set(ExportImport_BUILD_OPTIONS -DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM})
ENH: Added ExportImport test to test new export/import features.
2008-01-28 16:40:21 +03:00
ADD_TEST_MACRO(ExportImport ExportImport)
ENH: Add unset() command. This introduces the unset() command to make it easy to unset CMake variables, environment variables, and CMake cache variables. Previously it was not even possible to unset ENV or CACHE variables (as in completely remove them). Changes based on patch from Philip Lowman. See issue #7507.
2008-08-25 18:31:29 +04:00
ADD_TEST_MACRO(Unset Unset)
ENH: Better policies for functions and macros This teaches functions and macros to use policies recorded at creation time when they are invoked. It restores the policies as a weak policy stack entry so that any policies set by a function escape to its caller as before.
2009-01-22 21:16:47 +03:00
ADD_TEST_MACRO(PolicyScope PolicyScope)
Add test that CMake errors with empty libs When the library language cannot be determined, make sure CMake errors, not segfaults (bug #11230)
2010-09-30 19:01:35 +04:00
ADD_TEST_MACRO(EmptyLibrary EmptyLibrary)
Don't duplicate -D defines sent to the compiler. There is no need to do so. Be consistent with include directories and ensure uniqueness. This requires changing the API of the cmLocalGenerator::AppendDefines method, and changing the generators to match. The test unfortunately can't test for uniqueness, but it at least verifies that nothing gets lost.
2012-08-09 11:44:15 +04:00
ADD_TEST_MACRO(CompileDefinitions CompileDefinitions)
Add COMPILE_OPTIONS target property. This method reads generator expressions from the COMPILE_OPTIONS target property, as well as INTERFACE_COMPILE_OPTIONS from linked dependents.
2013-05-16 17:15:28 +04:00
ADD_TEST_MACRO(CompileOptions CompileOptions)
Make INTERFACE determined properties readable in generator expressions. The properties are evaluated as link-dependent interface properties when evaluating the generator expressions.
2013-01-19 14:21:14 +04:00
ADD_TEST_MACRO(CompatibleInterface CompatibleInterface)
Add the ALIAS target concept for libraries and executables. * The ALIAS name must match a validity regex. * Executables and libraries may be aliased. * An ALIAS acts immutable. It can not be used as the lhs of target_link_libraries or other commands. * An ALIAS can be used with add_custom_command, add_custom_target, and add_test in the same way regular targets can. * The target of an ALIAS can be retrieved with the ALIASED_TARGET target property. * An ALIAS does not appear in the generated buildsystem. It is kept separate from cmMakefile::Targets for that reason. * A target may have multiple aliases. * An ALIAS target may not itself have an alias. * An IMPORTED target may not have an alias. * An ALIAS may not be exported or imported.
2013-07-12 11:14:31 +04:00
ADD_TEST_MACRO(AliasTarget AliasTarget)
Introduce CMAKE_STAGING_PREFIX variable. This variable can be useful in cross-compiling contexts where the sysroot is read-only or where the sysroot should otherwise remain pristine. If the new CMAKE_STAGING_PREFIX variable is set, it is used instead of CMAKE_INSTALL_PREFIX when generating the installation rules in cmake_install.cmake. This way, the CMAKE_INSTALL_PREFIX variable always refers to the installation prefix on the target device, regardless of whether host==target. If any -rpath paths passed to the linker contain the CMAKE_STAGING_PREFIX, the matching path fragments are replaced with the CMAKE_INSTALL_PREFIX. Matching paths in the -rpath-link are not transformed. The cross-prefix usr-move workaround is assumed not to require extension regarding CMAKE_STAGING_PREFIX. The staging area is a single prefix, so there is no scope for cross-prefix symlinks. The CMAKE_INSTALL_PREFIX is still used to determine the workaround path, and that variable remains the relevant one even if CMAKE_STAGING_PREFIX is used. If the generated export files are deployed to the target, the workaround will still be in place, and still be employed if required.
2013-11-14 15:04:40 +04:00
ADD_TEST_MACRO(StagingPrefix StagingPrefix)
Add the INTERFACE_LIBRARY target type. This target type only contains INTERFACE_* properties, so it can be used as a structural node. The target-specific commands enforce that they may only be used with the INTERFACE keyword when used with INTERFACE_LIBRARY targets. The old-style target properties matching LINK_INTERFACE_LIBRARIES_<CONFIG> are always ignored for this target type. The name of the INTERFACE_LIBRARY must match a validity generator expression. The validity is similar to that of an ALIAS target, but with the additional restriction that it may not contain double colons. Double colons will carry the meaning of IMPORTED or ALIAS targets in CMake 2.8.13. An ALIAS target may be created for an INTERFACE library. At this point it can not be exported and does not appear in the buildsystem and project files are not created for them. That may be added as a feature in a later commit. The generators need some changes to handle the INTERFACE_LIBRARY targets returned by cmComputeLinkInterface::GetItems. The Ninja generator does not use that API, so it doesn't require changes related to that.
2012-11-02 18:47:40 +04:00
ADD_TEST_MACRO(InterfaceLibrary InterfaceLibrary)
cmTarget: Make the source files depend on the config. Disallow the use of config-specific source files with the Visual Studio and Xcode generators. They don't have any way to represent the condition currently. Use the same common-config API in cmQtAutoGenerators. While it accepts config-specific files, it doesn't have to support multiple configurations yet. Loop over the configs in cmTargetTraceDependencies and cmGlobalGenerator::WriteSummary and consume all source files. Loop over the configs in cmComputeTargetDepends and compute the object library dependencies for each config.
2014-02-13 20:25:00 +04:00
if (CMAKE_BUILD_TYPE MATCHES "[Dd][Ee][Bb][Uu][Gg]")
set(ConfigSources_BUILD_OPTIONS -DCMAKE_BUILD_TYPE=Debug)
ADD_TEST_MACRO(ConfigSources ConfigSources)
endif()
cmTarget: Allow transitive evaluation of SOURCES property. Extend the cmGeneratorExpressionDAGChecker with an interface returning the name of the top target. Use that to determine when there is a DAG violation, as required by the RunCMake.Languages tests.
2014-02-13 23:52:21 +04:00
ADD_TEST_MACRO(SourcesProperty SourcesProperty)
test: test source file properties with case-insensitivity Some filesystems are case insensitive, so when setting properties on the files, this should be respected (modulo a policy decision).
2014-11-21 21:21:55 +03:00
ADD_TEST_MACRO(SourceFileProperty SourceFileProperty)
cmTarget: Add CXX_STANDARD and CXX_EXTENSION target properties. These are used to determine whether to add -std=c++11, -std=gnu++11 etc flags on the compile line.
2013-10-13 04:00:24 +04:00
if(CMAKE_CXX_COMPILER_ID STREQUAL GNU
Fix the test for running the CxxDialog unit test. The existing versions have been used since commit v3.1.0-rc1~635^2~8 (cmTarget: Add CXX_STANDARD and CXX_EXTENSION target properties., 2013-10-13), but further discussions since then increased the initial minimum compiler versions this feature is available for.
2014-11-21 00:09:20 +03:00
AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.7)
cmTarget: Add CXX_STANDARD and CXX_EXTENSION target properties. These are used to determine whether to add -std=c++11, -std=gnu++11 etc flags on the compile line.
2013-10-13 04:00:24 +04:00
set(runCxxDialectTest 1)
endif()
if(CMAKE_CXX_COMPILER_ID STREQUAL Clang
Fix the test for running the CxxDialog unit test. The existing versions have been used since commit v3.1.0-rc1~635^2~8 (cmTarget: Add CXX_STANDARD and CXX_EXTENSION target properties., 2013-10-13), but further discussions since then increased the initial minimum compiler versions this feature is available for.
2014-11-21 00:09:20 +03:00
AND NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 3.4)
cmTarget: Add CXX_STANDARD and CXX_EXTENSION target properties. These are used to determine whether to add -std=c++11, -std=gnu++11 etc flags on the compile line.
2013-10-13 04:00:24 +04:00
if(NOT APPLE OR POLICY CMP0025)
set(runCxxDialectTest 1)
endif()
endif()
if(runCxxDialectTest)
ADD_TEST_MACRO(CxxDialect CxxDialect)
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(EmptyLibrary PROPERTIES
Add whitespace after colons in error messages.
2013-06-21 15:51:58 +04:00
PASS_REGULAR_EXPRESSION "CMake Error: CMake can not determine linker language for target: test")
Added test coverage for TRY_RUN in cross compile mode.
2009-11-09 19:14:21 +03:00
ADD_TEST_MACRO(CrossCompile CrossCompile)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CrossCompile PROPERTIES
Fix TRY_RUN cross compile test to pass consistently
2009-11-09 20:05:49 +03:00
PASS_REGULAR_EXPRESSION "TRY_RUN.. invoked in cross-compiling mode")
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Make")
Test support for OLD behavior of policy CMP0002 Policy CMP0002's OLD behavior allows duplicate non-custom targets. We test it with a project that builds two executables of the same name by setting CMP0002 to OLD.
2009-09-29 01:34:34 +04:00
ADD_TEST_MACRO(Policy0002 Policy0002)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_TEST_OSX_ARCH)
Test OSX_ARCHITECTURES target property We test the property with a project that fails to link due to an architecture mismatch between an executable and a static library. See issue #8725.
2009-10-21 21:01:17 +04:00
ADD_TEST_MACRO(Architecture Architecture)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(Architecture PROPERTIES
Fix 'Architecture' test for more Mac linkers Some Mac linkers produce the message "file was built for unsupported file format which is not the architecture being linked" for this test. Update the test output regex to match it.
2010-05-06 22:37:55 +04:00
PASS_REGULAR_EXPRESSION "(file is not of required architecture|does not match cputype|not the architecture being linked)")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS ${CMake_TEST_INSTALL_PREFIX})
Test 'install' target of CMake itself We create option CMake_TEST_INSTALL to enable a new CMake.Install test. It tests running the "make install" target to install CMake itself into a test directory. We enable the option by default for dashboard builds.
2009-12-10 18:34:36 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(NOT QT4_FOUND)
Tests: Make find_package(Qt4) QUIET The lack of Qt4 on a system should silently skip the corresponding tests with no other messages. This is already the case for other find_package calls in Tests/CMakeLists.txt.
2013-10-03 21:10:31 +04:00
find_package(Qt4 QUIET)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
BundleUtilities: Work w/ non .app exes on Mac (#12034) Also add a test of BundleUtilities including an exe, some shared libs, a plugin, and a framework-style lib. This test presently runs (and this functionality works) on Linux, Mac and Windows. For now, the framework-style lib is built as a plain old shared lib because there is another yet-unresolved issue with local frameworks without rpaths on the Mac.
2011-05-27 01:16:58 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(QT4_FOUND)
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
# test whether the Qt4 which has been found works, on some machines
# which run nightly builds there were errors like "wrong file format"
# for libQtCore.so. So first check it works, and only if it does add
# the automoc test.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
include(CheckCXXSourceCompiles)
set(_save_CMAKE_REQUIRED_INCLUDES "${CMAKE_REQUIRED_INCLUDES}")
set(_save_CMAKE_REQUIRED_LIBRARIES "${CMAKE_REQUIRED_LIBRARIES}")
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_REQUIRED_INCLUDES ${QT_INCLUDES})
set(CMAKE_REQUIRED_LIBRARIES ${QT_QTCORE_LIBRARIES})
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
CHECK_CXX_SOURCE_COMPILES("#include <QCoreApplication>\n int main() {return (qApp == 0 ? 0 : 1); }\n"
QT4_WORKS)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_REQUIRED_INCLUDES "${_save_CMAKE_REQUIRED_INCLUDES}")
set(CMAKE_REQUIRED_LIBRARIES "${_save_CMAKE_REQUIRED_LIBRARIES}")
endif()
BundleUtilities: Work w/ non .app exes on Mac (#12034) Also add a test of BundleUtilities including an exe, some shared libs, a plugin, and a framework-style lib. This test presently runs (and this functionality works) on Linux, Mac and Windows. For now, the framework-style lib is built as a plain old shared lib because there is another yet-unresolved issue with local frameworks without rpaths on the Mac.
2011-05-27 01:16:58 +04:00
BundleUtilities: Disable running test on Windows unless using MSVC.
2011-06-01 08:15:34 +04:00
# run test for BundleUtilities on supported platforms/compilers
Revert "BundleUtilities: Run test on Windows if either MSVC or dumpbin was found." This reverts commit f3de459cec78eac3a7081379b6ee9c6cde36bb60. There are some platforms without MSVC where this test doesn't work well. We can look into these later.
2011-06-02 19:09:14 +04:00
if(MSVC OR
GetPrerequisites: Enable test for BundleUtilities on MinGW Signed-off-by: Michael Tänzer <neo@nhng.de>
2013-03-01 19:26:07 +04:00
MINGW OR
BundleUtilities: Work w/ non .app exes on Mac (#12034) Also add a test of BundleUtilities including an exe, some shared libs, a plugin, and a framework-style lib. This test presently runs (and this functionality works) on Linux, Mac and Windows. For now, the framework-style lib is built as a plain old shared lib because there is another yet-unresolved issue with local frameworks without rpaths on the Mac.
2011-05-27 01:16:58 +04:00
CMAKE_SYSTEM_NAME MATCHES "Linux" OR
CMAKE_SYSTEM_NAME MATCHES "Darwin")
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(NOT "${CMAKE_GENERATOR}" STREQUAL "Watcom WMake")
Add test for DeployQt4.cmake
2012-01-21 03:30:35 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(BundleUtilities ${CMAKE_CTEST_COMMAND}
BundleUtilities: Work w/ non .app exes on Mac (#12034) Also add a test of BundleUtilities including an exe, some shared libs, a plugin, and a framework-style lib. This test presently runs (and this functionality works) on Linux, Mac and Windows. For now, the framework-style lib is built as a plain old shared lib because there is another yet-unresolved issue with local frameworks without rpaths on the Mac.
2011-05-27 01:16:58 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/BundleUtilities"
"${CMake_BINARY_DIR}/Tests/BundleUtilities"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
BundleUtilities: Work w/ non .app exes on Mac (#12034) Also add a test of BundleUtilities including an exe, some shared libs, a plugin, and a framework-style lib. This test presently runs (and this functionality works) on Linux, Mac and Windows. For now, the framework-style lib is built as a plain old shared lib because there is another yet-unresolved issue with local frameworks without rpaths on the Mac.
2011-05-27 01:16:58 +04:00
--build-project BundleUtilities
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
BundleUtilities: Work w/ non .app exes on Mac (#12034) Also add a test of BundleUtilities including an exe, some shared libs, a plugin, and a framework-style lib. This test presently runs (and this functionality works) on Linux, Mac and Windows. For now, the framework-style lib is built as a plain old shared lib because there is another yet-unresolved issue with local frameworks without rpaths on the Mac.
2011-05-27 01:16:58 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleUtilities")
Add test for DeployQt4.cmake
2012-01-21 03:30:35 +04:00
# run test for DeployQt4 on supported platforms/compilers (which depends on BundleUtilities)
# this test also depends on the existence of the standard qtiff plugin
Remove QtGui dependency in Qt4Deploy test and verify QtSql existance.
2012-02-29 18:55:31 +04:00
if(QT4_WORKS AND QT_QTSQL_FOUND)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(Qt4Deploy ${CMAKE_CTEST_COMMAND}
Add test for DeployQt4.cmake
2012-01-21 03:30:35 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Qt4Deploy"
"${CMake_BINARY_DIR}/Tests/Qt4Deploy"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Add test for DeployQt4.cmake
2012-01-21 03:30:35 +04:00
--build-project Qt4Deploy
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Add test for DeployQt4.cmake
2012-01-21 03:30:35 +04:00
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
Add test for DeployQt4.cmake
2012-01-21 03:30:35 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Deploy")
Add test for DeployQt4.cmake
2012-01-21 03:30:35 +04:00
endif()
BundleUtilities: Avoid test on Watcom dashboards (#12034)
2011-06-05 03:52:45 +04:00
endif()
endif()
BundleUtilities: Work w/ non .app exes on Mac (#12034) Also add a test of BundleUtilities including an exe, some shared libs, a plugin, and a framework-style lib. This test presently runs (and this functionality works) on Linux, Mac and Windows. For now, the framework-style lib is built as a plain old shared lib because there is another yet-unresolved issue with local frameworks without rpaths on the Mac.
2011-05-27 01:16:58 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/COnly")
set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/CMakeBuildCOnly")
set(CMAKE_BUILD_TEST_EXE COnly)
configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
BUG: 4244, add a --build option to cmake that can build projects configured by CMake
2008-10-15 21:56:07 +04:00
"${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake" @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CMakeBuildTest ${CMAKE_CMAKE_COMMAND} -P
BUG: 4244, add a --build option to cmake that can build projects configured by CMake
2008-10-15 21:56:07 +04:00
"${CMake_BINARY_DIR}/Tests/CMakeBuildTest.cmake")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
Fix the case where cmake --build failed with two project cmds in one file. This adds a test that uses two project commands in the same CMakeLists.txt file. It also adds a fix so that cmake --build will work in that case. The fix sets the name of the last project command in the top level CMakeLists.txt in the cache variable CMAKE_PROJECT_NAME. This variable is used by cmake --build to find the project name.
2011-12-16 06:56:34 +04:00
# now do it again for a project that has two project commands
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_BUILD_TEST_SOURCE_DIR "${CMake_SOURCE_DIR}/Tests/DoubleProject")
set(CMAKE_BUILD_TEST_BINARY_DIR "${CMake_BINARY_DIR}/Tests/DoubleProject")
set(CMAKE_BUILD_TEST_EXE just_silly)
configure_file("${CMake_SOURCE_DIR}/Tests/CMakeBuildTest.cmake.in"
Fix the case where cmake --build failed with two project cmds in one file. This adds a test that uses two project commands in the same CMakeLists.txt file. It also adds a fix so that cmake --build will work in that case. The fix sets the name of the last project command in the top level CMakeLists.txt in the cache variable CMAKE_PROJECT_NAME. This variable is used by cmake --build to find the project name.
2011-12-16 06:56:34 +04:00
"${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake" @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CMakeDoubleProject ${CMAKE_CMAKE_COMMAND} -P
Fix the case where cmake --build failed with two project cmds in one file. This adds a test that uses two project commands in the same CMakeLists.txt file. It also adds a fix so that cmake --build will work in that case. The fix sets the name of the last project command in the top level CMakeLists.txt in the cache variable CMAKE_PROJECT_NAME. This variable is used by cmake --build to find the project name.
2011-12-16 06:56:34 +04:00
"${CMake_BINARY_DIR}/Tests/CMakeBuildDoubleProjectTest.cmake")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS ${CMAKE_BUILD_TEST_BINARY_DIR})
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
Test the CheckTypeSize module We create test "Module.CheckTypeSize" to verify that type sizes get detected correctly.
2009-12-17 23:15:34 +03:00
ADD_TEST_MACRO(Module.CheckTypeSize CheckTypeSize)
ExternalData: Add tests covering interfaces and errors Add a Module.ExternalData test to verify data retrieval and test argument DATA{} references. Add a RunCMake.ExternalData test to verify error handling and automatic transformation of a raw data to a content link and staged object.
2013-01-26 01:39:57 +04:00
add_test(Module.ExternalData ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Module/ExternalData"
"${CMake_BINARY_DIR}/Tests/Module/ExternalData"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ExternalData: Add tests covering interfaces and errors Add a Module.ExternalData test to verify data retrieval and test argument DATA{} references. Add a RunCMake.ExternalData test to verify error handling and automatic transformation of a raw data to a content link and staged object.
2013-01-26 01:39:57 +04:00
--build-project ExternalDataTest
Fix Module.ExternalData test on VS 6 Run the test with the ctest --build-noclean option. The test CMakeLists.txt file already uses file(REMOVE_RECURSE) to clean out downloaded data anyway. Some file removed by "msdev ... /clean" causes CMake to re-run in the middle of the build step and file(REMOVE_RECURSE) wipes out already-generated files.
2013-02-03 20:44:05 +04:00
--build-noclean
ExternalData: Add tests covering interfaces and errors Add a Module.ExternalData test to verify data retrieval and test argument DATA{} references. Add a RunCMake.ExternalData test to verify error handling and automatic transformation of a raw data to a content link and staged object.
2013-01-26 01:39:57 +04:00
--force-new-ctest-process
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
-DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES}
ExternalData: Add tests covering interfaces and errors Add a Module.ExternalData test to verify data retrieval and test argument DATA{} references. Add a RunCMake.ExternalData test to verify error handling and automatic transformation of a raw data to a content link and staged object.
2013-01-26 01:39:57 +04:00
--test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} -V
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Module/ExternalData")
Add the GenerateExportMacro with unit tests. Reviewed-by: Marcus D. Hanwell <marcus.hanwell@kitware.com>
2011-07-13 04:13:33 +04:00
ADD_TEST_MACRO(Module.GenerateExportHeader GenerateExportHeader)
Add test for find_dependency macro.
2014-02-27 00:30:18 +04:00
ADD_TEST_MACRO(Module.FindDependency FindDependency)
Add the GenerateExportMacro with unit tests. Reviewed-by: Marcus D. Hanwell <marcus.hanwell@kitware.com>
2011-07-13 04:13:33 +04:00
Add the WriteCompilerDetectionHeader module. Provide a function to write a portable header to detect compiler features. Generate a preprocessor #error for unknown compilers and compiler versions whose features are not yet recorded. This error condition might be relaxed in the future, but for now it is useful for verification of expectations.
2013-10-21 18:59:40 +04:00
ADD_TEST_MACRO(Module.WriteCompilerDetectionHeader WriteCompilerDetectionHeader)
Refactor generation of shared library flags CMAKE_SHARED_LIBRARY_<lang>_FLAGS has flags on various platforms for a variety of purposes that are correlated with shared libraries but not exclusive to them. Refactor generation of these flags to use new purpose-specific platform variables CMAKE_<lang>_COMPILE_OPTIONS_DLL CMAKE_<lang>_COMPILE_OPTIONS_PIC CMAKE_<lang>_COMPILE_OPTIONS_PIE Activate the DLL flags specifically for shared libraries. Add a new POSITION_INDEPENDENT_CODE target property to activate PIC/PIE flags, and default to true for shared libraries to preserve default behavior. Initialize the new property from CMAKE_POSITION_INDEPENDENT_CODE to allow easy global configuration in projects. Although the default behavior is unchanged by this refactoring, the new approach ignores CMAKE_SHARED_LIBRARY_<lang>_FLAGS completely. We must leave it set in case projects reference the value. Furthermore, if a project modifies CMAKE_SHARED_LIBRARY_<lang>_FLAGS it expects the new value to be used. Add policy CMP0018 to handle compatibility with projects that modify this platform variable. Add a PositionIndependentCode test on platforms where we can get meaningful results.
2012-05-30 22:13:09 +04:00
if (APPLE OR CMAKE_CXX_COMPILER_ID MATCHES "GNU")
include(CheckCXXCompilerFlag)
check_cxx_compiler_flag(-fPIE run_pic_test)
else()
if (CMAKE_CXX_COMPILER_ID MATCHES "PGI"
OR CMAKE_CXX_COMPILER_ID MATCHES "PathScale"
OR CMAKE_SYSTEM_NAME MATCHES "IRIX64"
OR CMAKE_CXX_COMPILER_ID MATCHES "Intel")
set(run_pic_test 0)
else()
set(run_pic_test 1)
endif()
endif()
if (run_pic_test)
ADD_TEST_MACRO(PositionIndependentTargets PositionIndependentTargets)
endif()
VisibilityInlinesHidden: only apply -fvisibility-inlines-hidden to C++ sources
2014-01-31 19:09:06 +04:00
if((CMAKE_CXX_COMPILER_ID MATCHES "GNU") AND
(NOT "${CMAKE_CXX_COMPILER_VERSION}" VERSION_LESS 4.2) AND
(CMAKE_SYSTEM_NAME MATCHES "Linux"))
include(CheckCXXCompilerFlag)
check_cxx_compiler_flag(
-fvisibility-inlines-hidden run_inlines_hidden_test)
endif()
if(run_inlines_hidden_test)
Tests: Rename Visibility{InlinesHidden =>} We will soon generalize it to cover other visibility properties.
2015-05-22 22:24:18 +03:00
add_test(Visibility ${CMAKE_CTEST_COMMAND}
VisibilityInlinesHidden: only apply -fvisibility-inlines-hidden to C++ sources
2014-01-31 19:09:06 +04:00
--build-and-test
Tests: Rename Visibility{InlinesHidden =>} We will soon generalize it to cover other visibility properties.
2015-05-22 22:24:18 +03:00
"${CMake_SOURCE_DIR}/Tests/Visibility"
"${CMake_BINARY_DIR}/Tests/Visibility"
VisibilityInlinesHidden: only apply -fvisibility-inlines-hidden to C++ sources
2014-01-31 19:09:06 +04:00
${build_generator_args}
Tests: Rename Visibility{InlinesHidden =>} We will soon generalize it to cover other visibility properties.
2015-05-22 22:24:18 +03:00
--build-project Visibility
VisibilityInlinesHidden: only apply -fvisibility-inlines-hidden to C++ sources
2014-01-31 19:09:06 +04:00
--build-options ${build_options}
)
list(APPEND TEST_BUILD_DIRS
Tests: Rename Visibility{InlinesHidden =>} We will soon generalize it to cover other visibility properties.
2015-05-22 22:24:18 +03:00
"${CMake_BINARY_DIR}/Tests/Visibility"
VisibilityInlinesHidden: only apply -fvisibility-inlines-hidden to C++ sources
2014-01-31 19:09:06 +04:00
)
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(LinkFlags-prepare
Test LINK_FLAGS and STATIC_LIBRARY_FLAGS (#10768) Add a LinkFlags test series to check that these properties work. Since no link flag is accepted everywhere we test for presence of flags by adding a bad flag and looking for the complaint in the test output.
2010-05-28 17:47:12 +04:00
${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LinkFlags"
"${CMake_BINARY_DIR}/Tests/LinkFlags"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Test LINK_FLAGS and STATIC_LIBRARY_FLAGS (#10768) Add a LinkFlags test series to check that these properties work. Since no link flag is accepted everywhere we test for presence of flags by adding a bad flag and looking for the complaint in the test output.
2010-05-28 17:47:12 +04:00
--build-project LinkFlags
--build-target LinkFlags
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
-DTEST_CONFIG=\${CTEST_CONFIGURATION_TYPE}
Test LINK_FLAGS and STATIC_LIBRARY_FLAGS (#10768) Add a LinkFlags test series to check that these properties work. Since no link flag is accepted everywhere we test for presence of flags by adding a bad flag and looking for the complaint in the test output.
2010-05-28 17:47:12 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LinkFlags")
Test LINK_FLAGS and STATIC_LIBRARY_FLAGS (#10768) Add a LinkFlags test series to check that these properties work. Since no link flag is accepted everywhere we test for presence of flags by adding a bad flag and looking for the complaint in the test output.
2010-05-28 17:47:12 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
macro(ADD_LINK_FLAGS_TEST name depends)
add_test(LinkFlags-${name}
Test LINK_FLAGS and STATIC_LIBRARY_FLAGS (#10768) Add a LinkFlags test series to check that these properties work. Since no link flag is accepted everywhere we test for presence of flags by adding a bad flag and looking for the complaint in the test output.
2010-05-28 17:47:12 +04:00
${CMAKE_CMAKE_COMMAND} --build "${CMake_BINARY_DIR}/Tests/LinkFlags"
--target LinkFlags_${name} --config \${CTEST_CONFIGURATION_TYPE}
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(LinkFlags-${name} PROPERTIES
Test LINK_FLAGS and STATIC_LIBRARY_FLAGS (#10768) Add a LinkFlags test series to check that these properties work. Since no link flag is accepted everywhere we test for presence of flags by adding a bad flag and looking for the complaint in the test output.
2010-05-28 17:47:12 +04:00
PASS_REGULAR_EXPRESSION "BADFLAG" DEPENDS LinkFlags-${depends})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endmacro()
Test LINK_FLAGS and STATIC_LIBRARY_FLAGS (#10768) Add a LinkFlags test series to check that these properties work. Since no link flag is accepted everywhere we test for presence of flags by adding a bad flag and looking for the complaint in the test output.
2010-05-28 17:47:12 +04:00
ADD_LINK_FLAGS_TEST(lib prepare)
ADD_LINK_FLAGS_TEST(dll lib)
Add additonal tests for the linker flags Extend Tests/LinkFlags to test libraries of the type MODULE and the content of the CMAKE_*_LINKER_FLAGS_* variables.
2013-07-28 22:34:16 +04:00
ADD_LINK_FLAGS_TEST(mod dll)
ADD_LINK_FLAGS_TEST(exe mod)
Test LINK_FLAGS and STATIC_LIBRARY_FLAGS (#10768) Add a LinkFlags test series to check that these properties work. Since no link flag is accepted everywhere we test for presence of flags by adding a bad flag and looking for the complaint in the test output.
2010-05-28 17:47:12 +04:00
ADD_LINK_FLAGS_TEST(lib_config exe)
ADD_LINK_FLAGS_TEST(dll_config lib_config)
Add additonal tests for the linker flags Extend Tests/LinkFlags to test libraries of the type MODULE and the content of the CMAKE_*_LINKER_FLAGS_* variables.
2013-07-28 22:34:16 +04:00
ADD_LINK_FLAGS_TEST(mod_config dll_config)
ADD_LINK_FLAGS_TEST(exe_config mod_config)
ADD_LINK_FLAGS_TEST(lib_flags exe_config)
ADD_LINK_FLAGS_TEST(dll_flags lib_flags)
ADD_LINK_FLAGS_TEST(mod_flags dll_flags)
ADD_LINK_FLAGS_TEST(exe_flags mod_flags)
ADD_LINK_FLAGS_TEST(lib_flags_config exe_flags)
ADD_LINK_FLAGS_TEST(dll_flags_config lib_flags_config)
ADD_LINK_FLAGS_TEST(mod_flags_config dll_flags_config)
ADD_LINK_FLAGS_TEST(exe_flags_config mod_flags_config)
Test LINK_FLAGS and STATIC_LIBRARY_FLAGS (#10768) Add a LinkFlags test series to check that these properties work. Since no link flag is accepted everywhere we test for presence of flags by adding a bad flag and looking for the complaint in the test output.
2010-05-28 17:47:12 +04:00
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
# If we are running right now with a UnixMakefiles based generator,
# build the "Simple" test with the ExtraGenerators, if available
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
# This doesn't test whether the generated project files work (unfortunately),
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
# mainly it tests that cmake doesn't crash when generating these project files.
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(${CMAKE_GENERATOR} MATCHES "Unix Makefiles" OR ${CMAKE_GENERATOR} MATCHES "KDevelop")
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
# check which generators we have
Tests: Replace exec_program with execute_process Drop use of the old exec_program command from CMake's own CMakeLists.txt files.
2013-02-22 17:08:12 +04:00
execute_process(COMMAND ${CMAKE_CMAKE_COMMAND} --help
OUTPUT_VARIABLE cmakeOutput ERROR_VARIABLE cmakeOutput)
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
# check for the Eclipse generator
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if ("${cmakeOutput}" MATCHES Eclipse)
add_test(Simple_EclipseGenerator ${CMAKE_CTEST_COMMAND}
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Simple"
"${CMake_BINARY_DIR}/Tests/Simple_EclipseGenerator"
--build-two-config
--build-generator "Eclipse CDT4 - Unix Makefiles"
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
--build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
--build-project Simple
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
--test-command Simple)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_EclipseGenerator")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
# check for the CodeBlocks generator
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if ("${cmakeOutput}" MATCHES CodeBlocks)
add_test(Simple_CodeBlocksGenerator ${CMAKE_CTEST_COMMAND}
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Simple"
"${CMake_BINARY_DIR}/Tests/Simple_CodeBlocksGenerator"
--build-two-config
--build-generator "CodeBlocks - Unix Makefiles"
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
--build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
--build-project Simple
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
--test-command Simple)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_CodeBlocksGenerator")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
# check for the KDevelop3 generator
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if ("${cmakeOutput}" MATCHES KDevelop3)
add_test(Simple_KDevelop3Generator ${CMAKE_CTEST_COMMAND}
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Simple"
"${CMake_BINARY_DIR}/Tests/Simple_KDevelop3Generator"
--build-two-config
--build-generator "KDevelop3 - Unix Makefiles"
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
--build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
--build-project Simple
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
--test-command Simple)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_KDevelop3Generator")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
Revert "Qbs: Add new 'extra' generator for qbs project files" This reverts commit f85db2f32358e6de921aba7d1cb8ecb81da934c0. Discussion by the QtCreator community at https://bugreports.qt.io/browse/QTCREATORBUG-13695 raises concerns about this particular approach to working with CMake projects using QtCreator. Also, the functionality and design of the QBS extra generator was never discussed on the CMake mailing list or with QtCreator developers. There may be better ways to make the two tools work together. In order to avoid committing to long-term support of this generator prior to such discussion taking place, revert it from CMake for now. We may restore this or use an alternative design based on results of such discussion.
2015-05-21 16:05:58 +03:00
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: add simple tests to test that the extra generators don't crash Alex
2008-08-07 00:16:53 +04:00
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
# test for correct sub-project generation
Tests: Configure SubProject-Stage2 test more robustly Fix the condition that adds the test to check CMAKE_TEST_GENERATOR rather than the tools used to build CMake. Drop the test on Ninja because the generator does not support subproject generation anyway. Stop using the general build_generator_args and pass the --build-generator options explicitly. Also pass --build-makeprogram explicitly when CMAKE_TEST_MAKEPROGRAM is available because there is no CMakeCache.txt in the test project subdirectory from which to pick up the make program.
2013-11-15 19:33:04 +04:00
# not implemented in VS 6, VS 7.0, Xcode, or Ninja
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(NOT CMAKE_GENERATOR MATCHES "Visual Studio [67]$|Xcode|Ninja")
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
# run cmake and configure all of SubProject
# but only build the independent executable car
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(SubProject ${CMAKE_CTEST_COMMAND}
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SubProject"
"${CMake_BINARY_DIR}/Tests/SubProject"
--build-project SubProject
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
--build-target car
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
--test-command car
)
Ninja: Add the Ninja generator
2011-11-11 09:00:49 +04:00
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
# 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
Tests: Rename CMAKE_TEST_MAKEPROGRAM uses for explicit make program Rename uses of the variable for specifying the make program used to build test projects to CMake_TEST_EXPLICIT_MAKE_PROGRAM.
2014-03-03 22:58:19 +04:00
if(CMake_TEST_EXPLICIT_MAKE_PROGRAM)
Tests: Configure SubProject-Stage2 test more robustly Fix the condition that adds the test to check CMAKE_TEST_GENERATOR rather than the tools used to build CMake. Drop the test on Ninja because the generator does not support subproject generation anyway. Stop using the general build_generator_args and pass the --build-generator options explicitly. Also pass --build-makeprogram explicitly when CMAKE_TEST_MAKEPROGRAM is available because there is no CMakeCache.txt in the test project subdirectory from which to pick up the make program.
2013-11-15 19:33:04 +04:00
set(SubProject-Stage2_BUILD_MAKEPROGRAM
Tests: Rename CMAKE_TEST_MAKEPROGRAM uses for explicit make program Rename uses of the variable for specifying the make program used to build test projects to CMake_TEST_EXPLICIT_MAKE_PROGRAM.
2014-03-03 22:58:19 +04:00
--build-makeprogram ${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
Tests: Configure SubProject-Stage2 test more robustly Fix the condition that adds the test to check CMAKE_TEST_GENERATOR rather than the tools used to build CMake. Drop the test on Ninja because the generator does not support subproject generation anyway. Stop using the general build_generator_args and pass the --build-generator options explicitly. Also pass --build-makeprogram explicitly when CMAKE_TEST_MAKEPROGRAM is available because there is no CMakeCache.txt in the test project subdirectory from which to pick up the make program.
2013-11-15 19:33:04 +04:00
)
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(SubProject-Stage2 ${CMAKE_CTEST_COMMAND}
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
--build-and-test
Tests: Configure SubProject-Stage2 test more robustly Fix the condition that adds the test to check CMAKE_TEST_GENERATOR rather than the tools used to build CMake. Drop the test on Ninja because the generator does not support subproject generation anyway. Stop using the general build_generator_args and pass the --build-generator options explicitly. Also pass --build-makeprogram explicitly when CMAKE_TEST_MAKEPROGRAM is available because there is no CMakeCache.txt in the test project subdirectory from which to pick up the make program.
2013-11-15 19:33:04 +04:00
"${CMake_SOURCE_DIR}/Tests/SubProject/foo"
"${CMake_BINARY_DIR}/Tests/SubProject/foo"
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator ${CMAKE_GENERATOR}
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
--build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
Tests: Configure SubProject-Stage2 test more robustly Fix the condition that adds the test to check CMAKE_TEST_GENERATOR rather than the tools used to build CMake. Drop the test on Ninja because the generator does not support subproject generation anyway. Stop using the general build_generator_args and pass the --build-generator options explicitly. Also pass --build-makeprogram explicitly when CMAKE_TEST_MAKEPROGRAM is available because there is no CMakeCache.txt in the test project subdirectory from which to pick up the make program.
2013-11-15 19:33:04 +04:00
${SubProject-Stage2_BUILD_MAKEPROGRAM}
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
--build-nocmake
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
--build-project foo
--build-target foo
Ninja: Add the Ninja generator
2011-11-11 09:00:49 +04:00
--build-exe-dir "${CMake_BINARY_DIR}/Tests/SubProject/foo"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
--test-command foo
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties ( SubProject-Stage2 PROPERTIES DEPENDS SubProject)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubProject")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: fix for bug 3218 dependant projects are written out automatically if they are in the project. Also fix bug 5829, remove hard coded CMAKE_CONFIGURATION_TYPES from vs 7 generator
2008-01-30 20:04:38 +03:00
Add nightly builds for linux windows and mac.
2009-09-23 20:45:39 +04:00
# macro to add a test that will build a nightly release
# of CMake for given platform using the release scripts
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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"
Add nightly builds for linux windows and mac.
2009-09-23 20:45:39 +04:00
"cd ${_TEST_DIR}
Change the nightly tests to build from the nightly branch and not next. This will make sure that the nightly test matches the dashboard nightly section. When it was next, it used next from when the test was run.
2011-01-07 21:50:36 +03:00
${CMake_BINARY_DIR}/bin/cmake -DCMAKE_CREATE_VERSION=nightly -P ${CMake_SOURCE_DIR}/Utilities/Release/${script}
Utilities/Release: Fix nightly build upload Since commit 71b14dcb (Utilities/Release: Do not upload doc staging tarball, 2014-02-26) the prefix upload_release.cmake computes does not match any files when used with -DVERSION=master as has been done for the nightly binary builds. Since the version is not actually 'master' anyway, change the nightly binary upload logic to explicitly pass the destination directory. Do not pass any VERSION so the default is taken and matches the binaries.
2014-03-06 18:31:26 +04:00
${CMake_BINARY_DIR}/bin/cmake -DDIR=dev -P ${CMake_SOURCE_DIR}/Utilities/Release/upload_release.cmake
Add nightly builds for linux windows and mac.
2009-09-23 20:45:39 +04:00
")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endmacro()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_BUILD_NIGHTLY_RELEASES)
Add nightly builds for linux windows and mac.
2009-09-23 20:45:39 +04:00
ADD_NIGHTLY_BUILD_TEST(CMakeNightlyWindows
dash2win64_release.cmake)
ADD_NIGHTLY_BUILD_TEST(CMakeNightlyMac
dashmacmini2_release.cmake)
Tests: Add the more modern Mac64 nightly build We can remove the older ppc;i386 non-64-bit Mac nightly build in a little while after this one proves itself reliable.
2011-09-14 20:45:55 +04:00
ADD_NIGHTLY_BUILD_TEST(CMakeNightlyMac64
dashmacmini5_release.cmake)
Add nightly builds for linux windows and mac.
2009-09-23 20:45:39 +04:00
ADD_NIGHTLY_BUILD_TEST(CMakeNightlyLinux
magrathea_release.cmake)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Finish up the Framework creation code restructuring. Frameworks build and install now. More work needed on the packaging step. See Tests/Framework for example use.
2007-10-10 19:06:15 +04:00
ENH: some cleanup, condensing some tests, removing arguments that were not needed but rather were cut and paste copies etc
2007-05-18 23:11:20 +04:00
# add tests with more complex invocations
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(Framework ${CMAKE_CTEST_COMMAND}
ENH: Finish up the Framework creation code restructuring. Frameworks build and install now. More work needed on the packaging step. See Tests/Framework for example use.
2007-10-10 19:06:15 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Framework"
"${CMake_BINARY_DIR}/Tests/Framework"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: Finish up the Framework creation code restructuring. Frameworks build and install now. More work needed on the packaging step. See Tests/Framework for example use.
2007-10-10 19:06:15 +04:00
--build-project Framework
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: Finish up the Framework creation code restructuring. Frameworks build and install now. More work needed on the packaging step. See Tests/Framework for example use.
2007-10-10 19:06:15 +04:00
"-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/Framework/Install"
--test-command bar)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Framework")
ENH: Finish up the Framework creation code restructuring. Frameworks build and install now. More work needed on the packaging step. See Tests/Framework for example use.
2007-10-10 19:06:15 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(TargetName ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/TargetName"
"${CMake_BINARY_DIR}/Tests/TargetName"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project TargetName
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
--test-command ${CMAKE_CMAKE_COMMAND} -E compare_files
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
${CMake_SOURCE_DIR}/Tests/TargetName/scripts/hello_world
${CMake_BINARY_DIR}/Tests/TargetName/scripts/hello_world)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TargetName")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(LibName ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LibName"
"${CMake_BINARY_DIR}/Tests/LibName"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
--build-project LibName
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-exe-dir "${CMake_BINARY_DIR}/Tests/LibName/lib"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command foobar
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LibName")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CustComDepend ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CustComDepend"
"${CMake_BINARY_DIR}/Tests/CustComDepend"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
--build-project CustComDepend
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-exe-dir "${CMake_BINARY_DIR}/Tests/CustComDepend/bin"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command foo bar.c
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustComDepend")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(ArgumentExpansion ${CMAKE_CTEST_COMMAND}
Add 'ArgumentExpansion' test
2010-10-07 20:29:43 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/ArgumentExpansion"
"${CMake_BINARY_DIR}/Tests/ArgumentExpansion"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Add 'ArgumentExpansion' test
2010-10-07 20:29:43 +04:00
--build-project ArgumentExpansion
--build-exe-dir "${CMake_BINARY_DIR}/Tests/ArgumentExpansion/bin"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Add 'ArgumentExpansion' test
2010-10-07 20:29:43 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(ArgumentExpansion PROPERTIES
Fix ArgumentExpansion test expected results Teach the ArgumentExpansion test to expect flattened lists as has always been the case in the CMake language. Now that the test should pass enable the failure regex even when CMAKE_STRICT is not on. Replace the reference to the old ArgumentExpansion test behavior in the workaround comment in cmMakefile::TryCompile with a full inline explanation.
2011-01-12 01:10:28 +03:00
FAIL_REGULAR_EXPRESSION "Unexpected: ")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ArgumentExpansion")
Add 'ArgumentExpansion' test
2010-10-07 20:29:43 +04:00
Tests: Build config-dependent tests in the same config they run The CPackComponentsForAll-*, GeneratorExpression, and TestsWorkingDirectory tests all build binaries that they later need to run or package for the tested configuration. Tell the 'ctest --build-and-test' call to use the same configuration for driving the build process.
2014-11-13 17:34:31 +03:00
add_test(GeneratorExpression
${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
Add boolean generator expressions Add generator expressions that combine and use boolean test results: $<0:...> = empty string (ignores "...") $<1:...> = content of "..." $<AND:?[,?]...> = '1' if all '?' are '1', else '0' $<OR:?[,?]...> = '0' if all '?' are '0', else '1' $<NOT:?> = '0' if '?' is '1', else '1' These will be useful to evaluate (future) boolean query expressions and condition content on the results. Include tests and documentation.
2012-08-13 17:49:53 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/GeneratorExpression"
"${CMake_BINARY_DIR}/Tests/GeneratorExpression"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Add boolean generator expressions Add generator expressions that combine and use boolean test results: $<0:...> = empty string (ignores "...") $<1:...> = content of "..." $<AND:?[,?]...> = '1' if all '?' are '1', else '0' $<OR:?[,?]...> = '0' if all '?' are '0', else '1' $<NOT:?> = '0' if '?' is '1', else '1' These will be useful to evaluate (future) boolean query expressions and condition content on the results. Include tests and documentation.
2012-08-13 17:49:53 +04:00
--build-project GeneratorExpression
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
-DCMAKE_BUILD_TYPE=\${CTEST_CONFIGURATION_TYPE}
cmTestGenerator: Evaluate generator expressions in test properties This is useful for cases like: add_test(NAME mytest COMMAND mydriver $<TARGET_FILE:myexe>) set_tests_properties(mytest PROPERTIES REQUIRED_FILES "$<TARGET_FILE:myexe>" WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/$<CONFIGURATION>" ) In this example we require the actual test executable to exist to run the test in addition to the test driver at argv[0]. Also the $<CONFIGURATION> expression improves over \${CTEST_CONFIGURATION_TYPE} because the latter is not normalized for case-sensitive filesystems.
2013-08-08 01:07:30 +04:00
--test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE} -V
Add boolean generator expressions Add generator expressions that combine and use boolean test results: $<0:...> = empty string (ignores "...") $<1:...> = content of "..." $<AND:?[,?]...> = '1' if all '?' are '1', else '0' $<OR:?[,?]...> = '0' if all '?' are '0', else '1' $<NOT:?> = '0' if '?' is '1', else '1' These will be useful to evaluate (future) boolean query expressions and condition content on the results. Include tests and documentation.
2012-08-13 17:49:53 +04:00
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/GeneratorExpression")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CustomCommand ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CustomCommand"
"${CMake_BINARY_DIR}/Tests/CustomCommand"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project CustomCommand
--build-exe-dir "${CMake_BINARY_DIR}/Tests/CustomCommand/bin"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command CustomCommand
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommand")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Add an option for explicit BYPRODUCTS of custom commands (#14963) A common idiom in CMake-based build systems is to have custom commands that generate files not listed explicitly as outputs so that these files do not have to be newer than the inputs. The file modification times of such "byproducts" are updated only when their content changes. Then other build rules can depend on the byproducts explicitly so that their dependents rebuild when the content of the original byproducts really does change. This "undeclared byproduct" approach is necessary for Makefile, VS, and Xcode build tools because if a byproduct were listed as an output of a rule then the rule would always rerun when the input is newer than the byproduct but the byproduct may never be updated. Ninja solves this problem by offering a 'restat' feature to check whether an output was really modified after running a rule and tracking the fact that it is up to date separately from its timestamp. However, Ninja also stats all dependencies up front and will only restat files that are listed as outputs of rules with the 'restat' option enabled. Therefore an undeclared byproduct that does not exist at the start of the build will be considered missing and the build will fail even if other dependencies would cause the byproduct to be available before its dependents build. CMake works around this limitation by adding 'phony' build rules for custom command dependencies in the build tree that do not have any explicit specification of what produces them. This is not optimal because it prevents Ninja from reporting an error when an input to a rule really is missing. A better approach is to allow projects to explicitly specify the byproducts of their custom commands so that no phony rules are needed for them. In order to work with the non-Ninja generators, the byproducts must be known separately from the outputs. Add a new "BYPRODUCTS" option to the add_custom_command and add_custom_target commands to specify byproducts explicitly. Teach the Ninja generator to specify byproducts as outputs of the custom commands. In the case of POST_BUILD, PRE_LINK, and PRE_BUILD events on targets that link, the byproducts must be specified as outputs of the link rule that runs the commands. Activate 'restat' for such rules so that Ninja knows it needs to check the byproducts, but not for link rules that have no byproducts.
2014-11-14 02:54:52 +03:00
ADD_TEST_MACRO(CustomCommandByproducts CustomCommandByproducts)
NMake: Add a test to demonstrate EmptyDepends issue (#13392)
2012-11-21 19:23:17 +04:00
ADD_TEST_MACRO(EmptyDepends ${CMAKE_CTEST_COMMAND})
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CustomCommandWorkingDirectory ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CustomCommandWorkingDirectory"
"${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project TestWorkingDir
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command working
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CustomCommandWorkingDirectory")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
#add_test(SimpleExclude ${CMAKE_CTEST_COMMAND}
ENH: minor fixes
2007-05-11 20:17:27 +04:00
# --build-and-test
# "${CMake_SOURCE_DIR}/Tests/SimpleExclude"
# "${CMake_BINARY_DIR}/Tests/SimpleExclude"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
# ${build_generator_args}
ENH: minor fixes
2007-05-11 20:17:27 +04:00
# --build-project SimpleExclude
# --build-two-config
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
# --build-options ${build_options}
ENH: minor fixes
2007-05-11 20:17:27 +04:00
# --test-command t4
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
#--test-command "${CMAKE_COMMAND}"
#"-DCONFIGURATION=\${CTEST_CONFIGURATION_TYPE}"
Refer to self with CMake_(SOURCE|BINARY)_DIR (#10046) This is good practice, and is necessary to support building CMake as a subdirectory of another project.
2010-07-29 18:59:27 +04:00
#-P "${CMake_BINARY_DIR}/Tests/SimpleExclude/run.cmake"
ENH: minor fixes
2007-05-11 20:17:27 +04:00
#)
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
# add_test(SameName ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
# --build-and-test
# "${CMake_SOURCE_DIR}/Tests/SameName"
# "${CMake_BINARY_DIR}/Tests/SameName"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
# ${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
# --build-project SameName
# --build-two-config
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
# --build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
# --test-command
# "${CMake_BINARY_DIR}/Tests/SameName/Exe1/mytest2")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(OutOfSource ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/OutOfSource"
"${CMake_BINARY_DIR}/Tests/OutOfSource"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project OutOfSource
--build-two-config
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command
"${CMake_BINARY_DIR}/Tests/OutOfSource/SubDir/OutOfSourceSubdir/simple")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(BuildDepends ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/BuildDepends"
"${CMake_BINARY_DIR}/Tests/BuildDepends"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project BuildDepends
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BuildDepends")
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(SimpleInstallInstallDir
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
"${CMake_BINARY_DIR}/Tests/SimpleInstall/InstallDirectory")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(SimpleInstall ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SimpleInstall"
"${CMake_BINARY_DIR}/Tests/SimpleInstall"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project TestSimpleInstall
--build-two-config
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
"-DCMAKE_INSTALL_PREFIX:PATH=${SimpleInstallInstallDir}"
SimpleInstall test now builds an installer package if CTEST_TEST_CPACK is ON at the Tests/CMakeLists.txt level.
2009-11-16 23:35:04 +03:00
"-DCTEST_TEST_CPACK:BOOL=${CTEST_TEST_CPACK}"
COMP: Rename the executables for the SimpleInstall tests so that the executable files that run during the test do not have the word install in their file names. This allows running the tests on Windows Vista without admin privileges and without adding a manifest containing the asInvoker requestedExecutionLevel element.
2007-10-01 23:57:34 +04:00
--test-command ${SimpleInstallInstallDir}/MyTest/bin/SimpleInstExe)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleInstall")
add_test(SimpleInstall-Stage2 ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SimpleInstallS2"
"${CMake_BINARY_DIR}/Tests/SimpleInstallS2"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project TestSimpleInstall
--build-two-config
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
"-DCMAKE_INSTALL_PREFIX:PATH=${SimpleInstallInstallDir}"
"-DSTAGE2:BOOL=1"
COMP: Rename the executables for the SimpleInstall tests so that the executable files that run during the test do not have the word install in their file names. This allows running the tests on Windows Vista without admin privileges and without adding a manifest containing the asInvoker requestedExecutionLevel element.
2007-10-01 23:57:34 +04:00
--test-command ${SimpleInstallInstallDir}/MyTest/bin/SimpleInstExeS2)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleInstallS2")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
InstallRules: added new variable to disable generation of install rules The boolean variable CMAKE_SKIP_INSTALL_RULES allows disabling generation of install rules for projects which don't want them.
2013-12-25 20:59:24 +04:00
set(MissingInstallInstallDir
"${CMake_BINARY_DIR}/Tests/MissingInstall/InstallDirectory")
add_test(MissingInstall ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/MissingInstall"
"${CMake_BINARY_DIR}/Tests/MissingInstall"
${build_generator_args}
--build-project TestMissingInstall
--build-two-config
--build-options ${build_options}
"-DCMAKE_INSTALL_PREFIX:PATH=${MissingInstallInstallDir}")
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MissingInstall")
BUG: Avoid running the new CPackComponents test on Windows unless the NSIS installer is available.
2008-06-19 19:08:08 +04:00
# By default, run the CPackComponents test if the CTEST_TEST_CPACK
# option is ON:
#
set(CTEST_RUN_CPackComponents ${CTEST_TEST_CPACK})
BUG: Avoid trying to package the X11 test on Windows when there is no NSIS installer available.
2009-01-22 18:22:30 +03:00
set(CTEST_package_X11_TEST ${CTEST_TEST_CPACK})
CPack new tests for component install
2010-12-03 00:56:26 +03:00
set(CTEST_RUN_CPackComponentsForAll ${CTEST_TEST_CPACK})
cpack: Fix CPACK_PACKAGING_INSTALL_PREFIX handling for archives (#14677) Fix the case when the archive generator is used to package components with an install prefix.
2015-03-26 07:36:38 +03:00
set(CTEST_RUN_CPackComponentsPrefix ${CTEST_TEST_CPACK})
BUG: Avoid running the new CPackComponents test on Windows unless the NSIS installer is available.
2008-06-19 19:08:08 +04:00
Turn on the NSIS binary for the CPackComponents test if NSIS is found. Should increase coverage of the NSIS generator on the dash16 coverage dashboard.
2009-10-26 00:00:51 +03:00
find_program(NSIS_MAKENSIS_EXECUTABLE NAMES makensis
PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
DOC "makensis program location"
)
BUG: Avoid running the new CPackComponents test on Windows unless the NSIS installer is available.
2008-06-19 19:08:08 +04:00
# 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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
BUG: Avoid running the new CPackComponents test on Windows unless the NSIS installer is available.
2008-06-19 19:08:08 +04:00
set(CTEST_RUN_CPackComponents OFF)
BUG: Avoid trying to package the X11 test on Windows when there is no NSIS installer available.
2009-01-22 18:22:30 +03:00
set(CTEST_package_X11_TEST OFF)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
BUG: Avoid running the new CPackComponents test on Windows unless the NSIS installer is available.
2008-06-19 19:08:08 +04:00
CPack: Add a WiX Generator (#11575) This new CPack generator produces an *.msi installer file. Requires having the WiX Toolset installed in order to work properly. Download the WiX Toolset installer "WiX36.exe" here: http://wix.codeplex.com/releases/view/93929
2012-10-03 18:08:49 +04:00
# On Windows run the CPackWiXGenerator test
# if the WiX Toolset seems to be available
if(WIN32)
file(TO_CMAKE_PATH "$ENV{WIX}" WIX_ROOT)
find_program(WIX_LIGHT_EXECUTABLE light
PATHS "${WIX_ROOT}/bin"
DOC "WiX Toolset light.exe location")
if(WIX_LIGHT_EXECUTABLE)
add_test(CPackWiXGenerator ${CMAKE_CTEST_COMMAND}
CPackWiX: Fix test to build with expected config
2014-03-07 19:53:45 +04:00
-C \${CTEST_CONFIGURATION_TYPE}
CPack: Add a WiX Generator (#11575) This new CPack generator produces an *.msi installer file. Requires having the WiX Toolset installed in order to work properly. Download the WiX Toolset installer "WiX36.exe" here: http://wix.codeplex.com/releases/view/93929
2012-10-03 18:08:49 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CPackWiXGenerator"
"${CMake_BINARY_DIR}/Tests/CPackWiXGenerator"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
CPack: Add a WiX Generator (#11575) This new CPack generator produces an *.msi installer file. Requires having the WiX Toolset installed in order to work properly. Download the WiX Toolset installer "WiX36.exe" here: http://wix.codeplex.com/releases/view/93929
2012-10-03 18:08:49 +04:00
--build-project CPackWiXGenerator
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
CPack: Add a WiX Generator (#11575) This new CPack generator produces an *.msi installer file. Requires having the WiX Toolset installed in order to work properly. Download the WiX Toolset installer "WiX36.exe" here: http://wix.codeplex.com/releases/view/93929
2012-10-03 18:08:49 +04:00
--test-command ${CMAKE_CMAKE_COMMAND}
"-DCPackWiXGenerator_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackWiXGenerator"
CPackWiX: Fix test to build with expected config
2014-03-07 19:53:45 +04:00
"-Dconfig=\${CTEST_CONFIGURATION_TYPE}"
CPack: Add a WiX Generator (#11575) This new CPack generator produces an *.msi installer file. Requires having the WiX Toolset installed in order to work properly. Download the WiX Toolset installer "WiX36.exe" here: http://wix.codeplex.com/releases/view/93929
2012-10-03 18:08:49 +04:00
-P "${CMake_SOURCE_DIR}/Tests/CPackWiXGenerator/RunCPackVerifyResult.cmake")
CPackWiX: Attach wix.log on test failure.
2014-09-01 11:09:00 +04:00
set_property(TEST CPackWiXGenerator PROPERTY
ATTACHED_FILES_ON_FAIL
"${CMake_BINARY_DIR}/Tests/CPackWiXGenerator/_CPack_Packages/win32/WIX/wix.log")
CPack: Add a WiX Generator (#11575) This new CPack generator produces an *.msi installer file. Requires having the WiX Toolset installed in order to work properly. Download the WiX Toolset installer "WiX36.exe" here: http://wix.codeplex.com/releases/view/93929
2012-10-03 18:08:49 +04:00
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_RUN_CPackComponents)
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
set(CPackComponents_BUILD_OPTIONS)
BUG: Fix issue #8402. Add a drag and drop bundle generator to the Mac build of CPack. Add a test of it in the CPackComponents test. Thanks to Clinton Stimpson for the patch.
2009-01-22 20:12:44 +03:00
if(APPLE)
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
set(CPackComponents_BUILD_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Turn on the NSIS binary for the CPackComponents test if NSIS is found. Should increase coverage of the NSIS generator on the dash16 coverage dashboard.
2009-10-26 00:00:51 +03:00
if(NSIS_MAKENSIS_EXECUTABLE)
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
Turn on the NSIS binary for the CPackComponents test if NSIS is found. Should increase coverage of the NSIS generator on the dash16 coverage dashboard.
2009-10-26 00:00:51 +03:00
-DCPACK_BINARY_NSIS:BOOL=ON)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
BUG: Fix issue #8402. Add a drag and drop bundle generator to the Mac build of CPack. Add a test of it in the CPackComponents test. Thanks to Clinton Stimpson for the patch.
2009-01-22 20:12:44 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CPackComponents ${CMAKE_CTEST_COMMAND}
ENH: Add patch for feature request #6847 - CPack components for NSIS and PackageMaker installers. Thanks to Doug Gregor for all the hard work involved with implementing this patch! Also added new test CPackComponents that is conditionally executed only when NSIS or PackageMaker installer builders are available.
2008-06-17 19:39:26 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CPackComponents"
"${CMake_BINARY_DIR}/Tests/CPackComponents"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: Add patch for feature request #6847 - CPack components for NSIS and PackageMaker installers. Thanks to Doug Gregor for all the hard work involved with implementing this patch! Also added new test CPackComponents that is conditionally executed only when NSIS or PackageMaker installer builders are available.
2008-06-17 19:39:26 +04:00
--build-project CPackComponents
--build-two-config
--build-target package
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: Use settings for CPackComponents test to make it fail if the recent fix of cmCPackGenerator.cxx revision 1.16 ever encounters another regression.
2008-10-29 19:27:19 +03:00
-DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
-DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
${CPackComponents_BUILD_OPTIONS}
Add test CMakeTestBadCommandLines. Also add --graphviz arg to cmake invoked during the CPackComponents test. The purpose of each is to increase coverage of cmake.cxx.
2009-10-27 19:18:41 +03:00
--graphviz=CPackComponents.dot
ENH: Add patch for feature request #6847 - CPack components for NSIS and PackageMaker installers. Thanks to Doug Gregor for all the hard work involved with implementing this patch! Also added new test CPackComponents that is conditionally executed only when NSIS or PackageMaker installer builders are available.
2008-06-17 19:39:26 +04:00
--test-command ${CMAKE_CMAKE_COMMAND}
"-DCPackComponents_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponents"
-P "${CMake_SOURCE_DIR}/Tests/CPackComponents/VerifyResult.cmake")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponents")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Add patch for feature request #6847 - CPack components for NSIS and PackageMaker installers. Thanks to Doug Gregor for all the hard work involved with implementing this patch! Also added new test CPackComponents that is conditionally executed only when NSIS or PackageMaker installer builders are available.
2008-06-17 19:39:26 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_RUN_CPackComponentsForAll)
Do not run cpack at CMake time it is not available. cpack was used to get the list of available i.e. ACTIVE CPack generators in the CMake tests suite. This was done in order to get dynamically available CPack generators like DEB or RPM that may or may not be available on some platform like MacOSX depending on the fact that some command are installed or not. We may do that but not during initial configuration. The current patch fixes the problem and we may do better in the future like configuring CPack tests later.
2012-06-28 15:49:49 +04:00
# Check whether if rpmbuild command is found
# before adding RPM tests
CPack: Enable DEB and RPM tests more reliably CPack DEB and RPM generators were not used for some tests because CPACK_BINARY_DEB and CPACK_BINARY_RPM variable were not set. Fix this, simplify generator selection in CTEST_RUN_CPackComponentsForAll, and fix bugs that were detected after tests were run.
2015-05-09 01:42:30 +03:00
if(CPACK_BINARY_RPM)
Do not run cpack at CMake time it is not available. cpack was used to get the list of available i.e. ACTIVE CPack generators in the CMake tests suite. This was done in order to get dynamically available CPack generators like DEB or RPM that may or may not be available on some platform like MacOSX depending on the fact that some command are installed or not. We may do that but not during initial configuration. The current patch fixes the problem and we may do better in the future like configuring CPack tests later.
2012-06-28 15:49:49 +04:00
list(APPEND ACTIVE_CPACK_GENERATORS RPM)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Do not run cpack at CMake time it is not available. cpack was used to get the list of available i.e. ACTIVE CPack generators in the CMake tests suite. This was done in order to get dynamically available CPack generators like DEB or RPM that may or may not be available on some platform like MacOSX depending on the fact that some command are installed or not. We may do that but not during initial configuration. The current patch fixes the problem and we may do better in the future like configuring CPack tests later.
2012-06-28 15:49:49 +04:00
# Check whether if dpkg command is found
# before adding DEB tests
CPack: Enable DEB and RPM tests more reliably CPack DEB and RPM generators were not used for some tests because CPACK_BINARY_DEB and CPACK_BINARY_RPM variable were not set. Fix this, simplify generator selection in CTEST_RUN_CPackComponentsForAll, and fix bugs that were detected after tests were run.
2015-05-09 01:42:30 +03:00
if(CPACK_BINARY_DEB)
Do not run cpack at CMake time it is not available. cpack was used to get the list of available i.e. ACTIVE CPack generators in the CMake tests suite. This was done in order to get dynamically available CPack generators like DEB or RPM that may or may not be available on some platform like MacOSX depending on the fact that some command are installed or not. We may do that but not during initial configuration. The current patch fixes the problem and we may do better in the future like configuring CPack tests later.
2012-06-28 15:49:49 +04:00
list(APPEND ACTIVE_CPACK_GENERATORS DEB)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Do not run cpack at CMake time it is not available. cpack was used to get the list of available i.e. ACTIVE CPack generators in the CMake tests suite. This was done in order to get dynamically available CPack generators like DEB or RPM that may or may not be available on some platform like MacOSX depending on the fact that some command are installed or not. We may do that but not during initial configuration. The current patch fixes the problem and we may do better in the future like configuring CPack tests later.
2012-06-28 15:49:49 +04:00
CPack allow RPM and DEB generator to be used on OSX. More generally add the check for possible generator "activation" at runtime depending on a generator specific check. The dynamic behavior is currently implemented only for MacOS and should be fully backward compatible for other system. Inspired-By Tom Hughes <tomtheengineer@gmail.com>
2012-03-30 19:07:06 +04:00
# ACTIVE_CPACK_GENERATORS variable
# now contains the list of 'active generators'
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
set(CPackComponentsForAll_BUILD_OPTIONS)
CPack Tests the different ways of packaging components
2011-01-30 15:11:25 +03:00
# set up list of CPack generators
CPack: Enable DEB and RPM tests more reliably CPack DEB and RPM generators were not used for some tests because CPACK_BINARY_DEB and CPACK_BINARY_RPM variable were not set. Fix this, simplify generator selection in CTEST_RUN_CPackComponentsForAll, and fix bugs that were detected after tests were run.
2015-05-09 01:42:30 +03:00
list(APPEND ACTIVE_CPACK_GENERATORS "ZIP")
Add component support to DragNDrop generator.
2011-03-28 19:11:27 +04:00
if(APPLE)
CPack: Enable DEB and RPM tests more reliably CPack DEB and RPM generators were not used for some tests because CPACK_BINARY_DEB and CPACK_BINARY_RPM variable were not set. Fix this, simplify generator selection in CTEST_RUN_CPackComponentsForAll, and fix bugs that were detected after tests were run.
2015-05-09 01:42:30 +03:00
list(APPEND ACTIVE_CPACK_GENERATORS "DragNDrop")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
CPack allow RPM and DEB generator to be used on OSX. More generally add the check for possible generator "activation" at runtime depending on a generator specific check. The dynamic behavior is currently implemented only for MacOS and should be fully backward compatible for other system. Inspired-By Tom Hughes <tomtheengineer@gmail.com>
2012-03-30 19:07:06 +04:00
CPack Tests the different ways of packaging components
2011-01-30 15:11:25 +03:00
# set up list of component packaging ways
list(APPEND CWAYLST "default")
list(APPEND CWAYLST "OnePackPerGroup")
list(APPEND CWAYLST "IgnoreGroup")
list(APPEND CWAYLST "AllInOne")
CPack: Enable DEB and RPM tests more reliably CPack DEB and RPM generators were not used for some tests because CPACK_BINARY_DEB and CPACK_BINARY_RPM variable were not set. Fix this, simplify generator selection in CTEST_RUN_CPackComponentsForAll, and fix bugs that were detected after tests were run.
2015-05-09 01:42:30 +03:00
foreach(CPackGen IN LISTS ACTIVE_CPACK_GENERATORS)
CPack Tests the different ways of packaging components
2011-01-30 15:11:25 +03:00
set(CPackRun_CPackGen "-DCPackGen=${CPackGen}")
Avoid foreach IN LISTS syntax which is not supported by CMake 2.6
2011-01-31 19:25:29 +03:00
foreach(CPackComponentWay ${CWAYLST})
CPack Tests the different ways of packaging components
2011-01-30 15:11:25 +03:00
set(CPackRun_CPackComponentWay "-DCPackComponentWay=${CPackComponentWay}")
Tests: Build config-dependent tests in the same config they run The CPackComponentsForAll-*, GeneratorExpression, and TestsWorkingDirectory tests all build binaries that they later need to run or package for the tested configuration. Tell the 'ctest --build-and-test' call to use the same configuration for driving the build process.
2014-11-13 17:34:31 +03:00
add_test(CPackComponentsForAll-${CPackGen}-${CPackComponentWay}
${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
CPack Tests the different ways of packaging components
2011-01-30 15:11:25 +03:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll"
"${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
CPack Tests the different ways of packaging components
2011-01-30 15:11:25 +03:00
--build-project CPackComponentsForAll
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
CPackRPM: Add basic symlink support (#15209) RPM packages can contain symbolic links to relative paths - including support for multiple relocation paths through generation of post install relocation scripts. Add basic support with limitations described in documentation.
2015-03-29 21:55:20 +03:00
-DCPACK_GENERATOR:STRING=${CPackGen}
CPack Tests the different ways of packaging components
2011-01-30 15:11:25 +03:00
-DCPACK_BINARY_${CPackGen}:BOOL=ON
${CPackRun_CPackComponentWay}
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
${CPackComponentsForAll_BUILD_OPTIONS}
CPack Tests the different ways of packaging components
2011-01-30 15:11:25 +03:00
--graphviz=CPackComponentsForAll.dot
--test-command ${CMAKE_CMAKE_COMMAND}
"-DCPackComponentsForAll_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
"${CPackRun_CPackGen}"
"${CPackRun_CPackComponentWay}"
-P "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll/RunCPackVerifyResult.cmake")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endforeach()
endforeach()
CPackDeb: Add basic package tests Tests of generated component based deb packages with lintian and dpkg. Also includes basic file name check.
2015-04-21 23:48:37 +03:00
# debian specific
if(DPKG_EXECUTABLE)
unset(CPackRun_CPackDEBConfiguration_ALL_CONFIGS)
set(DEB_TEST_NAMES "CPackComponentsDEB")
CPackDEB component description Support for setting different description for each component.
2015-04-29 19:05:36 +03:00
set(DEB_CONFIGURATIONS_TO_TEST "components-lintian-dpkgdeb-checks"
"components-description1"
CPack/DEB component dependency auto-discovery Dependency auto-discovery can now be set per component
2015-05-02 23:14:57 +03:00
"components-description2"
CPack/DEB per component dependencies Dependencies may now be set per component
2015-05-09 00:36:26 +03:00
"components-shlibdeps1"
"components-depend1"
"components-depend2")
CPackDeb: Add basic package tests Tests of generated component based deb packages with lintian and dpkg. Also includes basic file name check.
2015-04-21 23:48:37 +03:00
set(CPackGen "DEB")
set(CPackRun_CPackGen "-DCPackGen=${CPackGen}")
foreach(CPackDEBConfiguration IN LISTS DEB_CONFIGURATIONS_TO_TEST)
set(CPackRun_CPackDEBConfiguration "-DCPackDEBConfiguration=${CPackDEBConfiguration}")
add_test(${DEB_TEST_NAMES}-${CPackDEBConfiguration}
${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}"
"${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}"
${build_generator_args}
--build-project CPackComponentsDEB
--build-options ${build_options}
-DCPACK_GENERATOR:STRING=${CPackGen}
-DCPACK_BINARY_${CPackGen}:BOOL=ON
${CPackRun_CPackDEBConfiguration}
${CPackRun_CPackDEBConfiguration_ALL_CONFIGS}
--graphviz=${DEB_TEST_NAMES}.dot
--test-command ${CMAKE_CMAKE_COMMAND}
"-D${DEB_TEST_NAMES}_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}"
"-D${DEB_TEST_NAMES}_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}"
"${CPackRun_CPackGen}"
"${CPackRun_CPackDEBConfiguration}"
-P "${CMake_SOURCE_DIR}/Tests/${DEB_TEST_NAMES}/RunCPackVerifyResult-${CPackDEBConfiguration}.cmake")
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${DEB_TEST_NAMES}/build${CPackGen}-${CPackDEBConfiguration}")
endforeach()
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
CPack new tests for component install
2010-12-03 00:56:26 +03:00
Add test of all available CPack generators. Add this test with the goal of increasing coverage of the cpack source code, even/especially when the underlying packager tool is not installed. The test does not fail if there is a cpack problem with a certain generator. I expect some generators will fail on every machine running a CMake dashboard.
2009-10-20 22:31:10 +04:00
# 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})
Remove CMake multiline block-end command arguments removing arguments omitted in 9db3116226cb99fcf54e936c833953abcde9b729
2012-08-15 19:59:36 +04:00
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Add test of all available CPack generators. Add this test with the goal of increasing coverage of the cpack source code, even/especially when the underlying packager tool is not installed. The test does not fail if there is a cpack problem with a certain generator. I expect some generators will fail on every machine running a CMake dashboard.
2009-10-20 22:31:10 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_RUN_CPackTestAllGenerators)
add_test(CPackTestAllGenerators ${CMAKE_CTEST_COMMAND}
Add test of all available CPack generators. Add this test with the goal of increasing coverage of the cpack source code, even/especially when the underlying packager tool is not installed. The test does not fail if there is a cpack problem with a certain generator. I expect some generators will fail on every machine running a CMake dashboard.
2009-10-20 22:31:10 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators"
"${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Add test of all available CPack generators. Add this test with the goal of increasing coverage of the cpack source code, even/especially when the underlying packager tool is not installed. The test does not fail if there is a cpack problem with a certain generator. I expect some generators will fail on every machine running a CMake dashboard.
2009-10-20 22:31:10 +04:00
--build-project CPackTestAllGenerators
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Add test of all available CPack generators. Add this test with the goal of increasing coverage of the cpack source code, even/especially when the underlying packager tool is not installed. The test does not fail if there is a cpack problem with a certain generator. I expect some generators will fail on every machine running a CMake dashboard.
2009-10-20 22:31:10 +04:00
--test-command
${CMAKE_CMAKE_COMMAND}
-D dir=${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators
-P ${CMake_SOURCE_DIR}/Tests/CPackTestAllGenerators/RunCPack.cmake
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackTestAllGenerators")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Add test of all available CPack generators. Add this test with the goal of increasing coverage of the cpack source code, even/especially when the underlying packager tool is not installed. The test does not fail if there is a cpack problem with a certain generator. I expect some generators will fail on every machine running a CMake dashboard.
2009-10-20 22:31:10 +04:00
cpack: Fix CPACK_PACKAGING_INSTALL_PREFIX handling for archives (#14677) Fix the case when the archive generator is used to package components with an install prefix.
2015-03-26 07:36:38 +03:00
if(CTEST_RUN_CPackComponentsPrefix)
set(CPackComponents_BUILD_OPTIONS)
if(APPLE)
set(CPackComponents_BUILD_OPTIONS -DCPACK_BINARY_DRAGNDROP:BOOL=ON)
endif()
if(NOT NSIS_MAKENSIS_EXECUTABLE)
set(CPackComponents_BUILD_OPTIONS ${CPackComponents_BUILD_OPTIONS}
-DCPACK_BINARY_NSIS:BOOL=OFF)
endif()
add_test(CPackComponentsPrefix ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CPackComponentsPrefix"
"${CMake_BINARY_DIR}/Tests/CPackComponentsPrefix"
${build_generator_args}
--build-project CPackComponentsPrefix
--build-two-config
--build-target package
--build-options ${build_options}
-DCPACK_BINARY_DEB:BOOL=${CPACK_BINARY_DEB}
-DCPACK_BINARY_RPM:BOOL=${CPACK_BINARY_RPM}
-DCPACK_BINARY_ZIP:BOOL=ON
${CPackComponents_BUILD_OPTIONS}
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsPrefix")
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_package_X11_TEST)
set(X11_build_target_arg --build-target package)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(X11_build_target_arg)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
BUG: Fix issue #7833: Add file extension handling to CPack generated installers for OSXX11 applications. Also modify the X11 test to build such an installer on Mac builds that test CPack and have X11 available. Thanks to Wes Turner for the patch.
2009-01-21 19:54:30 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(X11 ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/X11"
"${CMake_BINARY_DIR}/Tests/X11"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project UseX11
--build-two-config
BUG: Fix issue #7833: Add file extension handling to CPack generated installers for OSXX11 applications. Also modify the X11 test to build such an installer on Mac builds that test CPack and have X11 available. Thanks to Wes Turner for the patch.
2009-01-21 19:54:30 +03:00
${X11_build_target_arg}
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command UseX11)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/X11")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Add test of all cmake -G generators. Ignore any errors from this as not all generators are expected to be usable on all machines. Help to increase coverage of the various generators and cmake.cxx itself.
2009-10-22 18:14:40 +04:00
if(NOT DEFINED CTEST_RUN_CMakeTestAllGenerators)
set(CTEST_RUN_CMakeTestAllGenerators ON)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Add test of all cmake -G generators. Ignore any errors from this as not all generators are expected to be usable on all machines. Help to increase coverage of the various generators and cmake.cxx itself.
2009-10-22 18:14:40 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_RUN_CMakeTestAllGenerators)
add_test(CMakeTestAllGenerators ${CMAKE_CMAKE_COMMAND}
Add test of all cmake -G generators. Ignore any errors from this as not all generators are expected to be usable on all machines. Help to increase coverage of the various generators and cmake.cxx itself.
2009-10-22 18:14:40 +04:00
-D dir=${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators
-D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
-P ${CMake_SOURCE_DIR}/Tests/CMakeTestAllGenerators/RunCMake.cmake
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS
Add test of all cmake -G generators. Ignore any errors from this as not all generators are expected to be usable on all machines. Help to increase coverage of the various generators and cmake.cxx itself.
2009-10-22 18:14:40 +04:00
"${CMake_BINARY_DIR}/Tests/CMakeTestAllGenerators")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Add test of all cmake -G generators. Ignore any errors from this as not all generators are expected to be usable on all machines. Help to increase coverage of the various generators and cmake.cxx itself.
2009-10-22 18:14:40 +04:00
Add test to enable detecting differences between generation N and N+1 of a cmake generated build tree. Theoretically, each generation run with exactly the same arguments should be identical to the previous generation... Practically, there are differences. This is a tool to help us measure those differences. For now, the test always succeeds. Eventually, we may add the code to make it fail when there are differences.
2009-10-26 23:09:27 +03:00
if(NOT DEFINED CTEST_RUN_CMakeTestMultipleConfigures)
set(CTEST_RUN_CMakeTestMultipleConfigures ON)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Add test to enable detecting differences between generation N and N+1 of a cmake generated build tree. Theoretically, each generation run with exactly the same arguments should be identical to the previous generation... Practically, there are differences. This is a tool to help us measure those differences. For now, the test always succeeds. Eventually, we may add the code to make it fail when there are differences.
2009-10-26 23:09:27 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_RUN_CMakeTestMultipleConfigures)
add_test(CMakeTestMultipleConfigures ${CMAKE_CMAKE_COMMAND}
Add test to enable detecting differences between generation N and N+1 of a cmake generated build tree. Theoretically, each generation run with exactly the same arguments should be identical to the previous generation... Practically, there are differences. This is a tool to help us measure those differences. For now, the test always succeeds. Eventually, we may add the code to make it fail when there are differences.
2009-10-26 23:09:27 +03:00
-D dir=${CMake_BINARY_DIR}/Tests/CMakeTestMultipleConfigures
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
-D gen=${CMAKE_GENERATOR}
Add test to enable detecting differences between generation N and N+1 of a cmake generated build tree. Theoretically, each generation run with exactly the same arguments should be identical to the previous generation... Practically, there are differences. This is a tool to help us measure those differences. For now, the test always succeeds. Eventually, we may add the code to make it fail when there are differences.
2009-10-26 23:09:27 +03:00
-D CMake_SOURCE_DIR=${CMake_SOURCE_DIR}
-P ${CMake_SOURCE_DIR}/Tests/CMakeTestMultipleConfigures/RunCMake.cmake
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS
Add test to enable detecting differences between generation N and N+1 of a cmake generated build tree. Theoretically, each generation run with exactly the same arguments should be identical to the previous generation... Practically, there are differences. This is a tool to help us measure those differences. For now, the test always succeeds. Eventually, we may add the code to make it fail when there are differences.
2009-10-26 23:09:27 +03:00
"${CMake_BINARY_DIR}/Tests/CMakeTestMultipleConfigures")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Add test to enable detecting differences between generation N and N+1 of a cmake generated build tree. Theoretically, each generation run with exactly the same arguments should be identical to the previous generation... Practically, there are differences. This is a tool to help us measure those differences. For now, the test always succeeds. Eventually, we may add the code to make it fail when there are differences.
2009-10-26 23:09:27 +03:00
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
2014-03-04 00:24:03 +04:00
if(NOT CMake_TEST_EXTERNAL_CMAKE)
add_test(LoadedCommandOneConfig ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LoadCommandOneConfig"
"${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig"
${build_generator_args}
--build-project LoadCommand
--build-options ${build_options}
--test-command LoadedCommand
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LoadCommandOneConfig")
endif()
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(complex ${CMAKE_CTEST_COMMAND}
Remove unused test code We have not run tests with the "como" compiler or enabled the experimental ConvLibrary test for years.
2012-02-04 00:54:20 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Complex"
"${CMake_BINARY_DIR}/Tests/Complex"
--build-two-config
--build-config-sample "${CMAKE_CTEST_COMMAND}"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Remove unused test code We have not run tests with the "como" compiler or enabled the experimental ConvLibrary test for years.
2012-02-04 00:54:20 +04:00
--build-project Complex
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Complex/bin"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Remove unused test code We have not run tests with the "como" compiler or enabled the experimental ConvLibrary test for years.
2012-02-04 00:54:20 +04:00
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
--test-command complex
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Complex")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(complexOneConfig ${CMAKE_CTEST_COMMAND}
Remove unused test code We have not run tests with the "como" compiler or enabled the experimental ConvLibrary test for years.
2012-02-04 00:54:20 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/ComplexOneConfig"
"${CMake_BINARY_DIR}/Tests/ComplexOneConfig"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Remove unused test code We have not run tests with the "como" compiler or enabled the experimental ConvLibrary test for years.
2012-02-04 00:54:20 +04:00
--build-project Complex
--build-exe-dir "${CMake_BINARY_DIR}/Tests/ComplexOneConfig/bin"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Remove unused test code We have not run tests with the "como" compiler or enabled the experimental ConvLibrary test for years.
2012-02-04 00:54:20 +04:00
-DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
--test-command complex)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ComplexOneConfig")
Remove unused test code We have not run tests with the "como" compiler or enabled the experimental ConvLibrary test for years.
2012-02-04 00:54:20 +04:00
# because of the registry write these tests depend on each other
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties ( complex PROPERTIES DEPENDS complexOneConfig)
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(Environment ${CMAKE_CTEST_COMMAND}
ENH: Implement feature request from issue 7885. Allow setting environment variables on a per-test basis for ctest using set_test_properties ENVIRONMENT.
2008-11-26 22:38:43 +03:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Environment"
"${CMake_BINARY_DIR}/Tests/Environment"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: Implement feature request from issue 7885. Allow setting environment variables on a per-test basis for ctest using set_test_properties ENVIRONMENT.
2008-11-26 22:38:43 +03:00
--build-project EnvironmentProj
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Environment"
--force-new-ctest-process
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: remove some verbosity to reduce test time
2008-12-11 22:35:57 +03:00
--test-command ${CMAKE_CTEST_COMMAND} -V
ENH: Implement feature request from issue 7885. Allow setting environment variables on a per-test basis for ctest using set_test_properties ENVIRONMENT.
2008-11-26 22:38:43 +03:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Environment")
ENH: Implement feature request from issue 7885. Allow setting environment variables on a per-test basis for ctest using set_test_properties ENVIRONMENT.
2008-11-26 22:38:43 +03:00
Automoc: Don't create automoc targets if Qt is not used (#13999) Commit 79568f95 (automoc: Add source file to target early to set the linker language, 2013-02-20) changed automoc initialization to a two step process. In the first step, the generated source file was added to the target, which allows the link language to be determined. However, this bypassed the check for the availability of Qt itself. At build-time the automoc file could not be generated because the moc tool was not available to create it. The solution is to only add the automoc file to the target if Qt is found.
2013-03-12 02:26:38 +04:00
add_test(QtAutomocNoQt ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/QtAutomocNoQt"
"${CMake_BINARY_DIR}/Tests/QtAutomocNoQt"
${build_generator_args}
--build-project QtAutomocNoQt
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
-DCMAKE_BUILD_TYPE=\${CTEST_CONFIGURATION_TYPE}
Automoc: Don't create automoc targets if Qt is not used (#13999) Commit 79568f95 (automoc: Add source file to target early to set the linker language, 2013-02-20) changed automoc initialization to a two step process. In the first step, the generated source file was added to the target, which allows the link language to be determined. However, this bypassed the check for the availability of Qt itself. At build-time the automoc file could not be generated because the moc tool was not available to create it. The solution is to only add the automoc file to the target if Qt is found.
2013-03-12 02:26:38 +04:00
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/QtAutomocNoQt")
Run the main executable created in the autogen tests. Don't try to show the windows, which would require a gui capable test machine, and that's not guaranteed. Automatically link to qtmain.a on Windows to avoid a policy warning. Set policy CMP0020 to NEW by increasing the required version. Don't attempt to run the test when using Windows.
2013-10-11 22:16:43 +04:00
# On Windows there is no RPATH, so while Qt might be available for building,
# the required dlls may not be in the PATH, so we can't run the executables
# on that platform.
if(WIN32)
set(run_autogen_test ${CMAKE_CTEST_COMMAND} -V)
QtAutoUic: Add INTERFACE_AUTOUIC_OPTIONS target property. Transitively consume the property from linked dependents. Implement configuration-specific support by following the pattern set out for compile definitions and includes in cmQtAutoGenerators. Implement support for origin-tracking with CMAKE_DEBUG_TARGET_PROPERTIES. This is motivated by the needs of KDE, which provides a separate translation system based on gettext instead of the Qt linguist translation system. The Qt uic tool provides command line options for configuring the method used to translate text, and to add an include directive to the generated file to provide the method. http://thread.gmane.org/gmane.comp.kde.devel.frameworks/7930/focus=7992 Implement the interface to provide the uic options as a usage-requirement on the KI18n target, as designed for KDE.
2013-11-20 17:54:39 +04:00
set(run_autouic_test ${CMAKE_CTEST_COMMAND} -V)
Run the main executable created in the autogen tests. Don't try to show the windows, which would require a gui capable test machine, and that's not guaranteed. Automatically link to qtmain.a on Windows to avoid a policy warning. Set policy CMP0020 to NEW by increasing the required version. Don't attempt to run the test when using Windows.
2013-10-11 22:16:43 +04:00
else()
set(run_autogen_test QtAutogen)
QtAutoUic: Add INTERFACE_AUTOUIC_OPTIONS target property. Transitively consume the property from linked dependents. Implement configuration-specific support by following the pattern set out for compile definitions and includes in cmQtAutoGenerators. Implement support for origin-tracking with CMAKE_DEBUG_TARGET_PROPERTIES. This is motivated by the needs of KDE, which provides a separate translation system based on gettext instead of the Qt linguist translation system. The Qt uic tool provides command line options for configuring the method used to translate text, and to add an include directive to the generated file to provide the method. http://thread.gmane.org/gmane.comp.kde.devel.frameworks/7930/focus=7992 Implement the interface to provide the uic options as a usage-requirement on the KI18n target, as designed for KDE.
2013-11-20 17:54:39 +04:00
set(run_autouic_test QtAutoUicInterface)
Run the main executable created in the autogen tests. Don't try to show the windows, which would require a gui capable test machine, and that's not guaranteed. Automatically link to qtmain.a on Windows to avoid a policy warning. Set policy CMP0020 to NEW by increasing the required version. Don't attempt to run the test when using Windows.
2013-10-11 22:16:43 +04:00
endif()
Tests/QtAutogen: Enable per-config source tests when possible Pass CMAKE_BUILD_TYPE into the test on generators that use it so that the per-config part of the test can activate as needed. Do not make the per-config part conditional on the Debug configuration because the generator expressions evaluate to empty in other configurations. Skip the per-config source case with the Ninja generator because it does not currently work. cmQtAutoGenerators::InitializeAutogenTarget needs to know the list of source files on a target, but generator expressions in the list cannot be evaluated until after CreateGeneratorTargets has been called. That cannot happen until after Autogen targets have been generated. It is a chicken-and-egg problem.
2015-04-16 20:30:32 +03:00
if(NOT CMAKE_CONFIGURATION_TYPES)
set(QtAutogen_BUILD_OPTIONS -DCMAKE_BUILD_TYPE=$<CONFIGURATION>)
endif()
Run the main executable created in the autogen tests. Don't try to show the windows, which would require a gui capable test machine, and that's not guaranteed. Automatically link to qtmain.a on Windows to avoid a policy warning. Set policy CMP0020 to NEW by increasing the required version. Don't attempt to run the test when using Windows.
2013-10-11 22:16:43 +04:00
Add a test for Qt5Automoc The same source is used as for the Qt4Automoc test.
2013-03-16 18:52:18 +04:00
find_package(Qt5Widgets QUIET NO_MODULE)
if(Qt5Widgets_FOUND)
Tests/QtAutogen: Enable per-config source tests when possible Pass CMAKE_BUILD_TYPE into the test on generators that use it so that the per-config part of the test can activate as needed. Do not make the per-config part conditional on the Debug configuration because the generator expressions evaluate to empty in other configurations. Skip the per-config source case with the Ninja generator because it does not currently work. cmQtAutoGenerators::InitializeAutogenTarget needs to know the list of source files on a target, but generator expressions in the list cannot be evaluated until after CreateGeneratorTargets has been called. That cannot happen until after Autogen targets have been generated. It is a chicken-and-egg problem.
2015-04-16 20:30:32 +03:00
add_test(NAME Qt5Autogen COMMAND ${CMAKE_CTEST_COMMAND}
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
--build-and-test
Rename the QtAutomoc tests to QtAutogen.
2013-10-11 16:17:32 +04:00
"${CMake_SOURCE_DIR}/Tests/QtAutogen"
"${CMake_BINARY_DIR}/Tests/Qt5Autogen"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Rename the QtAutomoc tests to QtAutogen.
2013-10-11 16:17:32 +04:00
--build-project QtAutogen
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt5Autogen"
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
--force-new-ctest-process
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} -DQT_TEST_VERSION=5
Tests/QtAutogen: Enable per-config source tests when possible Pass CMAKE_BUILD_TYPE into the test on generators that use it so that the per-config part of the test can activate as needed. Do not make the per-config part conditional on the Debug configuration because the generator expressions evaluate to empty in other configurations. Skip the per-config source case with the Ninja generator because it does not currently work. cmQtAutoGenerators::InitializeAutogenTarget needs to know the list of source files on a target, but generator expressions in the list cannot be evaluated until after CreateGeneratorTargets has been called. That cannot happen until after Autogen targets have been generated. It is a chicken-and-egg problem.
2015-04-16 20:30:32 +03:00
${QtAutogen_BUILD_OPTIONS}
Run the main executable created in the autogen tests. Don't try to show the windows, which would require a gui capable test machine, and that's not guaranteed. Automatically link to qtmain.a on Windows to avoid a policy warning. Set policy CMP0020 to NEW by increasing the required version. Don't attempt to run the test when using Windows.
2013-10-11 22:16:43 +04:00
--test-command ${run_autogen_test}
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
)
Rename the QtAutomoc tests to QtAutogen.
2013-10-11 16:17:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt5Autogen")
QtAutoUic: Add INTERFACE_AUTOUIC_OPTIONS target property. Transitively consume the property from linked dependents. Implement configuration-specific support by following the pattern set out for compile definitions and includes in cmQtAutoGenerators. Implement support for origin-tracking with CMAKE_DEBUG_TARGET_PROPERTIES. This is motivated by the needs of KDE, which provides a separate translation system based on gettext instead of the Qt linguist translation system. The Qt uic tool provides command line options for configuring the method used to translate text, and to add an include directive to the generated file to provide the method. http://thread.gmane.org/gmane.comp.kde.devel.frameworks/7930/focus=7992 Implement the interface to provide the uic options as a usage-requirement on the KI18n target, as designed for KDE.
2013-11-20 17:54:39 +04:00
add_test(Qt5AutoUicInterface ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/QtAutoUicInterface"
"${CMake_BINARY_DIR}/Tests/Qt5AutoUicInterface"
${build_generator_args}
--build-project QtAutoUicInterface
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt5AutoUicInterface"
--force-new-ctest-process
--build-options ${build_options}
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} -DQT_TEST_VERSION=5
--test-command ${run_autouic_test}
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt5AutoUicInterface")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 12:41:09 +04:00
if(QT4_WORKS AND QT_QTGUI_FOUND)
Tests/QtAutogen: Enable per-config source tests when possible Pass CMAKE_BUILD_TYPE into the test on generators that use it so that the per-config part of the test can activate as needed. Do not make the per-config part conditional on the Debug configuration because the generator expressions evaluate to empty in other configurations. Skip the per-config source case with the Ninja generator because it does not currently work. cmQtAutoGenerators::InitializeAutogenTarget needs to know the list of source files on a target, but generator expressions in the list cannot be evaluated until after CreateGeneratorTargets has been called. That cannot happen until after Autogen targets have been generated. It is a chicken-and-egg problem.
2015-04-16 20:30:32 +03:00
add_test(NAME Qt4Autogen COMMAND ${CMAKE_CTEST_COMMAND}
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
--build-and-test
Rename the QtAutomoc tests to QtAutogen.
2013-10-11 16:17:32 +04:00
"${CMake_SOURCE_DIR}/Tests/QtAutogen"
"${CMake_BINARY_DIR}/Tests/Qt4Autogen"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Rename the QtAutomoc tests to QtAutogen.
2013-10-11 16:17:32 +04:00
--build-project QtAutogen
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4Autogen"
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
--force-new-ctest-process
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} -DQT_TEST_VERSION=4
Tests/QtAutogen: Enable per-config source tests when possible Pass CMAKE_BUILD_TYPE into the test on generators that use it so that the per-config part of the test can activate as needed. Do not make the per-config part conditional on the Debug configuration because the generator expressions evaluate to empty in other configurations. Skip the per-config source case with the Ninja generator because it does not currently work. cmQtAutoGenerators::InitializeAutogenTarget needs to know the list of source files on a target, but generator expressions in the list cannot be evaluated until after CreateGeneratorTargets has been called. That cannot happen until after Autogen targets have been generated. It is a chicken-and-egg problem.
2015-04-16 20:30:32 +03:00
${QtAutogen_BUILD_OPTIONS}
Run the main executable created in the autogen tests. Don't try to show the windows, which would require a gui capable test machine, and that's not guaranteed. Automatically link to qtmain.a on Windows to avoid a policy warning. Set policy CMP0020 to NEW by increasing the required version. Don't attempt to run the test when using Windows.
2013-10-11 22:16:43 +04:00
--test-command ${run_autogen_test}
Fix for Qt4Deploy on some test machines. Use the same check for whether Qt4 works for Qt4Automoc test before trying to do the Qt4Deploy test. Also pass down to Qt4Deploy which Qt to use.
2012-02-24 19:09:17 +04:00
)
Rename the QtAutomoc tests to QtAutogen.
2013-10-11 16:17:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Autogen")
Remove an endif() followed by an if() for the same condition.
2013-03-16 21:57:38 +04:00
QtAutoUic: Add INTERFACE_AUTOUIC_OPTIONS target property. Transitively consume the property from linked dependents. Implement configuration-specific support by following the pattern set out for compile definitions and includes in cmQtAutoGenerators. Implement support for origin-tracking with CMAKE_DEBUG_TARGET_PROPERTIES. This is motivated by the needs of KDE, which provides a separate translation system based on gettext instead of the Qt linguist translation system. The Qt uic tool provides command line options for configuring the method used to translate text, and to add an include directive to the generated file to provide the method. http://thread.gmane.org/gmane.comp.kde.devel.frameworks/7930/focus=7992 Implement the interface to provide the uic options as a usage-requirement on the KI18n target, as designed for KDE.
2013-11-20 17:54:39 +04:00
add_test(Qt4AutoUicInterface ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/QtAutoUicInterface"
"${CMake_BINARY_DIR}/Tests/Qt4AutoUicInterface"
${build_generator_args}
--build-project QtAutoUicInterface
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4AutoUicInterface"
--force-new-ctest-process
--build-options ${build_options}
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE} -DQT_TEST_VERSION=4
--test-command ${run_autouic_test}
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4AutoUicInterface")
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 12:41:09 +04:00
add_test(Qt4Targets ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Qt4Targets"
"${CMake_BINARY_DIR}/Tests/Qt4Targets"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 12:41:09 +04:00
--build-project Qt4Targets
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4Targets"
--force-new-ctest-process
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
-DQT_QMAKE_EXECUTABLE:FILEPATH=${QT_QMAKE_EXECUTABLE}
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 12:41:09 +04:00
--test-command ${CMAKE_CTEST_COMMAND} -V
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4Targets")
QtAutomoc: Get the Qt version through the target link interface In Qt 5.1, Qt5::Core has a INTERFACE_QT_MAJOR_VERSION property of '5', and since CMake 2.8.11, Qt4::QtCore has an INTERFACE_QT_MAJOR_VERSION of '4'. This was introduced in commit 4aa10cd6 (FindQt4: Set the INTERFACE_QT_MAJOR_VERSION for Qt4::QtCore, 2013-03-16), to produce an error if Qt 4 and Qt 5 are erroneously used by the same target. This can also be used however to determine the Qt major version, and therefore the particular moc executable to use during automoc steps. This means that targets in a single buildsystem can use a selection of Qt 4 and Qt 5, and still take advantage of the CMAKE_AUTOMOC feature without conflicting.
2013-05-27 19:58:57 +04:00
if(Qt5Widgets_FOUND AND NOT Qt5Widgets_VERSION VERSION_LESS 5.1.0)
add_test(Qt4And5Automoc ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Qt4And5Automoc"
"${CMake_BINARY_DIR}/Tests/Qt4And5Automoc"
${build_generator_args}
--build-project Qt4And5Automoc
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4And5Automoc"
--force-new-ctest-process
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
QtAutomoc: Get the Qt version through the target link interface In Qt 5.1, Qt5::Core has a INTERFACE_QT_MAJOR_VERSION property of '5', and since CMake 2.8.11, Qt4::QtCore has an INTERFACE_QT_MAJOR_VERSION of '4'. This was introduced in commit 4aa10cd6 (FindQt4: Set the INTERFACE_QT_MAJOR_VERSION for Qt4::QtCore, 2013-03-16), to produce an error if Qt 4 and Qt 5 are erroneously used by the same target. This can also be used however to determine the Qt major version, and therefore the particular moc executable to use during automoc steps. This means that targets in a single buildsystem can use a selection of Qt 4 and Qt 5, and still take advantage of the CMAKE_AUTOMOC feature without conflicting.
2013-05-27 19:58:57 +04:00
--test-command ${CMAKE_CTEST_COMMAND} -V
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4And5Automoc")
FindQt4: Make AUTOMOC work regardless which order Qt 4/5 is found. Commit 321e348e (QtAutogen: Use Qt 4 IMPORTED targets to find executable locations., 2014-01-24) attempted to fix this problem, but only solved it for a particular ordering of find_package for Qt 4 and Qt 5. Add a test to ensure that it works with both orderings.
2014-01-29 19:57:09 +04:00
add_test(Qt4And5AutomocReverse ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Qt4And5Automoc"
"${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse"
${build_generator_args}
--build-project Qt4And5Automoc
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse"
--force-new-ctest-process
--build-options ${build_options} -DQT_REVERSE_FIND_ORDER=1
--test-command ${CMAKE_CTEST_COMMAND} -V
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Qt4And5AutomocReverse")
QtAutomoc: Get the Qt version through the target link interface In Qt 5.1, Qt5::Core has a INTERFACE_QT_MAJOR_VERSION property of '5', and since CMake 2.8.11, Qt4::QtCore has an INTERFACE_QT_MAJOR_VERSION of '4'. This was introduced in commit 4aa10cd6 (FindQt4: Set the INTERFACE_QT_MAJOR_VERSION for Qt4::QtCore, 2013-03-16), to produce an error if Qt 4 and Qt 5 are erroneously used by the same target. This can also be used however to determine the Qt major version, and therefore the particular moc executable to use during automoc steps. This means that targets in a single buildsystem can use a selection of Qt 4 and Qt 5, and still take advantage of the CMAKE_AUTOMOC feature without conflicting.
2013-05-27 19:58:57 +04:00
endif()
Qt4: Add module dependencies to the IMPORTED targets This means for example, that consumers can use: target_link_libraries(foo ${QT_QTGUI_LIBRARIES}) instead of also needing to specify all 'public' dependencies: target_link_libraries(foo ${QT_QTGUI_LIBRARIES} ${QT_QTCORE_LIBRARIES} ) when using the IMPORTED targets. Also populate the IMPORTED_LINK_DEPENDENT_LIBRARIES property so CMake can help the linker find shared library dependencies.
2012-12-31 12:41:09 +04:00
endif()
Fix logic which decides when to execute automoc test Alex
2011-08-17 01:48:01 +04:00
FindGSL: Add module to find the GNU Scientific Library
2014-12-17 18:10:23 +03:00
if(CMake_TEST_FindGSL)
add_subdirectory(FindGSL)
endif()
FindJsonCpp: Add module to find JsonCpp package
2015-01-16 22:11:38 +03:00
if(CMake_TEST_FindJsonCpp)
add_subdirectory(FindJsonCpp)
endif()
FindGSL: Add module to find the GNU Scientific Library
2014-12-17 18:10:23 +03:00
FindOpenSSL: Provide imported targets OpenSSL::{SSL,Crypto}
2015-08-07 14:13:33 +03:00
if(CMake_TEST_FindOpenSSL)
add_subdirectory(FindOpenSSL)
endif()
FindMatlab: Rewrite module and provide a usage API Implement a brand new FindMatlab module: - Add support for versions and components. - Find Matlab and its version in a more precise and multiplatform way. - Add API to create a new mex extension with documentation. - Add API to add matlab unit tests (with or without the unit test framework). - Find as much as possible based on a single Matlab_ROOT_DIR cache entry and allow the user to change it to re-find everything.
2015-02-12 19:13:31 +03:00
# Matlab module
if(CMake_TEST_FindMatlab)
ADD_TEST_MACRO(FindMatlab.basic_checks ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>)
ADD_TEST_MACRO(FindMatlab.versions_checks ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>)
endif()
FindGTK2: Add tests for components and targets in gtk and gtkmm modules
2013-08-06 13:33:59 +04:00
find_package(GTK2 QUIET)
if(GTK2_FOUND)
add_subdirectory(FindGTK2)
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(ExternalProject ${CMAKE_CTEST_COMMAND}
ENH: First draft of add_external_project functionality. Tweaks, dashboard fixing, more tests and documentation certain to follow as it gets used by others...
2008-12-04 21:27:48 +03:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/ExternalProject"
"${CMake_BINARY_DIR}/Tests/ExternalProject"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: First draft of add_external_project functionality. Tweaks, dashboard fixing, more tests and documentation certain to follow as it gets used by others...
2008-12-04 21:27:48 +03:00
--build-project ExternalProjectTest
--build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProject"
--force-new-ctest-process
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: remove some verbosity to reduce test time
2008-12-11 22:35:57 +03:00
--test-command ${CMAKE_CTEST_COMMAND} -V
ENH: First draft of add_external_project functionality. Tweaks, dashboard fixing, more tests and documentation certain to follow as it gets used by others...
2008-12-04 21:27:48 +03:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProject")
set_tests_properties(ExternalProject PROPERTIES
ExternalProject Test: Increase test timeout value Previously, it was hard-coded at 1000 seconds. Now it uses the value of CMAKE_LONG_TEST_TIMEOUT, which has a minimum value of 1500 seconds, but might have a longer value depending on the CTEST_TEST_TIMEOUT value of the driving dashboard. This should help avoid test failures on overloaded dashboard machines where it really does take that long to finish the test successfully.
2011-01-11 23:24:50 +03:00
TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
ENH: First draft of add_external_project functionality. Tweaks, dashboard fixing, more tests and documentation certain to follow as it gets used by others...
2008-12-04 21:27:48 +03:00
Tests: Add case to cover ExternalProject with subdirectories Add an ExternalProjectSubdir test directory with a minimal test showing use of ExternalProject_Add for a source tree in a subdirectory. This will allow us to easily add test external projects that cover specific behavior where the client project must check results.
2015-04-21 17:38:17 +03:00
add_test(NAME ExternalProjectSubdir
COMMAND ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION>
--build-and-test
"${CMake_SOURCE_DIR}/Tests/ExternalProjectSubdir"
"${CMake_BINARY_DIR}/Tests/ExternalProjectSubdir"
${build_generator_args}
--build-project ExternalProjectSubdir
--force-new-ctest-process
--build-options ${build_options}
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectSubdir")
Tests: split the ExternalProject test Move the subtests that test with local projects into their own test. The reason is that on slower or crowded machines the test may reach the limit of 25 minutes and therefore fail while it would pass if it was given enough time. The split is roughly 3:1 with regard to the execution time, with the new ExternalProjectLocal test being the faster one.
2014-07-03 20:11:49 +04:00
add_test(ExternalProjectLocal ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/ExternalProjectLocal"
"${CMake_BINARY_DIR}/Tests/ExternalProjectLocal"
${build_generator_args}
--build-project ExternalProjectLocalTest
--build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal"
--force-new-ctest-process
--build-options ${build_options}
--test-command ${CMAKE_CTEST_COMMAND} -V
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectLocal")
set_tests_properties(ExternalProjectLocal PROPERTIES
TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
ExternalProject: Make sure the ExternalProjectUpdate setup is available. This prepares the numberous tests that occur in the ExternalProjectUpdate test. The tests were passing previously because a fresh build was not performed.
2012-11-01 19:50:58 +04:00
add_test(ExternalProjectUpdateSetup ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate"
"${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ExternalProject: Make sure the ExternalProjectUpdate setup is available. This prepares the numberous tests that occur in the ExternalProjectUpdate test. The tests were passing previously because a fresh build was not performed.
2012-11-01 19:50:58 +04:00
--build-project ExternalProjectUpdateTest
--build-exe-dir "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate"
--force-new-ctest-process
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ExternalProject: Make sure the ExternalProjectUpdate setup is available. This prepares the numberous tests that occur in the ExternalProjectUpdate test. The tests were passing previously because a fresh build was not performed.
2012-11-01 19:50:58 +04:00
--test-command ${CMAKE_CTEST_COMMAND} -V
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
set_tests_properties(ExternalProjectUpdateSetup PROPERTIES
TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
add_test(NAME ExternalProjectUpdate
COMMAND ${CMAKE_CMAKE_COMMAND}
ExternalProject: Add tests for UPDATE_COMMAND. Tests are added for UPDATE_COMMAND to ensure it is working properly. Testing infrastructure is added along with tests for Git, but tests for other version control systems could easily be added in the future.
2012-07-27 20:26:28 +04:00
-DExternalProjectUpdate_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
-DExternalProjectUpdate_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
-DCMAKE_GENERATOR=${CMAKE_GENERATOR}
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
-DCMAKE_GENERATOR_PLATFORM=${CMAKE_GENERATOR_PLATFORM}
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
-DCMAKE_GENERATOR_TOOLSET=${CMAKE_GENERATOR_TOOLSET}
ExternalProject: Add tests for UPDATE_COMMAND. Tests are added for UPDATE_COMMAND to ensure it is working properly. Testing infrastructure is added along with tests for Git, but tests for other version control systems could easily be added in the future.
2012-07-27 20:26:28 +04:00
-DCMAKE_CTEST_COMMAND=${CMAKE_CTEST_COMMAND}
-P ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate/ExternalProjectUpdateTest.cmake
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProjectUpdate")
set_tests_properties(ExternalProjectUpdate PROPERTIES
TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT}
WORKING_DIRECTORY ${CMake_SOURCE_DIR}/Tests/ExternalProjectUpdate
ExternalProject: Make sure the ExternalProjectUpdate setup is available. This prepares the numberous tests that occur in the ExternalProjectUpdate test. The tests were passing previously because a fresh build was not performed.
2012-11-01 19:50:58 +04:00
DEPENDS ExternalProjectUpdateSetup )
ExternalProject: Add tests for UPDATE_COMMAND. Tests are added for UPDATE_COMMAND to ensure it is working properly. Testing infrastructure is added along with tests for Git, but tests for other version control systems could easily be added in the future.
2012-07-27 20:26:28 +04:00
ENH: Add new Tutorial steps. Diff between Step5 and Step6 shows how to add a cpack driven installer to your project. Diff between Step6 and Step7 shows how to add ctest dashboard scripting capability.
2007-11-08 18:38:26 +03:00
# do each of the tutorial steps
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
foreach(STP RANGE 1 7)
add_test(TutorialStep${STP} ${CMAKE_CTEST_COMMAND}
ENH: some cleanup, condensing some tests, removing arguments that were not needed but rather were cut and paste copies etc
2007-05-18 23:11:20 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Tutorial/Step${STP}"
"${CMake_BINARY_DIR}/Tests/Tutorial/Step${STP}"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: some cleanup, condensing some tests, removing arguments that were not needed but rather were cut and paste copies etc
2007-05-18 23:11:20 +04:00
--build-project Tutorial
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: some cleanup, condensing some tests, removing arguments that were not needed but rather were cut and paste copies etc
2007-05-18 23:11:20 +04:00
--test-command Tutorial 25.0)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endforeach()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Tutorial")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(testing ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Testing"
"${CMake_BINARY_DIR}/Tests/Testing"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project Testing
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: Re-enable new 'testing' test mode This fixes selection of a configuration when none is specified to find an available configuration of the ctest test-command.
2009-01-05 22:14:25 +03:00
--test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(testing PROPERTIES PASS_REGULAR_EXPRESSION "Passed")
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Testing")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(wrapping ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Wrapping"
"${CMake_BINARY_DIR}/Tests/Wrapping"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project Wrapping
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command wrapping
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(qtwrapping ${CMAKE_CTEST_COMMAND}
ENH: remove findqt3 from cmake's cmakelist files
2007-11-02 17:46:03 +03:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Wrapping"
"${CMake_BINARY_DIR}/Tests/Wrapping"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: remove findqt3 from cmake's cmakelist files
2007-11-02 17:46:03 +03:00
--build-project Wrapping
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command qtwrapping
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Wrapping")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(testdriver1 ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/TestDriver"
"${CMake_BINARY_DIR}/Tests/TestDriver"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
--build-project TestDriverTest
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command TestDriverTest test1
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(testdriver2 ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/TestDriver"
"${CMake_BINARY_DIR}/Tests/TestDriver"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
--build-project TestDriverTest
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command TestDriverTest test2
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(testdriver3 ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/TestDriver"
"${CMake_BINARY_DIR}/Tests/TestDriver"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Wrapping/bin"
--build-project TestDriverTest
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command TestDriverTest subdir/test3
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestDriver")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(Dependency ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Dependency"
ENH: Combine all dependency* tests into one Dependency test. Add more difficult test cases.
2008-02-06 22:52:12 +03:00
"${CMake_BINARY_DIR}/Tests/Dependency"
--build-exe-dir "${CMake_BINARY_DIR}/Tests/Dependency/Exec"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project Dependency
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command exec
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Dependency")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Fix if() checks of CMAKE_SYSTEM_NAME on Cygwin The CMAKE_SYSTEM_NAME is "CYGWIN", but we also define a variable named "CYGWIN" to "1". Avoid allowing if() to expand the "CYGWIN" string as a variable.
2014-09-09 17:09:57 +04:00
if(CMAKE_SYSTEM_NAME MATCHES syllable)
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
# 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 .
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
# For now we just require on Syllable that the user adjusts the DLL_PATH
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
# environment variable, so except the two tests below all other tests will succeed.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(JumpWithLibOut ${CMAKE_CTEST_COMMAND}
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
--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
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
-DLIBRARY_OUTPUT_PATH:PATH=${CMake_BINARY_DIR}/Tests/Jump/WithLibOut/Lib
--test-command jumpExecutable
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(JumpNoLibOut ${CMAKE_CTEST_COMMAND}
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
--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
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
--test-command jumpExecutable
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Jump")
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(Plugin ${CMAKE_CTEST_COMMAND}
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Plugin"
"${CMake_BINARY_DIR}/Tests/Plugin"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
--build-project Plugin
--build-two-config
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
--test-command bin/example)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Plugin")
ENH: add support for the Syllable OS (http://www.syllable.org) major issues: -access() doesn't return false for an empty string (#ifdefed in cmake) -dlopen() doesn't return 0 on failure (#ifdefed in cmake and fixed now in Syllable) -the kwsys and Bootstrap tests fail with timeout due to the fact that I'm doing all that in qemu, which is quite slow -RPATH is now supported, so without modifying the test adapting DLL_PATH in Syllable is required for the tests to succeed -the Plugin test fails with an undefined reference to example_exe_function() in example_mod_1, it seems this isn't supported under Syllable Alex
2007-11-24 04:45:49 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG)
ENH: Added RuntimePath test to make sure rpath gets correct order.
2008-01-22 17:15:16 +03:00
ADD_TEST_MACRO(RuntimePath RuntimePath)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
OS X: Add test for rpaths on Mac. This also tests rpaths through export/import.
2013-05-02 08:19:06 +04:00
if(APPLE AND "${DARWIN_MAJOR_VERSION}" GREATER 9)
add_test(MacRuntimePath ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/MacRuntimePath"
"${CMake_BINARY_DIR}/Tests/MacRuntimePath"
${build_generator_args}
--build-project MacRuntimePath
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Tests: Rename CMAKE_TEST_MAKEPROGRAM uses for explicit make program Rename uses of the variable for specifying the make program used to build test projects to CMake_TEST_EXPLICIT_MAKE_PROGRAM.
2014-03-03 22:58:19 +04:00
-DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
OS X: Add test for rpaths on Mac. This also tests rpaths through export/import.
2013-05-02 08:19:06 +04:00
)
endif()
Tests: Enable XCTest tests for Xcode 5 Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
2015-03-23 20:06:46 +03:00
if(CMake_TEST_XCODE_VERSION AND NOT CMake_TEST_XCODE_VERSION VERSION_LESS 5
Tests: Add XCTest example to test Frameworks and Cocoa App Bundles Signed-off-by: Gregor Jasny <gjasny@googlemail.com>
2015-02-26 23:55:46 +03:00
AND OSX_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
set(XCTest_BUILD_OPTIONS -DCMAKE_OSX_DEPLOYMENT_TARGET=${CMAKE_MATCH_1})
ADD_TEST_MACRO(XCTest ${CMAKE_CTEST_COMMAND} -C $<CONFIGURATION> -V)
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(linkorder1 ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
"${CMake_BINARY_DIR}/Tests/LinkLineOrder"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project LinkLineOrder
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command Exec1
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(linkorder2 ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LinkLineOrder"
"${CMake_BINARY_DIR}/Tests/LinkLineOrder"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project LinkLineOrder
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command Exec2
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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)
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Test static linking with LINK_SEARCH_START_STATIC Add "LinkStatic" test that links a static executable against "libm.a". Pass both "/usr/lib/libm.a" and "-lm" to target_link_libraries to trigger the link type logic for both cases. If CMake incorrectly switches the link type to shared for "-lm" then the link will fail.
2011-03-04 02:02:53 +03:00
# Test static linking on toolchains known to support it.
Avoid if() quoted auto-dereference When testing CMAKE_<LANG>_COMPILER_ID values, do not explicitly dereference or quote the variable. We want if() to auto-dereference the variable and not its value. Also replace MATCHES with STREQUAL where equivalent.
2014-10-14 18:25:32 +04:00
if(CMAKE_C_COMPILER_ID STREQUAL "GNU"
Test static linking with LINK_SEARCH_START_STATIC Add "LinkStatic" test that links a static executable against "libm.a". Pass both "/usr/lib/libm.a" and "-lm" to target_link_libraries to trigger the link type logic for both cases. If CMake incorrectly switches the link type to shared for "-lm" then the link will fail.
2011-03-04 02:02:53 +03:00
AND NOT APPLE AND NOT WIN32 AND NOT CYGWIN
AND EXISTS "/usr/lib/libm.a")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(LinkStatic ${CMAKE_CTEST_COMMAND}
Test static linking with LINK_SEARCH_START_STATIC Add "LinkStatic" test that links a static executable against "libm.a". Pass both "/usr/lib/libm.a" and "-lm" to target_link_libraries to trigger the link type logic for both cases. If CMake incorrectly switches the link type to shared for "-lm" then the link will fail.
2011-03-04 02:02:53 +03:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/LinkStatic"
"${CMake_BINARY_DIR}/Tests/LinkStatic"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Test static linking with LINK_SEARCH_START_STATIC Add "LinkStatic" test that links a static executable against "libm.a". Pass both "/usr/lib/libm.a" and "-lm" to target_link_libraries to trigger the link type logic for both cases. If CMake incorrectly switches the link type to shared for "-lm" then the link will fail.
2011-03-04 02:02:53 +03:00
--build-project LinkStatic
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
-DMATH_LIBRARY:FILEPATH=/usr/lib/libm.a
Test static linking with LINK_SEARCH_START_STATIC Add "LinkStatic" test that links a static executable against "libm.a". Pass both "/usr/lib/libm.a" and "-lm" to target_link_libraries to trigger the link type logic for both cases. If CMake incorrectly switches the link type to shared for "-lm" then the link will fail.
2011-03-04 02:02:53 +03:00
--test-command LinkStatic
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
Test static linking with LINK_SEARCH_START_STATIC Add "LinkStatic" test that links a static executable against "libm.a". Pass both "/usr/lib/libm.a" and "-lm" to target_link_libraries to trigger the link type logic for both cases. If CMake incorrectly switches the link type to shared for "-lm" then the link will fail.
2011-03-04 02:02:53 +03:00
Tests: Activate tests accidentally excluded from Xcode The generator name is "Xcode", not "XCode". Fix this typo. Explicitly exclude the SubDirSpaces test on Xcode because it does not work. Also tell the RunCMake.File_Generate test when Xcode is not multi-config so it can exlcude the OutputConflict case. Inspired-by: Daniele E. Domenichelli <daniele.domenichelli@iit.it>
2014-07-17 17:31:53 +04:00
if(MAKE_SUPPORTS_SPACES AND NOT CMAKE_GENERATOR STREQUAL "Xcode")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(SubDirSpaces ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SubDirSpaces"
"${CMake_BINARY_DIR}/Tests/SubDirSpaces"
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
--build-exe-dir
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
"${CMake_BINARY_DIR}/Tests/SubDirSpaces/Executable Sources"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project SUBDIR
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command test
"${CMake_BINARY_DIR}/Tests/SubDirSpaces/ShouldBeHere"
"${CMake_BINARY_DIR}/Tests/SubDirSpaces/testfromsubdir.obj"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDirSpaces")
Remove CMake multiline block-end command arguments removing arguments omitted in 9db3116226cb99fcf54e936c833953abcde9b729
2012-08-15 19:59:36 +04:00
endif ()
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if (WIN32)
add_test(SubDir ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SubDir"
"${CMake_BINARY_DIR}/Tests/SubDir"
--build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project SUBDIR
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command test
"${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
"${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.obj"
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(SubDir ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SubDir"
"${CMake_BINARY_DIR}/Tests/SubDir"
--build-exe-dir "${CMake_BINARY_DIR}/Tests/SubDir/Executable"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project SUBDIR
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command test
"${CMake_BINARY_DIR}/Tests/SubDir/ShouldBeHere"
"${CMake_BINARY_DIR}/Tests/SubDir/testfromsubdir.o"
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SubDir")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Tests: Drop CMAKE_TEST_MSVC and test MSVC directly Now that we no longer support running tests using a different generator we can trust the MSVC platform indicator directly.
2014-03-03 21:39:30 +04:00
if(MSVC)
Map multiple /FI flags for VS < 10 (#11649) The /FI flag may be repeated so the flag table entry needs to be marked with SemicolonAppendable. This was already the case for VS 10.
2011-01-03 18:02:16 +03:00
ADD_TEST_MACRO(ForceInclude foo)
Run PDBDirectoryAndName test on MSVC and Intel Move it out of the condition that also accepts MinGW/MSYS. Teach the test to allow the Intel for Windows compiler but do not verify the results because the compiler does not seem to write PDB output in all cases.
2012-09-29 14:36:46 +04:00
ADD_TEST_MACRO(PDBDirectoryAndName myexe)
ENH: some cleanup, condensing some tests, removing arguments that were not needed but rather were cut and paste copies etc
2007-05-18 23:11:20 +04:00
ADD_TEST_MACRO(PrecompiledHeader foo)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
Tests: Drop CMAKE_TEST_MSVC and test MSVC directly Now that we no longer support running tests using a different generator we can trust the MSVC platform indicator directly.
2014-03-03 21:39:30 +04:00
if(MSVC OR
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
"${CMAKE_GENERATOR}" MATCHES "(MSYS|MinGW) Makefiles")
Test use of module .def files for MS tools This adds a "ModuleDefinition" test enabled when using MSVC tools. It checks that .def files can be used to export .dll and .exe symbols and create corresponding .lib files that can be linked. See issue #9613.
2009-09-30 00:39:43 +04:00
ADD_TEST_MACRO(ModuleDefinition example_exe)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Fix missing set of MSVC10 and add CheckCompilerRelatedVariables test.
2010-04-30 08:18:01 +04:00
ADD_TEST_MACRO(CheckCompilerRelatedVariables CheckCompilerRelatedVariables)
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Makefile")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(MakeClean ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/MakeClean"
"${CMake_BINARY_DIR}/Tests/MakeClean"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project MakeClean
--build-exe-dir "${CMake_BINARY_DIR}/MakeClean"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command check_clean
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MakeClean")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Tests: Add the MFC test (#11213) Build a simple, do-nothing VS 7.1 MFC wizard generated app with CMake. Build it two different ways via ExternalProject, one with CMAKE_MFC_FLAG set to 1 for linking to MFC statically, and one with CMAKE_MFC_FLAG set to 2 for linking to the shared MFC dlls. Validate that the install tree of the static build has only one *.exe file in it and nothing else. Also validate that the install tree of the shared library build has multiple files in it (no less than 3) and that they are only of the expected types *.exe, *.dll and *.manifest. This commit does not address the issue reported in #11213, it merely adds a test that may be used to show that the bug report is valid. After this commit, the MFC test should fail on any dashboard machines that have MSVC defined, but cannot build an MFC app. We can then analyze that failure data as input to solving the issue.
2011-10-25 00:55:52 +04:00
if(NOT DEFINED CTEST_RUN_MFC)
set(CTEST_RUN_MFC OFF)
Tests: Avoid MFC test automatically for Watcom WMake builds (#11213)
2011-11-03 21:21:06 +04:00
Tests: Add the MFC test (#11213) Build a simple, do-nothing VS 7.1 MFC wizard generated app with CMake. Build it two different ways via ExternalProject, one with CMAKE_MFC_FLAG set to 1 for linking to MFC statically, and one with CMAKE_MFC_FLAG set to 2 for linking to the shared MFC dlls. Validate that the install tree of the static build has only one *.exe file in it and nothing else. Also validate that the install tree of the shared library build has multiple files in it (no less than 3) and that they are only of the expected types *.exe, *.dll and *.manifest. This commit does not address the issue reported in #11213, it merely adds a test that may be used to show that the bug report is valid. After this commit, the MFC test should fail on any dashboard machines that have MSVC defined, but cannot build an MFC app. We can then analyze that failure data as input to solving the issue.
2011-10-25 00:55:52 +04:00
if(MSVC)
set(CTEST_RUN_MFC ON)
Tests: Avoid MFC test automatically for VCExpress builds (#11213)
2011-11-02 00:27:24 +04:00
# Look for evidence that this is a VCExpress build. If so, avoid
# the MFC test by default.
Tests: Drop CMAKE_TEST_MAKEPROGRAM variable Remaining uses of the variable simply test its value so use CMAKE_MAKE_PROGRAM directly instead.
2014-03-03 22:58:37 +04:00
string(TOLOWER "${CMAKE_MAKE_PROGRAM}" mkprog)
Tests: Avoid MFC test automatically for VCExpress builds (#11213)
2011-11-02 00:27:24 +04:00
if(mkprog MATCHES "vcexpress")
message(STATUS
Tests: Drop CMAKE_TEST_MAKEPROGRAM variable Remaining uses of the variable simply test its value so use CMAKE_MAKE_PROGRAM directly instead.
2014-03-03 22:58:37 +04:00
"CMAKE_MAKE_PROGRAM indicates vcexpress, avoiding MFC test")
Tests: Avoid MFC test automatically for VCExpress builds (#11213)
2011-11-02 00:27:24 +04:00
set(CTEST_RUN_MFC OFF)
endif()
# Since MSBuild might also be the "makeprogram" for a VCExpress
# build tree, use one more heuristic, too. The string representing
# the .vcproj file type contains "VCExpress" on machines where an
# express edition of VS was installed last:
if(CTEST_RUN_MFC)
execute_process(COMMAND cmd /c assoc .vcproj
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE ov)
if(ov MATCHES "VCExpress")
message(STATUS
".vcproj file association indicates VCExpress, avoiding MFC test")
set(CTEST_RUN_MFC OFF)
endif()
endif()
Tests: Avoid MFC test automatically for Watcom WMake builds (#11213)
2011-11-03 21:21:06 +04:00
# For the Watcom WMake generator, avoid the MFC test by default.
if(CTEST_RUN_MFC)
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if("${CMAKE_GENERATOR}" MATCHES "WMake")
Tests: Avoid MFC test automatically for Watcom WMake builds (#11213)
2011-11-03 21:21:06 +04:00
message(STATUS
"using the Watcom WMake generator, avoiding MFC test")
set(CTEST_RUN_MFC OFF)
endif()
endif()
Tests: Only really run MFC test if we can build MFC apps (#11213) Avoid problems on "undetected" VS Express build environments.
2011-12-16 22:49:27 +04:00
# Last resort, after quick checks are done. Do a try_compile, and avoid
# the MFC test if the simplest possible MFC app cannot be compiled.
if(CTEST_RUN_MFC AND NOT DEFINED HAVE_MFC)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/MFC/try_compile/CMakeLists.txt
${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile/CMakeLists.txt
COPYONLY
)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/MFC/mfc1/stdafx.cpp
${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile/stdafx.cpp
COPYONLY
)
configure_file(
${CMAKE_CURRENT_SOURCE_DIR}/MFC/mfc1/stdafx.h
${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile/stdafx.h
COPYONLY
)
message(STATUS "Looking for MFC")
try_compile(HAVE_MFC
${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile/build
${CMAKE_CURRENT_BINARY_DIR}/MFC/try_compile
try_compile_mfc
OUTPUT_VARIABLE HAVE_MFC_OUTPUT)
if(HAVE_MFC)
message(STATUS "Looking for MFC - found")
set(HAVE_MFC 1 CACHE INTERNAL "Have MFC")
file(APPEND
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
"Determining if MFC exists passed with the following output:\n"
"${HAVE_MFC_OUTPUT}\n\n")
else()
message(STATUS "Looking for MFC - not found")
set(HAVE_MFC "" CACHE INTERNAL "Have MFC")
file(APPEND
${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
"Determining if MFC exists failed with the following output:\n"
"${HAVE_MFC_OUTPUT}\n\n")
endif()
endif()
if(CTEST_RUN_MFC AND NOT HAVE_MFC)
message(STATUS
"cannot compile simplest ever MFC app, avoiding MFC test")
set(CTEST_RUN_MFC OFF)
endif()
Tests: Add the MFC test (#11213) Build a simple, do-nothing VS 7.1 MFC wizard generated app with CMake. Build it two different ways via ExternalProject, one with CMAKE_MFC_FLAG set to 1 for linking to MFC statically, and one with CMAKE_MFC_FLAG set to 2 for linking to the shared MFC dlls. Validate that the install tree of the static build has only one *.exe file in it and nothing else. Also validate that the install tree of the shared library build has multiple files in it (no less than 3) and that they are only of the expected types *.exe, *.dll and *.manifest. This commit does not address the issue reported in #11213, it merely adds a test that may be used to show that the bug report is valid. After this commit, the MFC test should fail on any dashboard machines that have MSVC defined, but cannot build an MFC app. We can then analyze that failure data as input to solving the issue.
2011-10-25 00:55:52 +04:00
endif()
endif()
if(CTEST_RUN_MFC)
add_test(MFC ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/MFC"
"${CMake_BINARY_DIR}/Tests/MFC"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Tests: Add the MFC test (#11213) Build a simple, do-nothing VS 7.1 MFC wizard generated app with CMake. Build it two different ways via ExternalProject, one with CMAKE_MFC_FLAG set to 1 for linking to MFC statically, and one with CMAKE_MFC_FLAG set to 2 for linking to the shared MFC dlls. Validate that the install tree of the static build has only one *.exe file in it and nothing else. Also validate that the install tree of the shared library build has multiple files in it (no less than 3) and that they are only of the expected types *.exe, *.dll and *.manifest. This commit does not address the issue reported in #11213, it merely adds a test that may be used to show that the bug report is valid. After this commit, the MFC test should fail on any dashboard machines that have MSVC defined, but cannot build an MFC app. We can then analyze that failure data as input to solving the issue.
2011-10-25 00:55:52 +04:00
--build-project mfc_driver
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Tests: Add the MFC test (#11213) Build a simple, do-nothing VS 7.1 MFC wizard generated app with CMake. Build it two different ways via ExternalProject, one with CMAKE_MFC_FLAG set to 1 for linking to MFC statically, and one with CMAKE_MFC_FLAG set to 2 for linking to the shared MFC dlls. Validate that the install tree of the static build has only one *.exe file in it and nothing else. Also validate that the install tree of the shared library build has multiple files in it (no less than 3) and that they are only of the expected types *.exe, *.dll and *.manifest. This commit does not address the issue reported in #11213, it merely adds a test that may be used to show that the bug report is valid. After this commit, the MFC test should fail on any dashboard machines that have MSVC defined, but cannot build an MFC app. We can then analyze that failure data as input to solving the issue.
2011-10-25 00:55:52 +04:00
--test-command ${CMAKE_CTEST_COMMAND}
-C \${CTEST_CONFIGURATION_TYPE} -VV)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/MFC")
endif()
VS: Add test for MASM support It is now expected to work with VS >= 10 and MSVC >= 13.1.
2014-08-07 22:53:57 +04:00
if(MSVC AND NOT MSVC_VERSION LESS 1310
VS: Add MASM support to VS 8 and 9 (#8170, #14984)
2014-08-07 23:20:49 +04:00
AND NOT CMAKE_GENERATOR MATCHES "Visual Studio [67]( |$)"
AND (NOT CMAKE_GENERATOR MATCHES "Visual Studio [89]( |$)"
OR CMAKE_SIZEOF_VOID_P EQUAL 4)
)
VS: Add test for MASM support It is now expected to work with VS >= 10 and MSVC >= 13.1.
2014-08-07 22:53:57 +04:00
ADD_TEST_MACRO(VSMASM VSMASM)
endif()
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(${CMAKE_GENERATOR} MATCHES "Visual Studio")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(NOT MSVC60)
VS6: Avoid SBCS test on VS6 (#12189) The previous commit, df19b9ca, assumed that the corresponding _UNICODE functionality in the VS6 generator actually worked. That turns out not to be the case. Unicode definition does not actually suppress _MBCS definition, so neither does this new code... Don't test it here, since the patch submitter for _SBCS does not need VS6 support. If somebody needs _UNICODE and _SBCS support to suppress the definition of _MBCS in the VS6 generator, it is work yet to do. Patches welcome.
2012-03-07 03:41:56 +04:00
ADD_TEST_MACRO(SBCS SBCS)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Visual Studio: Allow setting Single Byte Character Set (#12189) For Visual Studio using the Preprocessor Define _SBCS. This behavior is similar to the way that _UNICODE and _MBCS work already. Added tests to confirm this behavior.
2012-02-17 01:27:05 +04:00
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(NOT "${CMAKE_GENERATOR}" MATCHES "Visual Studio [6789]( |$)"
AND NOT CMAKE_GENERATOR_TOOLSET)
VS: Add Windows Forms Support Add support to maintain designer functionality for Visual Studio C++ Windows Forms projects. Also add a test project showing how to use the CMakeLists.txt file and, when successfully configured, will allow use of the designer for the included form.
2013-04-29 18:48:22 +04:00
ADD_TEST_MACRO(VSWindowsFormsResx VSWindowsFormsResx)
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(VSExternalInclude ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VSExternalInclude"
"${CMake_BINARY_DIR}/Tests/VSExternalInclude"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-project VSExternalInclude
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--test-command VSExternalInclude)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExternalInclude")
VS10: Finish Midl support (#11461) This commit addresses all of the following: http://public.kitware.com/Bug/view.php?id=8165 http://public.kitware.com/Bug/view.php?id=10687 http://public.kitware.com/Bug/view.php?id=11311 http://public.kitware.com/Bug/view.php?id=11461 With this commit, the midl support for VS10 is as complete as midl support ever was for VS9 and earlier. The VSMidl test should run on all Visual Studio generator based dashboards. CMake no longer sends C++ compiler /D flag values to the midl compiler in Visual Studio generated projects. I think if we want to add that in the future, we should add a way to pass midl compiler specific flags and perhaps an optional way to add in the C++ definitions, too. For now, not sending them along gets past the immediate problem wherein idl files in a CMake VS generated project just didn't work at all. The VSMidl test added in this commit was inspired by the patch attached to 8165. The test had to be modified such that it will run in a directory whose name contains no spaces. There is an existing bug filed against VS10's midl asking Microsoft to fix that problem. But for now, the test added in this commit works by copying the source directory to a location that avoids spaces in the directory names. Inspired-By: Robert Lenhardt
2011-01-05 02:51:15 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(VSMidl ${CMAKE_CTEST_COMMAND}
VS10: Finish Midl support (#11461) This commit addresses all of the following: http://public.kitware.com/Bug/view.php?id=8165 http://public.kitware.com/Bug/view.php?id=10687 http://public.kitware.com/Bug/view.php?id=11311 http://public.kitware.com/Bug/view.php?id=11461 With this commit, the midl support for VS10 is as complete as midl support ever was for VS9 and earlier. The VSMidl test should run on all Visual Studio generator based dashboards. CMake no longer sends C++ compiler /D flag values to the midl compiler in Visual Studio generated projects. I think if we want to add that in the future, we should add a way to pass midl compiler specific flags and perhaps an optional way to add in the C++ definitions, too. For now, not sending them along gets past the immediate problem wherein idl files in a CMake VS generated project just didn't work at all. The VSMidl test added in this commit was inspired by the patch attached to 8165. The test had to be modified such that it will run in a directory whose name contains no spaces. There is an existing bug filed against VS10's midl asking Microsoft to fix that problem. But for now, the test added in this commit works by copying the source directory to a location that avoids spaces in the directory names. Inspired-By: Robert Lenhardt
2011-01-05 02:51:15 +03:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VSMidl"
"${CMake_BINARY_DIR}/Tests/VSMidl"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
VS10: Finish Midl support (#11461) This commit addresses all of the following: http://public.kitware.com/Bug/view.php?id=8165 http://public.kitware.com/Bug/view.php?id=10687 http://public.kitware.com/Bug/view.php?id=11311 http://public.kitware.com/Bug/view.php?id=11461 With this commit, the midl support for VS10 is as complete as midl support ever was for VS9 and earlier. The VSMidl test should run on all Visual Studio generator based dashboards. CMake no longer sends C++ compiler /D flag values to the midl compiler in Visual Studio generated projects. I think if we want to add that in the future, we should add a way to pass midl compiler specific flags and perhaps an optional way to add in the C++ definitions, too. For now, not sending them along gets past the immediate problem wherein idl files in a CMake VS generated project just didn't work at all. The VSMidl test added in this commit was inspired by the patch attached to 8165. The test had to be modified such that it will run in a directory whose name contains no spaces. There is an existing bug filed against VS10's midl asking Microsoft to fix that problem. But for now, the test added in this commit works by copying the source directory to a location that avoids spaces in the directory names. Inspired-By: Robert Lenhardt
2011-01-05 02:51:15 +03:00
--build-project VSMidl
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
VS10: Finish Midl support (#11461) This commit addresses all of the following: http://public.kitware.com/Bug/view.php?id=8165 http://public.kitware.com/Bug/view.php?id=10687 http://public.kitware.com/Bug/view.php?id=11311 http://public.kitware.com/Bug/view.php?id=11461 With this commit, the midl support for VS10 is as complete as midl support ever was for VS9 and earlier. The VSMidl test should run on all Visual Studio generator based dashboards. CMake no longer sends C++ compiler /D flag values to the midl compiler in Visual Studio generated projects. I think if we want to add that in the future, we should add a way to pass midl compiler specific flags and perhaps an optional way to add in the C++ definitions, too. For now, not sending them along gets past the immediate problem wherein idl files in a CMake VS generated project just didn't work at all. The VSMidl test added in this commit was inspired by the patch attached to 8165. The test had to be modified such that it will run in a directory whose name contains no spaces. There is an existing bug filed against VS10's midl asking Microsoft to fix that problem. But for now, the test added in this commit works by copying the source directory to a location that avoids spaces in the directory names. Inspired-By: Robert Lenhardt
2011-01-05 02:51:15 +03:00
--test-command VSMidl)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSMidl")
Add tests for EXCLUDE_FROM_DEFAULT_BUILD Add tests for EXCLUDE_FROM_DEFAULT_BUILD and its per-configuration variants.
2012-10-12 17:30:17 +04:00
Tests: Rename CMAKE_TEST_DEVENV -> CMake_TEST_DEVENV Follow the convention of naming variables related to the CMake build itself as "CMake_" rather than "CMAKE_". While at it, consolidate the code computing CMake_TEST_DEVENV to be more localized.
2014-03-03 21:40:58 +04:00
if(CMake_TEST_DEVENV)
Add tests for EXCLUDE_FROM_DEFAULT_BUILD Add tests for EXCLUDE_FROM_DEFAULT_BUILD and its per-configuration variants.
2012-10-12 17:30:17 +04:00
# The test (and tested property) works with .sln files, so it's skipped when:
# * Using VS6, which doesn't use .sln files
# * cmake --build is set up to use MSBuild, since the MSBuild invocation does not use the .sln file
Serialize tests for EXCLUDE_FROM_DEFAULT_BUILD The tests share a single build directory and so should not run in parallel. While at it, add the build dir to the test_clean target.
2012-11-13 19:52:05 +04:00
set(_last_test "")
Add tests for EXCLUDE_FROM_DEFAULT_BUILD Add tests for EXCLUDE_FROM_DEFAULT_BUILD and its per-configuration variants.
2012-10-12 17:30:17 +04:00
foreach(config ${CMAKE_CONFIGURATION_TYPES})
add_test(NAME VSExcludeFromDefaultBuild-${config} COMMAND ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild"
"${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
--build-config ${config}
--build-two-config
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator ${CMAKE_GENERATOR}
Tests: Rename CMAKE_TEST_DEVENV -> CMake_TEST_DEVENV Follow the convention of naming variables related to the CMake build itself as "CMake_" rather than "CMAKE_". While at it, consolidate the code computing CMake_TEST_DEVENV to be more localized.
2014-03-03 21:40:58 +04:00
--build-makeprogram ${CMake_TEST_DEVENV}
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
--build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
Add tests for EXCLUDE_FROM_DEFAULT_BUILD Add tests for EXCLUDE_FROM_DEFAULT_BUILD and its per-configuration variants.
2012-10-12 17:30:17 +04:00
--build-project VSExcludeFromDefaultBuild
VS: Add option to put INSTALL target in .sln default build Add a CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD variable to control this behavior.
2015-05-01 20:46:17 +03:00
--build-target install
Add tests for EXCLUDE_FROM_DEFAULT_BUILD Add tests for EXCLUDE_FROM_DEFAULT_BUILD and its per-configuration variants.
2012-10-12 17:30:17 +04:00
--test-command ${CMAKE_COMMAND}
-D "activeConfig=${config}"
-D "allConfigs=${CMAKE_CONFIGURATION_TYPES}"
-D "dir=${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild"
-P "${CMake_SOURCE_DIR}/Tests/VSExcludeFromDefaultBuild/ResultTest.cmake")
Serialize tests for EXCLUDE_FROM_DEFAULT_BUILD The tests share a single build directory and so should not run in parallel. While at it, add the build dir to the test_clean target.
2012-11-13 19:52:05 +04:00
if(_last_test)
set_property(TEST VSExcludeFromDefaultBuild-${config} PROPERTY DEPENDS ${_last_test})
endif()
set(_last_test "VSExcludeFromDefaultBuild-${config}")
Add tests for EXCLUDE_FROM_DEFAULT_BUILD Add tests for EXCLUDE_FROM_DEFAULT_BUILD and its per-configuration variants.
2012-10-12 17:30:17 +04:00
endforeach()
Serialize tests for EXCLUDE_FROM_DEFAULT_BUILD The tests share a single build directory and so should not run in parallel. While at it, add the build dir to the test_clean target.
2012-11-13 19:52:05 +04:00
unset(_last_test)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSExcludeFromDefaultBuild")
Add tests for EXCLUDE_FROM_DEFAULT_BUILD Add tests for EXCLUDE_FROM_DEFAULT_BUILD and its per-configuration variants.
2012-10-12 17:30:17 +04:00
endif()
VS: Add test for building MSBuild project in subdir Add test covering cmGlobalGenerator::GenerateBuildCommand for VS solutions with MSBuild and building a target defined in a subdirectory and not part of ALL.
2013-01-03 16:43:42 +04:00
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(CMAKE_GENERATOR MATCHES "Visual Studio ([0-5]|[6-9][0-9])")
Tests: Simplify VSProjectInSubdir configuration The test is only enabled on VS 10 and above, where the generators now select for "ctest --build-and-test" the MSBuild tool by default. Simplify the test configuration by dropping the --build-makeprogram option and all the logic needed to compute its value. The test will automatically use MSBuild.
2013-11-14 23:21:40 +04:00
# This is Visual Studio 10 or above, so the default build tool is MSBuild.
add_test(NAME VSProjectInSubdir COMMAND ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VSProjectInSubdir"
"${CMake_BINARY_DIR}/Tests/VSProjectInSubdir"
--build-two-config
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator ${CMAKE_GENERATOR}
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
--build-generator-platform "${CMAKE_GENERATOR_PLATFORM}"
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
--build-generator-toolset "${CMAKE_GENERATOR_TOOLSET}"
Tests: Simplify VSProjectInSubdir configuration The test is only enabled on VS 10 and above, where the generators now select for "ctest --build-and-test" the MSBuild tool by default. Simplify the test configuration by dropping the --build-makeprogram option and all the logic needed to compute its value. The test will automatically use MSBuild.
2013-11-14 23:21:40 +04:00
--build-project VSProjectInSubdir
--build-target test)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSProjectInSubdir")
VS: Add test for building MSBuild project in subdir Add test covering cmGlobalGenerator::GenerateBuildCommand for VS solutions with MSBuild and building a target defined in a subdirectory and not part of ALL.
2013-01-03 16:43:42 +04:00
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Tests: Always detect VS and SDK availability on Windows Move the detection block out of the Windows >= 8 conditional so it can be used on other versions.
2014-09-16 17:35:56 +04:00
if(WIN32)
Tests: Run Tutorial steps 1-4 as tests for Windows CE
2014-10-29 16:27:11 +03:00
# Macro to search for available Windows CE SDKs in the windows Registry
macro(select_wince_sdk selected_reg selected_sdk)
if(CMAKE_HOST_WIN32)
execute_process(COMMAND reg QUERY "HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows CE Tools\\SDKs"
OUTPUT_VARIABLE sdk_reg
ERROR_VARIABLE my_err)
string(REGEX REPLACE "HKEY_LOCAL_MACHINE\\\\SOFTWARE\\\\Wow6432Node\\\\Microsoft\\\\Windows CE Tools\\\\SDKs\\\\" ";" sdk_list "${sdk_reg}")
list(LENGTH sdk_list sdk_list_len)
if (${sdk_list_len} GREATER 1)
list(GET sdk_list 1 _sdk) # The first entry is always empty due to the regex replace above
string(STRIP ${_sdk} _sdk) # Make sure there is no newline in the SDK name
endif()
# Build a key to be used by get_filename_component that is pointing to the SDK directory
set(_reg "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\Windows CE Tools\\SDKs\\${_sdk}]")
# Set return values
set(${selected_reg} ${_reg})
set(${selected_sdk} ${_sdk})
endif(CMAKE_HOST_WIN32)
endmacro(select_wince_sdk)
Tests: Add test for VS Nsight Tegra generator support Create a VSNsightTegra test based on the "two-libs" example from the Android NDK. Add it whenever testing on a machine with VS 11 or 12 and the NVIDIA Nsight Tegra Visual Studio Edition installed. Exclude it when there is a space in the path to the source or build tree because the tools do not seem to support it.
2014-09-16 17:48:38 +04:00
set(reg_vs10 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\10.0;InstallDir]")
Tests: Always detect VS and SDK availability on Windows Move the detection block out of the Windows >= 8 conditional so it can be used on other versions.
2014-09-16 17:35:56 +04:00
set(reg_vs11 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\11.0;InstallDir]")
set(reg_vs12 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\12.0;InstallDir]")
set(reg_ws80 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.0;InstallationFolder]")
set(reg_ws81 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v8.1;InstallationFolder]")
set(reg_wp80 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\WindowsPhone\\v8.0;InstallationFolder]")
set(reg_wp81 "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\WindowsPhone\\v8.1;InstallationFolder]")
Tests: Run Tutorial steps 1-4 as tests for Windows CE
2014-10-29 16:27:11 +03:00
select_wince_sdk(reg_wince wince_sdk)
Tests: Add test for VS Nsight Tegra generator support Create a VSNsightTegra test based on the "two-libs" example from the Android NDK. Add it whenever testing on a machine with VS 11 or 12 and the NVIDIA Nsight Tegra Visual Studio Edition installed. Exclude it when there is a space in the path to the source or build tree because the tools do not seem to support it.
2014-09-16 17:48:38 +04:00
set(reg_tegra "[HKEY_LOCAL_MACHINE\\SOFTWARE\\NVIDIA Corporation\\Nsight Tegra;sdkRoot]")
Tests: Run Tutorial steps 1-4 as tests for Windows CE
2014-10-29 16:27:11 +03:00
foreach(reg vs10 vs11 vs12 ws80 ws81 wp80 wp81 wince tegra)
Tests: Always detect VS and SDK availability on Windows Move the detection block out of the Windows >= 8 conditional so it can be used on other versions.
2014-09-16 17:35:56 +04:00
get_filename_component(r "${reg_${reg}}" ABSOLUTE)
if(IS_DIRECTORY "${r}")
set(${reg} 1)
else()
set(${reg} 0)
endif()
endforeach()
endif()
VS: Add test case for Windows Phone and Windows Store Add tests to build for each version of each system when the corresponding tools are available.
2014-08-28 17:53:24 +04:00
get_filename_component(ntver "[HKEY_LOCAL_MACHINE\\Software\\Microsoft\\Windows NT\\CurrentVersion;CurrentVersion]" NAME)
if(WIN32 AND ntver VERSION_GREATER 6.1) # Windows >= 8.0
macro(add_test_VSWinStorePhone name generator systemName systemVersion)
add_test(NAME VSWinStorePhone.${name} COMMAND ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VSWinStorePhone"
"${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}"
--build-generator "${generator}"
--build-project VSWinStorePhone
--build-config $<CONFIGURATION>
--build-options -DCMAKE_SYSTEM_NAME=${systemName}
-DCMAKE_SYSTEM_VERSION=${systemVersion}
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSWinStorePhone/${name}")
endmacro()
if(vs11 AND ws80)
add_test_VSWinStorePhone(vs11-store80-X86 "Visual Studio 11 2012" WindowsStore 8.0)
add_test_VSWinStorePhone(vs11-store80-ARM "Visual Studio 11 2012 ARM" WindowsStore 8.0)
add_test_VSWinStorePhone(vs11-store80-X64 "Visual Studio 11 2012 Win64" WindowsStore 8.0)
endif()
if(vs12 AND ws81)
add_test_VSWinStorePhone(vs12-store81-X86 "Visual Studio 12 2013" WindowsStore 8.1)
add_test_VSWinStorePhone(vs12-store81-ARM "Visual Studio 12 2013 ARM" WindowsStore 8.1)
add_test_VSWinStorePhone(vs12-store81-X64 "Visual Studio 12 2013 Win64" WindowsStore 8.1)
VS: Add support for XAML source files XAML files are by default of type Page in the vcxproj and can be overriden by setting the VS_XAML_TYPE property. The .cpp and .h file of the same name are automatically added as depending on the XAML file. New VSXaml test builds a basic XAML WindowsStore 8.1 app with VS2013.
2015-03-31 23:49:39 +03:00
add_test(NAME VSXaml COMMAND ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VSXaml"
"${CMake_BINARY_DIR}/Tests/VSXaml"
--build-generator "Visual Studio 12 2013"
--build-project VSXaml
--build-config $<CONFIGURATION>
--build-options -DCMAKE_SYSTEM_NAME=WindowsStore
-DCMAKE_SYSTEM_VERSION=8.1
)
VS: Add test case for Windows Phone and Windows Store Add tests to build for each version of each system when the corresponding tools are available.
2014-08-28 17:53:24 +04:00
endif()
if(vs11 AND wp80)
add_test_VSWinStorePhone(vs11-phone80-X86 "Visual Studio 11 2012" WindowsPhone 8.0)
add_test_VSWinStorePhone(vs11-phone80-ARM "Visual Studio 11 2012 ARM" WindowsPhone 8.0)
endif()
if(vs12 AND wp81)
add_test_VSWinStorePhone(vs12-phone81-X86 "Visual Studio 12 2013" WindowsPhone 8.1)
add_test_VSWinStorePhone(vs12-phone81-ARM "Visual Studio 12 2013 ARM" WindowsPhone 8.1)
endif()
endif()
Tests: Run Tutorial steps 1-4 as tests for Windows CE
2014-10-29 16:27:11 +03:00
if(WIN32 AND wince)
macro(add_test_VSWinCE name generator systemName systemVersion generatorPlatform)
# TODO: Fix the tutorial to make it work in cross compile
# currently the MakeTable is build for target and can not be used on the host
# This happens in part 5 so we build only part 1-4 of the tutorial
foreach(STP RANGE 1 4)
add_test(NAME "TutorialStep${STP}.${name}" COMMAND ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Tutorial/Step${STP}"
"${CMake_BINARY_DIR}/Tests/Tutorial/Step${STP}_${name}"
--build-generator "${generator}"
--build-project Tutorial
--build-config $<CONFIGURATION>
--build-options -DCMAKE_SYSTEM_NAME=${systemName}
-DCMAKE_SYSTEM_VERSION=${systemVersion}
-DCMAKE_GENERATOR_PLATFORM=${generatorPlatform})
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Tutorial/Step${STP}_${name}")
endforeach()
endmacro()
if(vs11)
add_test_VSWinCE(vs11-ce80-ARM "Visual Studio 11 2012" WindowsCE 8.0 ${wince_sdk})
endif()
if(vs12)
add_test_VSWinCE(vs12-ce80-ARM "Visual Studio 12 2013" WindowsCE 8.0 ${wince_sdk})
endif()
endif()
Add a 'Green Hills MULTI' generator on Windows Green Hills MULTI is an IDE for embedded real-time systems. The IDE's product page can be found here: http://www.ghs.com/products/MULTI_IDE.html It supports cross compiling on ARM, Intel x86, and other architectures with various operating systems. The IDE exists on Linux and Windows host systems, but CMake will currently only generate the project files on Windows host systems.
2015-03-24 08:12:55 +03:00
if (CMake_TEST_GreenHillsMULTI)
macro(add_test_GhsMulti name primaryTarget bspName)
add_test(NAME GhsMulti.${name} COMMAND ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/GhsMulti"
"${CMake_BINARY_DIR}/Tests/GhsMulti/${name}"
--build-generator "Green Hills MULTI"
--build-project ReturnNum
--build-config $<CONFIGURATION>
--build-options -DGHS_PRIMARY_TARGET=${primaryTarget}
-DGHS_BSP_NAME=${bspName}
)
endmacro ()
add_test_GhsMulti("arm_integrity_simarm" "arm_integrity.tgt" "simarm")
add_test_GhsMulti("arm64_integrity_simarm" "arm64_integrity.tgt" "simarm")
endif ()
Tests: Add test for VS Nsight Tegra generator support Create a VSNsightTegra test based on the "two-libs" example from the Android NDK. Add it whenever testing on a machine with VS 11 or 12 and the NVIDIA Nsight Tegra Visual Studio Edition installed. Exclude it when there is a space in the path to the source or build tree because the tools do not seem to support it.
2014-09-16 17:48:38 +04:00
if(tegra AND NOT "${CMake_SOURCE_DIR};${CMake_BINARY_DIR}" MATCHES " ")
macro(add_test_VSNsightTegra name generator)
add_test(NAME VSNsightTegra.${name} COMMAND ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VSNsightTegra"
"${CMake_BINARY_DIR}/Tests/VSNsightTegra/${name}"
--build-generator "${generator}"
--build-project VSNsightTegra
--build-config $<CONFIGURATION>
--build-options -DCMAKE_SYSTEM_NAME=Android
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/VSNsightTegra/${name}")
endmacro()
if(vs10)
add_test_VSNsightTegra(vs10 "Visual Studio 10 2010")
endif()
if(vs11)
add_test_VSNsightTegra(vs11 "Visual Studio 11 2012")
endif()
if(vs12)
add_test_VSNsightTegra(vs12 "Visual Studio 12 2013")
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if (APPLE)
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
if (CMAKE_COMPILER_IS_GNUCXX OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(BundleTestInstallDir
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
"${CMake_BINARY_DIR}/Tests/BundleTest/InstallDirectory")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(BundleTest ${CMAKE_CTEST_COMMAND}
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/BundleTest"
"${CMake_BINARY_DIR}/Tests/BundleTest"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
--build-project BundleTest
--build-target install
# --build-target package
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
"-DCMAKE_INSTALL_PREFIX:PATH=${BundleTestInstallDir}"
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
"-DCMake_SOURCE_DIR:PATH=${CMake_SOURCE_DIR}"
--test-command
${BundleTestInstallDir}/Applications/SecondBundleExe.app/Contents/MacOS/SecondBundleExe)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleTest")
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
Tests: Run CFBundleTest only with valid configuration The verification script needs to know the configuration tested.
2014-12-17 19:42:19 +03:00
add_test(NAME CFBundleTest COMMAND ${CMAKE_CTEST_COMMAND}
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/CFBundleTest"
"${CMake_BINARY_DIR}/Tests/CFBundleTest"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
--build-project CFBundleTest
Tests: Run CFBundleTest only with valid configuration The verification script needs to know the configuration tested.
2014-12-17 19:42:19 +03:00
--build-config $<CONFIGURATION>
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
--test-command
Tests: Run CFBundleTest only with valid configuration The verification script needs to know the configuration tested.
2014-12-17 19:42:19 +03:00
${CMAKE_CMAKE_COMMAND} -DCTEST_CONFIGURATION_TYPE=$<CONFIGURATION>
Add support for CFBundle targets on the Mac (#11295) This commit enables building, for example, plugin bundles to be loaded by web browsers.
2010-10-07 06:43:04 +04:00
-Ddir=${CMake_BINARY_DIR}/Tests/CFBundleTest
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
-Dgen=${CMAKE_GENERATOR}
Add support for CFBundle targets on the Mac (#11295) This commit enables building, for example, plugin bundles to be loaded by web browsers.
2010-10-07 06:43:04 +04:00
-P ${CMake_SOURCE_DIR}/Tests/CFBundleTest/VerifyResult.cmake)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CFBundleTest")
Add support for CFBundle targets on the Mac (#11295) This commit enables building, for example, plugin bundles to be loaded by web browsers.
2010-10-07 06:43:04 +04:00
Enable BundleTest with CLang too.
2012-07-16 13:26:56 +04:00
ADD_TEST_MACRO(ObjC++ ObjC++)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
endif ()
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(APPLE AND CTEST_TEST_CPACK)
add_test(BundleGeneratorTest ${CMAKE_CTEST_COMMAND}
ENH: Add test for the new CPack BundleGenerator. Thanks to Tim Shead for the patch. See issue #7170 for more details.
2008-07-31 00:36:22 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/BundleGeneratorTest"
"${CMake_BINARY_DIR}/Tests/BundleGeneratorTest"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: fix build with Xcode project was missing
2008-07-31 18:54:55 +04:00
--build-project BundleGeneratorTest
ENH: Add test for the new CPack BundleGenerator. Thanks to Tim Shead for the patch. See issue #7170 for more details.
2008-07-31 00:36:22 +04:00
--build-target package
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
"-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/BundleGeneratorTest/InstallDirectory"
ENH: Add test for the new CPack BundleGenerator. Thanks to Tim Shead for the patch. See issue #7170 for more details.
2008-07-31 00:36:22 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Add test for the new CPack BundleGenerator. Thanks to Tim Shead for the patch. See issue #7170 for more details.
2008-07-31 00:36:22 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(WarnUnusedUnusedViaSet ${CMAKE_CTEST_COMMAND}
Add test for unused detection via setting it
2010-09-16 21:52:54 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VariableUnusedViaSet"
"${CMake_BINARY_DIR}/Tests/WarnUnusedUnusedViaSet"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Add test for unused detection via setting it
2010-09-16 21:52:54 +04:00
--build-noclean
--build-project WarnUnusedUnusedViaSet
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
"--warn-unused-vars")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(WarnUnusedUnusedViaSet PROPERTIES
Update expected messages to new format
2010-12-08 00:46:10 +03:00
PASS_REGULAR_EXPRESSION "unused variable \\(changing definition\\) 'UNUSED_VARIABLE'")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(WarnUnusedUnusedViaSet PROPERTIES
Update expected messages to new format
2010-12-08 00:46:10 +03:00
FAIL_REGULAR_EXPRESSION "unused variable \\(unsetting\\) 'UNUSED_VARIABLE'")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedUnusedViaSet")
Add test for unused detection via setting it
2010-09-16 21:52:54 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(WarnUnusedUnusedViaUnset ${CMAKE_CTEST_COMMAND}
Add test for usage checks via unset
2010-09-16 21:51:51 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VariableUnusedViaUnset"
"${CMake_BINARY_DIR}/Tests/WarnUnusedUnusedViaUnset"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Add test for usage checks via unset
2010-09-16 21:51:51 +04:00
--build-noclean
--build-project WarnUnusedUnusedViaUnset
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
"--warn-unused-vars")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(WarnUnusedUnusedViaUnset PROPERTIES
tests: update unused variable test expected output The expected output is now a relative path, not a full path. Update the pass/fail detection accordingly.
2014-06-05 19:00:57 +04:00
PASS_REGULAR_EXPRESSION "CMake Warning \\(dev\\) at CMakeLists.txt:7 \\(set\\):")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(WarnUnusedUnusedViaUnset PROPERTIES
tests: update unused variable test expected output The expected output is now a relative path, not a full path. Update the pass/fail detection accordingly.
2014-06-05 19:00:57 +04:00
FAIL_REGULAR_EXPRESSION "CMakeLists.txt:5 \\(set\\):")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedUnusedViaUnset")
Add test for usage checks via unset
2010-09-16 21:51:51 +04:00
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Makefile" AND NOT WIN32)
CLI: Suppress the unused warning if the key value pair is cached. It is common to specify a CMAKE_TOOLCHAIN_FILE and get a warning for using it despite it not being used. The WarnUnusedCliUnused test relies on the warning being emitted each time cmake is run on an existing build. That behavior is changed by this patch to warn only on the first invokation of CMake, and not on subsequent invokations (because the variable is in the cache with the same value). For that test, a clean target is added which clears the cache and cause the warning to be emitted each time. As the Ninja generator does not support the feature needed to test this, it is not tested with that generator.
2013-05-16 23:51:45 +04:00
# Ninja does not support ADDITIONAL_MAKE_CLEAN_FILES and therefore fails
# this test. (See #13371)
# Apparently Visual Studio does not support it either. As the MakeClean
# test above is only run with the Makefiles generator, only run this
# test with the Makefiles generator also.
add_test(WarnUnusedCliUnused ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/WarnUnusedCliUnused"
"${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused"
${build_generator_args}
--build-project WarnUnusedCliUnused
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
"-DUNUSED_CLI_VARIABLE=Unused")
CLI: Suppress the unused warning if the key value pair is cached. It is common to specify a CMAKE_TOOLCHAIN_FILE and get a warning for using it despite it not being used. The WarnUnusedCliUnused test relies on the warning being emitted each time cmake is run on an existing build. That behavior is changed by this patch to warn only on the first invokation of CMake, and not on subsequent invokations (because the variable is in the cache with the same value). For that test, a clean target is added which clears the cache and cause the warning to be emitted each time. As the Ninja generator does not support the feature needed to test this, it is not tested with that generator.
2013-05-16 23:51:45 +04:00
set_tests_properties(WarnUnusedCliUnused PROPERTIES
PASS_REGULAR_EXPRESSION "CMake Warning:.*Manually-specified variables were not used by the project:.* UNUSED_CLI_VARIABLE")
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUnused")
endif()
Add tests for unused command line variables
2010-09-02 19:33:57 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(WarnUnusedCliUsed ${CMAKE_CTEST_COMMAND}
Add tests for unused command line variables
2010-09-02 19:33:57 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VariableUsage"
"${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Add tests for unused command line variables
2010-09-02 19:33:57 +04:00
--build-noclean
--build-project WarnUnusedCliUsed
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
"-DUSED_VARIABLE=Usage proven")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(WarnUnusedCliUsed PROPERTIES
Add tests for unused command line variables
2010-09-02 19:33:57 +04:00
PASS_REGULAR_EXPRESSION "Usage proven")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(WarnUnusedCliUsed PROPERTIES
Use 'CMake Warning' versus 'warning' for CDash
2010-12-07 22:17:50 +03:00
FAIL_REGULAR_EXPRESSION "CMake Warning: The variable, 'USED_VARIABLE'")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUnusedCliUsed")
Add tests for unused command line variables
2010-09-02 19:33:57 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(WarnUninitialized ${CMAKE_CTEST_COMMAND}
Add test for uninitialized variables
2010-09-02 19:34:13 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/VariableUsage"
"${CMake_BINARY_DIR}/Tests/WarnUninitialized"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Add test for uninitialized variables
2010-09-02 19:34:13 +04:00
--build-noclean
--build-project WarnUninitialized
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
"--warn-uninitialized")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(WarnUninitialized PROPERTIES
Fix expected output for WarnUninitialized test
2010-12-08 01:00:41 +03:00
PASS_REGULAR_EXPRESSION "uninitialized variable 'USED_VARIABLE'")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/WarnUninitialized")
Add test for uninitialized variables
2010-09-02 19:34:13 +04:00
Tests: Build config-dependent tests in the same config they run The CPackComponentsForAll-*, GeneratorExpression, and TestsWorkingDirectory tests all build binaries that they later need to run or package for the tested configuration. Tell the 'ctest --build-and-test' call to use the same configuration for driving the build process.
2014-11-13 17:34:31 +03:00
add_test(TestsWorkingDirectory
${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
Add the WORKING_DIRECTORY property to tests
2010-10-26 14:06:15 +04:00
--build-and-test
Rename WorkingDirectory test
2010-12-17 00:50:16 +03:00
"${CMake_SOURCE_DIR}/Tests/TestsWorkingDirectory"
"${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Rename WorkingDirectory test
2010-12-17 00:50:16 +03:00
--build-project TestsWorkingDirectoryProj
--build-exe-dir "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
Add the WORKING_DIRECTORY property to tests
2010-10-26 14:06:15 +04:00
--force-new-ctest-process
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
CTest: Report tests not run due to unknown configuration When add_test(NAME) is called without the CONFIGURATIONS argument then the test is intended to run in any configuration. In multi-config generators like the VS IDE and Xcode tests created by add_test(NAME) can only be run when testing a known configuration (otherwise there is no way to generate the test command line). If no test command line is known for a particular configuration, or if no configuration is given to ctest, report the test as not run instead of silently skipping it. Also fix CMake's own TestsWorkingDirectory test invocation to correct a previously silent failure exposed by this change.
2011-06-10 17:29:30 +04:00
--test-command ${CMAKE_CTEST_COMMAND} -V -C \${CTEST_CONFIGURATION_TYPE}
Add the WORKING_DIRECTORY property to tests
2010-10-26 14:06:15 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory")
Add the WORKING_DIRECTORY property to tests
2010-10-26 14:06:15 +04:00
Test that CTest can handle missing newlines We create test 'CTest.NoNewline' to print output with no newline. This tests CTest's ability to handle a missing newline.
2009-09-12 00:39:07 +04:00
# Make sure CTest can handle a test with no newline in output.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTest.NoNewline
Run CTest.NoNewline test using built CMake Even though this test is checking that the ctest running it can handle test output without newlines we should run the just-built CMake binary. This allows the MemCheck test mode to check the correct CMake.
2010-06-10 16:24:27 +04:00
${CMAKE_CMAKE_COMMAND} -E echo_append "This line has no newline!")
Test that CTest can handle missing newlines We create test 'CTest.NoNewline' to print output with no newline. This tests CTest's ability to handle a missing newline.
2009-09-12 00:39:07 +04:00
STYLE: don't load CMakeDetermineSystem and CMakeSystemSpecific directly from cmCTestScriptHandler, but have it load the new script CTestScriptMode.cmake -> that makes it more flexible, also add a simple test that the system name has been determined correctly Alex
2009-07-12 12:51:51 +04:00
# A simple test for ctest in script mode
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file("${CMake_SOURCE_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake.in"
STYLE: don't load CMakeDetermineSystem and CMakeSystemSpecific directly from cmCTestScriptHandler, but have it load the new script CTestScriptMode.cmake -> that makes it more flexible, also add a simple test that the system name has been determined correctly Alex
2009-07-12 12:51:51 +04:00
"${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake" @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
# add_test(CTest.ScriptMode ${CMAKE_CTEST_COMMAND}
BUG: disable the test for now, will make it work correctly later Alex
2009-07-12 22:52:31 +04:00
# -S "${CMake_BINARY_DIR}/Tests/CTestScriptMode/CTestTestScriptMode.cmake"
# )
STYLE: don't load CMakeDetermineSystem and CMakeSystemSpecific directly from cmCTestScriptHandler, but have it load the new script CTestScriptMode.cmake -> that makes it more flexible, also add a simple test that the system name has been determined correctly Alex
2009-07-12 12:51:51 +04:00
ctest_build: Pass projectDir to GenerateBuildCommand This allows the ctest_build command's TARGET option to name a target in a subdirectory and still build properly with msbuild. Add test case covering use of ctest_build() with such a TARGET.
2013-03-28 18:10:13 +04:00
# A test for ctest_build() with targets in subdirectories
Tests: Simplify CTest.BuildCommand.ProjectInSubdir configuration Collect all ctest_configure options in a list to configure it into the test script. Drop the unused -DCMAKE_MAKE_PROGRAM argument to ctest.
2013-11-14 22:32:39 +04:00
set(ctest_configure_options)
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
if(CMAKE_GENERATOR_PLATFORM)
Tests: Use -A option to pass generator platform selection This is less verbose than defining CMAKE_GENERATOR_PLATFORM.
2014-09-12 18:38:32 +04:00
list(APPEND ctest_configure_options -A ${CMAKE_GENERATOR_PLATFORM})
Tests: Add generator platform support Propagate CMAKE_GENERATOR_PLATFORM through the test hierarchy so that all tests can build with the selected generator platform, if any.
2014-09-05 23:40:01 +04:00
endif()
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(CMAKE_GENERATOR_TOOLSET)
list(APPEND ctest_configure_options -T ${CMAKE_GENERATOR_TOOLSET})
Tests: Simplify CTest.BuildCommand.ProjectInSubdir configuration Collect all ctest_configure options in a list to configure it into the test script. Drop the unused -DCMAKE_MAKE_PROGRAM argument to ctest.
2013-11-14 22:32:39 +04:00
endif()
Tests: Rename CMAKE_TEST_MAKEPROGRAM uses for explicit make program Rename uses of the variable for specifying the make program used to build test projects to CMake_TEST_EXPLICIT_MAKE_PROGRAM.
2014-03-03 22:58:19 +04:00
if(CMake_TEST_EXPLICIT_MAKE_PROGRAM)
list(APPEND ctest_configure_options -DCMAKE_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM})
ctest_build: Pass projectDir to GenerateBuildCommand This allows the ctest_build command's TARGET option to name a target in a subdirectory and still build properly with msbuild. Add test case covering use of ctest_build() with such a TARGET.
2013-03-28 18:10:13 +04:00
endif()
configure_file("${CMake_SOURCE_DIR}/Tests/CTestBuildCommandProjectInSubdir/CTestBuildCommandProjectInSubdir.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestBuildCommandProjectInSubdir/CTestBuildCommandProjectInSubdir.cmake" @ONLY)
Tests: Simplify CTest.BuildCommand.ProjectInSubdir configuration Collect all ctest_configure options in a list to configure it into the test script. Drop the unused -DCMAKE_MAKE_PROGRAM argument to ctest.
2013-11-14 22:32:39 +04:00
unset(ctest_configure_options)
ctest_build: Pass projectDir to GenerateBuildCommand This allows the ctest_build command's TARGET option to name a target in a subdirectory and still build properly with msbuild. Add test case covering use of ctest_build() with such a TARGET.
2013-03-28 18:10:13 +04:00
add_test(CTest.BuildCommand.ProjectInSubdir
Tests: Simplify CTest.BuildCommand.ProjectInSubdir configuration Collect all ctest_configure options in a list to configure it into the test script. Drop the unused -DCMAKE_MAKE_PROGRAM argument to ctest.
2013-11-14 22:32:39 +04:00
${CMAKE_CTEST_COMMAND} -S "${CMake_BINARY_DIR}/Tests/CTestBuildCommandProjectInSubdir/CTestBuildCommandProjectInSubdir.cmake")
ctest_build: Pass projectDir to GenerateBuildCommand This allows the ctest_build command's TARGET option to name a target in a subdirectory and still build properly with msbuild. Add test case covering use of ctest_build() with such a TARGET.
2013-03-28 18:10:13 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CTestBuildCommandProjectInSubdir/Nested")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CTEST_TEST_UPDATE 1)
if(CTEST_TEST_UPDATE)
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
# Test CTest Update with Subversion
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
find_package(Subversion QUIET)
if(Subversion_FOUND)
get_filename_component(_Subversion_BIN_DIR
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
${Subversion_SVN_EXECUTABLE} PATH)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
find_program(Subversion_SVNADMIN_EXECUTABLE svnadmin
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
HINTS ${_Subversion_BIN_DIR}
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
mark_as_advanced(Subversion_SVNADMIN_EXECUTABLE)
if(NOT Subversion_SVNADMIN_EXECUTABLE)
set(Subversion_FOUND FALSE)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(Subversion_FOUND)
set(CTestUpdateSVN_DIR "CTest UpdateSVN")
configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateSVN.cmake.in"
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
"${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake" @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTest.UpdateSVN ${CMAKE_CMAKE_COMMAND}
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateSVN.cmake"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateSVN_DIR}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
# Test CTest Update with CVS
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(EXISTS ${CMAKE_ROOT}/Modules/FindCVS.cmake)
find_package(CVS QUIET)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
find_program(CVS_EXECUTABLE NAMES cvs)
set(CVS_FOUND ${CVS_EXECUTABLE})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_TEST_UPDATE_CVS)
set(CTestUpdateCVS_DIR "CTest UpdateCVS")
configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateCVS.cmake.in"
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
"${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake" @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTest.UpdateCVS ${CMAKE_CMAKE_COMMAND}
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateCVS.cmake"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateCVS_DIR}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
ENH: Teach CTest to handle Bazaar repositories This creates cmCTestBZR to drive CTest Update handling on bzr-based work trees. Currently we always update to the head of the remote tracking branch (bzr pull), so the nightly start time is ignored for Nightly builds. A later change will address this. Patch from Tom Vercauteren. See issue #6857.
2009-05-15 00:13:52 +04:00
# Test CTest Update with BZR
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_TEST_UPDATE_BZR)
ENH: Teach CTest to handle Bazaar repositories This creates cmCTestBZR to drive CTest Update handling on bzr-based work trees. Currently we always update to the head of the remote tracking branch (bzr pull), so the nightly start time is ignored for Nightly builds. A later change will address this. Patch from Tom Vercauteren. See issue #6857.
2009-05-15 00:13:52 +04:00
# Check if xmloutput plugin is there
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
execute_process(COMMAND ${BZR_EXECUTABLE} xmlplugins RESULT_VARIABLE xmlplugres
ENH: Teach CTest to handle Bazaar repositories This creates cmCTestBZR to drive CTest Update handling on bzr-based work trees. Currently we always update to the head of the remote tracking branch (bzr pull), so the nightly start time is ignored for Nightly builds. A later change will address this. Patch from Tom Vercauteren. See issue #6857.
2009-05-15 00:13:52 +04:00
OUTPUT_QUIET ERROR_QUIET)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if( NOT ${xmlplugres} )
set(CTestUpdateBZR_DIR "CTest UpdateBZR")
configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateBZR.cmake.in"
ENH: Teach CTest to handle Bazaar repositories This creates cmCTestBZR to drive CTest Update handling on bzr-based work trees. Currently we always update to the head of the remote tracking branch (bzr pull), so the nightly start time is ignored for Nightly builds. A later change will address this. Patch from Tom Vercauteren. See issue #6857.
2009-05-15 00:13:52 +04:00
"${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake" @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTest.UpdateBZR ${CMAKE_CMAKE_COMMAND}
ENH: Teach CTest to handle Bazaar repositories This creates cmCTestBZR to drive CTest Update handling on bzr-based work trees. Currently we always update to the head of the remote tracking branch (bzr pull), so the nightly start time is ignored for Nightly builds. A later change will address this. Patch from Tom Vercauteren. See issue #6857.
2009-05-15 00:13:52 +04:00
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR.cmake"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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"
BUG: Fix CTest.UpdateBZR tests to run in parallel The UpdateBZR and UpdateBZR.CLocale tests should run in different directories so that they can be executed in parallel.
2009-06-25 18:51:53 +04:00
"${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake" @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTest.UpdateBZR.CLocale ${CMAKE_CMAKE_COMMAND}
BUG: Fix CTest.UpdateBZR tests to run in parallel The UpdateBZR and UpdateBZR.CLocale tests should run in different directories so that they can be executed in parallel.
2009-06-25 18:51:53 +04:00
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateBZR_CLocale.cmake"
BUG: Parse more bzr xml output encodings The BZR xml output plugin can use some encodings that are not recognized by expat, which leads to "Error parsing bzr log xml: unknown encoding". This works around the problem by giving expat a mapping, and adds a test. Patch from Tom Vercauteren. See issue #6857.
2009-05-18 18:34:35 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTest.UpdateBZR.CLocale PROPERTIES ENVIRONMENT LC_ALL=C)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateBZR_DIR}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
ENH: Teach CTest to handle Bazaar repositories This creates cmCTestBZR to drive CTest Update handling on bzr-based work trees. Currently we always update to the head of the remote tracking branch (bzr pull), so the nightly start time is ignored for Nightly builds. A later change will address this. Patch from Tom Vercauteren. See issue #6857.
2009-05-15 00:13:52 +04:00
ENH: Teach CTest to handle git repositories This creates cmCTestGIT to drive CTest Update handling on git-based work trees. Currently we always update to the head of the remote tracking branch (git pull), so the nightly start time is ignored for Nightly builds. A later change will address this. See issue #6994.
2009-04-22 17:19:06 +04:00
# Test CTest Update with GIT
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_TEST_UPDATE_GIT)
set(CTestUpdateGIT_DIR "CTest UpdateGIT")
configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateGIT.cmake.in"
ENH: Teach CTest to handle git repositories This creates cmCTestGIT to drive CTest Update handling on git-based work trees. Currently we always update to the head of the remote tracking branch (git pull), so the nightly start time is ignored for Nightly builds. A later change will address this. See issue #6994.
2009-04-22 17:19:06 +04:00
"${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake" @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTest.UpdateGIT ${CMAKE_CMAKE_COMMAND}
ENH: Teach CTest to handle git repositories This creates cmCTestGIT to drive CTest Update handling on git-based work trees. Currently we always update to the head of the remote tracking branch (git pull), so the nightly start time is ignored for Nightly builds. A later change will address this. See issue #6994.
2009-04-22 17:19:06 +04:00
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateGIT.cmake"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateGIT_DIR}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Teach CTest to handle git repositories This creates cmCTestGIT to drive CTest Update handling on git-based work trees. Currently we always update to the head of the remote tracking branch (git pull), so the nightly start time is ignored for Nightly builds. A later change will address this. See issue #6994.
2009-04-22 17:19:06 +04:00
ENH: Teach CTest to handle Mercurial repositories This creates cmCTestHG to drive CTest Update handling on hg-based work trees. Currently we always update to the head of the remote tracking branch (hg pull), so the nightly start time is ignored for Nightly builds. A later change will address this. See issue #7879. Patch from Emmanuel Christophe. I modified the patch slightly for code style, to finish up some parsing details, and to fix the test.
2009-07-10 19:08:05 +04:00
# Test CTest Update with HG
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CTEST_TEST_UPDATE_HG)
set(CTestUpdateHG_DIR "CTest UpdateHG")
configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateHG.cmake.in"
ENH: Teach CTest to handle Mercurial repositories This creates cmCTestHG to drive CTest Update handling on hg-based work trees. Currently we always update to the head of the remote tracking branch (hg pull), so the nightly start time is ignored for Nightly builds. A later change will address this. See issue #7879. Patch from Emmanuel Christophe. I modified the patch slightly for code style, to finish up some parsing details, and to fix the test.
2009-07-10 19:08:05 +04:00
"${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake" @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTest.UpdateHG ${CMAKE_CMAKE_COMMAND}
ENH: Teach CTest to handle Mercurial repositories This creates cmCTestHG to drive CTest Update handling on hg-based work trees. Currently we always update to the head of the remote tracking branch (hg pull), so the nightly start time is ignored for Nightly builds. A later change will address this. See issue #7879. Patch from Emmanuel Christophe. I modified the patch slightly for code style, to finish up some parsing details, and to fix the test.
2009-07-10 19:08:05 +04:00
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateHG.cmake"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateHG_DIR}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ctest_update: Add support for Perforce p4 client Teach the ctest_update implementation to use the p4 command-line client to perform updates and extract the list of changes. Add a CTest.UpdateP4 test like those that exist already for the other version control tools. Make the test available when p4 and the p4d server are found. During the test launch p4d in the background to serve a repository from the test directory. Then direct the client toward this server for the duration of the test.
2013-10-23 02:11:22 +04:00
# Test CTest Update with P4
find_program(P4_EXECUTABLE NAMES p4)
find_program(P4D_EXECUTABLE NAMES p4d)
mark_as_advanced(P4_EXECUTABLE P4D_EXECUTABLE)
set(CTEST_TEST_UPDATE_P4 0)
if(P4_EXECUTABLE AND P4D_EXECUTABLE)
if(NOT "${P4_EXECUTABLE};${P4D_EXECUTABLE}" MATCHES "cygwin" OR UNIX)
set(CTEST_TEST_UPDATE_P4 1)
endif()
endif()
if(CTEST_TEST_UPDATE_P4)
set(CTestUpdateP4_DIR "CTest UpdateP4")
configure_file("${CMake_SOURCE_DIR}/Tests/CTestUpdateP4.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestUpdateP4.cmake" @ONLY)
add_test(CTest.UpdateP4 ${CMAKE_CMAKE_COMMAND}
-P "${CMake_BINARY_DIR}/Tests/CTestUpdateP4.cmake"
)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/${CTestUpdateP4_DIR}")
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Test CTest update logic with VCS tools This creates new tests "CTest.UpdateSVN" and "CTest.UpdateCVS". They test that the Update.xml produced by CTest for a version-controlled project contains entries for files added, changed, and removed.
2008-10-19 19:53:01 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
"${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoBuild.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestNoBuild ${CMAKE_CTEST_COMMAND}
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoBuild.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut1.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestNoBuild PROPERTIES
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
FAIL_REGULAR_EXPRESSION "Error" WILL_FAIL true)
Fix issue #2336 - honor the -C arg to ctest. Honor it for all stages of running -D dashboards from the command line and running ctest_configure, ctest_build and ctest_test commands in -S scripts. Also, allow a script to change it by setting the CTEST_CONFIGURATION_TYPE variable: allows for multiple configuration build/test cycles within one script. Add a new signature for the cmake command build_command that accepts CONFIGURATION as one argument. The original build_command signature is still there, but now marked as deprecated in the documentation. Of course... also add CTestConfig tests to verify that -C is honored for -D dashboards and -S scripts.
2009-12-04 20:09:01 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
"${CMake_SOURCE_DIR}/Tests/CTestTestFailure/testNoExe.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestNoExe ${CMAKE_CTEST_COMMAND}
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testNoExe.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestFailure/testOut2.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestNoExe PROPERTIES DEPENDS CTestTestNoBuild
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
PASS_REGULAR_EXPRESSION "Could not find executable"
FAIL_REGULAR_EXPRESSION "SegFault")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Implement ctest_upload command
2011-02-18 20:11:51 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestUpload/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestUpload ${CMAKE_CTEST_COMMAND}
Implement ctest_upload command
2011-02-18 20:11:51 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestUpload/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestUpload/testOut.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestUpload PROPERTIES
Implement ctest_upload command
2011-02-18 20:11:51 +03:00
PASS_REGULAR_EXPRESSION "Upload\\.xml")
Fix issue #2336 - honor the -C arg to ctest. Honor it for all stages of running -D dashboards from the command line and running ctest_configure, ctest_build and ctest_test commands in -S scripts. Also, allow a script to change it by setting the CTEST_CONFIGURATION_TYPE variable: allows for multiple configuration build/test cycles within one script. Add a new signature for the cmake command build_command that accepts CONFIGURATION as one argument. The original build_command signature is still there, but now marked as deprecated in the documentation. Of course... also add CTestConfig tests to verify that -C is honored for -D dashboards and -S scripts.
2009-12-04 20:09:01 +03:00
CTestCoverageCollectGCOV: Add test case
2015-01-29 01:08:41 +03:00
configure_file(
"${CMake_SOURCE_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake"
@ONLY ESCAPE_QUOTES)
add_test(CTestCoverageCollectGCOV ${CMAKE_CTEST_COMMAND}
CTestCoverageCollectGCOV: Support CTEST_CUSTOM_COVERAGE_EXCLUDE
2015-04-02 18:02:08 +03:00
-C \${CTEST_CONFIGURATION_TYPE}
CTestCoverageCollectGCOV: Add test case
2015-01-29 01:08:41 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/test.cmake" -VV
--output-log "${CMake_BINARY_DIR}/Tests/CTestCoverageCollectGCOV/testOut.log"
)
set_tests_properties(CTestCoverageCollectGCOV PROPERTIES
PASS_REGULAR_EXPRESSION
CTestCoverageCollectGCOV: Support CTEST_CUSTOM_COVERAGE_EXCLUDE
2015-04-02 18:02:08 +03:00
"PASSED with correct output.*Testing/CoverageInfo/main.cpp.gcov")
Tests: Guard more CTest tests against parallel execution.
2015-04-27 23:03:40 +03:00
set_property(TEST CTestCoverageCollectGCOV PROPERTY ENVIRONMENT CTEST_PARALLEL_LEVEL=)
CTestCoverageCollectGCOV: Add test case
2015-01-29 01:08:41 +03:00
Tests: added test for ctest_empty_binary_directory()
2013-11-02 00:32:16 +04:00
configure_file(
"${CMake_SOURCE_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake"
@ONLY ESCAPE_QUOTES)
add_test(CTestTestEmptyBinaryDirectory ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestEmptyBinaryDirectory/testOut.log"
)
set_tests_properties(CTestTestEmptyBinaryDirectory PROPERTIES
PASS_REGULAR_EXPRESSION "TEST_SUCCESS")
Add test for mumps coverage. Also refactor code to prepare for cache coverage. Add a simple test to make sure the GTM mumps coverage is working. Also refactor the code so that cache coverage can be added.
2012-05-01 21:35:07 +04:00
# test coverage for mumps
# create a MumpsCoverage dir in the binary tree under Testing to
# avoid the .NoDartCoverage files in the cmake testing tree
configure_file(
"${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.tcl.in"
"${CMake_BINARY_DIR}/Testing/MumpsCoverage/DartConfiguration.tcl")
configure_file(
"${CMake_SOURCE_DIR}/Tests/MumpsCoverage/gtm_coverage.mcov.in"
"${CMake_BINARY_DIR}/Testing/MumpsCoverage/gtm_coverage.mcov")
CTest: Fix MUMPS coverage parsing and test Fix the MUMPS coverage parser: * Account for tabs after entry points * Stop double incrementing lines that have explicit calls to the 0 line * If a line has been previously marked as non executable, but then contains a count, increment it an extra one to push it back into the executable code set. Add a custom routine and corresponding coverage files in the test case. This file is smaller and has cmcov/mcov files that have data for only that routine.
2014-05-14 17:28:07 +04:00
file(REMOVE_RECURSE "${CMake_BINARY_DIR}/Testing/MumpsCoverage/VistA-FOIA")
Add test for mumps coverage. Also refactor code to prepare for cache coverage. Add a simple test to make sure the GTM mumps coverage is working. Also refactor the code so that cache coverage can be added.
2012-05-01 21:35:07 +04:00
file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCoverage")
Use <TARGET_FILE> expression to run ctest so it works with Xcode and VS IDE. Also add -crlf to the .gitconfig to handle the coverage data.
2012-05-02 19:51:38 +04:00
add_test(NAME CTestGTMCoverage
COMMAND cmake -E chdir
${CMake_BINARY_DIR}/Testing/MumpsCoverage
$<TARGET_FILE:ctest> -T Coverage --debug)
Add test for mumps coverage. Also refactor code to prepare for cache coverage. Add a simple test to make sure the GTM mumps coverage is working. Also refactor the code so that cache coverage can be added.
2012-05-01 21:35:07 +04:00
set_tests_properties(CTestGTMCoverage PROPERTIES
PASS_REGULAR_EXPRESSION
CTEST: Fix MUMPS file parser and update test The current file parser for a MUMPS routine uses a period "." as the one of the signals that a line of MUMPS code is executable. This is not a correct assumption. Add the period to the list of characters that CTest will not consider the start of a line of code. Update the test routine to have an entry point with code to match the scenario mentioned above.
2014-08-15 18:50:36 +04:00
"Process file.*ZZCOVTST.m.*Total LOC:.*30.*Percentage Coverage: 80.00*"
Disable bullseye coverage for mumps coverage test.
2012-05-04 19:41:15 +04:00
ENVIRONMENT COVFILE=)
Add support for Cache coverage. This adds support for Cache coverage parsing. A test is added that does a basic run of the coverage on a small bit of data.
2012-05-02 01:00:43 +04:00
configure_file(
"${CMake_SOURCE_DIR}/Tests/MumpsCoverage/DartConfiguration.cache.tcl.in"
"${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/DartConfiguration.tcl")
configure_file(
"${CMake_SOURCE_DIR}/Tests/MumpsCoverage/cache_coverage.cmcov.in"
"${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/cache_coverage.cmcov")
CTest: Fix MUMPS coverage parsing and test Fix the MUMPS coverage parser: * Account for tabs after entry points * Stop double incrementing lines that have explicit calls to the 0 line * If a line has been previously marked as non executable, but then contains a count, increment it an extra one to push it back into the executable code set. Add a custom routine and corresponding coverage files in the test case. This file is smaller and has cmcov/mcov files that have data for only that routine.
2014-05-14 17:28:07 +04:00
file(REMOVE_RECURSE "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage/VistA-FOIA")
Add support for Cache coverage. This adds support for Cache coverage parsing. A test is added that does a basic run of the coverage on a small bit of data.
2012-05-02 01:00:43 +04:00
file(COPY "${CMake_SOURCE_DIR}/Tests/MumpsCoverage/VistA-FOIA"
DESTINATION "${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage")
Use <TARGET_FILE> expression to run ctest so it works with Xcode and VS IDE. Also add -crlf to the .gitconfig to handle the coverage data.
2012-05-02 19:51:38 +04:00
add_test(NAME CTestCacheCoverage
COMMAND cmake -E chdir
${CMake_BINARY_DIR}/Testing/MumpsCacheCoverage
$<TARGET_FILE:ctest> -T Coverage --debug)
Add support for Cache coverage. This adds support for Cache coverage parsing. A test is added that does a basic run of the coverage on a small bit of data.
2012-05-02 01:00:43 +04:00
set_tests_properties(CTestCacheCoverage PROPERTIES
PASS_REGULAR_EXPRESSION
CTEST: Fix MUMPS file parser and update test The current file parser for a MUMPS routine uses a period "." as the one of the signals that a line of MUMPS code is executable. This is not a correct assumption. Add the period to the list of characters that CTest will not consider the start of a line of code. Update the test routine to have an entry point with code to match the scenario mentioned above.
2014-08-15 18:50:36 +04:00
"Process file.*ZZCOVTST.m.*Total LOC:.*29.*Percentage Coverage: 86.21.*"
Disable bullseye coverage for mumps coverage test.
2012-05-04 19:41:15 +04:00
ENVIRONMENT COVFILE=)
Adding support for the Python coverage.py tool. This assumes that coverage.py has been run in such a way to produce its standard XML output. This uses the Cobertura schema and should be somewhat generalizable.
2013-09-27 18:42:39 +04:00
# Adding a test case for Python Coverage
configure_file(
"${CMake_SOURCE_DIR}/Tests/PythonCoverage/coverage.xml.in"
"${CMake_BINARY_DIR}/Testing/PythonCoverage/coverage.xml")
configure_file(
"${CMake_SOURCE_DIR}/Tests/PythonCoverage/DartConfiguration.tcl.in"
"${CMake_BINARY_DIR}/Testing/PythonCoverage/DartConfiguration.tcl")
file(COPY "${CMake_SOURCE_DIR}/Tests/PythonCoverage/coveragetest"
DESTINATION "${CMake_BINARY_DIR}/Testing/PythonCoverage")
add_test(NAME CTestPythonCoverage
COMMAND cmake -E chdir
${CMake_BINARY_DIR}/Testing/PythonCoverage
$<TARGET_FILE:ctest> -T Coverage --debug)
set_tests_properties(CTestPythonCoverage PROPERTIES
PASS_REGULAR_EXPRESSION
"Process file.*foo.py.*Total LOC:.*13.*Percentage Coverage: 84.62.*"
ENVIRONMENT COVFILE=)
CTest: Generalize Cobertura coverage format handling Add support for Cobertura coverage files written by Java. Add a test which uses the report from a Java run of Cobertura to calculate coverage. In the documentation of CTEST_COVERAGE_COMMAND, give a sample .sh file to merge the Cobertura .ser files and generate the XML report from the merged file.
2014-05-29 21:47:31 +04:00
# Adding a test case for non-python Cobertura Coverage
configure_file(
"${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/DartConfiguration.tcl.in"
"${CMake_BINARY_DIR}/Testing/CoberturaCoverage/DartConfiguration.tcl")
configure_file(
"${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/coverage.xml.in"
"${CMake_BINARY_DIR}/Testing/CoberturaCoverage/coverage.xml")
file(COPY "${CMake_SOURCE_DIR}/Tests/CoberturaCoverage/src"
DESTINATION "${CMake_BINARY_DIR}/Testing/CoberturaCoverage")
add_test(NAME CTestCoberturaCoverage
COMMAND cmake -E chdir
${CMake_BINARY_DIR}/Testing/CoberturaCoverage
$<TARGET_FILE:ctest> -T Coverage --debug)
set_tests_properties(CTestCoberturaCoverage PROPERTIES
PASS_REGULAR_EXPRESSION
"Process file.*CoverageTest.java.*Total LOC:.*18.*Percentage Coverage: 72.22.*"
ENVIRONMENT COVFILE=)
CTest: Add Jacoco Coverage functionality Add the ability to parse the XML output of the Jacoco tool. Jacoco (www.eclemma.org/jacoco) is a Java coverage tool. Add and integrate a class for the parser and include a test which utilizes the new parser.
2014-05-21 23:19:35 +04:00
# Adding a test case for JaCoCo Coverage
configure_file(
"${CMake_SOURCE_DIR}/Tests/JacocoCoverage/DartConfiguration.tcl.in"
"${CMake_BINARY_DIR}/Testing/JacocoCoverage/DartConfiguration.tcl")
file(COPY "${CMake_SOURCE_DIR}/Tests/JacocoCoverage/Coverage"
DESTINATION "${CMake_BINARY_DIR}/Testing/JacocoCoverage")
CTest: Fix Jacoco Coverage Rename the example jacoco.xml file to be jacoco.xml.in to stop CMake from apptempting to calculate Jacoco Coverage when running over itself. Enclose a push of -1 to the coverage vector to only happen if there is a fin to calculate for. This prevents a crash if the target file doesn't exist.
2015-03-06 19:18:19 +03:00
configure_file("${CMake_BINARY_DIR}/Testing/JacocoCoverage/Coverage/target/site/jacoco.xml.in"
"${CMake_BINARY_DIR}/Testing/JacocoCoverage/Coverage/target/site/jacoco.xml")
CTest: Add Jacoco Coverage functionality Add the ability to parse the XML output of the Jacoco tool. Jacoco (www.eclemma.org/jacoco) is a Java coverage tool. Add and integrate a class for the parser and include a test which utilizes the new parser.
2014-05-21 23:19:35 +04:00
add_test(NAME CTestJacocoCoverage
COMMAND cmake -E chdir
${CMake_BINARY_DIR}/Testing/JacocoCoverage
$<TARGET_FILE:ctest> -T Coverage --debug)
set_tests_properties(CTestJacocoCoverage PROPERTIES
PASS_REGULAR_EXPRESSION
"Process file.*CoverageTest.java.*Total LOC:.*17.*Percentage Coverage: 76.47*"
ENVIRONMENT COVFILE=)
CTest: Add Javascript coverage parser Add a coverage parser for the Blanket.js library using the JSON output of the mocha.js test runner. Add a test for the new parser.
2014-10-24 01:03:30 +04:00
# Adding a test case for Javascript Coverage
configure_file(
"${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/DartConfiguration.tcl.in"
"${CMake_BINARY_DIR}/Testing/JavascriptCoverage/DartConfiguration.tcl")
configure_file(
"${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/output.json.in"
"${CMake_BINARY_DIR}/Testing/JavascriptCoverage/output.json")
file(COPY "${CMake_SOURCE_DIR}/Tests/JavascriptCoverage/"
DESTINATION "${CMake_BINARY_DIR}/Testing/JavascriptCoverage"
FILES_MATCHING PATTERN "*.js")
add_test(NAME CTestJavascriptCoverage
COMMAND cmake -E chdir
${CMake_BINARY_DIR}/Testing/JavascriptCoverage
$<TARGET_FILE:ctest> -T Coverage --debug)
set_tests_properties(CTestJavascriptCoverage PROPERTIES
PASS_REGULAR_EXPRESSION
"Process file.*test3.js.*Total LOC:.*49.*Percentage Coverage: 79.59*"
ENVIRONMENT COVFILE=)
CTest: Add code coverage parser for Pascal/Delphi Add a class to parse the HTML output of the Delphi-code-coverage tool http://code.google.com/p/delphi-code-coverage/ Add a test for the new parser.
2014-09-29 22:52:10 +04:00
# test coverage for Delphi-code-Coverage
configure_file(
"${CMake_SOURCE_DIR}/Tests/DelphiCoverage/DartConfiguration.tcl.in"
"${CMake_BINARY_DIR}/Testing/DelphiCoverage/DartConfiguration.tcl")
file(COPY "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/src"
DESTINATION "${CMake_BINARY_DIR}/Testing/DelphiCoverage")
file(COPY "${CMake_SOURCE_DIR}/Tests/DelphiCoverage/UTCovTest(UTCovTest.pas).html"
DESTINATION "${CMake_BINARY_DIR}/Testing/DelphiCoverage")
add_test(NAME CTestDelphiCoverage
COMMAND cmake -E chdir
${CMake_BINARY_DIR}/Testing/DelphiCoverage
$<TARGET_FILE:ctest> -T Coverage --debug)
set_tests_properties(CTestDelphiCoverage PROPERTIES
PASS_REGULAR_EXPRESSION
"Process file.*UTCovTest.pas.*Total LOC:.*20.*Percentage Coverage: 95.*"
ENVIRONMENT COVFILE=)
Require CMake 2.8.4 or greater to build CMake This allows the use of the $<TARGET_FILE:...> generator expression as a replacement for the use of the LOCATION target property. The use of the LOCATION target property is now deprecated for in-build targets. Also drop other checks for older CMake versions: * Simplify cmake_set_target_folder macro. * Use find_package(LibArchive) unconditionally. * Simplify condition for running testVisualStudioSlnParser test. * Convert two macros to functions. * Unconditionally run the CTestTestRerunFailed test.
2013-10-11 02:02:24 +04:00
function(add_config_tests cfg)
Fix issue #2336 - honor the -C arg to ctest. Honor it for all stages of running -D dashboards from the command line and running ctest_configure, ctest_build and ctest_test commands in -S scripts. Also, allow a script to change it by setting the CTEST_CONFIGURATION_TYPE variable: allows for multiple configuration build/test cycles within one script. Add a new signature for the cmake command build_command that accepts CONFIGURATION as one argument. The original build_command signature is still there, but now marked as deprecated in the documentation. Of course... also add CTestConfig tests to verify that -C is honored for -D dashboards and -S scripts.
2009-12-04 20:09:01 +03:00
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
)
Require CMake 2.8.4 or greater to build CMake This allows the use of the $<TARGET_FILE:...> generator expression as a replacement for the use of the LOCATION target property. The use of the LOCATION target property is now deprecated for in-build targets. Also drop other checks for older CMake versions: * Simplify cmake_set_target_folder macro. * Use find_package(LibArchive) unconditionally. * Simplify condition for running testVisualStudioSlnParser test. * Convert two macros to functions. * Unconditionally run the CTestTestRerunFailed test.
2013-10-11 02:02:24 +04:00
endfunction()
Fix issue #2336 - honor the -C arg to ctest. Honor it for all stages of running -D dashboards from the command line and running ctest_configure, ctest_build and ctest_test commands in -S scripts. Also, allow a script to change it by setting the CTEST_CONFIGURATION_TYPE variable: allows for multiple configuration build/test cycles within one script. Add a new signature for the cmake command build_command that accepts CONFIGURATION as one argument. The original build_command signature is still there, but now marked as deprecated in the documentation. Of course... also add CTestConfig tests to verify that -C is honored for -D dashboards and -S scripts.
2009-12-04 20:09:01 +03:00
add_config_tests(Debug)
add_config_tests(MinSizeRel)
add_config_tests(Release)
add_config_tests(RelWithDebInfo)
CTest: Add test to verify -D variable definitions work
2012-06-25 16:25:51 +04:00
# Test -S script with some -D variable definition args to ctest:
add_test(CTestConfig.ScriptWithArgs ${CMAKE_CTEST_COMMAND}
-C "Release"
-D arg1=this
-D arg2=that
-D "arg3=the other"
"-Darg4=this is the fourth"
-Darg5=the_fifth
-Darg6:STRING=value-with-type
-S "${CMake_SOURCE_DIR}/Tests/CTestConfig/ScriptWithArgs.cmake" -VV
--output-log "${CMake_BINARY_DIR}/Tests/CTestConfig/ScriptWithArgs.log"
)
Run the add_compile_options command unit test. This has not been executed since it was added in commit a984f325 (Introduce add_compile_options command., 2013-06-04).
2013-12-26 17:24:24 +04:00
ADD_TEST_MACRO(CMakeCommands.add_compile_options add_compile_options)
target_link_libraries: Add LINK_(PUBLIC|PRIVATE) options Makes it possible to specify the link dependencies and link interfaces in one command without repetition.
2011-10-07 04:41:37 +04:00
ADD_TEST_MACRO(CMakeCommands.target_link_libraries target_link_libraries)
Add the target_include_directories command. This is a convenience API to populate the corresponding properties.
2013-01-02 02:20:04 +04:00
ADD_TEST_MACRO(CMakeCommands.target_include_directories target_include_directories)
Add the target_compile_definitions command. This is a convenience API to populate the corresponding properties.
2013-01-08 03:34:41 +04:00
ADD_TEST_MACRO(CMakeCommands.target_compile_definitions target_compile_definitions)
Add target_compile_options command. This command populates the COMPILE_OPTIONS target property.
2013-05-16 17:20:16 +04:00
ADD_TEST_MACRO(CMakeCommands.target_compile_options target_compile_options)
target_link_libraries: Add LINK_(PUBLIC|PRIVATE) options Makes it possible to specify the link dependencies and link interfaces in one command without repetition.
2011-10-07 04:41:37 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
"${CMake_SOURCE_DIR}/Tests/CTestTestCrash/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestCrash ${CMAKE_CTEST_COMMAND}
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestCrash/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestCrash/testOutput.log"
)
SEGFAULT does not work on watcom with ctest, so don't expect it to...
2009-09-24 22:14:23 +04:00
# with watcom the SEGFAULT is not found, it just fails
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(CMAKE_GENERATOR MATCHES "Watcom WMake")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestCrash PROPERTIES
SEGFAULT does not work on watcom with ctest, so don't expect it to...
2009-09-24 22:14:23 +04:00
PASS_REGULAR_EXPRESSION "Failed")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestCrash PROPERTIES
Tests: Look for "Illegal" or "SegFault" in the output One of the dashmacmini5 runs of this test results in an "Illegal exception" detected instead of a segfault. For the purposes of this test, we're going to say that either is a "crash."
2011-09-06 20:06:36 +04:00
PASS_REGULAR_EXPRESSION "(Illegal|SegFault)")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Added a unit test for running a test command which exists but is not an executable, because it previously caused the outer ctest process to fail.
2009-12-07 17:34:05 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestBadExe/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestBadExe ${CMAKE_CTEST_COMMAND}
Added a unit test for running a test command which exists but is not an executable, because it previously caused the outer ctest process to fail.
2009-12-07 17:34:05 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/testOutput.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CTestTestBadExe_REGEX "BAD_COMMAND")
Different versions of cygwin report differet messages for cygwin For cygwin pass the badexe test if either ***Failed or BAD_COMMAND show up in the output of the test.
2010-02-26 21:45:23 +03:00
# some cygwin can not be made to produce a BAD_COMMAND error
Fix BadExe test on cygwin.
2009-12-18 17:24:49 +03:00
# the best we can get from it is a failed test
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CYGWIN)
set(CTestTestBadExe_REGEX "(\\*\\*\\*Failed)|BAD_COMMAND")
endif()
set_tests_properties(CTestTestBadExe PROPERTIES
Fix BadExe test on cygwin.
2009-12-18 17:24:49 +03:00
PASS_REGULAR_EXPRESSION "${CTestTestBadExe_REGEX}")
ctest_build: Do not crash on bad generator name If creation of the global generator fails, return early with an error message instead of trying to use the generator and crashing. Add a CTestTestBadGenerator test to cover this case. Reported-by: Mathieu Malaterre <malat@debian.org> Bug-Debian: http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=747306
2014-05-07 18:59:02 +04:00
configure_file(
"${CMake_SOURCE_DIR}/Tests/CTestTestBadGenerator/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/test.cmake"
@ONLY ESCAPE_QUOTES)
add_test(CTestTestBadGenerator ${CMAKE_CTEST_COMMAND}
-C "\${CTestTest_CONFIG}"
-S "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestBadGenerator/testOutput.log"
)
set_property(TEST CTestTestBadGenerator PROPERTY
PASS_REGULAR_EXPRESSION "could not create generator named \"Bad Generator\"")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
"${CMake_SOURCE_DIR}/Tests/CTestTestParallel/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestParallel ${CMAKE_CTEST_COMMAND}
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestParallel/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestParallel/testOutput.log"
)
Add unit test for RESOURCE_LOCK test property
2010-03-03 18:32:03 +03:00
CTest: Output test-specific env vars in verbose mode (#15446) Any environment vars that were configured for a test via the ENVIRONMENT property will now be output when the test is run with verbose logging enabled.
2015-03-15 20:00:31 +03:00
configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestVerboseOutput/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/test.cmake" @ONLY ESCAPE_QUOTES)
add_test(CTestTestVerboseOutput ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/test.cmake" -VV
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestVerboseOutput/testOutput.log"
-C "\${CTestTest_CONFIG}"
)
set_property(TEST CTestTestVerboseOutput PROPERTY PASS_REGULAR_EXPRESSION
"Environment variables:.*foo=bar.*this=that"
)
allow to mark a test as "Not Run" with a specific return code (#8466)
2012-09-21 19:37:08 +04:00
configure_file(
"${CMake_SOURCE_DIR}/Tests/CTestTestSkipReturnCode/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestSkipReturnCode/test.cmake"
@ONLY ESCAPE_QUOTES)
add_test(CTestTestSkipReturnCode ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestSkipReturnCode/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestSkipReturnCode/testOutput.log"
-C \${CTEST_CONFIGURATION_TYPE}
)
set_tests_properties(CTestTestSkipReturnCode PROPERTIES
PASS_REGULAR_EXPRESSION "CMakeV1 \\.* +Passed.*CMakeV2 \\.+\\*+Skipped")
Tests: Guard more CTest tests against parallel execution.
2015-04-27 23:03:40 +03:00
set_property(TEST CTestTestSkipReturnCode PROPERTY ENVIRONMENT CTEST_PARALLEL_LEVEL=)
allow to mark a test as "Not Run" with a specific return code (#8466)
2012-09-21 19:37:08 +04:00
CTest: fix dashboard issues associated with the ctest-fix-run-serial topic
2013-10-23 23:47:32 +04:00
ADD_TEST_MACRO(CTestTestSerialInDepends ${CMAKE_CTEST_COMMAND} -j 4
--output-on-failure -C "\${CTestTest_CONFIG}")
CTest: added test for RUN_SERIAL issue #14484
2013-10-22 00:13:22 +04:00
CTest: fix regressions introduced by the ctest-fix-run-serial topic The first regression resulted in endless looping due to unrun test dependencies. The second regression prioritized all tests with dependencies in serial test runs.
2013-12-21 01:44:37 +04:00
ADD_TEST_MACRO(CTestTestMissingDependsExe ${CMAKE_CTEST_COMMAND}
--output-on-failure -C "\${CTestTest_CONFIG}")
set_tests_properties(CTestTestMissingDependsExe PROPERTIES
PASS_REGULAR_EXPRESSION "\\*\\*\\*Not Run"
)
ADD_TEST_MACRO(CTestTestSerialOrder ${CMAKE_CTEST_COMMAND}
--output-on-failure -C "\${CTestTest_CONFIG}")
Tests: Protect CTestTestSerialOrder from environment (#15524) Reported-by: Stephen Kelly <steveire@gmail.com>
2015-04-21 18:46:18 +03:00
set_property(TEST CTestTestSerialOrder PROPERTY ENVIRONMENT CTEST_PARALLEL_LEVEL=)
CTest: fix regressions introduced by the ctest-fix-run-serial topic The first regression resulted in endless looping due to unrun test dependencies. The second regression prioritized all tests with dependencies in serial test runs.
2013-12-21 01:44:37 +04:00
Skip CTestLimitDashJ test on Borland The Borland-built CTest binary has trouble running many instances of itself in parallel, making the test unreliable. No particular recent change appears to be the culprit and the failure is not reliably reproducible. Just silence the failure for now by skipping the test.
2013-08-07 18:41:06 +04:00
if(NOT BORLAND)
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
set(CTestLimitDashJ_CTEST_OPTIONS --force-new-ctest-process)
Skip CTestLimitDashJ test on Borland The Borland-built CTest binary has trouble running many instances of itself in parallel, making the test unreliable. No particular recent change appears to be the culprit and the failure is not reliably reproducible. Just silence the failure for now by skipping the test.
2013-08-07 18:41:06 +04:00
add_test_macro(CTestLimitDashJ ${CMAKE_CTEST_COMMAND} -j 4
--output-on-failure -C "\${CTestTest_CONFIG}")
endif()
Add CTestLimitDashJ test (#12904) Add a test that verifies that when ctest -j 4 is called, at most, 4 tests are executed at any one time. The test works by running the same script as each of 100 tests. And then setting up test properties for DEPENDS, RUN_SERIAL, PROCESSORS and COST in order to get the tests to run in a semi-deterministic ordering, even in parallel. The script writes a file, sleeps for a bit, and then deletes the file. In the meantime, it counts files that currently exist, and emits output that triggers a test failure if the count of files is ever greater than 4. Prior to the commit that fixed bug #12904, this would result in a failed test because the output of some of the tests would indicate that more than 4 tests were running simultaneously. Now that this issue is resolved, this test will help guarantee that it stays resolved moving forward.
2012-12-27 00:22:59 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestPrintLabels ${CMAKE_CTEST_COMMAND} --print-labels)
set_tests_properties(CTestTestPrintLabels PROPERTIES LABELS "Label1;Label2")
set_tests_properties(CTestTestPrintLabels PROPERTIES PASS_REGULAR_EXPRESSION
Added CTest command --print-labels This command allows a user to quickly see the list of all available test labels. The labels are also printed in verbose show only mode, alongside their corresponding tests.
2010-08-31 18:41:23 +04:00
"All Labels:.* Label1.* Label2")
CTest: Fix combined inclusive/exclusive label regular expressions
2014-06-06 12:28:18 +04:00
configure_file(
"${CMake_SOURCE_DIR}/Tests/CTestTestLabelRegExp/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestLabelRegExp/test.cmake"
@ONLY ESCAPE_QUOTES)
add_test(NAME CTestTestLabelRegExp
COMMAND ${CMAKE_CMAKE_COMMAND}
-DSOURCE_DIR=${CMAKE_SOURCE_DIR}/Tests/CTestTestLabelRegExp
-P ${CMAKE_BINARY_DIR}/Tests/CTestTestLabelRegExp/test.cmake
WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/Tests/CTestTestLabelRegExp
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Add unit test for RESOURCE_LOCK test property
2010-03-03 18:32:03 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestResourceLock/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestResourceLock/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestResourceLock ${CMAKE_CTEST_COMMAND}
Add unit test for RESOURCE_LOCK test property
2010-03-03 18:32:03 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestResourceLock/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestResourceLock/output.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Re-enabled Scheduler test and fixed the underlying problem.
2010-02-04 00:32:26 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestScheduler/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestScheduler/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestScheduler ${CMAKE_CTEST_COMMAND}
Re-enabled Scheduler test and fixed the underlying problem.
2010-02-04 00:32:26 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestScheduler/testOutput.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestScheduler PROPERTIES
Support explicitly set test costs in non-parallel testing.
2011-01-03 19:25:46 +03:00
PASS_REGULAR_EXPRESSION "Start 1.*Start 2.*Start 3.*Start 4.*Start 4.*Start 3.*Start 2.*Start 1"
RESOURCE_LOCK "CostData")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Support explicitly set test costs in non-parallel testing.
2011-01-03 19:25:46 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestCostSerial/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestCostSerial ${CMAKE_CTEST_COMMAND}
Support explicitly set test costs in non-parallel testing.
2011-01-03 19:25:46 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestCostSerial/testOutput.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestCostSerial PROPERTIES
Support explicitly set test costs in non-parallel testing.
2011-01-03 19:25:46 +03:00
PASS_REGULAR_EXPRESSION "Start 2.*Start 3.*Start 1.*Start 2.*Start 3.*Start 1"
RESOURCE_LOCK "CostData")
Add the --stop-time argument Unit test and script hook for STOP_TIME
2010-03-16 22:33:55 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Add the --stop-time argument Unit test and script hook for STOP_TIME
2010-03-16 22:33:55 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Add the --stop-time argument Unit test and script hook for STOP_TIME
2010-03-16 22:33:55 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
"${CMake_BINARY_DIR}/Tests/CTestTestStopTime/GetDate.cmake"
COPYONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestStopTime ${CMAKE_CTEST_COMMAND}
Add the --stop-time argument Unit test and script hook for STOP_TIME
2010-03-16 22:33:55 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestStopTime/testOutput.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestStopTime PROPERTIES
Add the --stop-time argument Unit test and script hook for STOP_TIME
2010-03-16 22:33:55 +03:00
PASS_REGULAR_EXPRESSION "The stop time has been passed")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Added a ctest add_subdirectory test which fails before my patch made earlier today.
2009-10-20 21:35:44 +04:00
"${CMake_SOURCE_DIR}/Tests/CTestTestSubdir/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestSubdir ${CMAKE_CTEST_COMMAND}
Added a ctest add_subdirectory test which fails before my patch made earlier today.
2009-10-20 21:35:44 +04:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestSubdir/testOutput.log"
)
Change logic of ctest subdirs command to allow for absolute paths. Also added test coverage for passing absolute paths to subdirs.
2009-11-10 18:40:24 +03:00
#make sure all 3 subdirs were added
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestSubdir PROPERTIES
Change logic of ctest subdirs command to allow for absolute paths. Also added test coverage for passing absolute paths to subdirs.
2009-11-10 18:40:24 +03:00
PASS_REGULAR_EXPRESSION "0 tests failed out of 3")
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
ENH: Added ctest test coverage for a test timeout
2009-09-29 23:18:46 +04:00
"${CMake_SOURCE_DIR}/Tests/CTestTestTimeout/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestTimeout ${CMAKE_CTEST_COMMAND}
Always use a configuration for CTestTestTimeout This test requires that the dashboard script it drives be invoked with "ctest -C <config> -S ...". We create a "CTestTest_CONFIG" variable to hold a configuration selected at test time. We use the configuration given to the outer CTest, if any, and then default to either Debug or the CMAKE_BUILD_TYPE.
2009-12-01 17:12:07 +03:00
-C "\${CTestTest_CONFIG}"
ENH: Added ctest test coverage for a test timeout
2009-09-29 23:18:46 +04:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/testOutput.log"
Set new ctest tests to always run, whether CTEST_TEST_CTEST is enabled or not. Changed parallel test to be portable.
2009-09-23 19:38:37 +04:00
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestTimeout PROPERTIES
Tests: Try to make CTestTestTimeout more robust Write to the timeout test log file before sleeping and flush to be sure it is created. Move the check that the after-sleep line is not written out to the ctest script. Rename the CheckChild test to TestSleep since it no longer checks. Do not try to read the log file if it does not exist.
2014-05-23 17:47:44 +04:00
PASS_REGULAR_EXPRESSION "TestTimeout *\\.+ *\\*\\*\\*Timeout.*TestSleep *\\.+ *Passed.*timeout correctly killed child")
Fix cycle detection for test dependencies
2010-06-30 18:39:17 +04:00
Require CMake 2.8.4 or greater to build CMake This allows the use of the $<TARGET_FILE:...> generator expression as a replacement for the use of the LOCATION target property. The use of the LOCATION target property is now deprecated for in-build targets. Also drop other checks for older CMake versions: * Simplify cmake_set_target_folder macro. * Use find_package(LibArchive) unconditionally. * Simplify condition for running testVisualStudioSlnParser test. * Convert two macros to functions. * Unconditionally run the CTestTestRerunFailed test.
2013-10-11 02:02:24 +04:00
add_test(
NAME CTestTestRerunFailed
COMMAND ${CMAKE_CTEST_COMMAND} --rerun-failed)
set_tests_properties(CTestTestRerunFailed PROPERTIES
PASS_REGULAR_EXPRESSION "1/1 Test #1: TestTimeout" DEPENDS CTestTestTimeout
WORKING_DIRECTORY ${CMake_BINARY_DIR}/Tests/CTestTestTimeout)
ctest: Add --rerun-failed option Add a new command line argument to ctest. This allows users to rerun tests that failed during the previous call to ctest. This is accomplished by analyzing the most recently modified file named "^LastTestsFailed*" in the Testing/Temporary subdirectory of the project's binary directory.
2013-09-24 22:20:38 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestZeroTimeout/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestZeroTimeout ${CMAKE_CTEST_COMMAND}
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/test.cmake" -V
--output-log
"${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/testOutput.log")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestZeroTimeout PROPERTIES
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
FAIL_REGULAR_EXPRESSION "\\*\\*\\*Timeout")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Fix cycle detection for test dependencies
2010-06-30 18:39:17 +04:00
"${CMake_SOURCE_DIR}/Tests/CTestTestDepends/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestDepends ${CMAKE_CTEST_COMMAND}
Fix cycle detection for test dependencies
2010-06-30 18:39:17 +04:00
-C "\${CTestTest_CONFIG}"
-S "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestDepends/testOutput.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Fix cycle detection for test dependencies
2010-06-30 18:39:17 +04:00
"${CMake_SOURCE_DIR}/Tests/CTestTestCycle/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestCycle ${CMAKE_CTEST_COMMAND}
Fix cycle detection for test dependencies
2010-06-30 18:39:17 +04:00
-C "\${CTestTest_CONFIG}"
-S "${CMake_BINARY_DIR}/Tests/CTestTestCycle/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestCycle/testOutput.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestCycle PROPERTIES
Fix cycle detection for test dependencies
2010-06-30 18:39:17 +04:00
PASS_REGULAR_EXPRESSION "a cycle exists in the test dependency graph")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Changed RunScript test to be in-source build safe
2009-10-28 21:11:19 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/test.cmake.in"
Added test coverage for cmCTestRunScriptCommand
2009-10-26 20:10:46 +03:00
"${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file(
Changed RunScript test to be in-source build safe
2009-10-28 21:11:19 +03:00
"${CMake_SOURCE_DIR}/Tests/CTestTestRunScript/hello.cmake.in"
Added test coverage for cmCTestRunScriptCommand
2009-10-26 20:10:46 +03:00
"${CMake_BINARY_DIR}/Tests/CTestTestRunScript/hello.cmake"
@ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestRunScript ${CMAKE_CTEST_COMMAND}
Fixed CTestTestRunScript
2009-10-29 19:46:00 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestRunScript/testOutput.log"
)
Fix issue #2336 - honor the -C arg to ctest. Honor it for all stages of running -D dashboards from the command line and running ctest_configure, ctest_build and ctest_test commands in -S scripts. Also, allow a script to change it by setting the CTEST_CONFIGURATION_TYPE variable: allows for multiple configuration build/test cycles within one script. Add a new signature for the cmake command build_command that accepts CONFIGURATION as one argument. The original build_command signature is still there, but now marked as deprecated in the documentation. Of course... also add CTestConfig tests to verify that -C is honored for -D dashboards and -S scripts.
2009-12-04 20:09:01 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestShowOnly ${CMAKE_CTEST_COMMAND} -N)
Fix issue #2336 - honor the -C arg to ctest. Honor it for all stages of running -D dashboards from the command line and running ctest_configure, ctest_build and ctest_test commands in -S scripts. Also, allow a script to change it by setting the CTEST_CONFIGURATION_TYPE variable: allows for multiple configuration build/test cycles within one script. Add a new signature for the cmake command build_command that accepts CONFIGURATION as one argument. The original build_command signature is still there, but now marked as deprecated in the documentation. Of course... also add CTestConfig tests to verify that -C is honored for -D dashboards and -S scripts.
2009-12-04 20:09:01 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestBatchTest ${CMAKE_CTEST_COMMAND} -B)
Fix issue #2336 - honor the -C arg to ctest. Honor it for all stages of running -D dashboards from the command line and running ctest_configure, ctest_build and ctest_test commands in -S scripts. Also, allow a script to change it by setting the CTEST_CONFIGURATION_TYPE variable: allows for multiple configuration build/test cycles within one script. Add a new signature for the cmake command build_command that accepts CONFIGURATION as one argument. The original build_command signature is still there, but now marked as deprecated in the documentation. Of course... also add CTestConfig tests to verify that -C is honored for -D dashboards and -S scripts.
2009-12-04 20:09:01 +03:00
CTest: Add test for running many tests in parallel In particular, this checks that CTest's use of select() has a sufficient file descriptor set size limit (FD_SETSIZE) to handle many child processes at the same time. Running 20 tests requires more than 64 descriptors, the Cygwin default that we override.
2013-03-06 03:14:58 +04:00
configure_file(
"${CMake_SOURCE_DIR}/Tests/CTestTestFdSetSize/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake"
@ONLY ESCAPE_QUOTES)
add_test(CTestTestFdSetSize ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/test.cmake" -j20 -V --timeout 120
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestFdSetSize/testOutput.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if (CMAKE_TESTS_CDASH_SERVER)
Tests: Fix CMAKE_TESTS_CDASH_SERVER parsing Allow the value to end without a slash and have an empty server path component. This is needed to match "http://open.cdash.org" correctly.
2014-06-24 21:53:27 +04:00
set(regex "^([^:]+)://([^/]+)(.*)$")
Add CMAKE_TESTS_CDASH_SERVER variable and CTestSubmitLargeOutput test. If defined and non-empty, the value of CMAKE_TESTS_CDASH_SERVER should point to a CDash server willing to accept submissions for a project named PublicDashboard. On machines that also run a CDash dashboard, set this variable to "http://localhost/CDash-trunk-Testing" so that the CMake tests that submit dashboards do not have to send those submissions over the wire. The CTestSubmitLargeOutput test runs a dashboard that has a test that produces very large amount of output on stdout/stderr. Since we do not even want to attempt to send such large output over the wire, this test is off by default unless the CMAKE_TESTS_CDASH_SERVER server is localhost. This test is expected to cause a submission failure when sent to CDash. It passes if the submit results contain error output. It fails if the submit succeeds. CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests. If not defined or "", this variable defaults to the server at http://www.cdash.org/CDash. If set explicitly to "NOTFOUND", curl tests and ctest tests that use the network are skipped. If set to something starting with "http://localhost/", the CDash is expected to be an instance of CDash used for CDash testing, pointing to a cdash4simpletest database. In these cases, the CDash dashboards should be run first.
2010-03-08 20:14:47 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if ("${CMAKE_TESTS_CDASH_SERVER}" MATCHES "${regex}")
set(protocol "${CMAKE_MATCH_1}")
set(server "${CMAKE_MATCH_2}")
set(path "${CMAKE_MATCH_3}")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
else ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(protocol "http")
Update CDash server URL It is now at open.cdash.org and does not start in "/CDash".
2014-06-24 21:35:33 +04:00
set(server "open.cdash.org")
set(path "")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
message("warning: CMAKE_TESTS_CDASH_SERVER does not match expected regex...")
message(" ...using default url='${protocol}://${server}${path}' for CTestTest[23]")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
endif ()
Add CMAKE_TESTS_CDASH_SERVER variable and CTestSubmitLargeOutput test. If defined and non-empty, the value of CMAKE_TESTS_CDASH_SERVER should point to a CDash server willing to accept submissions for a project named PublicDashboard. On machines that also run a CDash dashboard, set this variable to "http://localhost/CDash-trunk-Testing" so that the CMake tests that submit dashboards do not have to send those submissions over the wire. The CTestSubmitLargeOutput test runs a dashboard that has a test that produces very large amount of output on stdout/stderr. Since we do not even want to attempt to send such large output over the wire, this test is off by default unless the CMAKE_TESTS_CDASH_SERVER server is localhost. This test is expected to cause a submission failure when sent to CDash. It passes if the submit results contain error output. It fails if the submit succeeds. CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests. If not defined or "", this variable defaults to the server at http://www.cdash.org/CDash. If set explicitly to "NOTFOUND", curl tests and ctest tests that use the network are skipped. If set to something starting with "http://localhost/", the CDash is expected to be an instance of CDash used for CDash testing, pointing to a cdash4simpletest database. In these cases, the CDash dashboards should be run first.
2010-03-08 20:14:47 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if (CTEST_TEST_CTEST AND CMAKE_RUN_LONG_TESTS AND CMAKE_TESTS_CDASH_SERVER)
configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest/test.cmake.in"
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
"${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" @ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTest ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
-S "${CMake_BINARY_DIR}/Tests/CTestTest/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTest/testOutput.log"
)
Add CMAKE_TESTS_CDASH_SERVER variable and CTestSubmitLargeOutput test. If defined and non-empty, the value of CMAKE_TESTS_CDASH_SERVER should point to a CDash server willing to accept submissions for a project named PublicDashboard. On machines that also run a CDash dashboard, set this variable to "http://localhost/CDash-trunk-Testing" so that the CMake tests that submit dashboards do not have to send those submissions over the wire. The CTestSubmitLargeOutput test runs a dashboard that has a test that produces very large amount of output on stdout/stderr. Since we do not even want to attempt to send such large output over the wire, this test is off by default unless the CMAKE_TESTS_CDASH_SERVER server is localhost. This test is expected to cause a submission failure when sent to CDash. It passes if the submit results contain error output. It fails if the submit succeeds. CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests. If not defined or "", this variable defaults to the server at http://www.cdash.org/CDash. If set explicitly to "NOTFOUND", curl tests and ctest tests that use the network are skipped. If set to something starting with "http://localhost/", the CDash is expected to be an instance of CDash used for CDash testing, pointing to a cdash4simpletest database. In these cases, the CDash dashboards should be run first.
2010-03-08 20:14:47 +03:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file("${CMake_SOURCE_DIR}/Tests/CTestTest2/test.cmake.in"
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
"${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" @ONLY ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTest2 ${CMAKE_CTEST_COMMAND}
ENH: remove some verbosity to reduce test time
2008-12-11 22:35:57 +03:00
-S "${CMake_BINARY_DIR}/Tests/CTestTest2/test.cmake" -V
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--output-log "${CMake_BINARY_DIR}/Tests/CTestTest2/testOutput.log"
)
Add CMAKE_TESTS_CDASH_SERVER variable and CTestSubmitLargeOutput test. If defined and non-empty, the value of CMAKE_TESTS_CDASH_SERVER should point to a CDash server willing to accept submissions for a project named PublicDashboard. On machines that also run a CDash dashboard, set this variable to "http://localhost/CDash-trunk-Testing" so that the CMake tests that submit dashboards do not have to send those submissions over the wire. The CTestSubmitLargeOutput test runs a dashboard that has a test that produces very large amount of output on stdout/stderr. Since we do not even want to attempt to send such large output over the wire, this test is off by default unless the CMAKE_TESTS_CDASH_SERVER server is localhost. This test is expected to cause a submission failure when sent to CDash. It passes if the submit results contain error output. It fails if the submit succeeds. CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests. If not defined or "", this variable defaults to the server at http://www.cdash.org/CDash. If set explicitly to "NOTFOUND", curl tests and ctest tests that use the network are skipped. If set to something starting with "http://localhost/", the CDash is expected to be an instance of CDash used for CDash testing, pointing to a cdash4simpletest database. In these cases, the CDash dashboards should be run first.
2010-03-08 20:14:47 +03:00
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if("${CMAKE_GENERATOR}" MATCHES "Makefiles" OR "${CMAKE_GENERATOR}" MATCHES "Ninja")
Tests: Add test for CTEST_USE_LAUNCHERS capture of custom commands This new test detects if custom command failures are detected with launchers.
2013-10-30 01:29:27 +04:00
configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestLaunchers/test.cmake.in"
"${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/test.cmake" @ONLY ESCAPE_QUOTES)
add_test(CTestTestLaunchers ${CMAKE_CTEST_COMMAND}
-S "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/test.cmake" -V
--output-log "${CMake_BINARY_DIR}/Tests/CTestTestLaunchers/testOutput.log"
)
set_tests_properties(CTestTestLaunchers PROPERTIES
PASS_REGULAR_EXPRESSION "CTEST_TEST_LAUNCHER_SUCCESS")
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
configure_file("${CMake_SOURCE_DIR}/Tests/CTestTestChecksum/test.cmake.in"
Testing for CTest checksum
2010-06-10 20:25:49 +04:00
"${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" @ONLY
ESCAPE_QUOTES)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(CTestTestChecksum ${CMAKE_CTEST_COMMAND}
Testing for CTest checksum
2010-06-10 20:25:49 +04:00
-S "${CMake_BINARY_DIR}/Tests/CTestTestChecksum/test.cmake" -V
--output-log
"${CMake_BINARY_DIR}/Tests/CTestTestChecksum/testOutput.log"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(CTestTestChecksum PROPERTIES PASS_REGULAR_EXPRESSION
Testing for CTest checksum
2010-06-10 20:25:49 +04:00
"Submission failed: Checksum failed for file")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
# these tests take a long time, make sure they have it
ENH: Remove condition on use of CMake 2.4 commands - Commands SET_TESTS_PROPERTIES and GET_TEST_PROPERTY exist in CMake 2.4, which is now required. - Therefore we need not check before using them.
2008-07-03 22:38:57 +04:00
# if timeouts have not already been set
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
get_test_property(CTestTest TIMEOUT PREVIOUS_TIMEOUT)
if ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
set_tests_properties ( CTestTest
ENH: Remove condition on use of CMake 2.4 commands - Commands SET_TESTS_PROPERTIES and GET_TEST_PROPERTY exist in CMake 2.4, which is now required. - Therefore we need not check before using them.
2008-07-03 22:38:57 +04:00
PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
ENH: Remove condition on use of CMake 2.4 commands - Commands SET_TESTS_PROPERTIES and GET_TEST_PROPERTY exist in CMake 2.4, which is now required. - Therefore we need not check before using them.
2008-07-03 22:38:57 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
get_test_property(CTestTest2 TIMEOUT PREVIOUS_TIMEOUT)
if ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
set_tests_properties ( CTestTest2
ENH: Remove condition on use of CMake 2.4 commands - Commands SET_TESTS_PROPERTIES and GET_TEST_PROPERTY exist in CMake 2.4, which is now required. - Therefore we need not check before using them.
2008-07-03 22:38:57 +04:00
PROPERTIES TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
endif ()
Add CMAKE_TESTS_CDASH_SERVER variable and CTestSubmitLargeOutput test. If defined and non-empty, the value of CMAKE_TESTS_CDASH_SERVER should point to a CDash server willing to accept submissions for a project named PublicDashboard. On machines that also run a CDash dashboard, set this variable to "http://localhost/CDash-trunk-Testing" so that the CMake tests that submit dashboards do not have to send those submissions over the wire. The CTestSubmitLargeOutput test runs a dashboard that has a test that produces very large amount of output on stdout/stderr. Since we do not even want to attempt to send such large output over the wire, this test is off by default unless the CMAKE_TESTS_CDASH_SERVER server is localhost. This test is expected to cause a submission failure when sent to CDash. It passes if the submit results contain error output. It fails if the submit succeeds. CMAKE_TESTS_CDASH_SERVER: CDash server used by CMake/Tests. If not defined or "", this variable defaults to the server at http://www.cdash.org/CDash. If set explicitly to "NOTFOUND", curl tests and ctest tests that use the network are skipped. If set to something starting with "http://localhost/", the CDash is expected to be an instance of CDash used for CDash testing, pointing to a cdash4simpletest database. In these cases, the CDash dashboards should be run first.
2010-03-08 20:14:47 +03:00
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if("${CMAKE_GENERATOR}" MATCHES Xcode)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_SKIP_BOOTSTRAP_TEST 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt")
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
# If there is CMakeLists.txt in the binary tree, assume in-source build
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(CMAKE_SKIP_BOOTSTRAP_TEST 1)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(bootstrap "")
if(CMAKE_RUN_LONG_TESTS AND NOT CMAKE_SKIP_BOOTSTRAP_TEST)
if(UNIX)
set(bootstrap ${CMake_SOURCE_DIR}/bootstrap)
elseif(MSYS)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/bootstrap.bat.in
Enable BootstrapTest on MSYS The bootstrap script works under MSYS, so test it. Use a launcher batch file since 'ctest --build-and-test' is a Windows program and will not honor the shebang line in the script.
2010-06-11 22:03:53 +04:00
${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set(bootstrap ${CMAKE_CURRENT_BINARY_DIR}/bootstrap.bat)
endif()
endif()
if(bootstrap)
Tests: Launch BootstrapTest through cmake instead of ctest Run the bootstrap script through "cmake -P" instead of "ctest --build-and-test" so that we do not need to abuse the --build-makeprogram option of the latter.
2013-11-14 18:18:51 +04:00
add_test(NAME BootstrapTest
COMMAND ${CMAKE_CMAKE_COMMAND}
-D "bootstrap=${bootstrap}"
-D "bin_dir=${CMake_BINARY_DIR}/Tests/BootstrapTest"
-P ${CMAKE_CURRENT_SOURCE_DIR}/BootstrapTest.cmake
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BootstrapTest")
Add a high COST value to BootstrapTest so that it will be scheduled first in parallel ctest executions.
2010-02-11 19:58:04 +03:00
# Make this test run early during parallel execution
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(BootstrapTest PROPERTIES COST 5000)
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
# provide more time for the bootstrap test
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
get_test_property(BootstrapTest TIMEOUT PREVIOUS_TIMEOUT)
if ("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
set_tests_properties ( BootstrapTest
BUG 9950: increase timeout for BootstrapTest to 1.5 hours
2009-11-23 18:22:09 +03:00
PROPERTIES TIMEOUT 5400)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif ()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_Fortran_COMPILER)
add_test(Fortran ${CMAKE_CTEST_COMMAND}
Enable Fortran tests for IDE builds.
2011-09-10 01:11:57 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Fortran"
"${CMake_BINARY_DIR}/Tests/Fortran"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Enable Fortran tests for IDE builds.
2011-09-10 01:11:57 +04:00
--build-project testf
--build-two-config
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Tests: Rename CMAKE_TEST_MAKEPROGRAM uses for explicit make program Rename uses of the variable for specifying the make program used to build test projects to CMake_TEST_EXPLICIT_MAKE_PROGRAM.
2014-03-03 22:58:19 +04:00
-DCMake_TEST_NESTED_MAKE_PROGRAM:FILEPATH=${CMake_TEST_EXPLICIT_MAKE_PROGRAM}
Enable Fortran tests for IDE builds.
2011-09-10 01:11:57 +04:00
--test-command testf)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Fortran")
Enable Fortran tests for IDE builds.
2011-09-10 01:11:57 +04:00
# FortranCInterface tests.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(UNIX)
configure_file(${CMAKE_CURRENT_SOURCE_DIR}/FortranC/Flags.cmake.in
Enable Fortran tests for IDE builds.
2011-09-10 01:11:57 +04:00
${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(FortranC.Flags ${CMAKE_CMAKE_COMMAND} -P
Enable Fortran tests for IDE builds.
2011-09-10 01:11:57 +04:00
${CMAKE_CURRENT_BINARY_DIR}/FortranC/Flags.cmake)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC/Flags")
else()
add_test(FortranC ${CMAKE_CTEST_COMMAND}
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-and-test
Enable Fortran tests for IDE builds.
2011-09-10 01:11:57 +04:00
"${CMake_SOURCE_DIR}/Tests/FortranC"
"${CMake_BINARY_DIR}/Tests/FortranC"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Enable Fortran tests for IDE builds.
2011-09-10 01:11:57 +04:00
--build-project FortranC
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
--build-two-config
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Enable Fortran tests for IDE builds.
2011-09-10 01:11:57 +04:00
--test-command CMakeFiles/FortranCInterface/FortranCInterface)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/FortranC")
endif()
endif()
ENH:
2007-06-26 23:15:52 +04:00
Tests: Check for the new Java exeutable variables.
2011-03-21 14:44:27 +03:00
find_package(Java COMPONENTS Development QUIET)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(Java_JAVA_EXECUTABLE AND Java_JAVAC_EXECUTABLE AND Java_JAR_EXECUTABLE AND NOT MINGW
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
AND NOT "${CMAKE_GENERATOR}" MATCHES "Xcode")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
get_filename_component(JNIPATH ${JAVA_COMPILE} PATH)
find_file(JNI_H jni.h
Enable Java test more carefully on Apple The CTEST_RUN_Java option added by commit c8f39193 (Avoid problem reading jni.h on Macs, 2010-10-25) was a quick hack to disable the Java test on Mac machines after an update from Apple created a broken jni.h symlink. Remove the option and instead test whether jni.h exists as a readable file before reading it. This restores the original Java test enabling logic but makes it robust to the broken symlink.
2011-03-18 20:46:57 +03:00
"${JNIPATH}/../include"
"${JNIPATH}/../java/include")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(JNI_H AND EXISTS "${JNI_H}") # in case jni.h is a broken symlink
file(READ "${JNI_H}" JNI_FILE)
if("${JNI_FILE}" MATCHES "JDK1_2")
UseJava: Teach add_jar to support file syntax for sources
2015-07-30 12:17:04 +03:00
add_test(Java.Jar ${CMAKE_CTEST_COMMAND}
Enable Java test more carefully on Apple The CTEST_RUN_Java option added by commit c8f39193 (Avoid problem reading jni.h on Macs, 2010-10-25) was a quick hack to disable the Java test on Mac machines after an update from Apple created a broken jni.h symlink. Remove the option and instead test whether jni.h exists as a readable file before reading it. This restores the original Java test enabling logic but makes it robust to the broken symlink.
2011-03-18 20:46:57 +03:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Java"
UseJava: Teach add_jar to support file syntax for sources
2015-07-30 12:17:04 +03:00
"${CMake_BINARY_DIR}/Tests/JavaJar"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Enable Java test more carefully on Apple The CTEST_RUN_Java option added by commit c8f39193 (Avoid problem reading jni.h on Macs, 2010-10-25) was a quick hack to disable the Java test on Mac machines after an update from Apple created a broken jni.h symlink. Remove the option and instead test whether jni.h exists as a readable file before reading it. This restores the original Java test enabling logic but makes it robust to the broken symlink.
2011-03-18 20:46:57 +03:00
--build-project hello
UseJava: Teach add_jar to support file syntax for sources
2015-07-30 12:17:04 +03:00
--build-target hello
Enable Java test more carefully on Apple The CTEST_RUN_Java option added by commit c8f39193 (Avoid problem reading jni.h on Macs, 2010-10-25) was a quick hack to disable the Java test on Mac machines after an update from Apple created a broken jni.h symlink. Remove the option and instead test whether jni.h exists as a readable file before reading it. This restores the original Java test enabling logic but makes it robust to the broken symlink.
2011-03-18 20:46:57 +03:00
--build-two-config
UseJava: Teach add_jar to support file syntax for sources
2015-07-30 12:17:04 +03:00
--build-run-dir "${CMake_BINARY_DIR}/Tests/JavaJar/"
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Enable Java test more carefully on Apple The CTEST_RUN_Java option added by commit c8f39193 (Avoid problem reading jni.h on Macs, 2010-10-25) was a quick hack to disable the Java test on Mac machines after an update from Apple created a broken jni.h symlink. Remove the option and instead test whether jni.h exists as a readable file before reading it. This restores the original Java test enabling logic but makes it robust to the broken symlink.
2011-03-18 20:46:57 +03:00
--test-command ${JAVA_RUNTIME} -classpath hello.jar HelloWorld)
UseJava: Teach add_jar to support file syntax for sources
2015-07-30 12:17:04 +03:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaJar")
add_test(Java.JarSourceList ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Java"
"${CMake_BINARY_DIR}/Tests/JavaJarSourceList"
${build_generator_args}
--build-project hello
--build-target hello2
--build-two-config
--build-run-dir "${CMake_BINARY_DIR}/Tests/JavaJarSourceList/"
--build-options ${build_options}
--test-command ${JAVA_RUNTIME} -classpath hello2.jar HelloWorld)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/JavaJarSourceList")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
endif()
ENH: more cleanup of some CMakeLists files
2007-05-11 17:02:17 +04:00
ENH: add a SimpleCOnly test, this is needed e.g. for testing sdcc since this doesn't support C++ and also doesn't have a printf() implementation by default -add a test for mingw cross compiler Alex
2007-06-26 23:30:02 +04:00
# add some cross compiler tests, for now only with makefile based generators
Tests: Drop CMAKE_TEST_GENERATOR(|_TOOLSET) variables s/CMAKE_TEST_GENERATOR/CMAKE_GENERATOR/g
2014-03-03 23:06:34 +04:00
if(CMAKE_GENERATOR MATCHES "Makefiles" OR CMAKE_GENERATOR MATCHES "KDevelop")
ENH: add a SimpleCOnly test, this is needed e.g. for testing sdcc since this doesn't support C++ and also doesn't have a printf() implementation by default -add a test for mingw cross compiler Alex
2007-06-26 23:30:02 +04:00
# if sdcc is found, build the SimpleCOnly project with sdcc
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
find_program(SDCC_EXECUTABLE sdcc)
mark_as_advanced(SDCC_EXECUTABLE)
if(SDCC_EXECUTABLE)
add_test(SimpleCOnly_sdcc ${CMAKE_CTEST_COMMAND}
ENH:
2007-06-26 23:15:52 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/SimpleCOnly"
ENH: add a SimpleCOnly test, this is needed e.g. for testing sdcc since this doesn't support C++ and also doesn't have a printf() implementation by default -add a test for mingw cross compiler Alex
2007-06-26 23:30:02 +04:00
"${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH:
2007-06-26 23:15:52 +04:00
--build-project SimpleC
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH:
2007-06-26 23:15:52 +04:00
"-DCMAKE_SYSTEM_NAME=Generic"
"-DCMAKE_C_COMPILER=${SDCC_EXECUTABLE}")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/SimpleCOnly_sdcc")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Test TIMEOUT property explicitly set to zero should be honored
2011-01-03 22:41:25 +03:00
Teach Simple_Mingw_Linux2Win test to use windres This test was broken by commit b2f308c8 (Add support for windows resources with mingw/msys, 2010-12-22) because the test does not set a resource compiler which is now required on MinGW for the 'RC' language. Use windres as the resource compiler for the test.
2011-01-14 18:22:15 +03:00
# If a Linux -> MinGW cross compiler is found then try it
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
find_program(MINGW_CC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-gcc)
find_program(MINGW_CXX_LINUX2WIN_EXECUTABLE i586-mingw32msvc-g++)
find_program(MINGW_RC_LINUX2WIN_EXECUTABLE i586-mingw32msvc-windres)
mark_as_advanced(MINGW_CC_LINUX2WIN_EXECUTABLE MINGW_CXX_LINUX2WIN_EXECUTABLE MINGW_RC_LINUX2WIN_EXECUTABLE)
if(MINGW_CC_LINUX2WIN_EXECUTABLE AND MINGW_CXX_LINUX2WIN_EXECUTABLE AND MINGW_RC_LINUX2WIN_EXECUTABLE)
add_test(Simple_Mingw_Linux2Win ${CMAKE_CTEST_COMMAND}
ENH: add a SimpleCOnly test, this is needed e.g. for testing sdcc since this doesn't support C++ and also doesn't have a printf() implementation by default -add a test for mingw cross compiler Alex
2007-06-26 23:30:02 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/Simple"
"${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win"
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
ENH: add a SimpleCOnly test, this is needed e.g. for testing sdcc since this doesn't support C++ and also doesn't have a printf() implementation by default -add a test for mingw cross compiler Alex
2007-06-26 23:30:02 +04:00
--build-project Simple
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
ENH: add a SimpleCOnly test, this is needed e.g. for testing sdcc since this doesn't support C++ and also doesn't have a printf() implementation by default -add a test for mingw cross compiler Alex
2007-06-26 23:30:02 +04:00
"-DCMAKE_SYSTEM_NAME=Windows"
ENH: also specify the C++ compiler for mingw Alex
2007-08-08 17:32:44 +04:00
"-DCMAKE_C_COMPILER=${MINGW_CC_LINUX2WIN_EXECUTABLE}"
Teach Simple_Mingw_Linux2Win test to use windres This test was broken by commit b2f308c8 (Add support for windows resources with mingw/msys, 2010-12-22) because the test does not set a resource compiler which is now required on MinGW for the 'RC' language. Use windres as the resource compiler for the test.
2011-01-14 18:22:15 +03:00
"-DCMAKE_CXX_COMPILER=${MINGW_CXX_LINUX2WIN_EXECUTABLE}"
"-DCMAKE_RC_COMPILER=${MINGW_RC_LINUX2WIN_EXECUTABLE}"
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Simple_Mingw_Linux2Win")
endif()
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH:
2007-06-26 23:15:52 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_TEST_PROJECT_CSE_DIR)
set(script "${CMAKE_TEST_PROJECT_CSE_DIR}/BuildProjectCSE.cmake")
if(NOT EXISTS "${script}")
set(script "${CMAKE_TEST_PROJECT_CSE_DIR}/cse_build.cmake")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(NOT EXISTS "${script}")
message("warning: CMAKE_TEST_PROJECT_CSE_DIR set, but no build script found...")
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(BuildCSE ${CMAKE_CTEST_COMMAND} -V -S "${script}")
set_tests_properties(BuildCSE PROPERTIES TIMEOUT 5400)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
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)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
COMP: change the order of the tests, so maybe the timeout works Alex
2007-08-08 18:05:11 +04:00
ENH: Add test_clean target to wipe out tests We frequently need to wipe out all the CMake test build directories in order to run tests from scratch. This change adds a test_clean custom target to remove all these directories for out-of-source builds.
2008-08-19 19:43:57 +04:00
# If this is not an in-source build, provide a target to wipe out
# all the test build directories.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(NOT EXISTS "${CMake_BINARY_DIR}/CMakeLists.txt")
configure_file(${CMake_SOURCE_DIR}/Tests/test_clean.cmake.in
ENH: Add test_clean target to wipe out tests We frequently need to wipe out all the CMake test build directories in order to run tests from scratch. This change adds a test_clean custom target to remove all these directories for out-of-source builds.
2008-08-19 19:43:57 +04:00
${CMake_BINARY_DIR}/Tests/test_clean.cmake @ONLY)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_custom_target(test_clean
ENH: Add test_clean target to wipe out tests We frequently need to wipe out all the CMake test build directories in order to run tests from scratch. This change adds a test_clean custom target to remove all these directories for out-of-source builds.
2008-08-19 19:43:57 +04:00
COMMAND ${CMAKE_COMMAND} -P ${CMake_BINARY_DIR}/Tests/test_clean.cmake
COMMENT "Removing test build directories."
)
Remove CMake-language block-end command arguments Ancient versions of CMake required else(), endif(), and similar block termination commands to have arguments matching the command starting the block. This is no longer the preferred style. Run the following shell code: for c in else endif endforeach endfunction endmacro endwhile; do echo 's/\b'"$c"'\(\s*\)(.\+)/'"$c"'\1()/' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | egrep -z -v 'Tests/CMakeTests/While-Endwhile-' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:50:14 +04:00
endif()
ENH: Add test_clean target to wipe out tests We frequently need to wipe out all the CMake test build directories in order to run tests from scratch. This change adds a test_clean custom target to remove all these directories for out-of-source builds.
2008-08-19 19:43:57 +04:00
cmake: Drop support for "-i" wizard mode Tell users to pass cache values with the -D option on the command line or use cmake-gui or ccmake.
2013-10-18 21:30:43 +04:00
add_test(NAME CMakeWizardTest COMMAND cmake -i)
set_property(TEST CMakeWizardTest PROPERTY PASS_REGULAR_EXPRESSION
"The \"cmake -i\" wizard mode is no longer supported.")
Add a "Contract" test for VTK. The test downloads and builds VTK. The idea is that we can make sure that CMake is staying backwards compatible by testing projects against CMake as the changes are made in CMake. Because these tests will take a long time to run, they will not be enabled by default. Instead, they will be enabled by putting a cache variable into CMake.
2010-09-21 18:23:09 +04:00
# If the cache variable CMAKE_CONTRACT_PROJECTS is set
# then the dashboard will run a contract with CMake test of that
# name. For example CMAKE_CONTRACT_PROJECTS = vtk542 would run
# the vtk542 contract test.
Fix contract test so it is not hard coded to the vtk542 test.
2010-09-21 23:08:13 +04:00
# For each Contract test, the project should provide a directory
# with at least one CMakeLists.txt file that uses ExternalProject
# to download and configure the project. The directory should also
# contain a RunTest.cmake file that has a single set of the format:
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
# set(project_RUN_TEST testToRun)
Fix contract test so it is not hard coded to the vtk542 test.
2010-09-21 23:08:13 +04:00
# The testToRun should be a test executable that can be run to
# smoke test the build.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
foreach(project ${CMAKE_CONTRACT_PROJECTS})
include(Contracts/${project}/RunTest.cmake)
Add a "Contract" test for VTK. The test downloads and builds VTK. The idea is that we can make sure that CMake is staying backwards compatible by testing projects against CMake as the changes are made in CMake. Because these tests will take a long time to run, they will not be enabled by default. Instead, they will be enabled by putting a cache variable into CMake.
2010-09-21 18:23:09 +04:00
ADD_TEST_MACRO(Contracts.${project}
Fix contract test so it is not hard coded to the vtk542 test.
2010-09-21 23:08:13 +04:00
${${project}_RUN_TEST})
Enable overriding contract test timeout values. Use a longer value as the default timeout (6 hours). For a per-contract-test timeout value, set ${project}_TEST_TIMEOUT in the project's RunTest.cmake file. To use a longer value for all non-specific contract tests, set a CMake cache variable named CMAKE_CONTRACT_TEST_TIMEOUT_DEFAULT. All timeout values are in seconds. Also, patch up last commit to defer evaluation of ENV{HOME} until EnforceConfig.cmake is included at ctest time. This allows Windows machines to have "\\" characters in the HOME environment variable if they want to.
2010-10-22 22:31:36 +04:00
# Contract test timeout in seconds.
# Default to 6 hours.
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(DEFINED ${project}_TEST_TIMEOUT)
set(timeout ${${project}_TEST_TIMEOUT})
elseif(CMAKE_CONTRACT_TEST_TIMEOUT_DEFAULT)
set(timeout ${CMAKE_CONTRACT_TEST_TIMEOUT_DEFAULT})
else()
set(timeout 21600)
endif()
set_tests_properties(Contracts.${project} PROPERTIES TIMEOUT ${timeout})
endforeach()
if(TEST_CompileCommandOutput)
Tests: Split <test>_EXTRA_OPTIONS into <test>_(CTEST|BUILD)_OPTIONS Some extra options are for "ctest --build-and-test" directly, and others are values for "--build-options". Split these two roles out into two separate variables and update existing uses.
2013-11-15 17:19:13 +04:00
set(CompileCommandOutput_BUILD_OPTIONS
-DMAKE_SUPPORTS_SPACES=${MAKE_SUPPORTS_SPACES})
Only offer the compile command output feature on unix systems
2011-04-25 21:16:01 +04:00
ADD_TEST_MACRO(CompileCommandOutput
"${CMake_BINARY_DIR}/Tests/CMakeLib/runcompilecommands")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
Fix for bug#10798. VS10 did not append -I flags with COMPILE_FLAGS prop. This fix adds a test for this case for all generators.
2011-06-02 18:28:10 +04:00
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(IncludeDirectories ${CMAKE_CTEST_COMMAND}
Fix for bug#10798. VS10 did not append -I flags with COMPILE_FLAGS prop. This fix adds a test for this case for all generators.
2011-06-02 18:28:10 +04:00
--build-and-test
"${CMake_SOURCE_DIR}/Tests/IncludeDirectories"
"${CMake_BINARY_DIR}/Tests/IncludeDirectories"
--build-two-config
Tests: Consolidate ctest --build-and-test generator options All ctest --build-and-test invocations require the options --build-generator ${CMAKE_GENERATOR} --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} to be passed and have consistent values, except for a few special cases. Collect the generator options in a variable instead of repeating the options everywhere explicitly.
2013-02-06 01:09:55 +04:00
${build_generator_args}
Fix for bug#10798. VS10 did not append -I flags with COMPILE_FLAGS prop. This fix adds a test for this case for all generators.
2011-06-02 18:28:10 +04:00
--build-project IncludeDirectories
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Fix for bug#10798. VS10 did not append -I flags with COMPILE_FLAGS prop. This fix adds a test for this case for all generators.
2011-06-02 18:28:10 +04:00
--test-command IncludeDirectories)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/IncludeDirectories")
Fix for bug#10798. VS10 did not append -I flags with COMPILE_FLAGS prop. This fix adds a test for this case for all generators.
2011-06-02 18:28:10 +04:00
Introduce the INTERFACE_LINK_LIBRARIES property. This property replaces the properties which match (IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?, and is enabled for IMPORTED targets, and for non-IMPORTED targets only with a policy. For static libraries, the INTERFACE_LINK_LIBRARIES property is also used as the source of transitive usage requirements content. Static libraries still require users to link to all entries in their LINK_LIBRARIES, but usage requirements such as INCLUDE_DIRECTORIES COMPILE_DEFINITIONS and COMPILE_OPTIONS can be restricted to only certain interface libraries. Because the INTERFACE_LINK_LIBRARIES property is populated unconditionally, we need to compare the evaluated result of it with the link implementation to determine whether to issue the policy warning for static libraries. For shared libraries, the policy warning is issued if the contents of the INTERFACE_LINK_LIBRARIES property differs from the contents of the relevant config-specific old LINK_INTERFACE_LIBRARIES property.
2013-06-04 18:25:47 +04:00
add_test(InterfaceLinkLibraries ${CMAKE_CTEST_COMMAND}
--build-and-test
"${CMake_SOURCE_DIR}/Tests/InterfaceLinkLibraries"
"${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries"
--build-two-config
${build_generator_args}
--build-project InterfaceLinkLibraries
Tests: Pass --build-options to every test Create a "build_options" variable whose value is passed to every "ctest --build-and-test" call through the --build-options argument.
2013-11-15 18:12:55 +04:00
--build-options ${build_options}
Introduce the INTERFACE_LINK_LIBRARIES property. This property replaces the properties which match (IMPORTED_)?LINK_INTERFACE_LIBRARIES(_<CONFIG>)?, and is enabled for IMPORTED targets, and for non-IMPORTED targets only with a policy. For static libraries, the INTERFACE_LINK_LIBRARIES property is also used as the source of transitive usage requirements content. Static libraries still require users to link to all entries in their LINK_LIBRARIES, but usage requirements such as INCLUDE_DIRECTORIES COMPILE_DEFINITIONS and COMPILE_OPTIONS can be restricted to only certain interface libraries. Because the INTERFACE_LINK_LIBRARIES property is populated unconditionally, we need to compare the evaluated result of it with the link implementation to determine whether to issue the policy warning for static libraries. For shared libraries, the policy warning is issued if the contents of the INTERFACE_LINK_LIBRARIES property differs from the contents of the relevant config-specific old LINK_INTERFACE_LIBRARIES property.
2013-06-04 18:25:47 +04:00
--test-command InterfaceLinkLibraries)
list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/InterfaceLinkLibraries")
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
if(CMAKE_USE_KWSTYLE AND KWSTYLE_EXECUTABLE)
Tests: Add a KWStyle test, equivalent to the make StyleCheck target
2011-08-04 05:37:01 +04:00
# The "make StyleCheck" command line as a test. If the test fails, look
# for lines like "Error #0 (624) Line length exceed 88 (max=79)" in the
# output to find where the style errors are...
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
add_test(KWStyle ${KWSTYLE_EXECUTABLE}
Tests: Add a KWStyle test, equivalent to the make StyleCheck target
2011-08-04 05:37:01 +04:00
-xml ${CMake_BINARY_DIR}/CMake.kws.xml
-o ${CMake_SOURCE_DIR}/Utilities/KWStyle/CMakeOverwrite.txt
-v
-D ${CMake_BINARY_DIR}/CMakeKWSFiles.txt
)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
set_tests_properties(KWStyle PROPERTIES
Tests: Add a KWStyle test, equivalent to the make StyleCheck target
2011-08-04 05:37:01 +04:00
WORKING_DIRECTORY ${CMake_BINARY_DIR}/Utilities/KWStyle)
Convert CMake-language commands to lower case Ancient CMake versions required upper-case commands. Later command names became case-insensitive. Now the preferred style is lower-case. Run the following shell code: cmake --help-command-list | grep -v "cmake version" | while read c; do echo 's/\b'"$(echo $c | tr '[:lower:]' '[:upper:]')"'\(\s*\)(/'"$c"'\1(/g' done >convert.sed && git ls-files -z -- bootstrap '*.cmake' '*.cmake.in' '*CMakeLists.txt' | egrep -z -v '^(Utilities/cm|Source/kwsys/)' | xargs -0 sed -i -f convert.sed && rm convert.sed
2012-08-13 21:47:32 +04:00
endif()
ENH: some more CMakeList cleanups
2007-05-11 18:22:20 +04:00
Tests: Optionally configure tests exclusively, with an external CMake Add an undocumented CMake_TEST_EXTERNAL_CMAKE option to name an external CMake 'bin' directory. Skip all main CMake binary builds and instead configure the Tests directory to run using the external CMake provided. This will provide a means to exercise the CMake test suite generating for target platforms and compilers with which the CMake source does not build. That will allow us to raise the level of C++ features required of a compiler to build our source while retaining tests for generating projects with older compiler tools.
2014-03-04 00:24:03 +04:00
if(NOT CMake_TEST_EXTERNAL_CMAKE)
add_subdirectory(CMakeTests)
endif()
Configure Tests/CMakeTests only with BUILD_TESTING ON Since commit e03f83f3 (ProcessorCount test: fix path to cmsysTestsCxx executable, 2013-01-24) the directory references a target that is not built when BUILD_TESTING is OFF. It makes no sense to add tests without BUILD_TESTING anyway. While at it, use add_subdirectory instead of subdirs to add CMakeTests.
2013-03-13 22:09:43 +04:00
endif()