Merge topic 'MemChecker-improvements'

10bc50e Tests: ignore Guard Malloc messages in MemChecker tests
159c3e9 Tests: add a test with custom options passed to valgrind
61ddb93 CTest: fix comment documenting cmBoundsCheckerParser class
cbdfcb0 Tests: add test for non-existent Valgrind suppression file
3b5b758 CTest: drop suppression for gcc 2.9.6 errors from default Valgrind flags
7752253 Tests: verify that memory checker output files are always present
abf1df4 Tests: remove code duplication in CTestTestMemCheck tests
f499422 CTest: remove unreachable code and CTestTestMemcheckUnknown test
dde6306 CTest: use an output file for Valgrind (#14110)
bcc0f3f Tests: create output files for all memory checkers

Source/CTest/cmCTestMemCheckHandler.cxx

@@ -43,8 +43,7 @@ static CatToErrorType cmCTestMemCheckBoundsChecker[] = {
   {0,0}
 };
 
-// parse the xml file storing the installed version of Xcode on
-// the machine
+// parse the xml file containing the results of last BoundsChecker run
 class cmBoundsCheckerParser : public cmXMLParser
 {
 public:
@@ -461,13 +460,6 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
     return false;
     }
 
-  if ( this->MemoryTester[0] == '\"' &&
-    this->MemoryTester[this->MemoryTester.size()-1] == '\"' )
-    {
-    this->MemoryTester
-      = this->MemoryTester.substr(1, this->MemoryTester.size()-2);
-    }
-
   // Setup the options
   std::string memoryTesterOptions;
   if ( this->CTest->GetCTestConfiguration(
@@ -491,13 +483,13 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
   switch ( this->MemoryTesterStyle )
     {
     case cmCTestMemCheckHandler::VALGRIND:
+      {
       if ( this->MemoryTesterOptions.empty() )
         {
         this->MemoryTesterOptions.push_back("-q");
         this->MemoryTesterOptions.push_back("--tool=memcheck");
         this->MemoryTesterOptions.push_back("--leak-check=yes");
         this->MemoryTesterOptions.push_back("--show-reachable=yes");
-        this->MemoryTesterOptions.push_back("--workaround-gcc296-bugs=yes");
         this->MemoryTesterOptions.push_back("--num-callers=50");
         }
       if ( this->CTest->GetCTestConfiguration(
@@ -516,7 +508,11 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
           + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
         this->MemoryTesterOptions.push_back(suppressions);
         }
+      std::string outputFile = "--log-file="
+        + this->MemoryTesterOutputFile;
+      this->MemoryTesterOptions.push_back(outputFile);
       break;
+      }
     case cmCTestMemCheckHandler::PURIFY:
       {
       std::string outputFile;
@@ -948,6 +944,21 @@ cmCTestMemCheckHandler::PostProcessPurifyTest(cmCTestTestResult& res)
   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
              "PostProcessPurifyTest for : "
              << res.Name.c_str() << std::endl);
+  appendMemTesterOutput(res);
+}
+
+void
+cmCTestMemCheckHandler::PostProcessValgrindTest(cmCTestTestResult& res)
+{
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+             "PostProcessValgrindTest for : "
+             << res.Name.c_str() << std::endl);
+  appendMemTesterOutput(res);
+}
+
+void
+cmCTestMemCheckHandler::appendMemTesterOutput(cmCTestTestResult& res)
+{
   if ( !cmSystemTools::FileExists(this->MemoryTesterOutputFile.c_str()) )
     {
     std::string log = "Cannot find memory tester output file: "

Source/CTest/cmCTestMemCheckHandler.h

@@ -119,6 +119,10 @@ private:
 
   void PostProcessPurifyTest(cmCTestTestResult& res);
   void PostProcessBoundsCheckerTest(cmCTestTestResult& res);
+  void PostProcessValgrindTest(cmCTestTestResult& res);
+
+  ///! append MemoryTesterOutputFile to the test log
+  void appendMemTesterOutput(cmCTestTestHandler::cmCTestTestResult& res);
 };
 
 #endif

Source/CTest/cmCTestRunTest.cxx

@@ -386,13 +386,19 @@ void cmCTestRunTest::MemCheckPostProcess()
              << this->TestResult.Name.c_str() << std::endl);
   cmCTestMemCheckHandler * handler = static_cast<cmCTestMemCheckHandler*>
     (this->TestHandler);
-  if(handler->MemoryTesterStyle == cmCTestMemCheckHandler::BOUNDS_CHECKER)
+  switch ( handler->MemoryTesterStyle )
     {
-    handler->PostProcessBoundsCheckerTest(this->TestResult);
-    }
-  else if(handler->MemoryTesterStyle == cmCTestMemCheckHandler::PURIFY)
-    {
-    handler->PostProcessPurifyTest(this->TestResult);
+    case cmCTestMemCheckHandler::VALGRIND:
+      handler->PostProcessValgrindTest(this->TestResult);
+      break;
+    case cmCTestMemCheckHandler::PURIFY:
+      handler->PostProcessPurifyTest(this->TestResult);
+      break;
+    case cmCTestMemCheckHandler::BOUNDS_CHECKER:
+      handler->PostProcessBoundsCheckerTest(this->TestResult);
+      break;
+    default:
+      break;
     }
 }
 

Tests/CTestTestMemcheck/CMakeLists.txt

@@ -1,10 +1,13 @@
 foreach (_retval 0 1)
-  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/ret${_retval}.c" "int main(){return ${_retval};}\n")
+  configure_file("${CMAKE_CURRENT_SOURCE_DIR}/memtester.cxx.in" "${CMAKE_CURRENT_BINARY_DIR}/ret${_retval}.cxx" @ONLY)
 endforeach ()
 
+include_directories(${CMake_SOURCE_DIR}/Source ${CMake_BINARY_DIR}/Source)
+
 # create binaries that we will use as a pseudo memory checker
-add_executable(pseudo_valgrind "${CMAKE_CURRENT_BINARY_DIR}/ret0.c")
+add_executable(pseudo_valgrind "${CMAKE_CURRENT_BINARY_DIR}/ret0.cxx")
 set_target_properties(pseudo_valgrind PROPERTIES OUTPUT_NAME valgrind)
+target_link_libraries(pseudo_valgrind CMakeLib)
 
 # Xcode 2.x forgets to create the output directory before linking
 # the individual architectures.
@@ -14,54 +17,125 @@ if(CMAKE_OSX_ARCHITECTURES AND XCODE AND NOT "${XCODE_VERSION}" MATCHES "^[^12]"
     )
 endif()
 
-add_executable(pseudo_purify "${CMAKE_CURRENT_BINARY_DIR}/ret0.c")
+add_executable(pseudo_purify "${CMAKE_CURRENT_BINARY_DIR}/ret0.cxx")
 set_target_properties(pseudo_purify PROPERTIES OUTPUT_NAME purify)
-add_executable(pseudo_BC "${CMAKE_CURRENT_BINARY_DIR}/ret0.c")
+target_link_libraries(pseudo_purify CMakeLib)
+add_executable(pseudo_BC "${CMAKE_CURRENT_BINARY_DIR}/ret0.cxx")
 set_target_properties(pseudo_BC PROPERTIES OUTPUT_NAME BC)
+target_link_libraries(pseudo_BC CMakeLib)
 
 # binary to be used as pre- and post-memcheck command that fails
-add_executable(memcheck_fail "${CMAKE_CURRENT_BINARY_DIR}/ret1.c")
-
-foreach  (_test IN ITEMS Unknown UnknownQuoted NotExist
-        DummyValgrind DummyValgrindPrePost
-        DummyValgrindFailPre DummyValgrindFailPost
-        DummyPurify DummyBC
-        DummyValgrindIgnoreMemcheck)
-    configure_file(
-        "${CMAKE_CURRENT_SOURCE_DIR}/${_test}/test.cmake.in"
-        "${CMAKE_CURRENT_BINARY_DIR}/${_test}/test.cmake"
-        @ONLY ESCAPE_QUOTES)
-    add_test(NAME CTestTestMemcheck${_test}
+add_executable(memcheck_fail "${CMAKE_CURRENT_BINARY_DIR}/ret1.cxx")
+target_link_libraries(memcheck_fail CMakeLib)
+
+# Binaries that are used as memchecker that do not write the expected
+# output file. Need to be in their own subdirectory as they have the
+# same filenames.
+add_subdirectory(NoLogDummyChecker)
+
+if (XCODE)
+    # filter out additional messages by Guard Malloc integrated in Xcode
+    set(GUARD_MALLOC_MSG "(ctest\([0-9]+\) malloc: [^\n]*\n)*")
+    set(NORMAL_CTEST_OUTPUT "\n1/1 MemCheck #1: RunCMake \\.+   Passed +[0-9]+\\.[0-9]+ sec\n${GUARD_MALLOC_MSG}\n${GUARD_MALLOC_MSG}100% tests passed, 0 tests failed out of 1\n.*\n-- Processing memory checking output: \n${GUARD_MALLOC_MSG}Memory checking results:\n${GUARD_MALLOC_MSG}")
+else ()
+    set(NORMAL_CTEST_OUTPUT "\n1/1 MemCheck #1: RunCMake \\.+   Passed +[0-9]+\\.[0-9]+ sec\n\n100% tests passed, 0 tests failed out of 1\n.*\n-- Processing memory checking output: \nMemory checking results:\n")
+endif ()
+set(BULLSEYE_MSG "(BullseyeCoverage[^\n]*\n)?")
+
+function(gen_mc_test_internal NAME CHECKER)
+    set(SUBTEST_NAME "${NAME}")
+    set(CHECKER_COMMAND "${CHECKER}")
+    foreach(_file IN ITEMS CMakeLists.txt CTestConfig.cmake test.cmake)
+        configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${_file}.in"
+            "${CMAKE_CURRENT_BINARY_DIR}/${NAME}/${_file}" @ONLY)
+    endforeach()
+    add_test(NAME CTestTestMemcheck${NAME}
         COMMAND ${CMAKE_CTEST_COMMAND}
-        -S "${CMAKE_CURRENT_BINARY_DIR}/${_test}/test.cmake" -V
-        --output-log "${CMAKE_CURRENT_BINARY_DIR}/${_test}/testOutput.log"
+        -C $<CONFIGURATION>
+        -S "${CMAKE_CURRENT_BINARY_DIR}/${NAME}/test.cmake" -V
+        --output-log "${CMAKE_CURRENT_BINARY_DIR}/${NAME}/testOutput.log"
+        ${ARGN}
+        )
+endfunction(gen_mc_test_internal)
+
+function(gen_mc_test NAME CHECKER)
+    gen_mc_test_internal(${NAME} "${CHECKER}"
         -D PSEUDO_BC=$<TARGET_FILE:pseudo_BC>
         -D PSEUDO_PURIFY=$<TARGET_FILE:pseudo_purify>
         -D PSEUDO_VALGRIND=$<TARGET_FILE:pseudo_valgrind>
         -D ERROR_COMMAND=$<TARGET_FILE:memcheck_fail>
         )
-endforeach ()
+endfunction(gen_mc_test)
+
+function(gen_mcnl_test NAME CHECKER)
+    gen_mc_test_internal(${NAME} ${CHECKER}
+        -D PSEUDO_BC=$<TARGET_FILE:pseudonl_BC>
+        -D PSEUDO_PURIFY=$<TARGET_FILE:pseudonl_purify>
+        -D PSEUDO_VALGRIND=$<TARGET_FILE:pseudonl_valgrind>
+        )
+    set_tests_properties(CTestTestMemcheck${NAME}
+        PROPERTIES
+        PASS_REGULAR_EXPRESSION "\nCannot find memory tester output file: ${CMAKE_CURRENT_BINARY_DIR}/${NAME}/Testing/Temporary/MemoryChecker.log\n(.*\n)?Error in read script: ${CMAKE_CURRENT_BINARY_DIR}/${NAME}/test.cmake\n")
+endfunction(gen_mcnl_test)
+
+unset(CTEST_EXTRA_CONFIG)
+unset(CTEST_EXTRA_CODE)
+unset(CMAKELISTS_EXTRA_CODE)
+
+gen_mc_test(DummyPurify "\${PSEUDO_PURIFY}")
+gen_mc_test(DummyValgrind "\${PSEUDO_VALGRIND}")
+gen_mc_test(DummyBC "\${PSEUDO_BC}")
+gen_mcnl_test(DummyPurifyNoLogfile "\${PSEUDO_PURIFY}")
+gen_mcnl_test(DummyValgrindNoLogfile "\${PSEUDO_VALGRIND}")
+gen_mcnl_test(DummyBCNoLogfile "\${PSEUDO_BC}")
+
+set(CTEST_EXTRA_CODE "set(CTEST_CUSTOM_PRE_MEMCHECK \"\${CTEST_MEMORYCHECK_COMMAND}\")\nset(CTEST_CUSTOM_POST_MEMCHECK \"\${CTEST_MEMORYCHECK_COMMAND}\")")
+gen_mc_test(DummyValgrindPrePost "\${PSEUDO_VALGRIND}")
+
+set(CTEST_EXTRA_CODE "set(CTEST_CUSTOM_POST_MEMCHECK \"\${ERROR_COMMAND}\")")
+gen_mc_test(DummyValgrindFailPost "\${PSEUDO_VALGRIND}")
+
+set(CTEST_EXTRA_CODE "set(CTEST_CUSTOM_PRE_MEMCHECK \"\${ERROR_COMMAND}\")")
+gen_mc_test(DummyValgrindFailPre "\${PSEUDO_VALGRIND}")
+
+unset(CTEST_EXTRA_CODE)
+set(CTEST_EXTRA_CONFIG "set(CTEST_CUSTOM_MEMCHECK_IGNORE RunCMakeAgain)\n")
+set(CMAKELISTS_EXTRA_CODE "add_test(NAME RunCMakeAgain COMMAND \"\${CMAKE_COMMAND}\" --version)")
+gen_mc_test(DummyValgrindIgnoreMemcheck "\${PSEUDO_VALGRIND}")
+
+set(CTEST_EXTRA_CONFIG "set(CTEST_MEMORYCHECK_SUPPRESSIONS_FILE \"\${CMAKE_CURRENT_BINARY_DIR}/does-not-exist\")")
+unset(CMAKELISTS_EXTRA_CODE)
+gen_mc_test(DummyValgrindInvalidSupFile "\${PSEUDO_VALGRIND}")
+
+# CTest will add the logfile option as last option. Tell the dummy memcheck
+# to ignore that argument. This will cause the logfile to be missing, which
+# will be the prove for us that the custom option is indeed used.
+set(CTEST_EXTRA_CONFIG "set(CTEST_MEMORYCHECK_COMMAND_OPTIONS \"--\")")
+gen_mc_test(DummyValgrindCustomOptions "\${PSEUDO_VALGRIND}")
+
+unset(CTEST_EXTRA_CONFIG)
+gen_mc_test(NotExist "\${CTEST_BINARY_DIRECTORY}/no-memcheck-exe")
+
+gen_mc_test(Unknown "${CMAKE_COMMAND}")
 
 string(REPLACE "\\" "\\\\" CMAKE_COMMAND_ESCAPED "${CMAKE_COMMAND}")
 string(REPLACE "(" "\\(" CMAKE_COMMAND_ESCAPED "${CMAKE_COMMAND_ESCAPED}")
 string(REPLACE ")" "\\)" CMAKE_COMMAND_ESCAPED "${CMAKE_COMMAND_ESCAPED}")
 string(REPLACE "+" "\\+" CMAKE_COMMAND_ESCAPED "${CMAKE_COMMAND_ESCAPED}")
 
-foreach (_unkn Unknown UnknownQuoted)
-    set_tests_properties(CTestTestMemcheck${_unkn} PROPERTIES
-        PASS_REGULAR_EXPRESSION "Do not understand memory checker: ${CMAKE_COMMAND_ESCAPED}\n(.*\n)?Error in read script: ${CMAKE_CURRENT_BINARY_DIR}/${_unkn}/test.cmake\n")
-endforeach ()
+set_tests_properties(CTestTestMemcheckUnknown PROPERTIES
+    PASS_REGULAR_EXPRESSION "Do not understand memory checker: ${CMAKE_COMMAND_ESCAPED}\n(.*\n)?Error in read script: ${CMAKE_CURRENT_BINARY_DIR}/Unknown/test.cmake\n")
 
 set_tests_properties(CTestTestMemcheckNotExist PROPERTIES
     PASS_REGULAR_EXPRESSION "Memory checker \\(MemoryCheckCommand\\) not set, or cannot find the specified program.")
 
-set(NORMAL_CTEST_OUTPUT "\n-- Processing memory checking output: \nMemory checking results:\n(BullseyeCoverage[^\n]*\n)?")
-
 # It is a valid result if valgrind does not output any files (can e.g. happen
 # if you have not compiled in debug mode), so these tests will not fail.
-set_tests_properties(CTestTestMemcheckDummyValgrind CTestTestMemcheckDummyValgrindPrePost
+set_tests_properties(CTestTestMemcheckDummyValgrind
+                     CTestTestMemcheckDummyValgrindPrePost
+                     CTestTestMemcheckDummyPurify
     PROPERTIES
-    PASS_REGULAR_EXPRESSION "${NORMAL_CTEST_OUTPUT}")
+    PASS_REGULAR_EXPRESSION "${NORMAL_CTEST_OUTPUT}${BULLSEYE_MSG}$")
 
 foreach (_pp Pre Post)
     string(TOLOWER ${_pp} _pp_lower)
@@ -72,10 +146,13 @@ endforeach ()
 
 set_tests_properties(CTestTestMemcheckDummyValgrindIgnoreMemcheck
     PROPERTIES
-    PASS_REGULAR_EXPRESSION "\n2/2 Test #2: RunCMakeAgain .*\n1/1 MemCheck #1: RunCMake .*${NORMAL_CTEST_OUTPUT}")
-
-set_tests_properties(CTestTestMemcheckDummyPurify PROPERTIES
-    PASS_REGULAR_EXPRESSION "\nCannot find memory tester output file: ${CMAKE_CURRENT_BINARY_DIR}/DummyPurify/Testing/Temporary/MemoryChecker.log\n(.*\n)?Error in read script: ${CMAKE_CURRENT_BINARY_DIR}/DummyPurify/test.cmake\n")
+    PASS_REGULAR_EXPRESSION "\n2/2 Test #2: RunCMakeAgain .*${NORMAL_CTEST_OUTPUT}${BULLSEYE_MSG}$")
 
 set_tests_properties(CTestTestMemcheckDummyBC PROPERTIES
-    PASS_REGULAR_EXPRESSION "\nCannot find memory tester output file: ${CMAKE_CURRENT_BINARY_DIR}/DummyBC/Testing/Temporary/MemoryChecker.log\n(.*\n)?Error parsing XML in stream at line 1: no element found\n(.*\n)?Error in read script: ${CMAKE_CURRENT_BINARY_DIR}/DummyBC/test.cmake\n")
+    PASS_REGULAR_EXPRESSION "\n1/1 MemCheck #1: RunCMake \\.+   Passed +[0-9]+.[0-9]+ sec\n\n100% tests passed, 0 tests failed out of 1\n(.*\n)?Error parsing XML in stream at line 1: no element found\n")
+
+set_tests_properties(CTestTestMemcheckDummyValgrindInvalidSupFile PROPERTIES
+    PASS_REGULAR_EXPRESSION "\nCannot find memory checker suppression file: ${CMAKE_CURRENT_BINARY_DIR}/does-not-exist\n")
+
+set_tests_properties(CTestTestMemcheckDummyValgrindCustomOptions PROPERTIES
+    PASS_REGULAR_EXPRESSION "\nCannot find memory tester output file: ${CMAKE_CURRENT_BINARY_DIR}/DummyValgrindCustomOptions/Testing/Temporary/MemoryChecker.log\n(.*\n)?Error in read script: ${CMAKE_CURRENT_BINARY_DIR}/DummyValgrindCustomOptions/test.cmake\n")

