Merge topic 'test-ctest-memcheck'

995a35f CTest: add a check with a quoted memory checker
de8bffc CTest: add a test for CTEST_CUSTOM_MEMCHECK_IGNORE
d26c9b6 CTest: improve memory checker type detection
fcae1da CTest: add tests that simulate memcheck runs
6187876 CTest: fix pre and post test commands with spaces
95bc8aa CTest: fix usage of memory checker with spaces in path

Source/CTest/cmCTestMemCheckHandler.cxx

@@ -247,7 +247,8 @@ void cmCTestMemCheckHandler::GenerateTestCommand(
 {
   std::vector<cmStdString>::size_type pp;
   std::string memcheckcommand = "";
-  memcheckcommand = this->MemoryTester;
+  memcheckcommand
+    = cmSystemTools::ConvertToOutputPath(this->MemoryTester.c_str());
   for ( pp = 0; pp < this->MemoryTesterOptions.size(); pp ++ )
     {
     args.push_back(this->MemoryTesterOptions[pp]);
@@ -410,29 +411,46 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
         "MemoryCheckCommand").c_str()) )
     {
     this->MemoryTester
-      = cmSystemTools::ConvertToOutputPath(this->CTest->GetCTestConfiguration(
-          "MemoryCheckCommand").c_str());
+      = this->CTest->GetCTestConfiguration("MemoryCheckCommand").c_str();
+
+    // determine the checker type
+    if ( this->MemoryTester.find("valgrind") != std::string::npos )
+      {
+        this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
+      }
+    else if ( this->MemoryTester.find("purify") != std::string::npos )
+      {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
+      }
+    else if ( this->MemoryTester.find("BC") != std::string::npos )
+      {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
+      }
+    else
+      {
+      this->MemoryTesterStyle = cmCTestMemCheckHandler::UNKNOWN;
+      }
     }
   else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
         "PurifyCommand").c_str()) )
     {
     this->MemoryTester
-      = cmSystemTools::ConvertToOutputPath(this->CTest->GetCTestConfiguration(
-          "PurifyCommand").c_str());
+      = this->CTest->GetCTestConfiguration("PurifyCommand").c_str();
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
     }
   else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
         "ValgrindCommand").c_str()) )
     {
     this->MemoryTester
-      = cmSystemTools::ConvertToOutputPath(this->CTest->GetCTestConfiguration(
-          "ValgrindCommand").c_str());
+      = this->CTest->GetCTestConfiguration("ValgrindCommand").c_str();
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND;
     }
   else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
         "BoundsCheckerCommand").c_str()) )
     {
     this->MemoryTester
-      = cmSystemTools::ConvertToOutputPath(this->CTest->GetCTestConfiguration(
-          "BoundsCheckerCommand").c_str());
+      = this->CTest->GetCTestConfiguration("BoundsCheckerCommand").c_str();
+    this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
     }
   else
     {
@@ -470,82 +488,81 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
   this->MemoryTesterOutputFile
     = this->CTest->GetBinaryDir() + "/Testing/Temporary/MemoryChecker.log";
 
-  if ( this->MemoryTester.find("valgrind") != std::string::npos )
+  switch ( this->MemoryTesterStyle )
     {
-    this->MemoryTesterStyle = 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(
-        "MemoryCheckSuppressionFile").size() )
-      {
-      if ( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
-            "MemoryCheckSuppressionFile").c_str()) )
+    case cmCTestMemCheckHandler::VALGRIND:
+      if ( this->MemoryTesterOptions.empty() )
         {
-        cmCTestLog(this->CTest, ERROR_MESSAGE,
-          "Cannot find memory checker suppression file: "
-          << this->CTest->GetCTestConfiguration(
-            "MemoryCheckSuppressionFile").c_str() << std::endl);
-        return false;
-        }
-      std::string suppressions = "--suppressions="
-        + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
-      this->MemoryTesterOptions.push_back(suppressions);
-      }
-    }
-  else if ( this->MemoryTester.find("purify") != std::string::npos )
-    {
-    this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY;
-    std::string outputFile;
-#ifdef _WIN32
-    if( this->CTest->GetCTestConfiguration(
+        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(
           "MemoryCheckSuppressionFile").size() )
+        {
+        if ( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
+              "MemoryCheckSuppressionFile").c_str()) )
+          {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+            "Cannot find memory checker suppression file: "
+            << this->CTest->GetCTestConfiguration(
+              "MemoryCheckSuppressionFile").c_str() << std::endl);
+          return false;
+          }
+        std::string suppressions = "--suppressions="
+          + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
+        this->MemoryTesterOptions.push_back(suppressions);
+        }
+      break;
+    case cmCTestMemCheckHandler::PURIFY:
       {
-      if( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
-                                       "MemoryCheckSuppressionFile").c_str()) )
+      std::string outputFile;
+#ifdef _WIN32
+      if( this->CTest->GetCTestConfiguration(
+            "MemoryCheckSuppressionFile").size() )
         {
-        cmCTestLog(this->CTest, ERROR_MESSAGE,
-                   "Cannot find memory checker suppression file: "
-                   << this->CTest->GetCTestConfiguration(
-                     "MemoryCheckSuppressionFile").c_str() << std::endl);
-        return false;
-        }
-      std::string filterFiles = "/FilterFiles="
-        + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
-      this->MemoryTesterOptions.push_back(filterFiles);
-      }
-    outputFile = "/SAVETEXTDATA=";
+        if( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration(
+                                       "MemoryCheckSuppressionFile").c_str()) )
+          {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Cannot find memory checker suppression file: "
+                     << this->CTest->GetCTestConfiguration(
+                       "MemoryCheckSuppressionFile").c_str() << std::endl);
+          return false;
+          }
+        std::string filterFiles = "/FilterFiles="
+          + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile");
+        this->MemoryTesterOptions.push_back(filterFiles);
+        }
+      outputFile = "/SAVETEXTDATA=";
 #else
