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

280 lines
9.0 KiB
CMake
Raw Normal View History

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
#-----------------------------------------------------------------------------
# Function to run a child process and report output only on error.
function(run_child)
execute_process(${ARGN}
RESULT_VARIABLE FAILED
OUTPUT_VARIABLE OUTPUT
ERROR_VARIABLE OUTPUT
OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_STRIP_TRAILING_WHITESPACE
)
if(FAILED)
Replace string(REGEX REPLACE) with string(REPLACE) where possible The simple replacement is much faster.
2014-04-06 23:51:33 +04:00
string(REPLACE "\n" "\n " OUTPUT "${OUTPUT}")
Output command that failed, if it fails.
2009-08-12 06:01:49 +04:00
message(FATAL_ERROR "Child failed (${FAILED}), output is\n ${OUTPUT}\n"
"Command = [${ARGN}]\n")
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()
endfunction()
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
#-----------------------------------------------------------------------------
# Function to find the Update.xml file and check for expected entries.
function(check_updates build)
# Find the Update.xml file for the given build tree
set(PATTERN ${TOP}/${build}/Testing/*/Update.xml)
file(GLOB UPDATE_XML_FILE RELATIVE ${TOP} ${PATTERN})
string(REGEX REPLACE "//Update.xml$" "/Update.xml"
UPDATE_XML_FILE "${UPDATE_XML_FILE}"
)
if(NOT UPDATE_XML_FILE)
message(FATAL_ERROR "Cannot find Update.xml with pattern\n ${PATTERN}")
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
message(" found ${UPDATE_XML_FILE}")
Fix machine-specific UpdateGIT test failures Generated Update.xml file is larger than the previously hard-coded limit of 4096. Introduce variable max_update_xml_size and bump it up to 16k for reliable test runs.
2011-07-29 18:24:06 +04:00
set(max_update_xml_size 16384)
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
# Read entries from the Update.xml file
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
set(types "Updated|Modified|Conflicting")
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
file(STRINGS ${TOP}/${UPDATE_XML_FILE} UPDATE_XML_ENTRIES
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
REGEX "<(${types}|FullName)>"
Fix machine-specific UpdateGIT test failures Generated Update.xml file is larger than the previously hard-coded limit of 4096. Introduce variable max_update_xml_size and bump it up to 16k for reliable test runs.
2011-07-29 18:24:06 +04:00
LIMIT_INPUT ${max_update_xml_size}
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
)
ctest_update: Do not remove the p4 depot name Instead of removing the depot name, which causes problems when looking at the file change list in CDash, make the Update test remove a given prefix from the files retrieved from Update.xml.
2013-11-01 00:24:57 +04:00
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
string(REGEX REPLACE
"[ \t]*<(${types})>[ \t]*;[ \t]*<FullName>([^<]*)</FullName>"
"\\1{\\2}" UPDATE_XML_ENTRIES "${UPDATE_XML_ENTRIES}")
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
ctest_update: Do not remove the p4 depot name Instead of removing the depot name, which causes problems when looking at the file change list in CDash, make the Update test remove a given prefix from the files retrieved from Update.xml.
2013-11-01 00:24:57 +04:00
# If specified, remove the given prefix from the files in Update.xml.
# Some VCS systems, like Perforce, return absolute locations
if(DEFINED REPOSITORY_FILE_PREFIX)
string(REPLACE
"${REPOSITORY_FILE_PREFIX}" ""
UPDATE_XML_ENTRIES "${UPDATE_XML_ENTRIES}")
endif()
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
# Compare expected and actual entries
set(EXTRA "${UPDATE_XML_ENTRIES}")
Teach ctest_update about Git submodules Git does not automatically checkout the matching version of a submodule when it checks out a new version of the parent project in the work tree. If the submodule reference changed in the parent project then we were reporting the submodule path as a local modification. Work around the problem in ctest_update using "git submodule update" after "git pull". For projects with no submodules this is a no-op. See issue #10662. Also add a submodule to the test project for CTest.UpdateGIT to test the work-around.
2010-05-04 17:35:27 +04:00
list(REMOVE_ITEM EXTRA ${ARGN} ${UPDATE_EXTRA} ${UPDATE_MAYBE})
set(MISSING "${ARGN}" ${UPDATE_EXTRA})
ctest_update: Handle P4 unknown revisions more robustly Mark unknown revisions as such and fail instead of reporting revision 0. Otherwise CTest reports massive file updates between revisions when the server timeouts while trying to fetch the current revision number.
2014-01-22 05:02:25 +04:00
if(NOT "" STREQUAL "${UPDATE_XML_ENTRIES}")
list(REMOVE_ITEM MISSING ${UPDATE_XML_ENTRIES})
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
Submit global tree revision in Update.xml We teach CTest to report in a <Revision> element the revision of the source tree that was tested. This makes sense for all modern VCS tools because they version the whole tree. We simply omit this element for CVS because it only versions files. See issue #7541.
2009-12-18 16:13:51 +03:00
if(NOT UPDATE_NOT_GLOBAL)
Test for SVNPath element in Update.xml The commit "Submit Subversion directory path in Update.xml" added the element <SVNPath>...</SVNPath> to Update.xml for Subversion work trees. This commit teaches the CTest.UpdateSVN test to verify the presence of the element.
2009-12-18 19:01:24 +03:00
set(rev_elements Revision PriorRevision ${UPDATE_GLOBAL_ELEMENTS})
string(REPLACE ";" "|" rev_regex "${rev_elements}")
set(rev_regex "^\t<(${rev_regex})>[^<\n]+</(${rev_regex})>$")
Submit global tree revision in Update.xml We teach CTest to report in a <Revision> element the revision of the source tree that was tested. This makes sense for all modern VCS tools because they version the whole tree. We simply omit this element for CVS because it only versions files. See issue #7541.
2009-12-18 16:13:51 +03:00
file(STRINGS ${TOP}/${UPDATE_XML_FILE} UPDATE_XML_REVISIONS
REGEX "${rev_regex}"
Fix machine-specific UpdateGIT test failures Generated Update.xml file is larger than the previously hard-coded limit of 4096. Introduce variable max_update_xml_size and bump it up to 16k for reliable test runs.
2011-07-29 18:24:06 +04:00
LIMIT_INPUT ${max_update_xml_size}
Submit global tree revision in Update.xml We teach CTest to report in a <Revision> element the revision of the source tree that was tested. This makes sense for all modern VCS tools because they version the whole tree. We simply omit this element for CVS because it only versions files. See issue #7541.
2009-12-18 16:13:51 +03:00
)
foreach(r IN LISTS UPDATE_XML_REVISIONS)
string(REGEX REPLACE "${rev_regex}" "\\1" element "${r}")
set(element_${element} 1)
endforeach()
foreach(element ${rev_elements})
if(NOT element_${element})
list(APPEND MISSING "global <${element}> element")
endif()
endforeach()
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
# Report the result
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
set(MSG "")
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
if(MISSING)
# List the missing entries
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
set(MSG "${MSG}Update.xml is missing expected entries:\n")
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
foreach(f ${MISSING})
set(MSG "${MSG} ${f}\n")
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()
else()
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
# Success
message(" no entries missing from Update.xml")
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
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
# Report the result
if(EXTRA)
# List the extra entries
set(MSG "${MSG}Update.xml has extra unexpected entries:\n")
foreach(f ${EXTRA})
set(MSG "${MSG} ${f}\n")
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()
else()
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
# Success
message(" no extra entries in Update.xml")
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()
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
if(MSG)
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
# Provide the log file
file(GLOB UPDATE_LOG_FILE
${TOP}/${build}/Testing/Temporary/LastUpdate*.log)
if(UPDATE_LOG_FILE)
Fix machine-specific UpdateGIT test failures Generated Update.xml file is larger than the previously hard-coded limit of 4096. Introduce variable max_update_xml_size and bump it up to 16k for reliable test runs.
2011-07-29 18:24:06 +04:00
file(READ ${UPDATE_LOG_FILE} UPDATE_LOG LIMIT ${max_update_xml_size})
Replace string(REGEX REPLACE) with string(REPLACE) where possible The simple replacement is much faster.
2014-04-06 23:51:33 +04:00
string(REPLACE "\n" "\n " UPDATE_LOG "${UPDATE_LOG}")
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
set(MSG "${MSG}Update log:\n ${UPDATE_LOG}")
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: 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
set(MSG "${MSG}No update log 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()
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
# Display the error message
message(FATAL_ERROR "${MSG}")
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()
endfunction()
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
#-----------------------------------------------------------------------------
# Function to create initial content.
function(create_content dir)
file(MAKE_DIRECTORY ${TOP}/${dir})
# An example CTest project configuration file.
file(WRITE ${TOP}/${dir}/CTestConfig.cmake
"# CTest Configuration File
set(CTEST_PROJECT_NAME TestProject)
set(CTEST_NIGHTLY_START_TIME \"21:00:00 EDT\")
")
# Some other files.
file(WRITE ${TOP}/${dir}/foo.txt "foo\n")
file(WRITE ${TOP}/${dir}/bar.txt "bar\n")
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
endfunction()
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
#-----------------------------------------------------------------------------
# Function to update content.
ENH: Enhance CTest.UpdateCVS/SVN tests This adds a source tree subdirectory to the content of the test projects. It also smoke tests more than one revision worth of changes.
2009-02-23 23:59:07 +03:00
function(update_content dir added_var removed_var dirs_var)
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
file(APPEND ${TOP}/${dir}/foo.txt "foo line 2\n")
file(WRITE ${TOP}/${dir}/zot.txt "zot\n")
file(REMOVE ${TOP}/${dir}/bar.txt)
ENH: Enhance CTest.UpdateCVS/SVN tests This adds a source tree subdirectory to the content of the test projects. It also smoke tests more than one revision worth of changes.
2009-02-23 23:59:07 +03:00
file(MAKE_DIRECTORY ${TOP}/${dir}/subdir)
file(WRITE ${TOP}/${dir}/subdir/foo.txt "foo\n")
file(WRITE ${TOP}/${dir}/subdir/bar.txt "bar\n")
set(${dirs_var} subdir PARENT_SCOPE)
set(${added_var} zot.txt subdir/foo.txt subdir/bar.txt PARENT_SCOPE)
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
set(${removed_var} bar.txt PARENT_SCOPE)
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
endfunction()
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: Enhance CTest.UpdateCVS/SVN tests This adds a source tree subdirectory to the content of the test projects. It also smoke tests more than one revision worth of changes.
2009-02-23 23:59:07 +03:00
#-----------------------------------------------------------------------------
# Function to change existing files
function(change_content dir)
file(APPEND ${TOP}/${dir}/foo.txt "foo line 3\n")
file(APPEND ${TOP}/${dir}/subdir/foo.txt "foo line 2\n")
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
endfunction()
ENH: Enhance CTest.UpdateCVS/SVN tests This adds a source tree subdirectory to the content of the test projects. It also smoke tests more than one revision worth of changes.
2009-02-23 23:59:07 +03:00
ENH: Extend CTest.UpdateSVN to test local mods This teaches the test to create local modifications in the work tree before updating.
2009-02-26 17:22:16 +03:00
#-----------------------------------------------------------------------------
# Function to create local modifications before update
function(modify_content dir)
file(APPEND ${TOP}/${dir}/CTestConfig.cmake "# local modification\n")
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
endfunction()
ENH: Extend CTest.UpdateSVN to test local mods This teaches the test to create local modifications in the work tree before updating.
2009-02-26 17:22:16 +03:00
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
#-----------------------------------------------------------------------------
# Function to write CTestConfiguration.ini content.
function(create_build_tree src_dir bin_dir)
file(MAKE_DIRECTORY ${TOP}/${bin_dir})
file(WRITE ${TOP}/${bin_dir}/CTestConfiguration.ini
"# CTest Configuration File
SourceDirectory: ${TOP}/${src_dir}
BuildDirectory: ${TOP}/${bin_dir}
Site: test.site
BuildName: user-test
")
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
endfunction()
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
#-----------------------------------------------------------------------------
# Function to write the dashboard test script.
Generalize CTest.Update* test dashboard script helpers Teach (create|run)_dashboard_script macros to treat the argument as the name of a build tree. Append '.cmake' to generate the dashboard script name. This allows future re-use of the macros for multiple test scripts.
2010-06-08 23:58:39 +04:00
function(create_dashboard_script bin_dir custom_text)
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
# Write the dashboard script.
Generalize CTest.Update* test dashboard script helpers Teach (create|run)_dashboard_script macros to treat the argument as the name of a build tree. Append '.cmake' to generate the dashboard script name. This allows future re-use of the macros for multiple test scripts.
2010-06-08 23:58:39 +04:00
file(WRITE ${TOP}/${bin_dir}.cmake
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
"# CTest Dashboard Script
set(CTEST_DASHBOARD_ROOT \"${TOP}\")
set(CTEST_SITE test.site)
set(CTEST_BUILD_NAME dash-test)
set(CTEST_SOURCE_DIRECTORY \${CTEST_DASHBOARD_ROOT}/dash-source)
Generalize CTest.Update* test dashboard script helpers Teach (create|run)_dashboard_script macros to treat the argument as the name of a build tree. Append '.cmake' to generate the dashboard script name. This allows future re-use of the macros for multiple test scripts.
2010-06-08 23:58:39 +04:00
set(CTEST_BINARY_DIRECTORY \${CTEST_DASHBOARD_ROOT}/${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
${custom_text}
# Start a dashboard and run the update step
ctest_start(Experimental)
ctest_update(SOURCE \${CTEST_SOURCE_DIRECTORY})
")
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
endfunction()
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
#-----------------------------------------------------------------------------
# Function to run the dashboard through the command line
function(run_dashboard_command_line bin_dir)
run_child(
WORKING_DIRECTORY ${TOP}/${bin_dir}
COMMAND ${CMAKE_CTEST_COMMAND} -M Experimental -T Start -T Update
)
# Verify the updates reported by CTest.
Make CTest.UpdateCVS robust to some cvs clients Commit "Teach CTest.Update tests to strongly check entries" (2010-02-09) started checking Update.xml entries strongly. This revealed that some cvs clients report "U CTestConfig.cmake" during update even though the file did not change and it selects the same revision. As a result the test fails with Update.xml has extra unexpected entries: Updated{CTestConfig.cmake} We fix the test to tolerate this particular extra entry without failing.
2010-02-10 19:48:09 +03:00
list(APPEND UPDATE_MAYBE Updated{subdir})
ctest_update: Support Git upstream branch rewrites Use 'git fetch' followed by 'git reset' to update the source tree. This is better than 'git pull' because it can handle a rewritten upstream branch and does not leave local modifications. After fetch, parse FETCH_HEAD to find the merge head that 'git pull' would choose to track the upstream branch. Then reset to the selected head. In the normal fast-forward case the behavior remains unchanged. However, now local modifications and commits will be erased, and upstream rewrites are handled smoothly. This ensures that the upstream branch is tested as expected.
2010-06-09 00:37:04 +04:00
set(_modified Modified{CTestConfig.cmake})
if(UPDATE_NO_MODIFIED)
set(_modified "")
endif()
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +03:00
check_updates(${bin_dir}
Updated{foo.txt}
Updated{bar.txt}
Updated{zot.txt}
Updated{subdir/foo.txt}
Updated{subdir/bar.txt}
ctest_update: Support Git upstream branch rewrites Use 'git fetch' followed by 'git reset' to update the source tree. This is better than 'git pull' because it can handle a rewritten upstream branch and does not leave local modifications. After fetch, parse FETCH_HEAD to find the merge head that 'git pull' would choose to track the upstream branch. Then reset to the selected head. In the normal fast-forward case the behavior remains unchanged. However, now local modifications and commits will be erased, and upstream rewrites are handled smoothly. This ensures that the upstream branch is tested as expected.
2010-06-09 00:37:04 +04:00
${_modified}
Teach CTest.Update tests to strongly check entries Previously these tests just checked for matching file names in the Update.xml files. Now we check the update types (Updated, Modified, or Conflicting) and reject unexpected extra entries.
2010-02-09 21:31:20 +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
endfunction()
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
ctest_update: Add CTEST_UPDATE_VERSION_ONLY option to only note the version This allows ctest_update to get the current version without actually changing the repository. This is useful when using Jenkins or an external project to update the source to a specific version, but you still want the current version to show up in CDash.
2014-08-13 21:45:08 +04:00
#-----------------------------------------------------------------------------
# Function to find the Update.xml file and make sure
# it only has the Revision in it and no updates
function(check_no_update bin_dir)
set(PATTERN ${TOP}/${bin_dir}/Testing/*/Update.xml)
file(GLOB UPDATE_XML_FILE RELATIVE ${TOP} ${PATTERN})
string(REGEX REPLACE "//Update.xml$" "/Update.xml"
UPDATE_XML_FILE "${UPDATE_XML_FILE}")
message(" found ${UPDATE_XML_FILE}")
set(rev_regex "Revision|PriorRevision")
file(STRINGS ${TOP}/${UPDATE_XML_FILE} UPDATE_XML_REVISIONS
REGEX "^\t<(${rev_regex})>[^<\n]+</(${rev_regex})>$"
)
set(found_revisons FALSE)
foreach(r IN LISTS UPDATE_XML_REVISIONS)
if("${r}" MATCHES "PriorRevision")
message(FATAL_ERROR "Found PriorRevision in no update test")
endif()
if("${r}" MATCHES "<Revision>")
set(found_revisons TRUE)
endif()
endforeach()
if(found_revisons)
message(" found <Revision> in no update test")
else()
message(FATAL_ERROR " missing <Revision> in no update test")
endif()
endfunction()
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
#-----------------------------------------------------------------------------
# Function to run the dashboard through a script
Generalize CTest.Update* test dashboard script helpers Teach (create|run)_dashboard_script macros to treat the argument as the name of a build tree. Append '.cmake' to generate the dashboard script name. This allows future re-use of the macros for multiple test scripts.
2010-06-08 23:58:39 +04:00
function(run_dashboard_script 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
run_child(
WORKING_DIRECTORY ${TOP}
Generalize CTest.Update* test dashboard script helpers Teach (create|run)_dashboard_script macros to treat the argument as the name of a build tree. Append '.cmake' to generate the dashboard script name. This allows future re-use of the macros for multiple test scripts.
2010-06-08 23:58:39 +04:00
COMMAND ${CMAKE_CTEST_COMMAND} -S ${bin_dir}.cmake -V
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
)
# Verify the updates reported by CTest.
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
list(APPEND UPDATE_MAYBE Updated{subdir} Updated{CTestConfig.cmake})
ctest_update: Add CTEST_UPDATE_VERSION_ONLY option to only note the version This allows ctest_update to get the current version without actually changing the repository. This is useful when using Jenkins or an external project to update the source to a specific version, but you still want the current version to show up in CDash.
2014-08-13 21:45:08 +04:00
if(NO_UPDATE)
check_no_update(${bin_dir})
else()
check_updates(${bin_dir}
Updated{foo.txt}
Updated{bar.txt}
Updated{zot.txt}
Updated{subdir/foo.txt}
Updated{subdir/bar.txt}
)
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
endfunction()
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
#-----------------------------------------------------------------------------
# Function to initialize the testing directory.
function(init_testing)
file(REMOVE_RECURSE ${TOP})
file(MAKE_DIRECTORY ${TOP})
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
endfunction()