Tests/CTestTestMemcheck/CMakeLists.txt.in

@@ -0,0 +1,7 @@
+cmake_minimum_required(VERSION 2.8.9)
+project(CTestTestMemcheck@SUBTEST_NAME@)
+include(CTest)
+
+add_test(NAME RunCMake COMMAND "${CMAKE_COMMAND}" --version)
+
+@CMAKELISTS_EXTRA_CODE@

Tests/CTestTestMemcheck/DummyValgrindPrePost/CTestConfig.cmake → Tests/CTestTestMemcheck/CTestConfig.cmake.in

@@ -1,7 +1,9 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckDummyValgrindPrePost")
+set (CTEST_PROJECT_NAME "CTestTestMemcheck@SUBTEST_NAME@")
 set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
 set (CTEST_DART_SERVER_VERSION "2")
 set(CTEST_DROP_METHOD "http")
 set(CTEST_DROP_SITE "www.cdash.org")
 set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
 set(CTEST_DROP_SITE_CDASH TRUE)
+
+@CTEST_EXTRA_CONFIG@

Tests/CTestTestMemcheck/DummyBC/CMakeLists.txt

@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckDummyBC)
-include(CTest)
-
-add_test (RunCMake "${CMAKE_COMMAND}")

Tests/CTestTestMemcheck/DummyBC/CTestConfig.cmake

