ENH: Cleanups

Source/CTest/cmCTestBuildCommand.cxx

@@ -33,7 +33,7 @@ bool cmCTestBuildCommand::InitialPass(
   const char* build_dir = args[0].c_str();
   const char* res_var = args[1].c_str();
 
-  m_CTest->SetDartConfiguration("BuildDirectory", build_dir);
+  m_CTest->SetCTestConfiguration("BuildDirectory", build_dir);
   cmCTestGenericHandler* handler = m_CTest->GetHandler("build");
   if ( !handler )
     {
@@ -44,7 +44,7 @@ bool cmCTestBuildCommand::InitialPass(
   const char* ctestBuildCommand = m_Makefile->GetDefinition("CTEST_BUILD_COMMAND");
   if ( ctestBuildCommand && *ctestBuildCommand )
     {
-    m_CTest->SetDartConfiguration("MakeCommand", ctestBuildCommand);
+    m_CTest->SetCTestConfiguration("MakeCommand", ctestBuildCommand);
     }
   else
     {
@@ -66,7 +66,7 @@ bool cmCTestBuildCommand::InitialPass(
       std::string buildCommand = gen->GenerateBuildCommand(cmakeMakeProgram, cmakeProjectName,
         0, cmakeBuildConfiguration, true);
 
-      m_CTest->SetDartConfiguration("MakeCommand", buildCommand.c_str());
+      m_CTest->SetCTestConfiguration("MakeCommand", buildCommand.c_str());
       }
     else
       {

Source/CTest/cmCTestBuildHandler.cxx

@@ -197,13 +197,13 @@ void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf)
 int cmCTestBuildHandler::ProcessHandler()
 {
   std::cout << "Build project" << std::endl;
-  const std::string &makeCommand = m_CTest->GetDartConfiguration("MakeCommand");
+  const std::string &makeCommand = m_CTest->GetCTestConfiguration("MakeCommand");
   if ( makeCommand.size() == 0 )
     {
     std::cerr << "Cannot find MakeCommand key in the DartConfiguration.tcl" << std::endl;
     return -1;
     }
-  const std::string &buildDirectory = m_CTest->GetDartConfiguration("BuildDirectory");
+  const std::string &buildDirectory = m_CTest->GetCTestConfiguration("BuildDirectory");
   if ( buildDirectory.size() == 0 )
     {
     std::cerr << "Cannot find BuildDirectory  key in the DartConfiguration.tcl" << std::endl;
@@ -239,11 +239,11 @@ int cmCTestBuildHandler::ProcessHandler()
     }
 
   std::vector<cmStdString>::size_type cc;
-  if ( m_CTest->GetDartConfiguration("SourceDirectory").size() > 20 ||
-    m_CTest->GetDartConfiguration("BuildDirectory").size() > 20 )
+  if ( m_CTest->GetCTestConfiguration("SourceDirectory").size() > 20 ||
+    m_CTest->GetCTestConfiguration("BuildDirectory").size() > 20 )
     {
-    std::string srcdir = m_CTest->GetDartConfiguration("SourceDirectory") + "/";
-    std::string bindir = m_CTest->GetDartConfiguration("BuildDirectory") + "/";
+    std::string srcdir = m_CTest->GetCTestConfiguration("SourceDirectory") + "/";
+    std::string bindir = m_CTest->GetCTestConfiguration("BuildDirectory") + "/";
     std::string srcdirrep;
     std::string bindirrep;
     for ( cc = srcdir.size()-2; cc > 0; cc -- )
@@ -456,7 +456,7 @@ void cmCTestBuildHandler::GenerateDartBuildOutput(
   os << "<Build>\n"
      << "\t<StartDateTime>" << m_StartBuild << "</StartDateTime>\n"
      << "<BuildCommand>" 
-     << m_CTest->MakeXMLSafe(m_CTest->GetDartConfiguration("MakeCommand"))
+     << m_CTest->MakeXMLSafe(m_CTest->GetCTestConfiguration("MakeCommand"))
      << "</BuildCommand>" << std::endl;
     
   std::vector<cmCTestBuildErrorWarning>::iterator it;
@@ -464,7 +464,7 @@ void cmCTestBuildHandler::GenerateDartBuildOutput(
   // only report the first 50 warnings and first 50 errors
   unsigned short numErrorsAllowed = 50;
   unsigned short numWarningsAllowed = 50;
-  std::string srcdir = m_CTest->GetDartConfiguration("SourceDirectory");
+  std::string srcdir = m_CTest->GetCTestConfiguration("SourceDirectory");
   // make sure the source dir is in the correct case on windows
   // via a call to collapse full path.
   srcdir = cmSystemTools::CollapseFullPath(srcdir.c_str());

Source/CTest/cmCTestConfigureCommand.cxx

@@ -31,8 +31,8 @@ bool cmCTestConfigureCommand::InitialPass(
   const char* build_dir = args[0].c_str();
   const char* res_var = args[1].c_str();
 
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "ConfigureCommand", "CTEST_CONFIGURE_COMMAND");
-  m_CTest->SetDartConfiguration("BuildDirectory", build_dir);
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "ConfigureCommand", "CTEST_CONFIGURE_COMMAND");
+  m_CTest->SetCTestConfiguration("BuildDirectory", build_dir);
 
   cmCTestGenericHandler* handler = m_CTest->GetHandler("configure");
   if ( !handler )

Source/CTest/cmCTestConfigureHandler.cxx

@@ -37,7 +37,7 @@ cmCTestConfigureHandler::cmCTestConfigureHandler()
 int cmCTestConfigureHandler::ProcessHandler()
 {
   std::cout << "Configure project" << std::endl;
-  std::string cCommand = m_CTest->GetDartConfiguration("ConfigureCommand");
+  std::string cCommand = m_CTest->GetCTestConfiguration("ConfigureCommand");
   if ( cCommand.size() == 0 )
     {
     std::cerr << "Cannot find ConfigureCommand key in the DartConfiguration.tcl" 
@@ -45,7 +45,7 @@ int cmCTestConfigureHandler::ProcessHandler()
     return -1;
     }
 
-  std::string buildDirectory = m_CTest->GetDartConfiguration("BuildDirectory");
+  std::string buildDirectory = m_CTest->GetCTestConfiguration("BuildDirectory");
   if ( buildDirectory.size() == 0 )
     {
     std::cerr << "Cannot find BuildDirectory  key in the DartConfiguration.tcl" << std::endl;

Source/CTest/cmCTestCoverageHandler.cxx

@@ -158,9 +158,9 @@ int cmCTestCoverageHandler::ProcessHandler()
 {
   int error = 0;
 
-  std::string sourceDir = m_CTest->GetDartConfiguration("SourceDirectory");
-  std::string binaryDir = m_CTest->GetDartConfiguration("BuildDirectory");
-  std::string gcovCommand = m_CTest->GetDartConfiguration("CoverageCommand");
+  std::string sourceDir = m_CTest->GetCTestConfiguration("SourceDirectory");
+  std::string binaryDir = m_CTest->GetCTestConfiguration("BuildDirectory");
+  std::string gcovCommand = m_CTest->GetCTestConfiguration("CoverageCommand");
 
   cmSystemTools::ConvertToUnixSlashes(sourceDir);
   cmSystemTools::ConvertToUnixSlashes(binaryDir);

Source/CTest/cmCTestMemCheckHandler.cxx

@@ -279,20 +279,20 @@ void cmCTestMemCheckHandler::GenerateDartOutput(std::ostream& os)
 bool cmCTestMemCheckHandler::InitializeMemoryChecking()
 {
   // Setup the command
-  if ( cmSystemTools::FileExists(m_CTest->GetDartConfiguration("MemoryCheckCommand").c_str()) )
+  if ( cmSystemTools::FileExists(m_CTest->GetCTestConfiguration("MemoryCheckCommand").c_str()) )
     {
     m_MemoryTester 
-      = cmSystemTools::ConvertToOutputPath(m_CTest->GetDartConfiguration("MemoryCheckCommand").c_str());
+      = cmSystemTools::ConvertToOutputPath(m_CTest->GetCTestConfiguration("MemoryCheckCommand").c_str());
     }
-  else if ( cmSystemTools::FileExists(m_CTest->GetDartConfiguration("PurifyCommand").c_str()) )
+  else if ( cmSystemTools::FileExists(m_CTest->GetCTestConfiguration("PurifyCommand").c_str()) )
     {
     m_MemoryTester 
-      = cmSystemTools::ConvertToOutputPath(m_CTest->GetDartConfiguration("PurifyCommand").c_str());
+      = cmSystemTools::ConvertToOutputPath(m_CTest->GetCTestConfiguration("PurifyCommand").c_str());
     }
-  else if ( cmSystemTools::FileExists(m_CTest->GetDartConfiguration("ValgrindCommand").c_str()) )
+  else if ( cmSystemTools::FileExists(m_CTest->GetCTestConfiguration("ValgrindCommand").c_str()) )
     {
     m_MemoryTester 
-      = cmSystemTools::ConvertToOutputPath(m_CTest->GetDartConfiguration("ValgrindCommand").c_str());
+      = cmSystemTools::ConvertToOutputPath(m_CTest->GetCTestConfiguration("ValgrindCommand").c_str());
     }
   else
     {
@@ -307,13 +307,13 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
     }
 
   // Setup the options
-  if ( m_CTest->GetDartConfiguration("MemoryCheckCommandOptions").size() )
+  if ( m_CTest->GetCTestConfiguration("MemoryCheckCommandOptions").size() )
     {
-    m_MemoryTesterOptions = m_CTest->GetDartConfiguration("MemoryCheckCommandOptions");
+    m_MemoryTesterOptions = m_CTest->GetCTestConfiguration("MemoryCheckCommandOptions");
     }
-  else if ( m_CTest->GetDartConfiguration("ValgrindCommandOptions").size() )
+  else if ( m_CTest->GetCTestConfiguration("ValgrindCommandOptions").size() )
     {
-    m_MemoryTesterOptions = m_CTest->GetDartConfiguration("ValgrindCommandOptions");
+    m_MemoryTesterOptions = m_CTest->GetCTestConfiguration("ValgrindCommandOptions");
     }
 
   m_MemoryTesterOutputFile = m_CTest->GetBinaryDir() + "/Testing/Temporary/MemoryChecker.log";
@@ -326,15 +326,15 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking()
       {
       m_MemoryTesterOptions = "-q --skin=memcheck --leak-check=yes --show-reachable=yes --workaround-gcc296-bugs=yes --num-callers=100";
       }
-    if ( m_CTest->GetDartConfiguration("MemoryCheckSuppressionFile").size() )
+    if ( m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").size() )
       {
-      if ( !cmSystemTools::FileExists(m_CTest->GetDartConfiguration("MemoryCheckSuppressionFile").c_str()) )
+      if ( !cmSystemTools::FileExists(m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").c_str()) )
         {
         std::cerr << "Cannot find memory checker suppression file: " 
-          << m_CTest->GetDartConfiguration("MemoryCheckSuppressionFile").c_str() << std::endl;
+          << m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").c_str() << std::endl;
         return false;
         }
-      m_MemoryTesterOptions += " --suppressions=" + cmSystemTools::EscapeSpaces(m_CTest->GetDartConfiguration("MemoryCheckSuppressionFile").c_str()) + "";
+      m_MemoryTesterOptions += " --suppressions=" + cmSystemTools::EscapeSpaces(m_CTest->GetCTestConfiguration("MemoryCheckSuppressionFile").c_str()) + "";
       }
     }
   else if ( m_MemoryTester.find("purify") != std::string::npos )

Source/CTest/cmCTestStartCommand.cxx

@@ -84,9 +84,9 @@ bool cmCTestStartCommand::InitialPass(
       }
     }
 
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "NightlyStartTime", "CTEST_NIGHTLY_START_TIME");
-  m_CTest->SetDartConfiguration("SourceDirectory", src_dir);
-  m_CTest->SetDartConfiguration("BuildDirectory", bld_dir); 
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "NightlyStartTime", "CTEST_NIGHTLY_START_TIME");
+  m_CTest->SetCTestConfiguration("SourceDirectory", src_dir);
+  m_CTest->SetCTestConfiguration("BuildDirectory", bld_dir); 
 
   int model = m_CTest->GetTestModelFromString(smodel);
   m_CTest->SetTestModel(model);

Source/CTest/cmCTestSubmitCommand.cxx

@@ -30,13 +30,13 @@ bool cmCTestSubmitCommand::InitialPass(
 
   const char* res_var = args[0].c_str();
 
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "DropMethod", "CTEST_DROP_METHOD");
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "DropSite", "CTEST_DROP_SITE");
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "DropLocation", "CTEST_DROP_LOCATION");
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "DropSiteUser", "CTEST_DROP_SITE_USER");
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "DropSitePassword", "CTEST_DROP_SITE_PASSWORD");
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "TriggerSite", "CTEST_TRIGGER_SITE");
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "ScpCommand", "CTEST_SCP_COMMAND");
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "DropMethod", "CTEST_DROP_METHOD");
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "DropSite", "CTEST_DROP_SITE");
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "DropLocation", "CTEST_DROP_LOCATION");
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "DropSiteUser", "CTEST_DROP_SITE_USER");
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "DropSitePassword", "CTEST_DROP_SITE_PASSWORD");
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "TriggerSite", "CTEST_TRIGGER_SITE");
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "ScpCommand", "CTEST_SCP_COMMAND");
 
   cmCTestGenericHandler* handler = m_CTest->GetHandler("submit");
   if ( !handler )