-    outputFile = "-log-file=";
+      outputFile = "-log-file=";
 #endif
-    outputFile += this->MemoryTesterOutputFile;
-    this->MemoryTesterOptions.push_back(outputFile);
-    }
-  else if ( this->MemoryTester.find("BC") != std::string::npos )
-    {
-    this->BoundsCheckerXMLFile = this->MemoryTesterOutputFile;
-    std::string dpbdFile = this->CTest->GetBinaryDir()
-      + "/Testing/Temporary/MemoryChecker.DPbd";
-    this->BoundsCheckerDPBDFile = dpbdFile;
-    this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER;
-    this->MemoryTesterOptions.push_back("/B");
-    this->MemoryTesterOptions.push_back(dpbdFile);
-    this->MemoryTesterOptions.push_back("/X");
-    this->MemoryTesterOptions.push_back(this->MemoryTesterOutputFile);
-    this->MemoryTesterOptions.push_back("/M");
-    }
-  else
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Do not understand memory checker: " << this->MemoryTester.c_str()
-      << std::endl);
-    return false;
+      outputFile += this->MemoryTesterOutputFile;
+      this->MemoryTesterOptions.push_back(outputFile);
+      break;
+      }
+    case cmCTestMemCheckHandler::BOUNDS_CHECKER:
+      {
+      this->BoundsCheckerXMLFile = this->MemoryTesterOutputFile;
+      std::string dpbdFile = this->CTest->GetBinaryDir()
+        + "/Testing/Temporary/MemoryChecker.DPbd";
+      this->BoundsCheckerDPBDFile = dpbdFile;
+      this->MemoryTesterOptions.push_back("/B");
+      this->MemoryTesterOptions.push_back(dpbdFile);
+      this->MemoryTesterOptions.push_back("/X");
+      this->MemoryTesterOptions.push_back(this->MemoryTesterOutputFile);
+      this->MemoryTesterOptions.push_back("/M");
+      break;
+      }
+    default:
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+        "Do not understand memory checker: " << this->MemoryTester.c_str()
+        << std::endl);
+      return false;
     }
 
   std::vector<cmStdString>::size_type cc;

Source/CTest/cmCTestTestHandler.cxx

@@ -1304,9 +1304,10 @@ int cmCTestTestHandler::ExecuteCommands(std::vector<cmStdString>& vec)
   for ( it = vec.begin(); it != vec.end(); ++it )
     {
     int retVal = 0;
-    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " << *it
+    std::string cmd = cmSystemTools::ConvertToOutputPath(it->c_str());
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " << cmd
       << std::endl);