@@ -1,7 +0,0 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckDummyBC")
-set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-set (CTEST_DART_SERVER_VERSION "2")
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "www.cdash.org")
-set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
-set(CTEST_DROP_SITE_CDASH TRUE)

Tests/CTestTestMemcheck/DummyPurify/CMakeLists.txt

@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckDummyPurify)
-include(CTest)
-
-add_test (RunCMake "${CMAKE_COMMAND}")

Tests/CTestTestMemcheck/DummyPurify/CTestConfig.cmake

@@ -1,7 +0,0 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckDummyPurify")
-set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-set (CTEST_DART_SERVER_VERSION "2")
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "www.cdash.org")
-set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
-set(CTEST_DROP_SITE_CDASH TRUE)

Tests/CTestTestMemcheck/DummyPurify/test.cmake.in

@@ -1,25 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-
-# Settings:
-set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
-set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckDummyPurify")
-
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/DummyPurify")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/DummyPurify")
-set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
-set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
-set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
-set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
-set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
-set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-
-set(CTEST_MEMORYCHECK_COMMAND "${PSEUDO_PURIFY}")
-
-#CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
-
-CTEST_START(Experimental)
-CTEST_CONFIGURE(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-#CTEST_BUILD(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_TEST(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/CTestTestMemcheck/DummyValgrind/CMakeLists.txt

@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckDummyValgrind)
-include(CTest)
-
-add_test (RunCMake "${CMAKE_COMMAND}")

