ENH: Cleanups

12 files changed, 82 insertions, 82 deletions

diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx
index 52c90e5..0f9b309 100644
--- a/Source/CTest/cmCTestBuildCommand.cxx
+++ b/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
       {
diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx
index a0e2ee7..5fe8e44 100644
--- a/Source/CTest/cmCTestBuildHandler.cxx
+++ b/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());
diff --git a/Source/CTest/cmCTestConfigureCommand.cxx b/Source/CTest/cmCTestConfigureCommand.cxx
index 7d49ca4..7fd1e50 100644
--- a/Source/CTest/cmCTestConfigureCommand.cxx
+++ b/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 )
diff --git a/Source/CTest/cmCTestConfigureHandler.cxx b/Source/CTest/cmCTestConfigureHandler.cxx
index 9351b31..1f6cc8b 100644
--- a/Source/CTest/cmCTestConfigureHandler.cxx
+++ b/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;
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index 3c7e197..f5872ea 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/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);
diff --git a/Source/CTest/cmCTestMemCheckHandler.cxx b/Source/CTest/cmCTestMemCheckHandler.cxx
index 490236a..ef56428 100644
--- a/Source/CTest/cmCTestMemCheckHandler.cxx
+++ b/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 )
diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx
index 09cdf6e..8f532cb 100644
--- a/Source/CTest/cmCTestStartCommand.cxx
+++ b/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);
diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx
index d21ade0..72fccb8 100644
--- a/Source/CTest/cmCTestSubmitCommand.cxx
+++ b/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 )
diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx
index bac3125..118a81d 100644
--- a/Source/CTest/cmCTestSubmitHandler.cxx
+++ b/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;
diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx
index 7588135..c0a48f3 100644
--- a/Source/CTest/cmCTestTestCommand.cxx
+++ b/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 )
diff --git a/Source/CTest/cmCTestUpdateCommand.cxx b/Source/CTest/cmCTestUpdateCommand.cxx
index 09bf0b8..d8ba866 100644
--- a/Source/CTest/cmCTestUpdateCommand.cxx
+++ b/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 )
diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx
index 7aecdb1..d6b11af 100644
--- a/Source/CTest/cmCTestUpdateHandler.cxx
+++ b/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;