-    if ( !cmSystemTools::RunSingleCommand(it->c_str(), 0, &retVal, 0,
+    if ( !cmSystemTools::RunSingleCommand(cmd.c_str(), 0, &retVal, 0,
                                           cmSystemTools::OUTPUT_MERGE
         /*this->Verbose*/) || retVal != 0 )
       {

Tests/CMakeLists.txt

@@ -57,6 +57,8 @@ if(BUILD_TESTING)
 
   add_subdirectory(FindPackageModeMakefileTest)
 
+  add_subdirectory(CTestTestMemcheck)
+
   # Collect a list of all test build directories.
   set(TEST_BUILD_DIRS)
 

Tests/CTestTestMemcheck/CMakeLists.txt

@@ -0,0 +1,81 @@
+foreach (_retval 0 1)
+  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/ret${_retval}.c" "int main(){return ${_retval};}\n")
+endforeach ()
+
+# create binaries that we will use as a pseudo memory checker
+add_executable(pseudo_valgrind "${CMAKE_CURRENT_BINARY_DIR}/ret0.c")
+set_target_properties(pseudo_valgrind PROPERTIES OUTPUT_NAME valgrind)
+
+# 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 pseudo_valgrind
+                       PRE_BUILD COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_CFG_INTDIR}"
+    )
+endif()
+
+add_executable(pseudo_purify "${CMAKE_CURRENT_BINARY_DIR}/ret0.c")
+set_target_properties(pseudo_purify PROPERTIES OUTPUT_NAME purify)
+add_executable(pseudo_BC "${CMAKE_CURRENT_BINARY_DIR}/ret0.c")
+set_target_properties(pseudo_BC PROPERTIES OUTPUT_NAME BC)
+
+# 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}
+        COMMAND ${CMAKE_CTEST_COMMAND}
+        -S "${CMAKE_CURRENT_BINARY_DIR}/${_test}/test.cmake" -V
+        --output-log "${CMAKE_CURRENT_BINARY_DIR}/${_test}/testOutput.log"
+        -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 ()
+
+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(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
+    PROPERTIES
+    PASS_REGULAR_EXPRESSION "${NORMAL_CTEST_OUTPUT}")
+
+foreach (_pp Pre Post)
+    string(TOLOWER ${_pp} _pp_lower)
+    set_tests_properties(CTestTestMemcheckDummyValgrindFail${_pp}
+        PROPERTIES
+        PASS_REGULAR_EXPRESSION "\nProblem running command: ${CMAKE_CURRENT_BINARY_DIR}[^\n]*fail[^\n]*\n(.*\n)?Problem executing ${_pp_lower}-memcheck command\\(s\\\).\n(.*\n)?Error in read script: ${CMAKE_CURRENT_BINARY_DIR}/DummyValgrindFail${_pp}/test.cmake\n")
+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")
+
+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")

Tests/CTestTestMemcheck/DummyBC/CMakeLists.txt

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

Tests/CTestTestMemcheck/DummyBC/CTestConfig.cmake

@@ -0,0 +1,7 @@
+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/DummyBC/test.cmake.in

@@ -0,0 +1,24 @@
+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_SOURCE_DIRECTORY              "@CMAKE_CURRENT_SOURCE_DIR@/DummyBC")
+set(CTEST_BINARY_DIRECTORY              "@CMAKE_CURRENT_BINARY_DIR@/DummyBC")
+set(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
+set(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
+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}")
+
+#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/DummyPurify/CMakeLists.txt

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

Tests/CTestTestMemcheck/DummyPurify/CTestConfig.cmake

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,24 @@
+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_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

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

Tests/CTestTestMemcheck/DummyValgrind/CTestConfig.cmake

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,24 @@
+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_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

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

Tests/CTestTestMemcheck/DummyValgrindFailPost/CTestConfig.cmake

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,26 @@
+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_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

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

Tests/CTestTestMemcheck/DummyValgrindFailPre/CTestConfig.cmake

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,26 @@
+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_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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,24 @@
+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_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

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

Tests/CTestTestMemcheck/DummyValgrindPrePost/CTestConfig.cmake

@@ -0,0 +1,7 @@
+set (CTEST_PROJECT_NAME "CTestTestMemcheckDummyValgrindPrePost")
+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/DummyValgrindPrePost/test.cmake.in

@@ -0,0 +1,27 @@
+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_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/NotExist/CMakeLists.txt

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

Tests/CTestTestMemcheck/NotExist/CTestConfig.cmake

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,18 @@
+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_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

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

Tests/CTestTestMemcheck/Unknown/CTestConfig.cmake

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,18 @@
+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_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

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

Tests/CTestTestMemcheck/UnknownQuoted/CTestConfig.cmake

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,18 @@
+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_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)