Tests/CTestTestMemcheck/DummyValgrind/CTestConfig.cmake

@@ -1,7 +0,0 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckDummyValgrind")
-set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-set (CTEST_DART_SERVER_VERSION "2")
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "www.cdash.org")
-set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
-set(CTEST_DROP_SITE_CDASH TRUE)

Tests/CTestTestMemcheck/DummyValgrind/test.cmake.in

@@ -1,25 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-
-# Settings:
-set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
-set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckDummyValgrind")
-
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/DummyValgrind")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/DummyValgrind")
-set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
-set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
-set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
-set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
-set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
-set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-
-set(CTEST_MEMORYCHECK_COMMAND "${PSEUDO_VALGRIND}")
-
-#CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
-
-CTEST_START(Experimental)
-CTEST_CONFIGURE(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-#CTEST_BUILD(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_TEST(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/CTestTestMemcheck/DummyValgrindFailPost/CMakeLists.txt

@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckDummyValgrindFailPost)
-include(CTest)
-
-add_test (RunCMake "${CMAKE_COMMAND}")

Tests/CTestTestMemcheck/DummyValgrindFailPost/CTestConfig.cmake

@@ -1,7 +0,0 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckDummyValgrind")
-set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-set (CTEST_DART_SERVER_VERSION "2")
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "www.cdash.org")
-set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
-set(CTEST_DROP_SITE_CDASH TRUE)