Source/CTest/cmCTestSubmitHandler.cxx

@@ -645,7 +645,7 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
 //----------------------------------------------------------------------------
 int cmCTestSubmitHandler::ProcessHandler()
 {
-  const std::string &buildDirectory = m_CTest->GetDartConfiguration("BuildDirectory");
+  const std::string &buildDirectory = m_CTest->GetCTestConfiguration("BuildDirectory");
   if ( buildDirectory.size() == 0 )
     {
     std::cerr << "Cannot find BuildDirectory  key in the DartConfiguration.tcl" << std::endl;
@@ -700,19 +700,19 @@ int cmCTestSubmitHandler::ProcessHandler()
       cnt ++;
       }
     }
-  std::cout << "Submit files (using " << m_CTest->GetDartConfiguration("DropMethod") << ")"
+  std::cout << "Submit files (using " << m_CTest->GetCTestConfiguration("DropMethod") << ")"
     << std::endl;
   this->SetLogFile(&ofs);
-  if ( m_CTest->GetDartConfiguration("DropMethod") == "" ||
-    m_CTest->GetDartConfiguration("DropMethod") ==  "ftp" )
+  if ( m_CTest->GetCTestConfiguration("DropMethod") == "" ||
+    m_CTest->GetCTestConfiguration("DropMethod") ==  "ftp" )
     {
     ofs << "Using drop method: FTP" << std::endl;
     std::cout << "  Using FTP submit method" << std::endl;
     std::string url = "ftp://";
-    url += cmCTest::MakeURLSafe(m_CTest->GetDartConfiguration("DropSiteUser")) + ":" + 
-      cmCTest::MakeURLSafe(m_CTest->GetDartConfiguration("DropSitePassword")) + "@" + 
-      m_CTest->GetDartConfiguration("DropSite") + 
-      cmCTest::MakeURLSafe(m_CTest->GetDartConfiguration("DropLocation"));
+    url += cmCTest::MakeURLSafe(m_CTest->GetCTestConfiguration("DropSiteUser")) + ":" + 
+      cmCTest::MakeURLSafe(m_CTest->GetCTestConfiguration("DropSitePassword")) + "@" + 
+      m_CTest->GetCTestConfiguration("DropSite") + 
+      cmCTest::MakeURLSafe(m_CTest->GetCTestConfiguration("DropLocation"));
     if ( !this->SubmitUsingFTP(buildDirectory+"/Testing/"+m_CTest->GetCurrentTag(), 
         files, prefix, url) )
       {
@@ -720,7 +720,7 @@ int cmCTestSubmitHandler::ProcessHandler()
       ofs << "  Problems when submitting via FTP" << std::endl;
       return -1;
       }
-    if ( !this->TriggerUsingHTTP(files, prefix, m_CTest->GetDartConfiguration("TriggerSite")) )
+    if ( !this->TriggerUsingHTTP(files, prefix, m_CTest->GetCTestConfiguration("TriggerSite")) )
       {
       std::cerr << "  Problems when triggering via HTTP" << std::endl;
       ofs << "  Problems when triggering via HTTP" << std::endl;
@@ -730,28 +730,28 @@ int cmCTestSubmitHandler::ProcessHandler()
     ofs << "  Submission successful" << std::endl;
     return 0;
     }
-  else if ( m_CTest->GetDartConfiguration("DropMethod") == "http" )
+  else if ( m_CTest->GetCTestConfiguration("DropMethod") == "http" )
     {
     ofs << "Using drop method: HTTP" << std::endl;
     std::cout << "  Using HTTP submit method" << std::endl;
     std::string url = "http://";
-    if ( m_CTest->GetDartConfiguration("DropSiteUser").size() > 0 )
+    if ( m_CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
       {
-      url += m_CTest->GetDartConfiguration("DropSiteUser");
-      if ( m_CTest->GetDartConfiguration("DropSitePassword").size() > 0 )
+      url += m_CTest->GetCTestConfiguration("DropSiteUser");
+      if ( m_CTest->GetCTestConfiguration("DropSitePassword").size() > 0 )
         {
-        url += ":" + m_CTest->GetDartConfiguration("DropSitePassword");
+        url += ":" + m_CTest->GetCTestConfiguration("DropSitePassword");
         }
       url += "@";
       }
-    url += m_CTest->GetDartConfiguration("DropSite") + m_CTest->GetDartConfiguration("DropLocation");
+    url += m_CTest->GetCTestConfiguration("DropSite") + m_CTest->GetCTestConfiguration("DropLocation");
     if ( !this->SubmitUsingHTTP(buildDirectory +"/Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) )
       {
       std::cerr << "  Problems when submitting via HTTP" << std::endl;
       ofs << "  Problems when submitting via HTTP" << std::endl;
       return -1;
       }
-    if ( !this->TriggerUsingHTTP(files, prefix, m_CTest->GetDartConfiguration("TriggerSite")) )
+    if ( !this->TriggerUsingHTTP(files, prefix, m_CTest->GetCTestConfiguration("TriggerSite")) )
       {
       std::cerr << "  Problems when triggering via HTTP" << std::endl;
       ofs << "  Problems when triggering via HTTP" << std::endl;
@@ -761,12 +761,12 @@ int cmCTestSubmitHandler::ProcessHandler()
     ofs << "  Submission successful" << std::endl;
     return 0;
     }
-  else if ( m_CTest->GetDartConfiguration("DropMethod") == "xmlrpc" )
+  else if ( m_CTest->GetCTestConfiguration("DropMethod") == "xmlrpc" )
     {
     ofs << "Using drop method: XML-RPC" << std::endl;
     std::cout << "  Using XML-RPC submit method" << std::endl;
-    std::string url = m_CTest->GetDartConfiguration("DropSite");
-    prefix = m_CTest->GetDartConfiguration("DropLocation");
+    std::string url = m_CTest->GetCTestConfiguration("DropSite");
+    prefix = m_CTest->GetCTestConfiguration("DropLocation");
     if ( !this->SubmitUsingXMLRPC(buildDirectory+"/Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) )
       {
       std::cerr << "  Problems when submitting via XML-RPC" << std::endl;
@@ -777,16 +777,16 @@ int cmCTestSubmitHandler::ProcessHandler()
     ofs << "  Submission successful" << std::endl;
     return 0;
     }
-  else if ( m_CTest->GetDartConfiguration("DropMethod") == "scp" )
+  else if ( m_CTest->GetCTestConfiguration("DropMethod") == "scp" )
     {
     std::string url;
-    if ( m_CTest->GetDartConfiguration("DropSiteUser").size() > 0 )
+    if ( m_CTest->GetCTestConfiguration("DropSiteUser").size() > 0 )
       {
-      url += m_CTest->GetDartConfiguration("DropSiteUser") + "@";
+      url += m_CTest->GetCTestConfiguration("DropSiteUser") + "@";
       }
-    url += m_CTest->GetDartConfiguration("DropSite") + ":" + m_CTest->GetDartConfiguration("DropLocation");
+    url += m_CTest->GetCTestConfiguration("DropSite") + ":" + m_CTest->GetCTestConfiguration("DropLocation");
 
-    if ( !this->SubmitUsingSCP(m_CTest->GetDartConfiguration("ScpCommand"),
+    if ( !this->SubmitUsingSCP(m_CTest->GetCTestConfiguration("ScpCommand"),
         buildDirectory+"/Testing/"+m_CTest->GetCurrentTag(), files, prefix, url) )
       {
       std::cerr << "  Problems when submitting via SCP" << std::endl;
@@ -796,15 +796,15 @@ int cmCTestSubmitHandler::ProcessHandler()
     std::cout << "  Submission successful" << std::endl;
     ofs << "  Submission successful" << std::endl;
     }
-  std::cout << "   Unknown submission method: \"" << m_CTest->GetDartConfiguration("DropMethod") << "\"" << std::endl;
+  std::cout << "   Unknown submission method: \"" << m_CTest->GetCTestConfiguration("DropMethod") << "\"" << std::endl;
   return -1;
 }
 
 //----------------------------------------------------------------------------
 std::string cmCTestSubmitHandler::GetSubmitResultsPrefix()
 {
-  std::string name = m_CTest->GetDartConfiguration("Site") +
-    "___" + m_CTest->GetDartConfiguration("BuildName") +
+  std::string name = m_CTest->GetCTestConfiguration("Site") +
+    "___" + m_CTest->GetCTestConfiguration("BuildName") +
     "___" + m_CTest->GetCurrentTag() + "-" +
     m_CTest->GetTestModelString() + "___XML___";
   return name;

Source/CTest/cmCTestTestCommand.cxx

@@ -31,7 +31,7 @@ bool cmCTestTestCommand::InitialPass(
   const char* build_dir = args[0].c_str();
   const char* res_var = args[1].c_str();
 
-  m_CTest->SetDartConfiguration("BuildDirectory", build_dir);
+  m_CTest->SetCTestConfiguration("BuildDirectory", build_dir);
 
   cmCTestGenericHandler* handler = m_CTest->GetHandler("test");
   if ( !handler )

Source/CTest/cmCTestUpdateCommand.cxx

@@ -31,8 +31,8 @@ bool cmCTestUpdateCommand::InitialPass(
   const char* source_dir = args[0].c_str();
   const char* res_var = args[1].c_str();
 
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "CVSCommand", "CTEST_CVS_COMMAND");
-  m_CTest->SetDartConfigurationFromCMakeVariable(m_Makefile, "SVNCommand", "CTEST_SVN_COMMAND");
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "CVSCommand", "CTEST_CVS_COMMAND");
+  m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile, "SVNCommand", "CTEST_SVN_COMMAND");
 
   cmCTestGenericHandler* handler = m_CTest->GetHandler("update");
   if ( !handler )

Source/CTest/cmCTestUpdateHandler.cxx

@@ -218,13 +218,13 @@ int cmCTestUpdateHandler::ProcessHandler()
   std::cout << "Updating the repository: " << sourceDirectory << std::endl;
 
   // Get update command
-  std::string updateCommand = m_CTest->GetDartConfiguration("UpdateCommand");
+  std::string updateCommand = m_CTest->GetCTestConfiguration("UpdateCommand");
   if ( updateCommand.empty() )
     {
-    updateCommand = m_CTest->GetDartConfiguration("CVSCommand");
+    updateCommand = m_CTest->GetCTestConfiguration("CVSCommand");
     if ( updateCommand.empty() )
       {
-      updateCommand = m_CTest->GetDartConfiguration("SVNCommand");
+      updateCommand = m_CTest->GetCTestConfiguration("SVNCommand");
       if ( updateCommand.empty() )
         {
         std::cerr << "Cannot find CVSCommand, SVNCommand, or UpdateCommand key in the DartConfiguration.tcl" << std::endl;
@@ -242,20 +242,20 @@ int cmCTestUpdateHandler::ProcessHandler()
     }
   else
     {
-    updateType = this->DetermineType(updateCommand.c_str(), m_CTest->GetDartConfiguration("UpdateType").c_str());
+    updateType = this->DetermineType(updateCommand.c_str(), m_CTest->GetCTestConfiguration("UpdateType").c_str());
     }
 
   // And update options
-  std::string updateOptions = m_CTest->GetDartConfiguration("UpdateOptions");
+  std::string updateOptions = m_CTest->GetCTestConfiguration("UpdateOptions");
   if ( updateOptions.empty() )
     {
     switch (updateType)
       {
     case cmCTestUpdateHandler::e_CVS:
-      updateOptions = m_CTest->GetDartConfiguration("CVSUpdateOptions");
+      updateOptions = m_CTest->GetCTestConfiguration("CVSUpdateOptions");
       break;
     case cmCTestUpdateHandler::e_SVN:
-      updateOptions = m_CTest->GetDartConfiguration("SVNUpdateOptions");
+      updateOptions = m_CTest->GetCTestConfiguration("SVNUpdateOptions");
       break;
       }
     }
@@ -264,7 +264,7 @@ int cmCTestUpdateHandler::ProcessHandler()
   std::string extra_update_opts;
   if ( m_CTest->GetTestModel() == cmCTest::NIGHTLY )
     {
-    struct tm* t = cmCTest::GetNightlyTime(m_CTest->GetDartConfiguration("NightlyStartTime"),
+    struct tm* t = cmCTest::GetNightlyTime(m_CTest->GetCTestConfiguration("NightlyStartTime"),
       m_Verbose, m_CTest->GetTomorrowTag());
     char current_time[1024];
     sprintf(current_time, "%04d-%02d-%02d %02d:%02d:%02d",
@@ -418,8 +418,8 @@ int cmCTestUpdateHandler::ProcessHandler()
   os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
     << "<Update mode=\"Client\" Generator=\"ctest-"
     << cmVersion::GetCMakeVersion() << "\">\n"
-    << "\t<Site>" << m_CTest->GetDartConfiguration("Site") << "</Site>\n"
-    << "\t<BuildName>" << m_CTest->GetDartConfiguration("BuildName")
+    << "\t<Site>" << m_CTest->GetCTestConfiguration("Site") << "</Site>\n"
+    << "\t<BuildName>" << m_CTest->GetCTestConfiguration("BuildName")
     << "</BuildName>\n"
     << "\t<BuildStamp>" << m_CTest->GetCurrentTag() << "-"
     << m_CTest->GetTestModelString() << "</BuildStamp>" << std::endl;

Source/cmCTest.cxx

@@ -344,7 +344,7 @@ int cmCTest::Initialize(const char* binary_dir)
       //std::cout << "TestModel: " << m_TestModel << std::endl;
       if ( m_TestModel == cmCTest::NIGHTLY )
         {
-        lctime = cmCTest::GetNightlyTime(m_DartConfiguration["NightlyStartTime"],
+        lctime = cmCTest::GetNightlyTime(m_CTestConfiguration["NightlyStartTime"],
           m_ExtraVerbose,
           m_TomorrowTag);
         }
@@ -424,13 +424,13 @@ bool cmCTest::UpdateCTestConfiguration()
       }
     std::string key = line.substr(0, cpos);
     std::string value = cmCTest::CleanString(line.substr(cpos+1, line.npos));
-    m_DartConfiguration[key] = value;
+    m_CTestConfiguration[key] = value;
     }
   fin.close();
   if ( m_ProduceXML )
     {
-    m_TimeOut = atoi(m_DartConfiguration["TimeOut"].c_str());
-    m_CompressXMLFiles = cmSystemTools::IsOn(m_DartConfiguration["CompressSubmission"].c_str());
+    m_TimeOut = atoi(m_CTestConfiguration["TimeOut"].c_str());
+    m_CompressXMLFiles = cmSystemTools::IsOn(m_CTestConfiguration["CompressSubmission"].c_str());
     }
   return true;
 }
@@ -621,7 +621,7 @@ int cmCTest::ProcessTests()
   if ( m_Tests[UPDATE_TEST] || m_Tests[ALL_TEST] )
     {
     cmCTestGenericHandler* uphandler = this->GetHandler("update");
-    uphandler->SetOption("SourceDirectory", this->GetDartConfiguration("SourceDirectory").c_str());
+    uphandler->SetOption("SourceDirectory", this->GetCTestConfiguration("SourceDirectory").c_str());
     update_count = uphandler->ProcessHandler(); 
     if ( update_count < 0 )
       {
@@ -977,10 +977,10 @@ int cmCTest::RunTest(std::vector<const char*> argv,
 void cmCTest::StartXML(std::ostream& ostr)
 {
   ostr << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
-    << "<Site BuildName=\"" << m_DartConfiguration["BuildName"]
+    << "<Site BuildName=\"" << m_CTestConfiguration["BuildName"]
     << "\" BuildStamp=\"" << m_CurrentTag << "-"
     << this->GetTestModelString() << "\" Name=\""
-    << m_DartConfiguration["Site"] << "\" Generator=\"ctest"
+    << m_CTestConfiguration["Site"] << "\" Generator=\"ctest"
     << cmVersion::GetCMakeVersion()
     << "\">" << std::endl;
 }
@@ -990,14 +990,14 @@ void cmCTest::EndXML(std::ostream& ostr)
   ostr << "</Site>" << std::endl;
 }
 
-int cmCTest::GenerateDartNotesOutput(std::ostream& os, const cmCTest::tm_VectorOfStrings& files)
+int cmCTest::GenerateCTestNotesOutput(std::ostream& os, const cmCTest::tm_VectorOfStrings& files)
 {
   cmCTest::tm_VectorOfStrings::const_iterator it;
   os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
     << "<?xml-stylesheet type=\"text/xsl\" href=\"Dart/Source/Server/XSL/Build.xsl <file:///Dart/Source/Server/XSL/Build.xsl> \"?>\n"
-    << "<Site BuildName=\"" << m_DartConfiguration["BuildName"] << "\" BuildStamp=\"" 
+    << "<Site BuildName=\"" << m_CTestConfiguration["BuildName"] << "\" BuildStamp=\"" 
     << m_CurrentTag << "-" << this->GetTestModelString() << "\" Name=\"" 
-    << m_DartConfiguration["Site"] << "\" Generator=\"ctest"
+    << m_CTestConfiguration["Site"] << "\" Generator=\"ctest"
     << cmVersion::GetCMakeVersion()
     << "\">\n"
     << "<Notes>" << std::endl;
@@ -1056,7 +1056,7 @@ int cmCTest::GenerateNotesFile(const char* cfiles)
     return 1;
     }
 
-  this->GenerateDartNotesOutput(ofs, files);
+  this->GenerateCTestNotesOutput(ofs, files);
   return 0;
 }
 
@@ -1995,8 +1995,8 @@ void cmCTest::PopulateCustomInteger(cmMakefile* mf, const char* def, int& val)
 
 std::string cmCTest::GetShortPathToFile(const char* cfname)
 {
-  const std::string& sourceDir = this->GetDartConfiguration("SourceDirectory");
-  const std::string& buildDir = this->GetDartConfiguration("BuildDirectory");
+  const std::string& sourceDir = this->GetCTestConfiguration("SourceDirectory");
+  const std::string& buildDir = this->GetCTestConfiguration("BuildDirectory");
   std::string fname = cmSystemTools::CollapseFullPath(cfname);
 
   // Find relative paths to both directories
@@ -2046,12 +2046,12 @@ std::string cmCTest::GetShortPathToFile(const char* cfname)
   return path;
 }
 
-std::string cmCTest::GetDartConfiguration(const char *name)
+std::string cmCTest::GetCTestConfiguration(const char *name)
 {
-  return m_DartConfiguration[name];
+  return m_CTestConfiguration[name];
 }
 
-void cmCTest::SetDartConfiguration(const char *name, const char* value)
+void cmCTest::SetCTestConfiguration(const char *name, const char* value)
 {
   if ( !name )
     {
@@ -2059,10 +2059,10 @@ void cmCTest::SetDartConfiguration(const char *name, const char* value)
     }
   if ( !value )
     {
-    m_DartConfiguration.erase(name);
+    m_CTestConfiguration.erase(name);
     return;
     }
-  m_DartConfiguration[name] = value;
+  m_CTestConfiguration[name] = value;
 }
 
   
@@ -2096,7 +2096,7 @@ bool cmCTest::GetProduceXML()
   return m_ProduceXML;
 }
 
-bool cmCTest::SetDartConfigurationFromCMakeVariable(cmMakefile* mf, const char* dconfig, const char* cmake_var)
+bool cmCTest::SetCTestConfigurationFromCMakeVariable(cmMakefile* mf, const char* dconfig, const char* cmake_var)
 {
   const char* ctvar;
   ctvar = mf->GetDefinition(cmake_var);
@@ -2104,6 +2104,6 @@ bool cmCTest::SetDartConfigurationFromCMakeVariable(cmMakefile* mf, const char*
     {
     return false;
     }
-  this->SetDartConfiguration(dconfig, ctvar);
+  this->SetCTestConfiguration(dconfig, ctvar);
   return true;
 }

Source/cmCTest.h

@@ -94,8 +94,8 @@ public:
   std::string GetTestModelString();
   static int GetTestModelFromString(const char* str);
   static std::string CleanString(const std::string& str);
-  std::string GetDartConfiguration(const char *name);
-  void SetDartConfiguration(const char *name, const char* value);
+  std::string GetCTestConfiguration(const char *name);
+  void SetCTestConfiguration(const char *name, const char* value);
   
   /**
    * constructor and destructor
@@ -191,7 +191,7 @@ public:
   /*
    * Set the CTest variable from CMake variable
    */
-  bool SetDartConfigurationFromCMakeVariable(cmMakefile* mf, const char* dconfig, const char* cmake_var);
+  bool SetCTestConfigurationFromCMakeVariable(cmMakefile* mf, const char* dconfig, const char* cmake_var);
 
   //! Make string safe to be send as an URL
   static std::string MakeURLSafe(const std::string&);
@@ -229,10 +229,10 @@ private:
   };
   
   //! Map of configuration properties
-  typedef std::map<cmStdString, cmStdString> tm_DartConfigurationMap;
+  typedef std::map<cmStdString, cmStdString> tm_CTestConfigurationMap;
 
   std::string             m_CTestConfigFile;
-  tm_DartConfigurationMap m_DartConfiguration;
+  tm_CTestConfigurationMap m_CTestConfiguration;
   int                     m_Tests[LAST_TEST];
   
   std::string             m_CurrentTag;
@@ -279,7 +279,7 @@ private:
   bool UpdateCTestConfiguration();
 
   //! Create not from files.
-  int GenerateDartNotesOutput(std::ostream& os, const tm_VectorOfStrings& files);
+  int GenerateCTestNotesOutput(std::ostream& os, const tm_VectorOfStrings& files);
 
   ///! Run CMake and build a test and then run it as a single test.
   int RunCMakeAndTest(std::string* output);