[Cmake-commits] CMake branch, master, updated. v3.8.0-1038-ga9e4896
Kitware Robot
kwrobot at kitware.com
Tue May 2 08:25:05 EDT 2017
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMake".
The branch, master has been updated
via a9e48968bb0f6b3919cb4ae3f00379631b98df5d (commit)
via 4804c7f30ff659420cc0be5491bb77faa47a2f0c (commit)
via 8fba1f4a0314dba983dee55190b8f903148a08fe (commit)
via 96a8b68d5a5d5ded8d4477c1185d41dd86d626ea (commit)
via 737d05b8f8764f86558ab9a8f2a522035eebc21b (commit)
via 96ad8fe60810a25b267cba6fa45f725e2614a003 (commit)
via 9b97cb5562317ecb6fe65e6185eb6fda2b0ad7d7 (commit)
via daae564d87044950edece389f09bde423e6ad867 (commit)
via 25e83ce580d7e6821a07198ce13338a82b966c0b (commit)
via 1de7084501aa094858d344f92dd2c9fe744a4e9a (commit)
via c273906f48f6e0a84917351288b68a1ec0da64cd (commit)
via c1b2b7c03c899c9b066840600ec15b16ae2fa9ac (commit)
via e17b1791843b473d0d57ccdbe98689d1be8228e2 (commit)
via d037be122e15fb3860869e07a0b6ccd8e7d4d94a (commit)
via b115bc49ff26da9db3e9238a98030fd94847d0d0 (commit)
via 750d58bf61e7ddc48d61d40fa2afa8716eb7fabd (commit)
via 2dec4695b7711126832f61f5e86cc3120cb419d4 (commit)
via 6f04dffb7d0935c997e6fd147e926d97c5cbf925 (commit)
from 7a8068fccd4907c76f065aaa64c7e4bd438a4c4d (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=a9e48968bb0f6b3919cb4ae3f00379631b98df5d
commit a9e48968bb0f6b3919cb4ae3f00379631b98df5d
Merge: 4804c7f 9b97cb5
Author: Brad King <brad.king at kitware.com>
AuthorDate: Tue May 2 12:24:00 2017 +0000
Commit: Kitware Robot <kwrobot at kitware.com>
CommitDate: Tue May 2 08:24:06 2017 -0400
Merge topic 'add-language-standards-to-more-compilers'
9b97cb55 PGI: Add language standards for PGI
daae564d Cray: Add language standards for the Cray compiler
25e83ce5 CompileFeatures: Let STD compile options be a list
1de70845 Compilers: Add common macros to be used by various compilers
Acked-by: Kitware Robot <kwrobot at kitware.com>
Merge-request: !784
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=4804c7f30ff659420cc0be5491bb77faa47a2f0c
commit 4804c7f30ff659420cc0be5491bb77faa47a2f0c
Merge: 8fba1f4 c273906
Author: Brad King <brad.king at kitware.com>
AuthorDate: Tue May 2 12:22:44 2017 +0000
Commit: Kitware Robot <kwrobot at kitware.com>
CommitDate: Tue May 2 08:22:47 2017 -0400
Merge topic 'doc-no-depend'
c273906f Utilities/Sphinx: Build documentation independently by default
Acked-by: Kitware Robot <kwrobot at kitware.com>
Merge-request: !786
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=8fba1f4a0314dba983dee55190b8f903148a08fe
commit 8fba1f4a0314dba983dee55190b8f903148a08fe
Merge: 96a8b68 c1b2b7c
Author: Brad King <brad.king at kitware.com>
AuthorDate: Tue May 2 12:22:02 2017 +0000
Commit: Kitware Robot <kwrobot at kitware.com>
CommitDate: Tue May 2 08:22:07 2017 -0400
Merge topic 'excludeFixtures'
c1b2b7c0 Add ctest options for limiting which tests fixtures add
Acked-by: Kitware Robot <kwrobot at kitware.com>
Merge-request: !778
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=96a8b68d5a5d5ded8d4477c1185d41dd86d626ea
commit 96a8b68d5a5d5ded8d4477c1185d41dd86d626ea
Merge: 737d05b e17b179
Author: Brad King <brad.king at kitware.com>
AuthorDate: Tue May 2 12:20:34 2017 +0000
Commit: Kitware Robot <kwrobot at kitware.com>
CommitDate: Tue May 2 08:20:38 2017 -0400
Merge topic 'sunpro-c++11-link'
e17b1791 Features: On SunPro link with language standard compiler flag
d037be12 cmLocalGenerator: Add a hook for compiler flags used at link time
b115bc49 Features: Refactor <LANG>_STANDARD update
Acked-by: Kitware Robot <kwrobot at kitware.com>
Merge-request: !783
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=737d05b8f8764f86558ab9a8f2a522035eebc21b
commit 737d05b8f8764f86558ab9a8f2a522035eebc21b
Merge: 96ad8fe 750d58b
Author: Brad King <brad.king at kitware.com>
AuthorDate: Tue May 2 12:19:00 2017 +0000
Commit: Kitware Robot <kwrobot at kitware.com>
CommitDate: Tue May 2 08:19:39 2017 -0400
Merge topic 'update-kwsys'
750d58bf Merge branch 'upstream-KWSys' into update-kwsys
2dec4695 KWSys 2017-05-01 (3ec3252c)
Acked-by: Kitware Robot <kwrobot at kitware.com>
Merge-request: !781
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=96ad8fe60810a25b267cba6fa45f725e2614a003
commit 96ad8fe60810a25b267cba6fa45f725e2614a003
Merge: 7a8068f 6f04dff
Author: Brad King <brad.king at kitware.com>
AuthorDate: Tue May 2 12:18:47 2017 +0000
Commit: Kitware Robot <kwrobot at kitware.com>
CommitDate: Tue May 2 08:18:52 2017 -0400
Merge topic 'FindMatlab-2017a'
6f04dffb FindMatlab: Add support for Matlab 2017a
Acked-by: Kitware Robot <kwrobot at kitware.com>
Merge-request: !780
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=9b97cb5562317ecb6fe65e6185eb6fda2b0ad7d7
commit 9b97cb5562317ecb6fe65e6185eb6fda2b0ad7d7
Author: Chuck Atkins <chuck.atkins at kitware.com>
AuthorDate: Mon May 1 09:20:22 2017 -0400
Commit: Chuck Atkins <chuck.atkins at kitware.com>
CommitDate: Mon May 1 15:15:30 2017 -0400
PGI: Add language standards for PGI
diff --git a/Modules/Compiler/PGI-C.cmake b/Modules/Compiler/PGI-C.cmake
index 85d6e7e..a24e554 100644
--- a/Modules/Compiler/PGI-C.cmake
+++ b/Modules/Compiler/PGI-C.cmake
@@ -2,3 +2,16 @@ include(Compiler/PGI)
__compiler_pgi(C)
string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -DNDEBUG")
+
+if (CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 12.10)
+ set(CMAKE_C90_STANDARD_COMPILE_OPTION -c89)
+ set(CMAKE_C90_EXTENSION_COMPILE_OPTION -c89)
+ set(CMAKE_C99_STANDARD_COMPILE_OPTION -c99)
+ set(CMAKE_C99_EXTENSION_COMPILE_OPTION -c99)
+ if (CMAKE_C_COMPILER_VERSION VERSION_CREATER_EQUAL 15.3)
+ set(CMAKE_C11_STANDARD_COMPILE_OPTION -c11)
+ set(CMAKE_C11_EXTENSION_COMPILE_OPTION -c11)
+ endif ()
+endif ()
+
+__compiler_check_default_language_standard(C 12.10 90)
diff --git a/Modules/Compiler/PGI-CXX.cmake b/Modules/Compiler/PGI-CXX.cmake
index 896e298..abc7349 100644
--- a/Modules/Compiler/PGI-CXX.cmake
+++ b/Modules/Compiler/PGI-CXX.cmake
@@ -2,3 +2,22 @@ include(Compiler/PGI)
__compiler_pgi(CXX)
string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -DNDEBUG")
+
+if(CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 12.10)
+ set(CMAKE_CXX98_STANDARD_COMPILE_OPTION -A)
+ set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION --gnu_extensions)
+ if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 13.10)
+ set(CMAKE_CXX11_STANDARD_COMPILE_OPTION --c++11 -A)
+ set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION --c++11 --gnu_extensions)
+ if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 15.7)
+ set(CMAKE_CXX14_STANDARD_COMPILE_OPTION --c++14 -A)
+ set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION --c++14 --gnu_extensions)
+ if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 17.1)
+ set(CMAKE_CXX17_STANDARD_COMPILE_OPTION --c++17 -A)
+ set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION --c++17 --gnu_extensions)
+ endif()
+ endif()
+ endif()
+endif()
+
+__compiler_check_default_language_standard(CXX 12.10 98)
diff --git a/Modules/Compiler/PGI.cmake b/Modules/Compiler/PGI.cmake
index cc76deb..bdabeba 100644
--- a/Modules/Compiler/PGI.cmake
+++ b/Modules/Compiler/PGI.cmake
@@ -8,6 +8,8 @@ if(__COMPILER_PGI)
endif()
set(__COMPILER_PGI 1)
+include(Compiler/CMakeCommonCompilerMacros)
+
macro(__compiler_pgi lang)
# Feature flags.
set(CMAKE_${lang}_VERBOSE_FLAG "-v")
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=daae564d87044950edece389f09bde423e6ad867
commit daae564d87044950edece389f09bde423e6ad867
Author: Chuck Atkins <chuck.atkins at kitware.com>
AuthorDate: Mon May 1 09:10:14 2017 -0400
Commit: Chuck Atkins <chuck.atkins at kitware.com>
CommitDate: Mon May 1 15:15:30 2017 -0400
Cray: Add language standards for the Cray compiler
diff --git a/Modules/Compiler/Cray-C.cmake b/Modules/Compiler/Cray-C.cmake
index 675560c..87ce20f 100644
--- a/Modules/Compiler/Cray-C.cmake
+++ b/Modules/Compiler/Cray-C.cmake
@@ -1 +1,22 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/Cray)
+
set(CMAKE_C_VERBOSE_FLAG "-v")
+
+string(APPEND CMAKE_C_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_C_FLAGS_RELEASE_INIT " -DNDEBUG")
+
+if (CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
+ set(CMAKE_C90_STANDARD_COMPILE_OPTION -h noc99,conform)
+ set(CMAKE_C90_EXTENSION_COMPILE_OPTION -h noc99,gnu)
+ set(CMAKE_C99_STANDARD_COMPILE_OPTION -h c99,conform)
+ set(CMAKE_C99_EXTENSION_COMPILE_OPTION -h c99,gnu)
+ if (CMAKE_C_COMPILER_VERSION VERSION_GREATER_EQUAL 8.5)
+ set(CMAKE_C11_STANDARD_COMPILE_OPTION -h std=c11,conform)
+ set(CMAKE_C11_EXTENSION_COMPILE_OPTION -h std=c11,gnu)
+ endif ()
+endif ()
+
+__compiler_check_default_language_standard(C 8.1 99)
diff --git a/Modules/Compiler/Cray-CXX.cmake b/Modules/Compiler/Cray-CXX.cmake
index 9fb191c..8506c09 100644
--- a/Modules/Compiler/Cray-CXX.cmake
+++ b/Modules/Compiler/Cray-CXX.cmake
@@ -1 +1,20 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+include(Compiler/Cray)
+
set(CMAKE_CXX_VERBOSE_FLAG "-v")
+
+string(APPEND CMAKE_CXX_FLAGS_MINSIZEREL_INIT " -DNDEBUG")
+string(APPEND CMAKE_CXX_FLAGS_RELEASE_INIT " -DNDEBUG")
+
+if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 8.1)
+ set(CMAKE_CXX98_STANDARD_COMPILE_OPTION -h conform)
+ set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION -h gnu)
+ if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 8.4)
+ set(CMAKE_CXX11_STANDARD_COMPILE_OPTION -h std=c++11)
+ set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION -h std=c++11,gnu)
+ endif ()
+endif ()
+
+__compiler_check_default_language_standard(CXX 8.1 98)
diff --git a/Modules/Compiler/Cray.cmake b/Modules/Compiler/Cray.cmake
new file mode 100644
index 0000000..8fe8eeb
--- /dev/null
+++ b/Modules/Compiler/Cray.cmake
@@ -0,0 +1,10 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# This module is shared by multiple languages; use include blocker.
+if(__COMPILER_CRAY)
+ return()
+endif()
+set(__COMPILER_CRAY 1)
+
+include(Compiler/CMakeCommonCompilerMacros)
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=25e83ce580d7e6821a07198ce13338a82b966c0b
commit 25e83ce580d7e6821a07198ce13338a82b966c0b
Author: Chuck Atkins <chuck.atkins at kitware.com>
AuthorDate: Wed Oct 5 14:54:54 2016 -0400
Commit: Chuck Atkins <chuck.atkins at kitware.com>
CommitDate: Mon May 1 15:15:29 2017 -0400
CompileFeatures: Let STD compile options be a list
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 33e32d1..b9448b3 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -1464,7 +1464,11 @@ void cmLocalGenerator::AddCompilerRequirementFlag(
"does not know the compile flags to use to enable it.";
this->IssueMessage(cmake::FATAL_ERROR, e.str());
} else {
- this->AppendFlagEscape(flags, opt);
+ std::vector<std::string> optVec;
+ cmSystemTools::ExpandListArgument(opt, optVec);
+ for (size_t i = 0; i < optVec.size(); ++i) {
+ this->AppendFlagEscape(flags, optVec[i]);
+ }
}
return;
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=1de7084501aa094858d344f92dd2c9fe744a4e9a
commit 1de7084501aa094858d344f92dd2c9fe744a4e9a
Author: Chuck Atkins <chuck.atkins at kitware.com>
AuthorDate: Mon May 1 09:06:58 2017 -0400
Commit: Chuck Atkins <chuck.atkins at kitware.com>
CommitDate: Mon May 1 15:15:23 2017 -0400
Compilers: Add common macros to be used by various compilers
With numerous compilers now supporting multiple language standards in CMake,
some common design patterns have begun to emerge. This is intended to
be a collection of macros implementing many of those common design
patterns that can be factored out and leveraged by many compilers.
Currently this only contains the code to set the default language
standard of not preset. More functionality will be added in the future
as appropriate.
diff --git a/Modules/Compiler/CMakeCommonCompilerMacros.cmake b/Modules/Compiler/CMakeCommonCompilerMacros.cmake
new file mode 100644
index 0000000..cb365d6
--- /dev/null
+++ b/Modules/Compiler/CMakeCommonCompilerMacros.cmake
@@ -0,0 +1,62 @@
+# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+# This module is shared by multiple languages and compilers; use include guard
+if (__COMPILER_CMAKE_COMMON_COMPILER_MACROS)
+ return()
+endif ()
+set(__COMPILER_CMAKE_COMMON_COMPILER_MACROS 1)
+
+
+# Check that a compiler's language standard is properly detected
+# Parameters:
+# lang - Language to check
+# stdver1 - Minimum version to set a given default for
+# std1 - Default to use for compiler ver >= stdver1
+# stdverN - Minimum version to set a given default for
+# stdN - Default to use for compiler ver >= stdverN
+#
+# The order of stdverN stdN pairs passed as arguments is expected to be in
+# monotonically increasing version order.
+#
+# Note:
+# This macro can be called with multiple version / std pairs to convey that
+# newer compiler versions may use a newer standard default.
+#
+# Example:
+# To specify that compiler version 6.1 and newer defaults to C++11 while
+# 4.8 <= ver < 6.1 default to C++98, you would call:
+#
+# __compiler_check_default_language_standard(CXX 4.8 98 6.1 11)
+#
+macro(__compiler_check_default_language_standard lang stdver1 std1)
+ set(__std_ver_pairs "${stdver1};${std1};${ARGN}")
+ string(REGEX REPLACE " *; *" " " __std_ver_pairs "${__std_ver_pairs}")
+ string(REGEX MATCHALL "[^ ]+ [^ ]+" __std_ver_pairs "${__std_ver_pairs}")
+
+ # If the compiler version is below the threshold of even having CMake
+ # support for language standards, then don't bother.
+ if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL "${stdver1}")
+ if (NOT CMAKE_${lang}_COMPILER_FORCED)
+ if (NOT CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT)
+ message(FATAL_ERROR "CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT should be set for ${CMAKE_${lang}_COMPILER_ID} (${CMAKE_${lang}_COMPILER}) version ${CMAKE_${lang}_COMPILER_VERSION}")
+ endif ()
+ set(CMAKE_${lang}_STANDARD_DEFAULT ${CMAKE_${lang}_STANDARD_COMPUTED_DEFAULT})
+ else ()
+ list(REVERSE __std_ver_pairs)
+ foreach (__std_ver_pair IN LISTS __std_ver_pairs)
+ string(REGEX MATCH "([^ ]+) (.+)" __std_ver_pair "${__std_ver_pair}")
+ set(__stdver ${CMAKE_MATCH_1})
+ set(__std ${CMAKE_MATCH_2})
+ if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL __stdver AND
+ NOT DEFINED CMAKE_${lang}_STANDARD_DEFAULT)
+ # Compiler id was forced so just guess the default standard level.
+ set(CMAKE_${lang}_STANDARD_DEFAULT ${__std})
+ endif ()
+ unset(__std)
+ unset(__stdver)
+ endforeach ()
+ endif ()
+ endif ()
+ unset(__std_ver_pairs)
+endmacro()
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=c273906f48f6e0a84917351288b68a1ec0da64cd
commit c273906f48f6e0a84917351288b68a1ec0da64cd
Author: Brad King <brad.king at kitware.com>
AuthorDate: Mon May 1 13:14:25 2017 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Mon May 1 13:18:25 2017 -0400
Utilities/Sphinx: Build documentation independently by default
Previously we made the `documentation` target depend on the executable
targets. There is no real reason to do this other than serializing the
documentation build output in terminals. Move this dependency behind an
undocumented option so that it is not on by default.
diff --git a/Utilities/Sphinx/CMakeLists.txt b/Utilities/Sphinx/CMakeLists.txt
index edb9469..a29380c 100644
--- a/Utilities/Sphinx/CMakeLists.txt
+++ b/Utilities/Sphinx/CMakeLists.txt
@@ -128,18 +128,20 @@ endforeach()
add_custom_target(documentation ALL DEPENDS ${doc_format_outputs})
-foreach(t
- cmake
- ccmake
- cmake-gui
- cpack
- ctest
- )
- if(TARGET ${t})
- # Build documentation after main executables.
- add_dependencies(documentation ${t})
- endif()
-endforeach()
+if(CMake_SPHINX_DEPEND_ON_EXECUTABLES)
+ foreach(t
+ cmake
+ ccmake
+ cmake-gui
+ cpack
+ ctest
+ )
+ if(TARGET ${t})
+ # Build documentation after main executables.
+ add_dependencies(documentation ${t})
+ endif()
+ endforeach()
+endif()
if(SPHINX_MAN)
file(GLOB man_rst RELATIVE ${CMake_SOURCE_DIR}/Help/manual
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=c1b2b7c03c899c9b066840600ec15b16ae2fa9ac
commit c1b2b7c03c899c9b066840600ec15b16ae2fa9ac
Author: Craig Scott <craig.scott at crascit.com>
AuthorDate: Sat Apr 22 19:38:55 2017 +1000
Commit: Craig Scott <craig.scott at crascit.com>
CommitDate: Tue May 2 01:54:13 2017 +1000
Add ctest options for limiting which tests fixtures add
The new options allow the user to restrict the setup and cleanup tests
automatically added for fixtures.
diff --git a/Help/command/ctest_memcheck.rst b/Help/command/ctest_memcheck.rst
index a983d68..288b65a 100644
--- a/Help/command/ctest_memcheck.rst
+++ b/Help/command/ctest_memcheck.rst
@@ -13,6 +13,9 @@ Perform the :ref:`CTest MemCheck Step` as a :ref:`Dashboard Client`.
[INCLUDE <include-regex>]
[EXCLUDE_LABEL <label-exclude-regex>]
[INCLUDE_LABEL <label-include-regex>]
+ [EXCLUDE_FIXTURE <regex>]
+ [EXCLUDE_FIXTURE_SETUP <regex>]
+ [EXCLUDE_FIXTURE_CLEANUP <regex>]
[PARALLEL_LEVEL <level>]
[TEST_LOAD <threshold>]
[SCHEDULE_RANDOM <ON|OFF>]
diff --git a/Help/command/ctest_test.rst b/Help/command/ctest_test.rst
index ce50d42..4a69491 100644
--- a/Help/command/ctest_test.rst
+++ b/Help/command/ctest_test.rst
@@ -13,6 +13,9 @@ Perform the :ref:`CTest Test Step` as a :ref:`Dashboard Client`.
[INCLUDE <include-regex>]
[EXCLUDE_LABEL <label-exclude-regex>]
[INCLUDE_LABEL <label-include-regex>]
+ [EXCLUDE_FIXTURE <regex>]
+ [EXCLUDE_FIXTURE_SETUP <regex>]
+ [EXCLUDE_FIXTURE_CLEANUP <regex>]
[PARALLEL_LEVEL <level>]
[TEST_LOAD <threshold>]
[SCHEDULE_RANDOM <ON|OFF>]
@@ -61,6 +64,20 @@ The options are:
Specify a regular expression matching test labels to include.
Tests not matching this expression are excluded.
+``EXCLUDE_FIXTURE <regex>``
+ If a test in the set of tests to be executed requires a particular fixture,
+ that fixture's setup and cleanup tests would normally be added to the test
+ set automatically. This option prevents adding setup or cleanup tests for
+ fixtures matching the ``<regex>``. Note that all other fixture behavior is
+ retained, including test dependencies and skipping tests that have fixture
+ setup tests that fail.
+
+``EXCLUDE_FIXTURE_SETUP <regex>``
+ Same as ``EXCLUDE_FIXTURE`` except only matching setup tests are excluded.
+
+``EXCLUDE_FIXTURE_CLEANUP <regex>``
+ Same as ``EXCLUDE_FIXTURE`` except only matching cleanup tests are excluded.
+
``PARALLEL_LEVEL <level>``
Specify a positive number representing the number of tests to
be run in parallel.
diff --git a/Help/manual/ctest.1.rst b/Help/manual/ctest.1.rst
index ce81578..a89c4e9 100644
--- a/Help/manual/ctest.1.rst
+++ b/Help/manual/ctest.1.rst
@@ -117,6 +117,23 @@ Options
This option tells ctest to NOT run the tests whose labels match the
given regular expression.
+``-FA <regex>, --fixture-exclude-any <regex>``
+ Exclude fixtures matching ``<regex>`` from automatically adding any tests to
+ the test set.
+
+ If a test in the set of tests to be executed requires a particular fixture,
+ that fixture's setup and cleanup tests would normally be added to the test set
+ automatically. This option prevents adding setup or cleanup tests for fixtures
+ matching the ``<regex>``. Note that all other fixture behavior is retained,
+ including test dependencies and skipping tests that have fixture setup tests
+ that fail.
+
+``-FS <regex>, --fixture-exclude-setup <regex>``
+ Same as ``-FA`` except only matching setup tests are excluded.
+
+``-FC <regex>, --fixture-exclude-cleanup <regex>``
+ Same as ``-FA`` except only matching cleanup tests are excluded.
+
``-D <dashboard>, --dashboard <dashboard>``
Execute dashboard test.
diff --git a/Help/release/dev/excludeFixtures.rst b/Help/release/dev/excludeFixtures.rst
new file mode 100644
index 0000000..56d4226
--- /dev/null
+++ b/Help/release/dev/excludeFixtures.rst
@@ -0,0 +1,9 @@
+excludeFixtures
+---------------
+
+* The :manual:`ctest(1)` executable gained new options which allow the
+ developer to disable automatically adding tests to the test set to satisfy
+ fixture dependencies. ``-FS`` prevents adding setup tests for fixtures
+ matching the provided regular expression, ``-FC`` prevents adding cleanup
+ tests for matching fixtures and ``-FA`` prevents adding any test for matching
+ fixtures.
diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx
index 21b1003..075b140 100644
--- a/Source/CTest/cmCTestTestCommand.cxx
+++ b/Source/CTest/cmCTestTestCommand.cxx
@@ -20,6 +20,9 @@ cmCTestTestCommand::cmCTestTestCommand()
this->Arguments[ctt_INCLUDE] = "INCLUDE";
this->Arguments[ctt_EXCLUDE_LABEL] = "EXCLUDE_LABEL";
this->Arguments[ctt_INCLUDE_LABEL] = "INCLUDE_LABEL";
+ this->Arguments[ctt_EXCLUDE_FIXTURE] = "EXCLUDE_FIXTURE";
+ this->Arguments[ctt_EXCLUDE_FIXTURE_SETUP] = "EXCLUDE_FIXTURE_SETUP";
+ this->Arguments[ctt_EXCLUDE_FIXTURE_CLEANUP] = "EXCLUDE_FIXTURE_CLEANUP";
this->Arguments[ctt_PARALLEL_LEVEL] = "PARALLEL_LEVEL";
this->Arguments[ctt_SCHEDULE_RANDOM] = "SCHEDULE_RANDOM";
this->Arguments[ctt_STOP_TIME] = "STOP_TIME";
@@ -76,6 +79,18 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
handler->SetOption("LabelRegularExpression",
this->Values[ctt_INCLUDE_LABEL]);
}
+ if (this->Values[ctt_EXCLUDE_FIXTURE]) {
+ handler->SetOption("ExcludeFixtureRegularExpression",
+ this->Values[ctt_EXCLUDE_FIXTURE]);
+ }
+ if (this->Values[ctt_EXCLUDE_FIXTURE_SETUP]) {
+ handler->SetOption("ExcludeFixtureSetupRegularExpression",
+ this->Values[ctt_EXCLUDE_FIXTURE_SETUP]);
+ }
+ if (this->Values[ctt_EXCLUDE_FIXTURE_CLEANUP]) {
+ handler->SetOption("ExcludeFixtureCleanupRegularExpression",
+ this->Values[ctt_EXCLUDE_FIXTURE_CLEANUP]);
+ }
if (this->Values[ctt_PARALLEL_LEVEL]) {
handler->SetOption("ParallelLevel", this->Values[ctt_PARALLEL_LEVEL]);
}
diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h
index 1893104..be7e783 100644
--- a/Source/CTest/cmCTestTestCommand.h
+++ b/Source/CTest/cmCTestTestCommand.h
@@ -53,6 +53,9 @@ protected:
ctt_INCLUDE,
ctt_EXCLUDE_LABEL,
ctt_INCLUDE_LABEL,
+ ctt_EXCLUDE_FIXTURE,
+ ctt_EXCLUDE_FIXTURE_SETUP,
+ ctt_EXCLUDE_FIXTURE_CLEANUP,
ctt_PARALLEL_LEVEL,
ctt_SCHEDULE_RANDOM,
ctt_STOP_TIME,
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index d73811b..a5cc1fa 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -362,6 +362,9 @@ void cmCTestTestHandler::Initialize()
this->ExcludeLabelRegularExpression = "";
this->IncludeRegExp = "";
this->ExcludeRegExp = "";
+ this->ExcludeFixtureRegExp.clear();
+ this->ExcludeFixtureSetupRegExp.clear();
+ this->ExcludeFixtureCleanupRegExp.clear();
TestsToRunString = "";
this->UseUnion = false;
@@ -439,6 +442,18 @@ int cmCTestTestHandler::ProcessHandler()
this->UseExcludeRegExp();
this->SetExcludeRegExp(val);
}
+ val = this->GetOption("ExcludeFixtureRegularExpression");
+ if (val) {
+ this->ExcludeFixtureRegExp = val;
+ }
+ val = this->GetOption("ExcludeFixtureSetupRegularExpression");
+ if (val) {
+ this->ExcludeFixtureSetupRegExp = val;
+ }
+ val = this->GetOption("ExcludeFixtureCleanupRegularExpression");
+ if (val) {
+ this->ExcludeFixtureCleanupRegExp = val;
+ }
this->SetRerunFailed(cmSystemTools::IsOn(this->GetOption("RerunFailed")));
this->TestResults.clear();
@@ -828,13 +843,35 @@ void cmCTestTestHandler::UpdateForFixtures(ListOfTests& tests) const
"Updating test list for fixtures" << std::endl,
this->Quiet);
+ // Prepare regular expression evaluators
+ std::string setupRegExp(this->ExcludeFixtureRegExp);
+ std::string cleanupRegExp(this->ExcludeFixtureRegExp);
+ if (!this->ExcludeFixtureSetupRegExp.empty()) {
+ if (setupRegExp.empty()) {
+ setupRegExp = this->ExcludeFixtureSetupRegExp;
+ } else {
+ setupRegExp.append("(" + setupRegExp + ")|(" +
+ this->ExcludeFixtureSetupRegExp + ")");
+ }
+ }
+ if (!this->ExcludeFixtureCleanupRegExp.empty()) {
+ if (cleanupRegExp.empty()) {
+ cleanupRegExp = this->ExcludeFixtureCleanupRegExp;
+ } else {
+ cleanupRegExp.append("(" + cleanupRegExp + ")|(" +
+ this->ExcludeFixtureCleanupRegExp + ")");
+ }
+ }
+ cmsys::RegularExpression excludeSetupRegex(setupRegExp);
+ cmsys::RegularExpression excludeCleanupRegex(cleanupRegExp);
+
// Prepare some maps to help us find setup and cleanup tests for
// any given fixture
typedef ListOfTests::const_iterator TestIterator;
typedef std::multimap<std::string, TestIterator> FixtureDependencies;
typedef FixtureDependencies::const_iterator FixtureDepsIterator;
FixtureDependencies fixtureSetups;
- FixtureDependencies fixtureDeps;
+ FixtureDependencies fixtureCleanups;
for (ListOfTests::const_iterator it = this->TestList.begin();
it != this->TestList.end(); ++it) {
@@ -844,13 +881,12 @@ void cmCTestTestHandler::UpdateForFixtures(ListOfTests& tests) const
for (std::set<std::string>::const_iterator depsIt = setups.begin();
depsIt != setups.end(); ++depsIt) {
fixtureSetups.insert(std::make_pair(*depsIt, it));
- fixtureDeps.insert(std::make_pair(*depsIt, it));
}
const std::set<std::string>& cleanups = p.FixturesCleanup;
for (std::set<std::string>::const_iterator depsIt = cleanups.begin();
depsIt != cleanups.end(); ++depsIt) {
- fixtureDeps.insert(std::make_pair(*depsIt, it));
+ fixtureCleanups.insert(std::make_pair(*depsIt, it));
}
}
@@ -924,34 +960,72 @@ void cmCTestTestHandler::UpdateForFixtures(ListOfTests& tests) const
// added from a previously checked test). A fixture isn't required
// to have setup/cleanup tests.
if (!addedFixtures.insert(requiredFixtureName).second) {
- // Already added this fixture
+ // Already seen this fixture, no need to check it again
continue;
}
- std::pair<FixtureDepsIterator, FixtureDepsIterator> fixtureRange =
- fixtureDeps.equal_range(requiredFixtureName);
- for (FixtureDepsIterator it = fixtureRange.first;
- it != fixtureRange.second; ++it) {
- ListOfTests::const_iterator lotIt = it->second;
- const cmCTestTestProperties& p = *lotIt;
-
- if (!addedTests.insert(p.Name).second) {
- // Already have p in our test list
- continue;
+
+ // Only add setup tests if this fixture has not been excluded
+ if (setupRegExp.empty() ||
+ !excludeSetupRegex.find(requiredFixtureName)) {
+ std::pair<FixtureDepsIterator, FixtureDepsIterator> fixtureRange =
+ fixtureSetups.equal_range(requiredFixtureName);
+ for (FixtureDepsIterator it = fixtureRange.first;
+ it != fixtureRange.second; ++it) {
+ ListOfTests::const_iterator lotIt = it->second;
+ const cmCTestTestProperties& p = *lotIt;
+
+ if (!addedTests.insert(p.Name).second) {
+ // Already have p in our test list
+ continue;
+ }
+
+ // This is a test not yet in our list, so add it and
+ // update its index to reflect where it was in the original
+ // full list of all tests (needed to track individual tests
+ // across ctest runs for re-run failed, etc.)
+ tests.push_back(p);
+ tests.back().Index =
+ 1 + static_cast<int>(std::distance(this->TestList.begin(), lotIt));
+ ++fixtureTestsAdded;
+
+ cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+ "Added setup test "
+ << p.Name << " required by fixture "
+ << requiredFixtureName << std::endl,
+ this->Quiet);
}
+ }
- // This is a test not yet in our list, so add it and
- // update its index to reflect where it was in the original
- // full list of all tests (needed to track individual tests
- // across ctest runs for re-run failed, etc.)
- tests.push_back(p);
- tests.back().Index =
- 1 + static_cast<int>(std::distance(this->TestList.begin(), lotIt));
- ++fixtureTestsAdded;
-
- cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Added test "
- << p.Name << " required by fixture "
- << requiredFixtureName << std::endl,
- this->Quiet);
+ // Only add cleanup tests if this fixture has not been excluded
+ if (cleanupRegExp.empty() ||
+ !excludeCleanupRegex.find(requiredFixtureName)) {
+ std::pair<FixtureDepsIterator, FixtureDepsIterator> fixtureRange =
+ fixtureCleanups.equal_range(requiredFixtureName);
+ for (FixtureDepsIterator it = fixtureRange.first;
+ it != fixtureRange.second; ++it) {
+ ListOfTests::const_iterator lotIt = it->second;
+ const cmCTestTestProperties& p = *lotIt;
+
+ if (!addedTests.insert(p.Name).second) {
+ // Already have p in our test list
+ continue;
+ }
+
+ // This is a test not yet in our list, so add it and
+ // update its index to reflect where it was in the original
+ // full list of all tests (needed to track individual tests
+ // across ctest runs for re-run failed, etc.)
+ tests.push_back(p);
+ tests.back().Index =
+ 1 + static_cast<int>(std::distance(this->TestList.begin(), lotIt));
+ ++fixtureTestsAdded;
+
+ cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+ "Added cleanup test "
+ << p.Name << " required by fixture "
+ << requiredFixtureName << std::endl,
+ this->Quiet);
+ }
}
}
diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h
index 3700f8a..0edcb14 100644
--- a/Source/CTest/cmCTestTestHandler.h
+++ b/Source/CTest/cmCTestTestHandler.h
@@ -280,6 +280,9 @@ private:
std::string ExcludeLabelRegExp;
std::string IncludeRegExp;
std::string ExcludeRegExp;
+ std::string ExcludeFixtureRegExp;
+ std::string ExcludeFixtureSetupRegExp;
+ std::string ExcludeFixtureCleanupRegExp;
cmsys::RegularExpression IncludeLabelRegularExpression;
cmsys::RegularExpression ExcludeLabelRegularExpression;
cmsys::RegularExpression IncludeTestsRegularExpression;
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 46fa86e..010221e 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -1899,6 +1899,34 @@ bool cmCTest::HandleCommandLineArguments(size_t& i,
->SetPersistentOption("ExcludeRegularExpression", args[i].c_str());
}
+ if (this->CheckArgument(arg, "-FA", "--fixture-exclude-any") &&
+ i < args.size() - 1) {
+ i++;
+ this->GetHandler("test")->SetPersistentOption(
+ "ExcludeFixtureRegularExpression", args[i].c_str());
+ this->GetHandler("memcheck")
+ ->SetPersistentOption("ExcludeFixtureRegularExpression",
+ args[i].c_str());
+ }
+ if (this->CheckArgument(arg, "-FS", "--fixture-exclude-setup") &&
+ i < args.size() - 1) {
+ i++;
+ this->GetHandler("test")->SetPersistentOption(
+ "ExcludeFixtureSetupRegularExpression", args[i].c_str());
+ this->GetHandler("memcheck")
+ ->SetPersistentOption("ExcludeFixtureSetupRegularExpression",
+ args[i].c_str());
+ }
+ if (this->CheckArgument(arg, "-FC", "--fixture-exclude-cleanup") &&
+ i < args.size() - 1) {
+ i++;
+ this->GetHandler("test")->SetPersistentOption(
+ "ExcludeFixtureCleanupRegularExpression", args[i].c_str());
+ this->GetHandler("memcheck")
+ ->SetPersistentOption("ExcludeFixtureCleanupRegularExpression",
+ args[i].c_str());
+ }
+
if (this->CheckArgument(arg, "--rerun-failed")) {
this->GetHandler("test")->SetPersistentOption("RerunFailed", "true");
this->GetHandler("memcheck")->SetPersistentOption("RerunFailed", "true");
diff --git a/Source/ctest.cxx b/Source/ctest.cxx
index 135062d..15d4cf4 100644
--- a/Source/ctest.cxx
+++ b/Source/ctest.cxx
@@ -52,6 +52,18 @@ static const char* cmDocumentationOptions[][2] = {
"expression." },
{ "-LE <regex>, --label-exclude <regex>", "Exclude tests with labels "
"matching regular expression." },
+ { "-FA <regex>, --fixture-exclude-any <regex>", "Do not automatically "
+ "add any tests for "
+ "fixtures matching "
+ "regular expression." },
+ { "-FS <regex>, --fixture-exclude-setup <regex>", "Do not automatically "
+ "add setup tests for "
+ "fixtures matching "
+ "regular expression." },
+ { "-FC <regex>, --fixture-exclude-cleanup <regex>", "Do not automatically "
+ "add cleanup tests for "
+ "fixtures matching "
+ "regular expression." },
{ "-D <dashboard>, --dashboard <dashboard>", "Execute dashboard test" },
{ "-D <var>:<type>=<value>", "Define a variable for script mode" },
{ "-M <model>, --test-model <model>", "Sets the model for a dashboard" },
diff --git a/Tests/RunCMake/ctest_fixtures/CMakeLists.txt.in b/Tests/RunCMake/ctest_fixtures/CMakeLists.txt.in
index ab50fdd..5cb0b4e 100644
--- a/Tests/RunCMake/ctest_fixtures/CMakeLists.txt.in
+++ b/Tests/RunCMake/ctest_fixtures/CMakeLists.txt.in
@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 3.6.2)
+cmake_minimum_required (VERSION 3.8.0)
project(ctest_fixtures LANGUAGES NONE)
include(CTest)
diff --git a/Tests/RunCMake/ctest_fixtures/RunCMakeTest.cmake b/Tests/RunCMake/ctest_fixtures/RunCMakeTest.cmake
index 673cf57..1754203 100644
--- a/Tests/RunCMake/ctest_fixtures/RunCMakeTest.cmake
+++ b/Tests/RunCMake/ctest_fixtures/RunCMakeTest.cmake
@@ -19,6 +19,41 @@ run_ctest_test(setupFoo INCLUDE setupFoo)
run_ctest_test(wontRun INCLUDE wontRun)
run_ctest_test(unused INCLUDE Unused)
+run_ctest_test(exclude_setup_foo
+ INCLUDE "one|two"
+ EXCLUDE_FIXTURE_SETUP "Foo"
+)
+
+run_ctest_test(exclude_setup_bar
+ INCLUDE "one|two"
+ EXCLUDE_FIXTURE_SETUP "Bar"
+)
+
+run_ctest_test(exclude_cleanup_foo
+ INCLUDE "one|two"
+ EXCLUDE_FIXTURE_CLEANUP "Foo"
+)
+
+run_ctest_test(exclude_cleanup_bar
+ INCLUDE "one|two"
+ EXCLUDE_FIXTURE_CLEANUP "Bar"
+)
+
+run_ctest_test(exclude_any_foo
+ INCLUDE "one|two"
+ EXCLUDE_FIXTURE "Foo"
+)
+
+run_ctest_test(exclude_any_bar
+ INCLUDE "one|two"
+ EXCLUDE_FIXTURE "Bar"
+)
+
+run_ctest_test(exclude_any_foobar
+ INCLUDE "one|two"
+ EXCLUDE_FIXTURE "Foo|Bar"
+)
+
#------------------------------------------------------------
# CMake configure will fail due to cyclic test dependencies
#------------------------------------------------------------
@@ -35,3 +70,18 @@ set(CASE_CMAKELISTS_CYCLIC_CODE [[
FIXTURES_REQUIRED "Foo")
]])
run_ctest(cyclicCleanup)
+
+#------------------------------------------------------------
+# Repeat some of the exclusion tests with ctest command line
+# options instead of arguments to ctest_test(). This verifies
+# that the command line options make it through as well.
+#------------------------------------------------------------
+unset(CASE_CMAKELISTS_CYCLIC_CODE)
+set(CASE_CTEST_FIXTURES_ARGS "")
+
+run_ctest(exclude_setup_foo -R "one|two" -FS Foo)
+run_ctest(exclude_setup_foo -R "one|two" --fixture-exclude-setup Foo)
+run_ctest(exclude_cleanup_foo -R "one|two" -FC Foo)
+run_ctest(exclude_cleanup_foo -R "one|two" --fixture-exclude-cleanup Foo)
+run_ctest(exclude_any_foo -R "one|two" -FA Foo)
+run_ctest(exclude_any_foo -R "one|two" --fixture-exclude-any Foo)
diff --git a/Tests/RunCMake/ctest_fixtures/exclude_any_bar-stdout.txt b/Tests/RunCMake/ctest_fixtures/exclude_any_bar-stdout.txt
new file mode 100644
index 0000000..82663d5
--- /dev/null
+++ b/Tests/RunCMake/ctest_fixtures/exclude_any_bar-stdout.txt
@@ -0,0 +1,15 @@
+Test project .*/Tests/RunCMake/ctest_fixtures/exclude_any_bar-build
+ Start 3: setupFoo
+1/5 Test #3: setupFoo +\.+ +Passed +[0-9.]+ sec
+ Start 2: setupBoth
+2/5 Test #2: setupBoth +\.+ +Passed +[0-9.]+ sec
+ Start 1: one
+3/5 Test #1: one +\.+ +Passed +[0-9.]+ sec
+ Start 5: cleanupFoo
+4/5 Test #5: cleanupFoo +\.+ +Passed +[0-9.]+ sec
+ Start 6: two
+5/5 Test #6: two +\.+ +Passed +[0-9.]+ sec
++
+100% tests passed, 0 tests failed out of 5
++
+Total Test time \(real\) = +[0-9.]+ sec$
diff --git a/Tests/RunCMake/ctest_fixtures/exclude_any_foo-stdout.txt b/Tests/RunCMake/ctest_fixtures/exclude_any_foo-stdout.txt
new file mode 100644
index 0000000..8c08d08
--- /dev/null
+++ b/Tests/RunCMake/ctest_fixtures/exclude_any_foo-stdout.txt
@@ -0,0 +1,13 @@
+Test project .*/Tests/RunCMake/ctest_fixtures/exclude_any_foo-build
+ Start 2: setupBoth
+1/4 Test #2: setupBoth +\.+ +Passed +[0-9.]+ sec
+ Start 1: one
+2/4 Test #1: one +\.+ +Passed +[0-9.]+ sec
+ Start 6: two
+3/4 Test #6: two +\.+ +Passed +[0-9.]+ sec
+ Start 7: cleanupBar
+4/4 Test #7: cleanupBar +\.+ +Passed +[0-9.]+ sec
++
+100% tests passed, 0 tests failed out of 4
++
+Total Test time \(real\) = +[0-9.]+ sec$
diff --git a/Tests/RunCMake/ctest_fixtures/exclude_any_foobar-stdout.txt b/Tests/RunCMake/ctest_fixtures/exclude_any_foobar-stdout.txt
new file mode 100644
index 0000000..876768b
--- /dev/null
+++ b/Tests/RunCMake/ctest_fixtures/exclude_any_foobar-stdout.txt
@@ -0,0 +1,9 @@
+Test project .*/Tests/RunCMake/ctest_fixtures/exclude_any_foobar-build
+ Start 1: one
+1/2 Test #1: one +\.+ +Passed +[0-9.]+ sec
+ Start 6: two
+2/2 Test #6: two +\.+ +Passed +[0-9.]+ sec
++
+100% tests passed, 0 tests failed out of 2
++
+Total Test time \(real\) = +[0-9.]+ sec$
diff --git a/Tests/RunCMake/ctest_fixtures/exclude_cleanup_bar-stdout.txt b/Tests/RunCMake/ctest_fixtures/exclude_cleanup_bar-stdout.txt
new file mode 100644
index 0000000..0d27198
--- /dev/null
+++ b/Tests/RunCMake/ctest_fixtures/exclude_cleanup_bar-stdout.txt
@@ -0,0 +1,15 @@
+Test project .*/Tests/RunCMake/ctest_fixtures/exclude_cleanup_bar-build
+ Start 3: setupFoo
+1/5 Test #3: setupFoo +\.+ +Passed +[0-9.]+ sec
+ Start 2: setupBoth
+2/5 Test #2: setupBoth +\.+ +Passed +[0-9.]+ sec
+ Start 1: one
+3/5 Test #1: one +\.+ +Passed +[0-9.]+ sec
+ Start 5: cleanupFoo
+4/5 Test #5: cleanupFoo +\.+ +Passed +[0-9.]+ sec
+ Start 6: two
+5/5 Test #6: two +\.+ +Passed +[0-9.]+ sec
++
+100% tests passed, 0 tests failed out of 5
++
+Total Test time \(real\) = +[0-9.]+ sec$
diff --git a/Tests/RunCMake/ctest_fixtures/exclude_cleanup_foo-stdout.txt b/Tests/RunCMake/ctest_fixtures/exclude_cleanup_foo-stdout.txt
new file mode 100644
index 0000000..5b201a3
--- /dev/null
+++ b/Tests/RunCMake/ctest_fixtures/exclude_cleanup_foo-stdout.txt
@@ -0,0 +1,15 @@
+Test project .*/Tests/RunCMake/ctest_fixtures/exclude_cleanup_foo-build
+ Start 3: setupFoo
+1/5 Test #3: setupFoo +\.+ +Passed +[0-9.]+ sec
+ Start 2: setupBoth
+2/5 Test #2: setupBoth +\.+ +Passed +[0-9.]+ sec
+ Start 1: one
+3/5 Test #1: one +\.+ +Passed +[0-9.]+ sec
+ Start 6: two
+4/5 Test #6: two +\.+ +Passed +[0-9.]+ sec
+ Start 7: cleanupBar
+5/5 Test #7: cleanupBar +\.+ +Passed +[0-9.]+ sec
++
+100% tests passed, 0 tests failed out of 5
++
+Total Test time \(real\) = +[0-9.]+ sec$
diff --git a/Tests/RunCMake/ctest_fixtures/exclude_setup_bar-stdout.txt b/Tests/RunCMake/ctest_fixtures/exclude_setup_bar-stdout.txt
new file mode 100644
index 0000000..5357fef
--- /dev/null
+++ b/Tests/RunCMake/ctest_fixtures/exclude_setup_bar-stdout.txt
@@ -0,0 +1,17 @@
+Test project .*/Tests/RunCMake/ctest_fixtures/exclude_setup_bar-build
+ Start 3: setupFoo
+1/6 Test #3: setupFoo +\.+ +Passed +[0-9.]+ sec
+ Start 2: setupBoth
+2/6 Test #2: setupBoth +\.+ +Passed +[0-9.]+ sec
+ Start 1: one
+3/6 Test #1: one +\.+ +Passed +[0-9.]+ sec
+ Start 5: cleanupFoo
+4/6 Test #5: cleanupFoo +\.+ +Passed +[0-9.]+ sec
+ Start 6: two
+5/6 Test #6: two +\.+ +Passed +[0-9.]+ sec
+ Start 7: cleanupBar
+6/6 Test #7: cleanupBar +\.+ +Passed +[0-9.]+ sec
++
+100% tests passed, 0 tests failed out of 6
++
+Total Test time \(real\) = +[0-9.]+ sec$
diff --git a/Tests/RunCMake/ctest_fixtures/exclude_setup_foo-stdout.txt b/Tests/RunCMake/ctest_fixtures/exclude_setup_foo-stdout.txt
new file mode 100644
index 0000000..89f7f44
--- /dev/null
+++ b/Tests/RunCMake/ctest_fixtures/exclude_setup_foo-stdout.txt
@@ -0,0 +1,15 @@
+Test project .*/Tests/RunCMake/ctest_fixtures/exclude_setup_foo-build
+ Start 2: setupBoth
+1/5 Test #2: setupBoth +\.+ +Passed +[0-9.]+ sec
+ Start 1: one
+2/5 Test #1: one +\.+ +Passed +[0-9.]+ sec
+ Start 5: cleanupFoo
+3/5 Test #5: cleanupFoo +\.+ +Passed +[0-9.]+ sec
+ Start 6: two
+4/5 Test #6: two +\.+ +Passed +[0-9.]+ sec
+ Start 7: cleanupBar
+5/5 Test #7: cleanupBar +\.+ +Passed +[0-9.]+ sec
++
+100% tests passed, 0 tests failed out of 5
++
+Total Test time \(real\) = +[0-9.]+ sec$
diff --git a/Tests/RunCMake/ctest_fixtures/test.cmake.in b/Tests/RunCMake/ctest_fixtures/test.cmake.in
index 43df172..7067117 100644
--- a/Tests/RunCMake/ctest_fixtures/test.cmake.in
+++ b/Tests/RunCMake/ctest_fixtures/test.cmake.in
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.6.2)
+cmake_minimum_required(VERSION 3.8.0)
set(CTEST_SITE "test-site")
set(CTEST_BUILD_NAME "test-build-name")
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=e17b1791843b473d0d57ccdbe98689d1be8228e2
commit e17b1791843b473d0d57ccdbe98689d1be8228e2
Author: Brad King <brad.king at kitware.com>
AuthorDate: Fri Apr 28 14:45:11 2017 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Mon May 1 10:33:06 2017 -0400
Features: On SunPro link with language standard compiler flag
When C++ feature requirements or `CXX_STANDARD` cause us to compile
on SunPro with the `-std=c++11` option, link with the option too.
This is needed to make the compiler use the matching standard library.
diff --git a/Modules/Compiler/SunPro-CXX.cmake b/Modules/Compiler/SunPro-CXX.cmake
index f4345b8..b4183db 100644
--- a/Modules/Compiler/SunPro-CXX.cmake
+++ b/Modules/Compiler/SunPro-CXX.cmake
@@ -36,6 +36,7 @@ if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.13)
set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "")
set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=c++11")
+ set(CMAKE_CXX_LINK_WITH_STANDARD_COMPILE_OPTION 1)
endif()
if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.13)
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index dd1b86f..8ce158b 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -1321,6 +1321,15 @@ void cmLocalGenerator::AddLanguageFlagsForLinking(
std::string& flags, cmGeneratorTarget const* target, const std::string& lang,
const std::string& config)
{
+ if (this->Makefile->IsOn("CMAKE_" + lang +
+ "_LINK_WITH_STANDARD_COMPILE_OPTION")) {
+ // This toolchain requires use of the language standard flag
+ // when linking in order to use the matching standard library.
+ // FIXME: If CMake gains an abstraction for standard library
+ // selection, this will have to be reconciled with it.
+ this->AddCompilerRequirementFlag(flags, target, lang);
+ }
+
this->AddLanguageFlags(flags, target, lang, config);
}
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=d037be122e15fb3860869e07a0b6ccd8e7d4d94a
commit d037be122e15fb3860869e07a0b6ccd8e7d4d94a
Author: Brad King <brad.king at kitware.com>
AuthorDate: Fri Apr 28 14:30:00 2017 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Mon May 1 10:33:05 2017 -0400
cmLocalGenerator: Add a hook for compiler flags used at link time
When using a compiler to drive linking we add compiler flags from
`CMAKE_<LANG>_FLAGS` in case they affect the way the compiler invokes
the linker, but we don't add flags from other places that are meant only
for compiling sources. Rather than calling the `AddLanguageFlags`
method (which is used to add flags for compiling sources) directly, add
an intermediate method that is used when adding the flags for linking.
This will give us a way to add language-specific compiler flags needed
when driving the linker in the same place on the command line as other
compiler flags go.
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 6c8f132..dd1b86f 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -1002,7 +1002,7 @@ void cmLocalGenerator::GetTargetFlags(
target->GetName().c_str());
return;
}
- this->AddLanguageFlags(flags, target, linkLanguage, buildType);
+ this->AddLanguageFlagsForLinking(flags, target, linkLanguage, buildType);
if (pcli) {
this->OutputLinkLibraries(pcli, linkLineComputer, linkLibs,
frameworkPath, linkPath);
@@ -1317,6 +1317,13 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
}
}
+void cmLocalGenerator::AddLanguageFlagsForLinking(
+ std::string& flags, cmGeneratorTarget const* target, const std::string& lang,
+ const std::string& config)
+{
+ this->AddLanguageFlags(flags, target, lang, config);
+}
+
cmGeneratorTarget* cmLocalGenerator::FindGeneratorTargetToUse(
const std::string& name) const
{
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 7d591ac..e888094 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -102,6 +102,10 @@ public:
void AddLanguageFlags(std::string& flags, cmGeneratorTarget const* target,
const std::string& lang, const std::string& config);
+ void AddLanguageFlagsForLinking(std::string& flags,
+ cmGeneratorTarget const* target,
+ const std::string& lang,
+ const std::string& config);
void AddCMP0018Flags(std::string& flags, cmGeneratorTarget const* target,
std::string const& lang, const std::string& config);
void AddVisibilityPresetFlags(std::string& flags,
diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx
index fb39f01..359b9fd 100644
--- a/Source/cmMakefileExecutableTargetGenerator.cxx
+++ b/Source/cmMakefileExecutableTargetGenerator.cxx
@@ -150,8 +150,8 @@ void cmMakefileExecutableTargetGenerator::WriteDeviceExecutableRule(
linkLanguage, *this->GeneratorTarget));
// Add language feature flags.
- this->LocalGenerator->AddLanguageFlags(flags, this->GeneratorTarget,
- linkLanguage, this->ConfigName);
+ this->LocalGenerator->AddLanguageFlagsForLinking(
+ flags, this->GeneratorTarget, linkLanguage, this->ConfigName);
this->LocalGenerator->AddArchitectureFlags(flags, this->GeneratorTarget,
linkLanguage, this->ConfigName);
@@ -434,8 +434,8 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink)
}
// Add language feature flags.
- this->LocalGenerator->AddLanguageFlags(flags, this->GeneratorTarget,
- linkLanguage, this->ConfigName);
+ this->LocalGenerator->AddLanguageFlagsForLinking(
+ flags, this->GeneratorTarget, linkLanguage, this->ConfigName);
this->LocalGenerator->AddArchitectureFlags(flags, this->GeneratorTarget,
linkLanguage, this->ConfigName);
diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx
index 5ee9f45..2b37b4d 100644
--- a/Source/cmMakefileLibraryTargetGenerator.cxx
+++ b/Source/cmMakefileLibraryTargetGenerator.cxx
@@ -397,8 +397,8 @@ void cmMakefileLibraryTargetGenerator::WriteDeviceLibraryRules(
// Add language-specific flags.
std::string langFlags;
- this->LocalGenerator->AddLanguageFlags(langFlags, this->GeneratorTarget,
- linkLanguage, this->ConfigName);
+ this->LocalGenerator->AddLanguageFlagsForLinking(
+ langFlags, this->GeneratorTarget, linkLanguage, this->ConfigName);
vars.LanguageCompileFlags = langFlags.c_str();
@@ -858,8 +858,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules(
// Add language-specific flags.
std::string langFlags;
- this->LocalGenerator->AddLanguageFlags(langFlags, this->GeneratorTarget,
- linkLanguage, this->ConfigName);
+ this->LocalGenerator->AddLanguageFlagsForLinking(
+ langFlags, this->GeneratorTarget, linkLanguage, this->ConfigName);
this->LocalGenerator->AddArchitectureFlags(
langFlags, this->GeneratorTarget, linkLanguage, this->ConfigName);
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index 54ae196..0331828 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -655,7 +655,8 @@ void cmNinjaNormalTargetGenerator::WriteDeviceLinkStatement()
localGen.AddArchitectureFlags(t, &genTarget, cudaLinkLanguage, cfgName);
vars["ARCH_FLAGS"] = t;
t = "";
- localGen.AddLanguageFlags(t, &genTarget, cudaLinkLanguage, cfgName);
+ localGen.AddLanguageFlagsForLinking(t, &genTarget, cudaLinkLanguage,
+ cfgName);
vars["LANGUAGE_COMPILE_FLAGS"] = t;
}
if (this->GetGeneratorTarget()->HasSOName(cfgName)) {
@@ -874,7 +875,8 @@ void cmNinjaNormalTargetGenerator::WriteLinkStatement()
vars["ARCH_FLAGS"] = t;
t = "";
t += lwyuFlags;
- localGen.AddLanguageFlags(t, &genTarget, TargetLinkLanguage, cfgName);
+ localGen.AddLanguageFlagsForLinking(t, &genTarget, TargetLinkLanguage,
+ cfgName);
vars["LANGUAGE_COMPILE_FLAGS"] = t;
}
if (this->GetGeneratorTarget()->HasSOName(cfgName)) {
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=b115bc49ff26da9db3e9238a98030fd94847d0d0
commit b115bc49ff26da9db3e9238a98030fd94847d0d0
Author: Brad King <brad.king at kitware.com>
AuthorDate: Fri Apr 28 14:17:13 2017 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Mon May 1 10:33:05 2017 -0400
Features: Refactor <LANG>_STANDARD update
In order to support generator expressions in target COMPILE_FEATURES
we apply them at generate time. Move this step to the beginning of
generation instead of doing it on demand while collecting flags.
This avoids repeating the process unnecessarily, and will then allow
`cmLocalGenerator::AddCompilerRequirementFlag` to be used any time
during generation.
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index a0f677b..3f50e32 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -2919,6 +2919,19 @@ void cmGeneratorTarget::ComputeTargetManifest(const std::string& config) const
}
}
+bool cmGeneratorTarget::ComputeCompileFeatures(std::string const& config) const
+{
+ std::vector<std::string> features;
+ this->GetCompileFeatures(features, config);
+ for (std::vector<std::string>::const_iterator it = features.begin();
+ it != features.end(); ++it) {
+ if (!this->Makefile->AddRequiredTargetFeature(this->Target, *it)) {
+ return false;
+ }
+ }
+ return true;
+}
+
std::string cmGeneratorTarget::GetImportedLibName(
std::string const& config) const
{
diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h
index 13b6b73..134b7c7 100644
--- a/Source/cmGeneratorTarget.h
+++ b/Source/cmGeneratorTarget.h
@@ -412,6 +412,8 @@ public:
/** Add the target output files to the global generator manifest. */
void ComputeTargetManifest(const std::string& config) const;
+ bool ComputeCompileFeatures(std::string const& config) const;
+
/**
* Trace through the source files in this target and add al source files
* that they depend on, used by all generators
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 50ad1a8..f3eb249 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -1272,6 +1272,18 @@ bool cmGlobalGenerator::Compute()
this->LocalGenerators[i]->AddHelperCommands();
}
+ // Finalize the set of compile features for each target.
+ // FIXME: This turns into calls to cmMakefile::AddRequiredTargetFeature
+ // which actually modifies the <lang>_STANDARD target property
+ // on the original cmTarget instance. It accumulates features
+ // across all configurations. Some refactoring is needed to
+ // compute a per-config resulta purely during generation.
+ for (i = 0; i < this->LocalGenerators.size(); ++i) {
+ if (!this->LocalGenerators[i]->ComputeTargetCompileFeatures()) {
+ return false;
+ }
+ }
+
#ifdef CMAKE_BUILD_WITH_CMAKE
for (std::vector<cmGeneratorTarget const*>::iterator it =
autogenTargets.begin();
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 33e32d1..6c8f132 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -558,6 +558,31 @@ void cmLocalGenerator::ComputeTargetManifest()
}
}
+bool cmLocalGenerator::ComputeTargetCompileFeatures()
+{
+ // Collect the set of configuration types.
+ std::vector<std::string> configNames;
+ this->Makefile->GetConfigurations(configNames);
+ if (configNames.empty()) {
+ configNames.push_back("");
+ }
+
+ // Process compile features of all targets.
+ std::vector<cmGeneratorTarget*> targets = this->GetGeneratorTargets();
+ for (std::vector<cmGeneratorTarget*>::iterator t = targets.begin();
+ t != targets.end(); ++t) {
+ cmGeneratorTarget* target = *t;
+ for (std::vector<std::string>::iterator ci = configNames.begin();
+ ci != configNames.end(); ++ci) {
+ if (!target->ComputeCompileFeatures(*ci)) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+}
+
bool cmLocalGenerator::IsRootMakefile() const
{
return !this->StateSnapshot.GetBuildsystemDirectoryParent().IsValid();
@@ -742,14 +767,6 @@ void cmLocalGenerator::AddCompileOptions(std::string& flags,
this->AppendFlagEscape(flags, *i);
}
}
- std::vector<std::string> features;
- target->GetCompileFeatures(features, config);
- for (std::vector<std::string>::const_iterator it = features.begin();
- it != features.end(); ++it) {
- if (!this->Makefile->AddRequiredTargetFeature(target->Target, *it)) {
- return;
- }
- }
for (std::map<std::string, std::string>::const_iterator it =
target->GetMaxLanguageStandards().begin();
diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h
index 1a238a8..7d591ac 100644
--- a/Source/cmLocalGenerator.h
+++ b/Source/cmLocalGenerator.h
@@ -70,6 +70,8 @@ public:
*/
void ComputeTargetManifest();
+ bool ComputeTargetCompileFeatures();
+
bool IsRootMakefile() const;
///! Get the makefile for this generator
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=750d58bf61e7ddc48d61d40fa2afa8716eb7fabd
commit 750d58bf61e7ddc48d61d40fa2afa8716eb7fabd
Merge: e80e8eb 2dec469
Author: Brad King <brad.king at kitware.com>
AuthorDate: Mon May 1 10:25:35 2017 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Mon May 1 10:25:35 2017 -0400
Merge branch 'upstream-KWSys' into update-kwsys
* upstream-KWSys:
KWSys 2017-05-01 (3ec3252c)
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=2dec4695b7711126832f61f5e86cc3120cb419d4
commit 2dec4695b7711126832f61f5e86cc3120cb419d4
Author: KWSys Upstream <kwrobot at kitware.com>
AuthorDate: Mon May 1 09:43:28 2017 -0400
Commit: Brad King <brad.king at kitware.com>
CommitDate: Mon May 1 10:25:35 2017 -0400
KWSys 2017-05-01 (3ec3252c)
Code extracted from:
https://gitlab.kitware.com/utils/kwsys.git
at commit 3ec3252c4829f929fff246d0d8757ed71f9850f3 (master).
Upstream Shortlog
-----------------
Chuck Atkins (1):
51e95ba7 XL: Fix compatibility with newer clang-based XL on Linux
Daniel Pfeifer (1):
2564822b Disable clang-tidy
diff --git a/CMakeLists.txt b/CMakeLists.txt
index e15b49e..e915b1a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -797,6 +797,8 @@ ENDFOREACH()
IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
ADD_LIBRARY(${KWSYS_NAMESPACE} ${KWSYS_LIBRARY_TYPE}
${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
+ SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY C_CLANG_TIDY "")
+ SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY CXX_CLANG_TIDY "")
SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY C_INCLUDE_WHAT_YOU_USE "")
SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY LABELS ${KWSYS_LABELS_LIB})
@@ -943,6 +945,8 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
ENDIF()
IF(KWSYS_USE_ConsoleBuf)
ADD_EXECUTABLE(testConsoleBufChild testConsoleBufChild.cxx)
+ SET_PROPERTY(TARGET testConsoleBufChild PROPERTY C_CLANG_TIDY "")
+ SET_PROPERTY(TARGET testConsoleBufChild PROPERTY CXX_CLANG_TIDY "")
SET_PROPERTY(TARGET testConsoleBufChild PROPERTY C_INCLUDE_WHAT_YOU_USE "")
SET_PROPERTY(TARGET testConsoleBufChild PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
SET_PROPERTY(TARGET testConsoleBufChild PROPERTY LABELS ${KWSYS_LABELS_EXE})
@@ -972,6 +976,8 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
${KWSYS_CXX_TESTS}
)
ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_CXX_TEST_SRCS})
+ SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_CLANG_TIDY "")
+ SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_CLANG_TIDY "")
SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_INCLUDE_WHAT_YOU_USE "")
SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
@@ -1039,8 +1045,12 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
# Some Apple compilers produce bad optimizations in this source.
IF(APPLE AND CMAKE_C_COMPILER_ID MATCHES "^(GNU|LLVM)$")
SET_SOURCE_FILES_PROPERTIES(testProcess.c PROPERTIES COMPILE_FLAGS -O0)
- ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "XL")
+ ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "XL" AND
+ NOT (CMAKE_SYSTEM MATCHES "Linux.*ppc64le" AND
+ NOT CMAKE_C_COMPILER_VERSION VERSION_LESS "13.1.1"))
# Tell IBM XL not to warn about our test infinite loop
+ # v13.1.1 and newer on Linux ppc64le is clang based and does not accept
+ # the -qsuppress option
SET_PROPERTY(SOURCE testProcess.c PROPERTY COMPILE_FLAGS -qsuppress=1500-010)
ENDIF()
https://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=6f04dffb7d0935c997e6fd147e926d97c5cbf925
commit 6f04dffb7d0935c997e6fd147e926d97c5cbf925
Author: Raffi Enficiaud <raffi.enficiaud at mines-paris.org>
AuthorDate: Sat Apr 29 11:38:38 2017 +0200
Commit: Brad King <brad.king at kitware.com>
CommitDate: Mon May 1 09:26:32 2017 -0400
FindMatlab: Add support for Matlab 2017a
diff --git a/Modules/FindMatlab.cmake b/Modules/FindMatlab.cmake
index eae1585..80bcda3 100644
--- a/Modules/FindMatlab.cmake
+++ b/Modules/FindMatlab.cmake
@@ -225,6 +225,7 @@ if(NOT MATLAB_ADDITIONAL_VERSIONS)
endif()
set(MATLAB_VERSIONS_MAPPING
+ "R2017a=9.2"
"R2016b=9.1"
"R2016a=9.0"
"R2015b=8.6"
-----------------------------------------------------------------------
Summary of changes:
Help/command/ctest_memcheck.rst | 3 +
Help/command/ctest_test.rst | 17 +++
Help/manual/ctest.1.rst | 17 +++
Help/release/dev/excludeFixtures.rst | 9 ++
Modules/Compiler/CMakeCommonCompilerMacros.cmake | 62 ++++++++++
Modules/Compiler/Cray-C.cmake | 21 ++++
Modules/Compiler/Cray-CXX.cmake | 19 +++
.../GHS-MULTI.cmake => Compiler/Cray.cmake} | 13 +-
Modules/Compiler/PGI-C.cmake | 13 ++
Modules/Compiler/PGI-CXX.cmake | 19 +++
Modules/Compiler/PGI.cmake | 2 +
Modules/Compiler/SunPro-CXX.cmake | 1 +
Modules/FindMatlab.cmake | 1 +
Source/CTest/cmCTestTestCommand.cxx | 15 +++
Source/CTest/cmCTestTestCommand.h | 3 +
Source/CTest/cmCTestTestHandler.cxx | 128 +++++++++++++++-----
Source/CTest/cmCTestTestHandler.h | 3 +
Source/cmCTest.cxx | 28 +++++
Source/cmGeneratorTarget.cxx | 13 ++
Source/cmGeneratorTarget.h | 2 +
Source/cmGlobalGenerator.cxx | 12 ++
Source/cmLocalGenerator.cxx | 57 +++++++--
Source/cmLocalGenerator.h | 6 +
Source/cmMakefileExecutableTargetGenerator.cxx | 8 +-
Source/cmMakefileLibraryTargetGenerator.cxx | 8 +-
Source/cmNinjaNormalTargetGenerator.cxx | 6 +-
Source/ctest.cxx | 12 ++
Source/kwsys/CMakeLists.txt | 12 +-
Tests/RunCMake/ctest_fixtures/CMakeLists.txt.in | 2 +-
Tests/RunCMake/ctest_fixtures/RunCMakeTest.cmake | 50 ++++++++
.../ctest_fixtures/exclude_any_bar-stdout.txt | 15 +++
.../ctest_fixtures/exclude_any_foo-stdout.txt | 13 ++
.../ctest_fixtures/exclude_any_foobar-stdout.txt | 9 ++
.../ctest_fixtures/exclude_cleanup_bar-stdout.txt | 15 +++
.../ctest_fixtures/exclude_cleanup_foo-stdout.txt | 15 +++
...ree-stdout.txt => exclude_setup_bar-stdout.txt} | 10 +-
.../ctest_fixtures/exclude_setup_foo-stdout.txt | 15 +++
Tests/RunCMake/ctest_fixtures/test.cmake.in | 2 +-
Utilities/Sphinx/CMakeLists.txt | 26 ++--
39 files changed, 605 insertions(+), 77 deletions(-)
create mode 100644 Help/release/dev/excludeFixtures.rst
create mode 100644 Modules/Compiler/CMakeCommonCompilerMacros.cmake
copy Modules/{Platform/GHS-MULTI.cmake => Compiler/Cray.cmake} (59%)
create mode 100644 Tests/RunCMake/ctest_fixtures/exclude_any_bar-stdout.txt
create mode 100644 Tests/RunCMake/ctest_fixtures/exclude_any_foo-stdout.txt
create mode 100644 Tests/RunCMake/ctest_fixtures/exclude_any_foobar-stdout.txt
create mode 100644 Tests/RunCMake/ctest_fixtures/exclude_cleanup_bar-stdout.txt
create mode 100644 Tests/RunCMake/ctest_fixtures/exclude_cleanup_foo-stdout.txt
copy Tests/RunCMake/ctest_fixtures/{three-stdout.txt => exclude_setup_bar-stdout.txt} (66%)
create mode 100644 Tests/RunCMake/ctest_fixtures/exclude_setup_foo-stdout.txt
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list