Tests/CTestTestMemcheck/DummyValgrindFailPost/test.cmake.in

@@ -1,27 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-
-# Settings:
-set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
-set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckDummyValgrindFailPost")
-
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/DummyValgrindFailPost")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/DummyValgrindFailPost")
-set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
-set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
-set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
-set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
-set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
-set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-
-set(CTEST_MEMORYCHECK_COMMAND "${PSEUDO_VALGRIND}")
-
-set(CTEST_CUSTOM_POST_MEMCHECK "${ERROR_COMMAND}")
-
-#CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
-
-CTEST_START(Experimental)
-CTEST_CONFIGURE(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-#CTEST_BUILD(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_TEST(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/CTestTestMemcheck/DummyValgrindFailPre/CMakeLists.txt

@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckDummyValgrindFailPre)
-include(CTest)
-
-add_test (RunCMake "${CMAKE_COMMAND}")

Tests/CTestTestMemcheck/DummyValgrindFailPre/CTestConfig.cmake

@@ -1,7 +0,0 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckDummyValgrind")
-set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-set (CTEST_DART_SERVER_VERSION "2")
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "www.cdash.org")
-set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
-set(CTEST_DROP_SITE_CDASH TRUE)

Tests/CTestTestMemcheck/DummyValgrindFailPre/test.cmake.in

