kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Tests/RunCMake/RunCMake.cmake

149 lines
5.1 KiB
CMake
Raw Normal View History

Add stronger infrastructure for CMake-only tests The CMakeOnly directory added by commit 9a20abf0 (Add infrastructure for CMake-only tests, 2012-01-11) was sufficient only for tests that always run CMake to successfully configure a project. Later commit eeaaffcb (find_package: Test error and warning messages in failure cases, 2012-02-28) added a sample test that covers failure cases. Generalize the above to create new "RunCMake" test infrastructure that can run CMake multiple times for a single project with different variations and check for expected result/stdout/stderr. Allow for both successful and failing CMake project configuration cases. This will be useful to test error messages and failure behavior.
2012-03-10 01:24:43 +04:00
foreach(arg
RunCMake_GENERATOR
RunCMake_SOURCE_DIR
RunCMake_BINARY_DIR
)
if(NOT DEFINED ${arg})
message(FATAL_ERROR "${arg} not given!")
endif()
endforeach()
function(run_cmake test)
set(top_src "${RunCMake_SOURCE_DIR}")
set(top_bin "${RunCMake_BINARY_DIR}")
if(EXISTS ${top_src}/${test}-result.txt)
file(READ ${top_src}/${test}-result.txt expect_result)
string(REGEX REPLACE "\n+$" "" expect_result "${expect_result}")
else()
set(expect_result 0)
endif()
foreach(o out err)
RunCMake: Allow specifying the stderr file for a test.
2015-02-09 10:41:06 +03:00
if(RunCMake-std${o}-file AND EXISTS ${top_src}/${RunCMake-std${o}-file})
file(READ ${top_src}/${RunCMake-std${o}-file} expect_std${o})
string(REGEX REPLACE "\n+$" "" expect_std${o} "${expect_std${o}}")
elseif(EXISTS ${top_src}/${test}-std${o}.txt)
Add stronger infrastructure for CMake-only tests The CMakeOnly directory added by commit 9a20abf0 (Add infrastructure for CMake-only tests, 2012-01-11) was sufficient only for tests that always run CMake to successfully configure a project. Later commit eeaaffcb (find_package: Test error and warning messages in failure cases, 2012-02-28) added a sample test that covers failure cases. Generalize the above to create new "RunCMake" test infrastructure that can run CMake multiple times for a single project with different variations and check for expected result/stdout/stderr. Allow for both successful and failing CMake project configuration cases. This will be useful to test error messages and failure behavior.
2012-03-10 01:24:43 +04:00
file(READ ${top_src}/${test}-std${o}.txt expect_std${o})
string(REGEX REPLACE "\n+$" "" expect_std${o} "${expect_std${o}}")
else()
unset(expect_std${o})
endif()
endforeach()
RunCMake: Expect empty output by default. Expect tests to specify stderr content if it is present. Fix the CMP0019 test, which has only been testing the WARN status until now. Specify in the CommandLine and FPHSA tests that content is at least one character. Set policies in the Language and CheckModules tests, which have empty test output, modulo unrelated policies on some platforms.
2014-12-17 00:11:40 +03:00
if (NOT expect_stderr)
if (NOT RunCMake_DEFAULT_stderr)
set(RunCMake_DEFAULT_stderr "^$")
endif()
set(expect_stderr ${RunCMake_DEFAULT_stderr})
endif()
RunCMake: Allow specifying the source dir and file to test. This will allow decoupling the name of the test from the name and location of the source file under test, which means one source file can be used for multiple tests. Rename the PARENT_SCOPE test in RunCMake.set to not use a keyword of the if() command as a file name. As the filename is now used with an if condition, this causes a conflict.
2014-04-07 01:53:52 +04:00
if (NOT RunCMake_TEST_SOURCE_DIR)
set(RunCMake_TEST_SOURCE_DIR "${top_src}")
endif()
Tests/RunCMake: Allow tests to control build tree behavior Teach the run_cmake to allow tests to set a custom test build directory. Also add an option to skip removing the build directory.
2013-02-18 19:43:40 +04:00
if(NOT RunCMake_TEST_BINARY_DIR)
set(RunCMake_TEST_BINARY_DIR "${top_bin}/${test}-build")
endif()
if(NOT RunCMake_TEST_NO_CLEAN)
file(REMOVE_RECURSE "${RunCMake_TEST_BINARY_DIR}")
endif()
Teach RunCMake tests to allow custom checks Look for a <SubTest>-check.cmake script and load it to check side effects of the sub test. Provide it with the test source and build tree paths in variables. Check for a failure message in a result variable.
2012-04-18 19:09:18 +04:00
file(MAKE_DIRECTORY "${RunCMake_TEST_BINARY_DIR}")
CMake: Add -T option to choose a generator toolset Reject the option by default. It will be implemented on a per-generator basis. Pass the setting into try_compile project generation. Add cache entry CMAKE_GENERATOR_TOOLSET and associated variable documentation to hold the value persistently. Add a RunCMake.GeneratorToolset test to cover basic "-T" option cases. Verify that CMAKE_GENERATOR_TOOLSET is empty without -T, that -T is rejected when the generator doesn't support it, and that two -T options are always rejected.
2012-12-10 19:42:33 +04:00
if(NOT DEFINED RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS "")
endif()
Set policy CMP0025 to NEW while building CMake itself CMake is aware of the policy's NEW behavior and the AppleClang compiler id. Set the policy to NEW explicitly to avoid the warning and get the NEW behavior. Also teach the RunCMake test infrastructure to build tests with -DCMAKE_POLICY_DEFAULT_CMP0025=NEW to avoid the policy warning in test output that must match specific regular expressions.
2013-10-02 22:45:54 +04:00
if(APPLE)
list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_POLICY_DEFAULT_CMP0025=NEW)
endif()
Deprecate Visual Studio 7 .NET 2003 generator Update documentation to mark the generator deprecated. Add a warning at the end of generation plus an option to turn off the warning.
2016-04-28 17:09:15 +03:00
if(RunCMake_GENERATOR STREQUAL "Visual Studio 7 .NET 2003" AND NOT RunCMake_WARN_VS71)
list(APPEND RunCMake_TEST_OPTIONS -DCMAKE_WARN_VS71=OFF)
endif()
Tests/RunCMake: Honor CMAKE_MAKE_PROGRAM If tests are using an explicit make program, pass it through to RunCMake tests so that any that actually do build use the expected tool.
2015-01-24 15:08:12 +03:00
if(RunCMake_MAKE_PROGRAM)
list(APPEND RunCMake_TEST_OPTIONS "-DCMAKE_MAKE_PROGRAM=${RunCMake_MAKE_PROGRAM}")
endif()
Tests: Teach RunCMake to optionally merge command output to stdout Some tests may need to read "cmake --build" output passed through from native build tools and do not know if it will be on stdout or stderr. Optionally use the same variable for the execute_process output so that it merges them and we can always match using expected stdout.
2015-04-07 16:06:51 +03:00
if(RunCMake_TEST_OUTPUT_MERGE)
set(actual_stderr_var actual_stdout)
set(actual_stderr "")
else()
set(actual_stderr_var actual_stderr)
endif()
Tests: Teach RunCMake infrastructure to optionally timeout Add a RunCMake_TEST_TIMEOUT option that tests can set to cause RunCMake to limit the time it waits for the child process to finish.
2015-06-24 16:53:37 +03:00
if(DEFINED RunCMake_TEST_TIMEOUT)
set(maybe_timeout TIMEOUT ${RunCMake_TEST_TIMEOUT})
else()
set(maybe_timeout "")
endif()
Tests/RunCMake: Add function to run a specified command-line Add a 'run_cmake_command' function that can be used by tests to run a given command-line and check the results rather than always running a CMake configuration process. This can be used in the future to test 'cmake -E' for example.
2014-01-20 22:46:51 +04:00
if(RunCMake_TEST_COMMAND)
execute_process(
COMMAND ${RunCMake_TEST_COMMAND}
WORKING_DIRECTORY "${RunCMake_TEST_BINARY_DIR}"
OUTPUT_VARIABLE actual_stdout
Tests: Teach RunCMake to optionally merge command output to stdout Some tests may need to read "cmake --build" output passed through from native build tools and do not know if it will be on stdout or stderr. Optionally use the same variable for the execute_process output so that it merges them and we can always match using expected stdout.
2015-04-07 16:06:51 +03:00
ERROR_VARIABLE ${actual_stderr_var}
Tests/RunCMake: Add function to run a specified command-line Add a 'run_cmake_command' function that can be used by tests to run a given command-line and check the results rather than always running a CMake configuration process. This can be used in the future to test 'cmake -E' for example.
2014-01-20 22:46:51 +04:00
RESULT_VARIABLE actual_result
Tests: Teach RunCMake infrastructure to optionally timeout Add a RunCMake_TEST_TIMEOUT option that tests can set to cause RunCMake to limit the time it waits for the child process to finish.
2015-06-24 16:53:37 +03:00
${maybe_timeout}
Tests/RunCMake: Add function to run a specified command-line Add a 'run_cmake_command' function that can be used by tests to run a given command-line and check the results rather than always running a CMake configuration process. This can be used in the future to test 'cmake -E' for example.
2014-01-20 22:46:51 +04:00
)
else()
execute_process(
COMMAND ${CMAKE_COMMAND} "${RunCMake_TEST_SOURCE_DIR}"
-G "${RunCMake_GENERATOR}"
cmake: Add -A option to specify a generator platform Define the 'cmake -A' option to set CMAKE_GENERATOR_PLATFORM without having to spell out the whole variable name. We choose the name '-A' for "platform" because '-P' is already taken, and in the common use case the "platform" is actually an architecture (e.g. x64). Teach the RunCMake test infrastructure to use -A to pass the generator platform. Extend the RunCMake.GeneratorPlatform test with a case to verify that the -A option cannot be repeated.
2014-09-12 17:55:06 +04:00
-A "${RunCMake_GENERATOR_PLATFORM}"
Tests/RunCMake: Add function to run a specified command-line Add a 'run_cmake_command' function that can be used by tests to run a given command-line and check the results rather than always running a CMake configuration process. This can be used in the future to test 'cmake -E' for example.
2014-01-20 22:46:51 +04:00
-T "${RunCMake_GENERATOR_TOOLSET}"
Tests: Drop broken and now unused RunCMake_TEST_FILE option We cannot use -DRunCMake_TEST=${RunCMake_TEST_FILE} because test cases use project(${RunCMake_TEST}) and the project name cannot be a path to a file. The parent and grandparent commits removed the only uses of the option. Drop it now.
2014-06-30 22:35:52 +04:00
-DRunCMake_TEST=${test}
Tests/RunCMake: Tell cmake not to report unused command-line options On OS X we pass -DCMAKE_POLICY_DEFAULT_CMP0025=NEW to all tests. Once tests start using cmake_minimum_required(VERSION 3.0) then CMake will warn that CMAKE_POLICY_DEFAULT_CMP0025 is unused. These warnings are not part of the expected test output and can cause such tests to fail. Pass --no-warn-unused-cli to each test cmake invocation to tell it not to produce these warnings.
2014-02-27 22:22:58 +04:00
--no-warn-unused-cli
Tests/RunCMake: Add function to run a specified command-line Add a 'run_cmake_command' function that can be used by tests to run a given command-line and check the results rather than always running a CMake configuration process. This can be used in the future to test 'cmake -E' for example.
2014-01-20 22:46:51 +04:00
${RunCMake_TEST_OPTIONS}
WORKING_DIRECTORY "${RunCMake_TEST_BINARY_DIR}"
OUTPUT_VARIABLE actual_stdout
Tests: Teach RunCMake to optionally merge command output to stdout Some tests may need to read "cmake --build" output passed through from native build tools and do not know if it will be on stdout or stderr. Optionally use the same variable for the execute_process output so that it merges them and we can always match using expected stdout.
2015-04-07 16:06:51 +03:00
ERROR_VARIABLE ${actual_stderr_var}
Tests/RunCMake: Add function to run a specified command-line Add a 'run_cmake_command' function that can be used by tests to run a given command-line and check the results rather than always running a CMake configuration process. This can be used in the future to test 'cmake -E' for example.
2014-01-20 22:46:51 +04:00
RESULT_VARIABLE actual_result
Tests: Teach RunCMake infrastructure to optionally timeout Add a RunCMake_TEST_TIMEOUT option that tests can set to cause RunCMake to limit the time it waits for the child process to finish.
2015-06-24 16:53:37 +03:00
${maybe_timeout}
Tests/RunCMake: Add function to run a specified command-line Add a 'run_cmake_command' function that can be used by tests to run a given command-line and check the results rather than always running a CMake configuration process. This can be used in the future to test 'cmake -E' for example.
2014-01-20 22:46:51 +04:00
)
endif()
Add stronger infrastructure for CMake-only tests The CMakeOnly directory added by commit 9a20abf0 (Add infrastructure for CMake-only tests, 2012-01-11) was sufficient only for tests that always run CMake to successfully configure a project. Later commit eeaaffcb (find_package: Test error and warning messages in failure cases, 2012-02-28) added a sample test that covers failure cases. Generalize the above to create new "RunCMake" test infrastructure that can run CMake multiple times for a single project with different variations and check for expected result/stdout/stderr. Allow for both successful and failing CMake project configuration cases. This will be useful to test error messages and failure behavior.
2012-03-10 01:24:43 +04:00
set(msg "")
Tests: Allow RunCMake expected result code to be a regex This will allow the '-result.txt' files to specify a regex matching different results on different platforms.
2014-12-16 21:33:47 +03:00
if(NOT "${actual_result}" MATCHES "${expect_result}")
Use string(APPEND) in Tests Automate with: find Tests -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-28 01:43:04 +03:00
string(APPEND msg "Result is [${actual_result}], not [${expect_result}].\n")
Add stronger infrastructure for CMake-only tests The CMakeOnly directory added by commit 9a20abf0 (Add infrastructure for CMake-only tests, 2012-01-11) was sufficient only for tests that always run CMake to successfully configure a project. Later commit eeaaffcb (find_package: Test error and warning messages in failure cases, 2012-02-28) added a sample test that covers failure cases. Generalize the above to create new "RunCMake" test infrastructure that can run CMake multiple times for a single project with different variations and check for expected result/stdout/stderr. Allow for both successful and failing CMake project configuration cases. This will be useful to test error messages and failure behavior.
2012-03-10 01:24:43 +04:00
endif()
foreach(o out err)
Tests/RunCMake: Normalize newlines before checking actual output We read the expected output with file(STRINGS) which converts CRLF newlines to LF. Do the same with the actual output before comparing.
2015-01-26 21:41:38 +03:00
string(REGEX REPLACE "\r\n" "\n" actual_std${o} "${actual_std${o}}")
Tests: Teach RunCMake to tolerate 'Bullseye Testing' lines in test output When testing under Bullseye coverage, some tests get lines on stderr of the form: ... Bullseye Testing Technology ... Remove such lines from output before matching because they are not representative of the actual test output.
2015-09-17 16:10:36 +03:00
string(REGEX REPLACE "(^|\n)((==[0-9]+==|BullseyeCoverage|[a-z]+\\([0-9]+\\) malloc:|Error kstat returned|[^\n]*from Time Machine by path|[^\n]*Bullseye Testing Technology)[^\n]*\n)+" "\\1" actual_std${o} "${actual_std${o}}")
Add stronger infrastructure for CMake-only tests The CMakeOnly directory added by commit 9a20abf0 (Add infrastructure for CMake-only tests, 2012-01-11) was sufficient only for tests that always run CMake to successfully configure a project. Later commit eeaaffcb (find_package: Test error and warning messages in failure cases, 2012-02-28) added a sample test that covers failure cases. Generalize the above to create new "RunCMake" test infrastructure that can run CMake multiple times for a single project with different variations and check for expected result/stdout/stderr. Allow for both successful and failing CMake project configuration cases. This will be useful to test error messages and failure behavior.
2012-03-10 01:24:43 +04:00
string(REGEX REPLACE "\n+$" "" actual_std${o} "${actual_std${o}}")
set(expect_${o} "")
if(DEFINED expect_std${o})
if(NOT "${actual_std${o}}" MATCHES "${expect_std${o}}")
string(REGEX REPLACE "\n" "\n expect-${o}> " expect_${o}
" expect-${o}> ${expect_std${o}}")
set(expect_${o} "Expected std${o} to match:\n${expect_${o}}\n")
Use string(APPEND) in Tests Automate with: find Tests -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-28 01:43:04 +03:00
string(APPEND msg "std${o} does not match that expected.\n")
Add stronger infrastructure for CMake-only tests The CMakeOnly directory added by commit 9a20abf0 (Add infrastructure for CMake-only tests, 2012-01-11) was sufficient only for tests that always run CMake to successfully configure a project. Later commit eeaaffcb (find_package: Test error and warning messages in failure cases, 2012-02-28) added a sample test that covers failure cases. Generalize the above to create new "RunCMake" test infrastructure that can run CMake multiple times for a single project with different variations and check for expected result/stdout/stderr. Allow for both successful and failing CMake project configuration cases. This will be useful to test error messages and failure behavior.
2012-03-10 01:24:43 +04:00
endif()
endif()
endforeach()
Teach RunCMake tests to allow custom checks Look for a <SubTest>-check.cmake script and load it to check side effects of the sub test. Provide it with the test source and build tree paths in variables. Check for a failure message in a result variable.
2012-04-18 19:09:18 +04:00
unset(RunCMake_TEST_FAILED)
Tests: Teach RunCMake infrastructure to use custom check.cmake file
2015-09-16 17:07:49 +03:00
if(RunCMake-check-file AND EXISTS ${top_src}/${RunCMake-check-file})
include(${top_src}/${RunCMake-check-file})
else()
include(${top_src}/${test}-check.cmake OPTIONAL)
endif()
Teach RunCMake tests to allow custom checks Look for a <SubTest>-check.cmake script and load it to check side effects of the sub test. Provide it with the test source and build tree paths in variables. Check for a failure message in a result variable.
2012-04-18 19:09:18 +04:00
if(RunCMake_TEST_FAILED)
set(msg "${RunCMake_TEST_FAILED}\n${msg}")
endif()
Tests: Teach RunCMake to report command-line on failure When a test sets RunCMake_TEST_COMMAND, report the command line on failure to make it easier to run by hand for debugging.
2015-01-15 22:36:10 +03:00
if(msg AND RunCMake_TEST_COMMAND)
string(REPLACE ";" "\" \"" command "\"${RunCMake_TEST_COMMAND}\"")
Use string(APPEND) in Tests Automate with: find Tests -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-28 01:43:04 +03:00
string(APPEND msg "Command was:\n command> ${command}\n")
Tests: Teach RunCMake to report command-line on failure When a test sets RunCMake_TEST_COMMAND, report the command line on failure to make it easier to run by hand for debugging.
2015-01-15 22:36:10 +03:00
endif()
Add stronger infrastructure for CMake-only tests The CMakeOnly directory added by commit 9a20abf0 (Add infrastructure for CMake-only tests, 2012-01-11) was sufficient only for tests that always run CMake to successfully configure a project. Later commit eeaaffcb (find_package: Test error and warning messages in failure cases, 2012-02-28) added a sample test that covers failure cases. Generalize the above to create new "RunCMake" test infrastructure that can run CMake multiple times for a single project with different variations and check for expected result/stdout/stderr. Allow for both successful and failing CMake project configuration cases. This will be useful to test error messages and failure behavior.
2012-03-10 01:24:43 +04:00
if(msg)
string(REGEX REPLACE "\n" "\n actual-out> " actual_out " actual-out> ${actual_stdout}")
string(REGEX REPLACE "\n" "\n actual-err> " actual_err " actual-err> ${actual_stderr}")
message(SEND_ERROR "${test} - FAILED:\n"
"${msg}"
"${expect_out}"
"Actual stdout:\n${actual_out}\n"
"${expect_err}"
"Actual stderr:\n${actual_err}\n"
)
else()
message(STATUS "${test} - PASSED")
endif()
endfunction()
Tests/RunCMake: Add function to run a specified command-line Add a 'run_cmake_command' function that can be used by tests to run a given command-line and check the results rather than always running a CMake configuration process. This can be used in the future to test 'cmake -E' for example.
2014-01-20 22:46:51 +04:00
function(run_cmake_command test)
set(RunCMake_TEST_COMMAND "${ARGN}")
run_cmake(${test})
endfunction()
Tests: Protect RunCMake tests from MAKEFLAGS in environment (#15542)
2015-04-29 23:13:50 +03:00
# Protect RunCMake tests from calling environment.
unset(ENV{MAKEFLAGS})