@@ -1,27 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-
-# Settings:
-set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
-set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckDummyValgrindFailPre")
-
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/DummyValgrindFailPre")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/DummyValgrindFailPre")
-set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
-set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
-set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
-set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
-set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
-set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-
-set(CTEST_MEMORYCHECK_COMMAND "${PSEUDO_VALGRIND}")
-
-set(CTEST_CUSTOM_PRE_MEMCHECK "${ERROR_COMMAND}")
-
-#CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
-
-CTEST_START(Experimental)
-CTEST_CONFIGURE(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-#CTEST_BUILD(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_TEST(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/CTestTestMemcheck/DummyValgrindIgnoreMemcheck/CMakeLists.txt

@@ -1,6 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckDummyValgrindIgnoreMemcheck)
-include(CTest)
-
-add_test (RunCMake "${CMAKE_COMMAND}")
-add_test (RunCMakeAgain "${CMAKE_COMMAND}")

Tests/CTestTestMemcheck/DummyValgrindIgnoreMemcheck/CTestConfig.cmake

@@ -1,9 +0,0 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckDummyValgrindIgnoreMemcheck")
-set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-set (CTEST_DART_SERVER_VERSION "2")
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "www.cdash.org")
-set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
-set(CTEST_DROP_SITE_CDASH TRUE)
-
-set(CTEST_CUSTOM_MEMCHECK_IGNORE RunCMakeAgain)

Tests/CTestTestMemcheck/DummyValgrindIgnoreMemcheck/test.cmake.in

@@ -1,25 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-
-# Settings:
-set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
-set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckDummyValgrindIgnoreMemcheck")
-
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/DummyValgrindIgnoreMemcheck")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/DummyValgrindIgnoreMemcheck")
-set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
-set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
-set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
-set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
-set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
-set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-
-set(CTEST_MEMORYCHECK_COMMAND "${PSEUDO_VALGRIND}")
-
-#CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
-
-CTEST_START(Experimental)
-CTEST_CONFIGURE(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-#CTEST_BUILD(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_TEST(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/CTestTestMemcheck/DummyValgrindPrePost/CMakeLists.txt

@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckDummyValgrindPrePost)
-include(CTest)
-
-add_test (RunCMake "${CMAKE_COMMAND}")

Tests/CTestTestMemcheck/DummyValgrindPrePost/test.cmake.in

@@ -1,28 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-
-# Settings:
-set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
-set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckDummyValgrindPrePost")
-
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/DummyValgrindPrePost")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/DummyValgrindPrePost")
-set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
-set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
-set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
-set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
-set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
-set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-
-set(CTEST_MEMORYCHECK_COMMAND "${PSEUDO_VALGRIND}")
-
-set(CTEST_CUSTOM_PRE_MEMCHECK "${CTEST_MEMORYCHECK_COMMAND}")
-set(CTEST_CUSTOM_POST_MEMCHECK "${CTEST_MEMORYCHECK_COMMAND}")
-
-#CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
-
-CTEST_START(Experimental)
-CTEST_CONFIGURE(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-#CTEST_BUILD(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_TEST(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/CTestTestMemcheck/NoLogDummyChecker/CMakeLists.txt

@@ -0,0 +1,17 @@
+# A dummy checker implementation that does not write the requested output file
+# so it triggers an error for every checker.
+
+file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/ret0.c" "int main(){return 0;}\n")
+
+foreach(_pseudo IN ITEMS valgrind purify BC)
+  add_executable(pseudonl_${_pseudo} "${CMAKE_CURRENT_BINARY_DIR}/ret0.c")
+  set_target_properties(pseudonl_${_pseudo} PROPERTIES OUTPUT_NAME ${_pseudo})
+endforeach()
+
+# Xcode 2.x forgets to create the output directory before linking
+# the individual architectures.
+if(CMAKE_OSX_ARCHITECTURES AND XCODE AND NOT "${XCODE_VERSION}" MATCHES "^[^12]")
+    add_custom_command(TARGET pseudonl_valgrind
+                       PRE_BUILD COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CFG_INTDIR}"
+    )
+endif()

Tests/CTestTestMemcheck/NotExist/CMakeLists.txt

@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckNotExist)
-include(CTest)
-
-add_test (RunCMake "${CMAKE_COMMAND}")

Tests/CTestTestMemcheck/NotExist/CTestConfig.cmake

@@ -1,7 +0,0 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckUnknown")
-set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-set (CTEST_DART_SERVER_VERSION "2")
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "www.cdash.org")
-set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
-set(CTEST_DROP_SITE_CDASH TRUE)

Tests/CTestTestMemcheck/NotExist/test.cmake.in

@@ -1,19 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-
-# Settings:
-set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
-set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckNotExist")
-
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/NotExist")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/NotExist")
-set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
-set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
-set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
-set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
-set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
-set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-set(CTEST_MEMORYCHECK_COMMAND           "${CTEST_BINARY_DIRECTORY}/no-memcheck-exe")
-
-CTEST_START(Experimental)
-CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/CTestTestMemcheck/Unknown/CMakeLists.txt

@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckUnknown)
-include(CTest)
-
-add_test (RunCMake "${CMAKE_COMMAND}")

Tests/CTestTestMemcheck/Unknown/CTestConfig.cmake

@@ -1,7 +0,0 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckUnknown")
-set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-set (CTEST_DART_SERVER_VERSION "2")
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "www.cdash.org")
-set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
-set(CTEST_DROP_SITE_CDASH TRUE)

Tests/CTestTestMemcheck/Unknown/test.cmake.in

@@ -1,19 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-
-# Settings:
-set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
-set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckUnknown")
-
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/Unknown")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/Unknown")
-set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
-set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
-set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
-set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
-set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
-set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-set(CTEST_MEMORYCHECK_COMMAND           "@CMAKE_COMMAND@")
-
-CTEST_START(Experimental)
-CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/CTestTestMemcheck/UnknownQuoted/CMakeLists.txt

@@ -1,5 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-project(CTestTestMemcheckUnknownQuoted)
-include(CTest)
-
-add_test (RunCMake "\"${CMAKE_COMMAND}\"")

Tests/CTestTestMemcheck/UnknownQuoted/CTestConfig.cmake

@@ -1,7 +0,0 @@
-set (CTEST_PROJECT_NAME "CTestTestMemcheckUnknownQuoted")
-set (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-set (CTEST_DART_SERVER_VERSION "2")
-set(CTEST_DROP_METHOD "http")
-set(CTEST_DROP_SITE "www.cdash.org")
-set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
-set(CTEST_DROP_SITE_CDASH TRUE)

Tests/CTestTestMemcheck/UnknownQuoted/test.cmake.in

@@ -1,19 +0,0 @@
-cmake_minimum_required(VERSION 2.8.9)
-
-# Settings:
-set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
-set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckUnknownQuoted")
-
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/UnknownQuoted")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/UnknownQuoted")
-set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
-set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
-set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
-set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
-set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
-set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
-set(CTEST_MEMORYCHECK_COMMAND           "@CMAKE_COMMAND@")
-
-CTEST_START(Experimental)
-CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/CTestTestMemcheck/memtester.cxx.in

@@ -0,0 +1,58 @@
+#include <string>
+#include <cmSystemTools.h>
+
+#define RETVAL @_retval@
+
+int
+main(int argc, char **argv)
+{
+  std::string exename = argv[0];
+  std::string logarg;
+  bool nextarg = false;
+
+  if (exename.find("valgrind") != exename.npos)
+    logarg = "--log-file=";
+  else if (exename.find("purify") != exename.npos)
+#ifdef _WIN32
+    logarg = "/SAVETEXTDATA=";
+#else
+    logarg = "-log-file=";
+#endif
+  else if (exename.find("BC") != exename.npos)
+    {
+    nextarg = true;
+    logarg = "/X";
+    }
+
+  if (!logarg.empty()) {
+    std::string logfile;
+    for (int i = 1; i < argc; i++) {
+      std::string arg = argv[i];
+      // stop processing options, this allows to force
+      // the logfile to be ignored
+      if (arg == "--")
+        {
+        break;
+        }
+      if (arg.find(logarg) == 0)
+        {
+        if (nextarg)
+          {
+          if (i == argc - 1)
+            return 1; // invalid command line
+          logfile = argv[i + 1];
+          }
+        else
+          {
+          logfile = arg.substr(logarg.length());
+          }
+        break;
+        }
+      }
+
+    if (!logfile.empty())
+      cmSystemTools::Touch(logfile.c_str(), true);
+  }
+
+  return RETVAL;
+}

Tests/CTestTestMemcheck/DummyBC/test.cmake.in → Tests/CTestTestMemcheck/test.cmake.in

@@ -3,10 +3,10 @@ cmake_minimum_required(VERSION 2.8.9)
 # Settings:
 set(CTEST_DASHBOARD_ROOT                "@CMAKE_CURRENT_BINARY_DIR@")
 set(CTEST_SITE                          "@SITE@")
-set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-MemcheckDummyBC")
+set(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-Memcheck@SUBTEST_NAME@")
 
-set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/DummyBC")
-set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/DummyBC")
+set(CTEST_SOURCE_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/@SUBTEST_NAME@")
+set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/@SUBTEST_NAME@")
 set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
 set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
 set(CTEST_CMAKE_GENERATOR_TOOLSET       "@CMAKE_TEST_GENERATOR_TOOLSET@")
@@ -14,12 +14,11 @@ set(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
 set(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
 set(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
 
-set(CTEST_MEMORYCHECK_COMMAND "${PSEUDO_BC}")
+set(CTEST_MEMORYCHECK_COMMAND "@CHECKER_COMMAND@")
 
-#CTEST_EMPTY_BINARY_DIRECTORY(${CTEST_BINARY_DIRECTORY})
+@CTEST_EXTRA_CODE@
 
 CTEST_START(Experimental)
 CTEST_CONFIGURE(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
-#CTEST_BUILD(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
 CTEST_TEST(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
 CTEST_MEMCHECK(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)