diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index 91f300994..bb8f0a4ac 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -212,6 +212,7 @@ SET(CMTEST_SRCS cmCTest.cxx
CTest/cmCTestCoverageHandler.cxx
CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
CTest/cmCTestGenericHandler.cxx
+ CTest/cmCTestHandlerCommand.cxx
CTest/cmCTestMemCheckCommand.cxx
CTest/cmCTestMemCheckHandler.cxx
CTest/cmCTestRunScriptCommand.cxx
diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx
index 01af29473..10420af77 100644
--- a/Source/CTest/cmCTestBuildAndTestHandler.cxx
+++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx
@@ -34,6 +34,7 @@ cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
//----------------------------------------------------------------------
void cmCTestBuildAndTestHandler::Initialize()
{
+ this->Superclass::Initialize();
}
//----------------------------------------------------------------------
diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx
index 79c4e3c10..fcfdf2fdc 100644
--- a/Source/CTest/cmCTestBuildCommand.cxx
+++ b/Source/CTest/cmCTestBuildCommand.cxx
@@ -91,7 +91,7 @@ bool cmCTestBuildCommand::InitialPass(
m_CTest->SetCTestConfiguration("BuildDirectory", build_dir);
}
- cmCTestGenericHandler* handler = m_CTest->GetHandler("build");
+ cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("build");
if ( !handler )
{
this->SetError("internal CTest error. Cannot instantiate build handler");
diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx
index afae26b70..158e55f7b 100644
--- a/Source/CTest/cmCTestBuildHandler.cxx
+++ b/Source/CTest/cmCTestBuildHandler.cxx
@@ -189,6 +189,7 @@ cmCTestBuildHandler::cmCTestBuildHandler()
//----------------------------------------------------------------------
void cmCTestBuildHandler::Initialize()
{
+ this->Superclass::Initialize();
m_StartBuild = "";
m_EndBuild = "";
m_CustomErrorMatches.clear();
@@ -282,9 +283,9 @@ int cmCTestBuildHandler::ProcessHandler()
// Create a last build log
cmGeneratedFileStream ofs;
double elapsed_time_start = cmSystemTools::GetTime();
- if ( !m_CTest->OpenOutputFile("Temporary", "LastBuild.log", ofs) )
+ if ( !this->StartLogFile("Build", ofs) )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create LastBuild.log file" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create build log file" << std::endl);
}
// Create lists of regular expression strings for errors, error exceptions,
@@ -414,7 +415,7 @@ int cmCTestBuildHandler::ProcessHandler()
// Generate XML output
cmGeneratedFileStream xofs;
- if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Build.xml", xofs, true) )
+ if( !this->StartResultingXML("Build", xofs))
{
cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create build XML file" << std::endl);
return -1;
diff --git a/Source/CTest/cmCTestConfigureCommand.cxx b/Source/CTest/cmCTestConfigureCommand.cxx
index f7744d7df..8f3574c9f 100644
--- a/Source/CTest/cmCTestConfigureCommand.cxx
+++ b/Source/CTest/cmCTestConfigureCommand.cxx
@@ -132,7 +132,7 @@ bool cmCTestConfigureCommand::InitialPass(
}
}
- cmCTestGenericHandler* handler = m_CTest->GetHandler("configure");
+ cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("configure");
if ( !handler )
{
this->SetError("internal CTest error. Cannot instantiate configure handler");
diff --git a/Source/CTest/cmCTestConfigureHandler.cxx b/Source/CTest/cmCTestConfigureHandler.cxx
index b336f504c..07d41906b 100644
--- a/Source/CTest/cmCTestConfigureHandler.cxx
+++ b/Source/CTest/cmCTestConfigureHandler.cxx
@@ -31,6 +31,7 @@ cmCTestConfigureHandler::cmCTestConfigureHandler()
//----------------------------------------------------------------------
void cmCTestConfigureHandler::Initialize()
{
+ this->Superclass::Initialize();
}
//----------------------------------------------------------------------
@@ -61,7 +62,7 @@ int cmCTestConfigureHandler::ProcessHandler()
if ( !m_CTest->GetShowOnly() )
{
cmGeneratedFileStream os;
- if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Configure.xml", os, true) )
+ if ( !this->StartResultingXML("Configure", os) )
{
cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open configure file" << std::endl);
return 1;
@@ -69,7 +70,7 @@ int cmCTestConfigureHandler::ProcessHandler()
std::string start_time = m_CTest->CurrentTime();
cmGeneratedFileStream ofs;
- m_CTest->OpenOutputFile("Temporary", "LastConfigure.log", ofs);
+ this->StartLogFile("Configure", ofs);
cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Configure with command: " << cCommand.c_str() << std::endl);
res = m_CTest->RunMakeCommand(cCommand.c_str(), &output,
&retVal, buildDirectory.c_str(),
diff --git a/Source/CTest/cmCTestCoverageCommand.cxx b/Source/CTest/cmCTestCoverageCommand.cxx
index 5a36e6b3d..340693edd 100644
--- a/Source/CTest/cmCTestCoverageCommand.cxx
+++ b/Source/CTest/cmCTestCoverageCommand.cxx
@@ -74,7 +74,7 @@ bool cmCTestCoverageCommand::InitialPass(
m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
"CoverageCommand", "CTEST_COVERAGE_COMMAND");
- cmCTestGenericHandler* handler = m_CTest->GetHandler("coverage");
+ cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("coverage");
if ( !handler )
{
this->SetError("internal CTest error. Cannot instantiate test handler");
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index 915eb8cf5..b87fb5e51 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -39,16 +39,16 @@ cmCTestCoverageHandler::cmCTestCoverageHandler()
//----------------------------------------------------------------------
void cmCTestCoverageHandler::Initialize()
{
+ this->Superclass::Initialize();
}
//----------------------------------------------------------------------
-bool cmCTestCoverageHandler::StartLogFile(cmGeneratedFileStream& covLogFile, int logFileCount)
+bool cmCTestCoverageHandler::StartCoverageLogFile(cmGeneratedFileStream& covLogFile, int logFileCount)
{
char covLogFilename[1024];
- sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount);
+ sprintf(covLogFilename, "CoverageLog-%d", logFileCount);
cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Open file: " << covLogFilename << std::endl);
- if (!m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(),
- covLogFilename, covLogFile, true))
+ if (!this->StartResultingXML(covLogFilename, covLogFile) )
{
cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open log file: " << covLogFilename << std::endl);
return false;
@@ -61,7 +61,7 @@ bool cmCTestCoverageHandler::StartLogFile(cmGeneratedFileStream& covLogFile, int
}
//----------------------------------------------------------------------
-void cmCTestCoverageHandler::EndLogFile(cmGeneratedFileStream& ostr, int logFileCount)
+void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount)
{
std::string local_end_time = m_CTest->CurrentTime();
ostr << "\t" << local_end_time << "" << std::endl
@@ -161,7 +161,7 @@ int cmCTestCoverageHandler::ProcessHandler()
cmGeneratedFileStream ofs;
double elapsed_time_start = cmSystemTools::GetTime();
- if ( !m_CTest->OpenOutputFile("Temporary", "LastCoverage.log", ofs) )
+ if ( !this->StartLogFile("Coverage", ofs) )
{
cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create LastCoverage.log file" << std::endl);
}
@@ -333,10 +333,9 @@ int cmCTestCoverageHandler::ProcessHandler()
cmGeneratedFileStream covSumFile;
cmGeneratedFileStream covLogFile;
- if (!m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(),
- "Coverage.xml", covSumFile, true))
+ if (!this->StartResultingXML("Coverage", covSumFile))
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open coverage summary file: Coverage.xml" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open coverage summary file." << std::endl);
return -1;
}
@@ -347,7 +346,7 @@ int cmCTestCoverageHandler::ProcessHandler()
covSumFile << "" << std::endl
<< "\t" << coverage_start_time << "" << std::endl;
int logFileCount = 0;
- if ( !this->StartLogFile(covLogFile, logFileCount) )
+ if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
{
return -1;
}
@@ -364,9 +363,9 @@ int cmCTestCoverageHandler::ProcessHandler()
if ( cnt == 100 )
{
cnt = 0;
- this->EndLogFile(covLogFile, logFileCount);
+ this->EndCoverageLogFile(covLogFile, logFileCount);
logFileCount ++;
- if ( !this->StartLogFile(covLogFile, logFileCount) )
+ if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
{
return -1;
}
@@ -468,7 +467,7 @@ int cmCTestCoverageHandler::ProcessHandler()
<< "\t" << std::endl;
cnt ++;
}
- this->EndLogFile(covLogFile, logFileCount);
+ this->EndCoverageLogFile(covLogFile, logFileCount);
int total_lines = total_tested + total_untested;
float percent_coverage = 100 * SAFEDIV(static_cast(total_tested),
diff --git a/Source/CTest/cmCTestCoverageHandler.h b/Source/CTest/cmCTestCoverageHandler.h
index c2a686d98..9ad287344 100644
--- a/Source/CTest/cmCTestCoverageHandler.h
+++ b/Source/CTest/cmCTestCoverageHandler.h
@@ -45,8 +45,8 @@ public:
private:
bool ShouldIDoCoverage(const char* file, const char* srcDir,
const char* binDir);
- bool StartLogFile(cmGeneratedFileStream& ostr, int logFileCount);
- void EndLogFile(cmGeneratedFileStream& ostr, int logFileCount);
+ bool StartCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
+ void EndCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount);
struct cmCTestCoverage
{
diff --git a/Source/CTest/cmCTestGenericHandler.cxx b/Source/CTest/cmCTestGenericHandler.cxx
index 12ee3612a..1499d2406 100644
--- a/Source/CTest/cmCTestGenericHandler.cxx
+++ b/Source/CTest/cmCTestGenericHandler.cxx
@@ -17,11 +17,14 @@
#include "cmCTestGenericHandler.h"
+#include "cmCTest.h"
+
//----------------------------------------------------------------------
cmCTestGenericHandler::cmCTestGenericHandler()
{
m_HandlerVerbose = false;
m_CTest = 0;
+ m_SubmitIndex = 0;
}
//----------------------------------------------------------------------
@@ -50,6 +53,12 @@ void cmCTestGenericHandler::SetOption(const char* op, const char* value)
m_Options[op] = value;
}
+//----------------------------------------------------------------------
+void cmCTestGenericHandler::Initialize()
+{
+ m_Options.clear();
+}
+
//----------------------------------------------------------------------
const char* cmCTestGenericHandler::GetOption(const char* op)
{
@@ -62,3 +71,51 @@ const char* cmCTestGenericHandler::GetOption(const char* op)
return remit->second.c_str();
}
+//----------------------------------------------------------------------
+bool cmCTestGenericHandler::StartResultingXML(const char* name, cmGeneratedFileStream& xofs)
+{
+ if ( !name )
+ {
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create resulting XML file without providing the name" << std::endl;);
+ return false;
+ }
+ cmOStringStream ostr;
+ ostr << name;
+ if ( m_SubmitIndex > 0 )
+ {
+ ostr << "_" << m_SubmitIndex;
+ }
+ ostr << ".xml";
+ if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), ostr.str().c_str(), xofs, true) )
+ {
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create resulting XML file: " << ostr.str().c_str() << std::endl);
+ return false;
+ }
+ m_CTest->AddSubmitFile(ostr.str().c_str());
+ return true;
+}
+
+//----------------------------------------------------------------------
+bool cmCTestGenericHandler::StartLogFile(const char* name, cmGeneratedFileStream& xofs)
+{
+ if ( !name )
+ {
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create log file without providing the name" << std::endl;);
+ return false;
+ }
+ cmOStringStream ostr;
+ ostr << "Last" << name;
+ if ( m_SubmitIndex > 0 )
+ {
+ ostr << "_" << m_SubmitIndex;
+ }
+ ostr << "_" << m_CTest->GetCurrentTag();
+ ostr << ".log";
+ if( !m_CTest->OpenOutputFile("Temporary", ostr.str().c_str(), xofs) )
+ {
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create log file: " << ostr.str().c_str() << std::endl);
+ return false;
+ }
+ return true;
+}
+
diff --git a/Source/CTest/cmCTestGenericHandler.h b/Source/CTest/cmCTestGenericHandler.h
index e2013a19b..29f199b2f 100644
--- a/Source/CTest/cmCTestGenericHandler.h
+++ b/Source/CTest/cmCTestGenericHandler.h
@@ -24,6 +24,7 @@
class cmCTest;
class cmMakefile;
class cmCTestCommand;
+class cmGeneratedFileStream;
/** \class cmCTestGenericHandler
* \brief A superclass of all CTest Handlers
@@ -58,7 +59,7 @@ public:
/**
* Initialize handler
*/
- virtual void Initialize() = 0;
+ virtual void Initialize();
/**
* Set the CTest instance
@@ -82,12 +83,19 @@ public:
m_Command = command;
}
+ void SetSubmitIndex(int idx) { m_SubmitIndex = idx; }
+ int GetSubmitIndex() { return m_SubmitIndex; }
+
protected:
+ bool StartResultingXML(const char* name, cmGeneratedFileStream& xofs);
+ bool StartLogFile(const char* name, cmGeneratedFileStream& xofs);
+
bool m_HandlerVerbose;
cmCTest *m_CTest;
t_StringToString m_Options;
cmCTestCommand* m_Command;
+ int m_SubmitIndex;
};
#endif
diff --git a/Source/CTest/cmCTestHandlerCommand.cxx b/Source/CTest/cmCTestHandlerCommand.cxx
new file mode 100644
index 000000000..56aa3bc86
--- /dev/null
+++ b/Source/CTest/cmCTestHandlerCommand.cxx
@@ -0,0 +1,133 @@
+/*=========================================================================
+
+ Program: CMake - Cross-Platform Makefile Generator
+ Module: $RCSfile$
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+ Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
+ See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+#include "cmCTestHandlerCommand.h"
+
+#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
+
+cmCTestHandlerCommand::cmCTestHandlerCommand()
+{
+ const size_t INIT_SIZE = 100;
+ size_t cc;
+ m_Arguments.reserve(INIT_SIZE);
+ for ( cc = 0; cc < INIT_SIZE; ++ cc )
+ {
+ m_Arguments[cc] = 0;
+ }
+ m_Arguments[ct_RETURN_VALUE] = "RETURN_VALUE";
+ m_Arguments[ct_SOURCE] = "SOURCE";
+ m_Arguments[ct_BUILD] = "BUILD";
+ m_Arguments[ct_SUBMIT_INDEX] = "SUBMIT_INDEX";
+ m_Last = ct_LAST;
+}
+
+bool cmCTestHandlerCommand::InitialPass(
+ std::vector const& args)
+{
+ if ( !this->ProcessArguments(args, m_Last, &*m_Arguments.begin(), m_Values) )
+ {
+ return false;
+ }
+
+ cmCTestGenericHandler* handler = this->InitializeHandler();
+ if ( !handler )
+ {
+ this->SetError("internal CTest error. Cannot instantiate test handler");
+ return false;
+ }
+
+ if ( m_Values[ct_BUILD] )
+ {
+ m_CTest->SetCTestConfiguration("BuildDirectory", m_Values[ct_BUILD]);
+ }
+ if ( m_Values[ct_SUBMIT_INDEX] )
+ {
+ if ( m_CTest->GetDartVersion() <= 1 )
+ {
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Dart before version 2.0 does not support collecting submissions." << std::endl
+ << "Please upgrade the server to Dart 2 or higher, or do not use SUBMIT_INDEX." << std::endl);
+ }
+ else
+ {
+ handler->SetSubmitIndex(atoi(m_Values[ct_SUBMIT_INDEX]));
+ }
+ }
+
+
+ std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
+ cmSystemTools::ChangeDirectory(m_CTest->GetCTestConfiguration("BuildDirectory").c_str());
+ int res = handler->ProcessHandler();
+ if ( m_Values[ct_RETURN_VALUE] && *m_Values[ct_RETURN_VALUE])
+ {
+ cmOStringStream str;
+ str << res;
+ m_Makefile->AddDefinition(m_Values[ct_RETURN_VALUE], str.str().c_str());
+ }
+ cmSystemTools::ChangeDirectory(current_dir.c_str());
+ return true;
+}
+
+bool cmCTestHandlerCommand::ProcessArguments(std::vector const& args,
+ int last, const char** strings, std::vector& values)
+{
+ int state = 0;
+ int cc;
+ values.resize(last);
+ for ( cc = 0; cc < last; ++ cc )
+ {
+ values[cc] = 0;
+ }
+
+ for(size_t i=0; i < args.size(); ++i)
+ {
+ if ( state > 0 && state < last )
+ {
+ values[state] = args[i].c_str();
+#undef cerr
+ cmCTestLog(m_CTest, DEBUG, "Set " << strings[state] << " to " << args[i].c_str() << std::endl);
+ state = 0;
+ }
+ else
+ {
+ bool found = false;
+ for ( cc = 0; cc < last; ++ cc )
+ {
+ if ( strings[cc] && args[i] == strings[cc] )
+ {
+ state = cc;
+ if ( values[state] )
+ {
+ cmOStringStream ostr;
+ ostr << "called with incorrect number of arguments. " << strings[state] << " specified twice.";
+ this->SetError(ostr.str().c_str());
+ return false;
+ }
+ found = true;
+ break;
+ }
+ }
+ if ( !found )
+ {
+ cmOStringStream str;
+ str << "called with incorrect number of arguments. Extra argument is: " << args[i].c_str() << ".";
+ this->SetError(str.str().c_str());
+ return false;
+ }
+ }
+ }
+ return true;
+}
diff --git a/Source/CTest/cmCTestHandlerCommand.h b/Source/CTest/cmCTestHandlerCommand.h
new file mode 100644
index 000000000..2f6b5165b
--- /dev/null
+++ b/Source/CTest/cmCTestHandlerCommand.h
@@ -0,0 +1,63 @@
+/*=========================================================================
+
+ Program: CMake - Cross-Platform Makefile Generator
+ Module: $RCSfile$
+ Language: C++
+ Date: $Date$
+ Version: $Revision$
+
+ Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
+ See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ PURPOSE. See the above copyright notices for more information.
+
+=========================================================================*/
+#ifndef cmCTestHandlerCommand_h
+#define cmCTestHandlerCommand_h
+
+#include "cmCTestCommand.h"
+
+class cmCTestGenericHandler;
+
+/** \class cmCTestHandler
+ * \brief Run a ctest script
+ *
+ * cmCTestHandlerCommand defineds the command to test the project.
+ */
+class cmCTestHandlerCommand : public cmCTestCommand
+{
+public:
+ cmCTestHandlerCommand();
+
+ /**
+ * This is called when the command is first encountered in
+ * the CMakeLists.txt file.
+ */
+ virtual bool InitialPass(std::vector const& args);
+
+ cmTypeMacro(cmCTestHandlerCommand, cmCTestCommand);
+
+ enum
+ {
+ ct_NONE,
+ ct_RETURN_VALUE,
+ ct_BUILD,
+ ct_SOURCE,
+ ct_SUBMIT_INDEX,
+ ct_LAST
+ };
+
+protected:
+ virtual cmCTestGenericHandler* InitializeHandler() = 0;
+ bool ProcessArguments(std::vector const& args,
+ int last, const char** strings, std::vector& values);
+
+ std::string m_ReturnVariable;
+ std::vector m_Arguments;
+ std::vector m_Values;
+ size_t m_Last;
+};
+
+#endif
diff --git a/Source/CTest/cmCTestMemCheckCommand.cxx b/Source/CTest/cmCTestMemCheckCommand.cxx
index f8ca9a063..7bf04637e 100644
--- a/Source/CTest/cmCTestMemCheckCommand.cxx
+++ b/Source/CTest/cmCTestMemCheckCommand.cxx
@@ -19,57 +19,10 @@
#include "cmCTest.h"
#include "cmCTestGenericHandler.h"
-bool cmCTestMemCheckCommand::InitialPass(
- std::vector const& args)
+
+cmCTestGenericHandler* cmCTestMemCheckCommand::InitializeActualHandler()
{
- const char* build_dir = 0;
- const char* res_var = 0;
-
- bool havereturn_variable = false;
- bool havesource = false;
- for(size_t i=0; i < args.size(); ++i)
- {
- if ( havereturn_variable )
- {
- res_var = args[i].c_str();
- havereturn_variable = false;
- }
- else if ( havesource )
- {
- build_dir = args[i].c_str();
- havesource = false;
- }
- else if(args[i] == "RETURN_VALUE")
- {
- if ( res_var )
- {
- this->SetError("called with incorrect number of arguments. RETURN_VALUE specified twice.");
- return false;
- }
- havereturn_variable = true;
- }
- else if(args[i] == "BUILD")
- {
- if ( build_dir )
- {
- this->SetError("called with incorrect number of arguments. BUILD specified twice.");
- return false;
- }
- havesource = true;
- }
- else
- {
- cmOStringStream str;
- str << "called with incorrect number of arguments. Extra argument is: " << args[i].c_str() << ".";
- this->SetError(str.str().c_str());
- return false;
- }
- }
-
- if ( build_dir )
- {
- m_CTest->SetCTestConfiguration("BuildDirectory", build_dir);
- }
+ cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("memcheck");
m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
"MemoryCheckCommand", "CTEST_MEMORYCHECK_COMMAND");
@@ -78,24 +31,6 @@ bool cmCTestMemCheckCommand::InitialPass(
m_CTest->SetCTestConfigurationFromCMakeVariable(m_Makefile,
"MemoryCheckSuppressionFile", "CTEST_MEMORYCHECK_SUPPRESSIONS_FILE");
- cmCTestGenericHandler* handler = m_CTest->GetHandler("memcheck");
- if ( !handler )
- {
- this->SetError("internal CTest error. Cannot instantiate test handler");
- return false;
- }
- std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
- cmSystemTools::ChangeDirectory(m_CTest->GetCTestConfiguration("BuildDirectory").c_str());
- int res = handler->ProcessHandler();
- if ( res_var )
- {
- cmOStringStream str;
- str << res;
- m_Makefile->AddDefinition(res_var, str.str().c_str());
- }
- cmSystemTools::ChangeDirectory(current_dir.c_str());
- return true;
+ return handler;
}
-
-
diff --git a/Source/CTest/cmCTestMemCheckCommand.h b/Source/CTest/cmCTestMemCheckCommand.h
index 72b509507..9e66216c3 100644
--- a/Source/CTest/cmCTestMemCheckCommand.h
+++ b/Source/CTest/cmCTestMemCheckCommand.h
@@ -17,14 +17,16 @@
#ifndef cmCTestMemCheckCommand_h
#define cmCTestMemCheckCommand_h
-#include "cmCTestCommand.h"
+#include "cmCTestTestCommand.h"
+
+class cmCTestGenericHandler;
/** \class cmCTestMemCheck
* \brief Run a ctest script
*
* cmCTestMemCheckCommand defineds the command to test the project.
*/
-class cmCTestMemCheckCommand : public cmCTestCommand
+class cmCTestMemCheckCommand : public cmCTestTestCommand
{
public:
@@ -41,12 +43,6 @@ public:
return ni;
}
- /**
- * This is called when the command is first encountered in
- * the CMakeLists.txt file.
- */
- virtual bool InitialPass(std::vector const& args);
-
/**
* The name of the command as specified in CMakeList.txt.
*/
@@ -72,8 +68,10 @@ public:
"will hold value.";
}
- cmTypeMacro(cmCTestMemCheckCommand, cmCTestCommand);
+ cmTypeMacro(cmCTestMemCheckCommand, cmCTestTestCommand);
+protected:
+ cmCTestGenericHandler* InitializeActualHandler();
};
diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx
index f71983f17..34ec49361 100644
--- a/Source/CTest/cmCTestScriptHandler.cxx
+++ b/Source/CTest/cmCTestScriptHandler.cxx
@@ -100,6 +100,7 @@ cmCTestScriptHandler::cmCTestScriptHandler()
//----------------------------------------------------------------------
void cmCTestScriptHandler::Initialize()
{
+ this->Superclass::Initialize();
m_Backup = false;
m_EmptyBinDir = false;
m_EmptyBinDirOnce = false;
diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx
index 7b6645b0c..20e657194 100644
--- a/Source/CTest/cmCTestStartCommand.cxx
+++ b/Source/CTest/cmCTestStartCommand.cxx
@@ -68,8 +68,9 @@ bool cmCTestStartCommand::InitialPass(
m_CTest->SetCTestConfiguration("SourceDirectory", src_dir);
m_CTest->SetCTestConfiguration("BuildDirectory", bld_dir);
- cmCTestLog(m_CTest, OUTPUT, "Run dashboard with model " << smodel << std::endl
- << " Source directory: " << src_dir << std::endl << " Build directory: " << bld_dir << std::endl);
+ cmCTestLog(m_CTest, HANDLER_OUTPUT, "Run dashboard with model " << smodel << std::endl
+ << " Source directory: " << src_dir << std::endl
+ << " Build directory: " << bld_dir << std::endl);
m_Makefile->AddDefinition("CTEST_RUN_CURRENT_SCRIPT", "OFF");
m_CTest->SetSuppressUpdatingCTestConfiguration(true);
diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx
index f744947c7..81252a767 100644
--- a/Source/CTest/cmCTestSubmitCommand.cxx
+++ b/Source/CTest/cmCTestSubmitCommand.cxx
@@ -98,7 +98,7 @@ bool cmCTestSubmitCommand::InitialPass(
m_CTest->GenerateNotesFile(newNotesFiles);
}
- cmCTestGenericHandler* handler = m_CTest->GetHandler("submit");
+ cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("submit");
if ( !handler )
{
this->SetError("internal CTest error. Cannot instantiate submit handler");
diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx
index 147166025..4112907ff 100644
--- a/Source/CTest/cmCTestSubmitHandler.cxx
+++ b/Source/CTest/cmCTestSubmitHandler.cxx
@@ -70,6 +70,7 @@ cmCTestSubmitHandler::cmCTestSubmitHandler() : m_HTTPProxy(), m_FTPProxy()
//----------------------------------------------------------------------------
void cmCTestSubmitHandler::Initialize()
{
+ this->Superclass::Initialize();
m_HTTPProxy = "";
m_HTTPProxyType = 0;
m_HTTPProxyAuth = "";
@@ -80,7 +81,7 @@ void cmCTestSubmitHandler::Initialize()
//----------------------------------------------------------------------------
bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
- const std::vector& files,
+ const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url)
{
@@ -92,8 +93,8 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
/* In windows, this will init the winsock stuff */
::curl_global_init(CURL_GLOBAL_ALL);
- cmStdString::size_type cc;
- for ( cc = 0; cc < files.size(); cc ++ )
+ cmCTest::tm_SetOfStrings::iterator file;
+ for ( file = files.begin(); file != files.end(); ++file )
{
/* get a curl handle */
curl = curl_easy_init();
@@ -119,12 +120,15 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
// enable uploading
::curl_easy_setopt(curl, CURLOPT_UPLOAD, 1) ;
- cmStdString local_file = localprefix + "/" + files[cc];
- cmStdString upload_as = url + "/" + remoteprefix + files[cc];
+ cmStdString local_file = localprefix + "/" + *file;
+ cmStdString upload_as = url + "/" + remoteprefix + *file;
struct stat st;
if ( ::stat(local_file.c_str(), &st) )
{
+ cmCTestLog(m_CTest, ERROR_MESSAGE, " Cannot find file: " << local_file.c_str() << std::endl);
+ ::curl_easy_cleanup(curl);
+ ::curl_global_cleanup();
return false;
}
@@ -192,7 +196,7 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const cmStdString& localprefix,
//----------------------------------------------------------------------------
// Uploading files is simpler
bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
- const std::vector& files,
+ const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url)
{
@@ -204,8 +208,9 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
/* In windows, this will init the winsock stuff */
::curl_global_init(CURL_GLOBAL_ALL);
- cmStdString::size_type cc, kk;
- for ( cc = 0; cc < files.size(); cc ++ )
+ cmStdString::size_type kk;
+ cmCTest::tm_SetOfStrings::iterator file;
+ for ( file = files.begin(); file != files.end(); ++file )
{
/* get a curl handle */
curl = curl_easy_init();
@@ -241,8 +246,8 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
::curl_easy_setopt(curl, CURLOPT_PUT, 1);
::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
- cmStdString local_file = localprefix + "/" + files[cc];
- cmStdString remote_file = remoteprefix + files[cc];
+ cmStdString local_file = localprefix + "/" + *file;
+ cmStdString remote_file = remoteprefix + *file;
*m_LogFile << "\tUpload file: " << local_file.c_str() << " to "
<< remote_file.c_str() << std::endl;
@@ -277,6 +282,9 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
struct stat st;
if ( ::stat(local_file.c_str(), &st) )
{
+ cmCTestLog(m_CTest, ERROR_MESSAGE, " Cannot find file: " << local_file.c_str() << std::endl);
+ ::curl_easy_cleanup(curl);
+ ::curl_global_cleanup();
return false;
}
@@ -339,7 +347,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const cmStdString& localprefix,
}
//----------------------------------------------------------------------------
-bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::vector& files,
+bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url)
{
@@ -349,8 +357,8 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::vector& file
/* In windows, this will init the winsock stuff */
::curl_global_init(CURL_GLOBAL_ALL);
- cmStdString::size_type cc, kk;
- for ( cc = 0; cc < files.size(); cc ++ )
+ cmCTest::tm_SetOfStrings::iterator file;
+ for ( file = files.begin(); file != files.end(); ++file )
{
/* get a curl handle */
curl = curl_easy_init();
@@ -393,11 +401,12 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::vector& file
::curl_easy_setopt(curl, CURLOPT_FILE, (void *)&chunk);
::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
- cmStdString file = remoteprefix + files[cc];
+ cmStdString rfile = remoteprefix + *file;
cmStdString ofile = "";
- for ( kk = 0; kk < file.size(); kk ++ )
+ cmStdString::iterator kk;
+ for ( kk = rfile.begin(); kk < rfile.end(); ++ kk)
{
- char c = file[kk];
+ char c = *kk;
char hex[4] = { 0, 0, 0, 0 };
hex[0] = c;
switch ( c )
@@ -456,7 +465,7 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP(const std::vector& file
bool cmCTestSubmitHandler::SubmitUsingSCP(
const cmStdString& scp_command,
const cmStdString& localprefix,
- const std::vector& files,
+ const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url)
{
@@ -477,19 +486,17 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
int problems = 0;
- std::vector::const_iterator it;
- for ( it = files.begin();
- it != files.end();
- it ++ )
+ cmCTest::tm_SetOfStrings::iterator file;
+ for ( file = files.begin(); file != files.end(); ++file )
{
int retVal;
std::string lfname = localprefix;
cmSystemTools::ConvertToUnixSlashes(lfname);
- lfname += "/" + *it;
+ lfname += "/" + *file;
lfname = cmSystemTools::ConvertToOutputPath(lfname.c_str());
argv[1] = lfname.c_str();
- std::string rfname = url + "/" + remoteprefix + *it;
+ std::string rfname = url + "/" + remoteprefix + *file;
argv[2] = rfname.c_str();
cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Execute \"" << argv[0] << "\" \"" << argv[1] << "\" \""
<< argv[2] << "\"" << std::endl);
@@ -548,7 +555,7 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(
//----------------------------------------------------------------------------
bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
- const std::vector& files,
+ const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url)
{
@@ -565,12 +572,12 @@ bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const cmStdString& localprefix,
/* Call the famous server at UserLand. */
cmCTestLog(m_CTest, HANDLER_OUTPUT, " Submitting to: " << realURL.c_str() << " (" << remoteprefix.c_str() << ")" << std::endl);
- std::vector::const_iterator it;
- for ( it = files.begin(); it != files.end(); ++it )
+ cmCTest::tm_SetOfStrings::iterator file;
+ for ( file = files.begin(); file != files.end(); ++file )
{
xmlrpc_value *result;
- std::string local_file = localprefix + "/" + *it;
+ std::string local_file = localprefix + "/" + *file;
cmCTestLog(m_CTest, HANDLER_OUTPUT, " Submit file: " << local_file.c_str() << std::endl);
struct stat st;
if ( ::stat(local_file.c_str(), &st) )
@@ -705,9 +712,9 @@ int cmCTestSubmitHandler::ProcessHandler()
cmCTestLog(m_CTest, HANDLER_OUTPUT, " Use FTP Proxy: " << m_FTPProxy << std::endl);
}
cmGeneratedFileStream ofs;
- m_CTest->OpenOutputFile("Temporary", "LastSubmit.log", ofs);
+ this->StartLogFile("Submit", ofs);
- cmCTest::tm_VectorOfStrings files;
+ cmCTest::tm_SetOfStrings files;
std::string prefix = this->GetSubmitResultsPrefix();
// TODO:
// Check if test is enabled
@@ -729,7 +736,7 @@ int cmCTestSubmitHandler::ProcessHandler()
{
gfiles[cc] = gfiles[cc].substr(glen);
cmCTestLog(m_CTest, DEBUG, "Glob file: " << gfiles[cc].c_str() << std::endl);
- files.push_back(gfiles[cc]);
+ files.insert(gfiles[cc]);
}
}
else
@@ -741,11 +748,19 @@ int cmCTestSubmitHandler::ProcessHandler()
m_CTest->AddIfExists(files, "Purify.xml");
m_CTest->AddIfExists(files, "Notes.xml");
+ cmCTest::tm_SetOfStrings::iterator it;
+ for ( it = m_CTest->GetSubmitFiles()->begin();
+ it != m_CTest->GetSubmitFiles()->end();
+ ++ it )
+ {
+ files.insert(files.end(), *it);
+ }
+
if ( ofs )
{
ofs << "Upload files:" << std::endl;
int cnt = 0;
- cmCTest::tm_VectorOfStrings::iterator it;
+ cmCTest::tm_SetOfStrings::iterator it;
for ( it = files.begin(); it != files.end(); ++ it )
{
ofs << cnt << "\t" << it->c_str() << std::endl;
diff --git a/Source/CTest/cmCTestSubmitHandler.h b/Source/CTest/cmCTestSubmitHandler.h
index 804710fcc..0450de8d7 100644
--- a/Source/CTest/cmCTestSubmitHandler.h
+++ b/Source/CTest/cmCTestSubmitHandler.h
@@ -47,25 +47,25 @@ private:
* Submit file using various ways
*/
bool SubmitUsingFTP(const cmStdString& localprefix,
- const std::vector& files,
+ const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url);
bool SubmitUsingHTTP(const cmStdString& localprefix,
- const std::vector& files,
+ const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url);
bool SubmitUsingSCP(const cmStdString& scp_command,
const cmStdString& localprefix,
- const std::vector& files,
+ const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url);
- bool TriggerUsingHTTP(const std::vector& files,
+ bool TriggerUsingHTTP(const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url);
bool SubmitUsingXMLRPC(const cmStdString& localprefix,
- const std::vector& files,
+ const std::set& files,
const cmStdString& remoteprefix,
const cmStdString& url);
diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx
index 38b705144..6be718c08 100644
--- a/Source/CTest/cmCTestTestCommand.cxx
+++ b/Source/CTest/cmCTestTestCommand.cxx
@@ -19,75 +19,42 @@
#include "cmCTest.h"
#include "cmCTestGenericHandler.h"
-bool cmCTestTestCommand::InitialPass(
- std::vector const& args)
+cmCTestTestCommand::cmCTestTestCommand()
{
- const char* build_dir = 0;
- const char* res_var = 0;
-
- bool havereturn_variable = false;
- bool havesource = false;
- for(size_t i=0; i < args.size(); ++i)
- {
- if ( havereturn_variable )
- {
- res_var = args[i].c_str();
- havereturn_variable = false;
- }
- else if ( havesource )
- {
- build_dir = args[i].c_str();
- havesource = false;
- }
- else if(args[i] == "RETURN_VALUE")
- {
- if ( res_var )
- {
- this->SetError("called with incorrect number of arguments. RETURN_VALUE specified twice.");
- return false;
- }
- havereturn_variable = true;
- }
- else if(args[i] == "BUILD")
- {
- if ( build_dir )
- {
- this->SetError("called with incorrect number of arguments. BUILD specified twice.");
- return false;
- }
- havesource = true;
- }
- else
- {
- cmOStringStream str;
- str << "called with incorrect number of arguments. Extra argument is: " << args[i].c_str() << ".";
- this->SetError(str.str().c_str());
- return false;
- }
- }
-
- if ( build_dir )
- {
- m_CTest->SetCTestConfiguration("BuildDirectory", build_dir);
- }
-
- cmCTestGenericHandler* handler = m_CTest->GetHandler("test");
- if ( !handler )
- {
- this->SetError("internal CTest error. Cannot instantiate test handler");
- return false;
- }
- std::string current_dir = cmSystemTools::GetCurrentWorkingDirectory();
- cmSystemTools::ChangeDirectory(m_CTest->GetCTestConfiguration("BuildDirectory").c_str());
- int res = handler->ProcessHandler();
- if ( res_var )
- {
- cmOStringStream str;
- str << res;
- m_Makefile->AddDefinition(res_var, str.str().c_str());
- }
- cmSystemTools::ChangeDirectory(current_dir.c_str());
- return true;
+ m_Arguments[ctt_START] = "START";
+ m_Arguments[ctt_END] = "END";
+ m_Arguments[ctt_STRIDE] = "STRIDE";
+ m_Arguments[ctt_LAST] = 0;
+ m_Last = ctt_LAST;
}
+cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
+{
+ cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("test");
+ if ( m_Values[ctt_START] || m_Values[ctt_END] || m_Values[ctt_STRIDE] )
+ {
+ cmOStringStream testsToRunString;
+ if ( m_Values[ctt_START] )
+ {
+ testsToRunString << m_Values[ctt_START];
+ }
+ testsToRunString << ",";
+ if ( m_Values[ctt_END] )
+ {
+ testsToRunString << m_Values[ctt_END];
+ }
+ testsToRunString << ",";
+ if ( m_Values[ctt_STRIDE] )
+ {
+ testsToRunString << m_Values[ctt_STRIDE];
+ }
+ handler->SetOption("TestsToRunInformation", testsToRunString.str().c_str());
+ }
+ return handler;
+}
+
+cmCTestGenericHandler* cmCTestTestCommand::InitializeActualHandler()
+{
+ return m_CTest->GetInitializedHandler("test");
+}
diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h
index c0e6bf3f9..d68de9f8a 100644
--- a/Source/CTest/cmCTestTestCommand.h
+++ b/Source/CTest/cmCTestTestCommand.h
@@ -17,18 +17,20 @@
#ifndef cmCTestTestCommand_h
#define cmCTestTestCommand_h
-#include "cmCTestCommand.h"
+#include "cmCTestHandlerCommand.h"
+
+class cmCTestGenericHandler;
/** \class cmCTestTest
* \brief Run a ctest script
*
* cmCTestTestCommand defineds the command to test the project.
*/
-class cmCTestTestCommand : public cmCTestCommand
+class cmCTestTestCommand : public cmCTestHandlerCommand
{
public:
- cmCTestTestCommand() {}
+ cmCTestTestCommand();
/**
* This is a virtual constructor for the command.
@@ -41,12 +43,6 @@ public:
return ni;
}
- /**
- * This is called when the command is first encountered in
- * the CMakeLists.txt file.
- */
- virtual bool InitialPass(std::vector const& args);
-
/**
* The name of the command as specified in CMakeList.txt.
*/
@@ -71,8 +67,20 @@ public:
"second argument is a variable that will hold value.";
}
- cmTypeMacro(cmCTestTestCommand, cmCTestCommand);
+ cmTypeMacro(cmCTestTestCommand, cmCTestHandlerCommand);
+protected:
+ cmCTestGenericHandler* InitializeActualHandler();
+ cmCTestGenericHandler* InitializeHandler();
+
+ enum {
+ ctt_BUILD = ct_LAST,
+ ctt_RETURN_VALUE,
+ ctt_START,
+ ctt_END,
+ ctt_STRIDE,
+ ctt_LAST
+ };
};
diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx
index 368272ab3..44756b531 100644
--- a/Source/CTest/cmCTestTestHandler.cxx
+++ b/Source/CTest/cmCTestTestHandler.cxx
@@ -296,6 +296,8 @@ cmCTestTestHandler::cmCTestTestHandler()
//----------------------------------------------------------------------
void cmCTestTestHandler::Initialize()
{
+ this->Superclass::Initialize();
+
m_ElapsedTestingTime = -1;
m_TestResults.clear();
@@ -435,7 +437,7 @@ int cmCTestTestHandler::ProcessHandler()
cmGeneratedFileStream ofs;
cmCTestLog(m_CTest, ERROR_MESSAGE, std::endl << "The following tests FAILED:" << std::endl);
- m_CTest->OpenOutputFile("Temporary", "LastTestsFailed.log", ofs);
+ this->StartLogFile("TestsFailed", ofs);
std::vector::iterator ftit;
for(ftit = m_TestResults.begin();
@@ -456,8 +458,7 @@ int cmCTestTestHandler::ProcessHandler()
if ( m_CTest->GetProduceXML() )
{
cmGeneratedFileStream xmlfile;
- if( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(),
- (m_MemCheck ? "DynamicAnalysis.xml" : "Test.xml"), xmlfile, true) )
+ if( !this->StartResultingXML((m_MemCheck ? "DynamicAnalysis" : "Test"), xmlfile) )
{
cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create " << (m_MemCheck ? "memory check" : "testing")
<< " XML file" << std::endl);
@@ -492,8 +493,7 @@ void cmCTestTestHandler::ProcessDirectory(std::vector &passed,
cmGeneratedFileStream ofs;
cmGeneratedFileStream *olog = 0;
if ( !m_CTest->GetShowOnly() && tmsize > 0 &&
- m_CTest->OpenOutputFile("Temporary",
- (m_MemCheck?"LastMemCheck.log":"LastTest.log"), ofs) )
+ this->StartResultingXML((m_MemCheck?"MemCheck":"Test"), ofs) )
{
olog = &ofs;
}
diff --git a/Source/CTest/cmCTestUpdateCommand.cxx b/Source/CTest/cmCTestUpdateCommand.cxx
index 50030d96f..1008cc5fe 100644
--- a/Source/CTest/cmCTestUpdateCommand.cxx
+++ b/Source/CTest/cmCTestUpdateCommand.cxx
@@ -76,7 +76,7 @@ bool cmCTestUpdateCommand::InitialPass(
initialCheckoutCommand = m_Makefile->GetDefinition("CTEST_CVS_CHECKOUT");
}
- cmCTestGenericHandler* handler = m_CTest->GetHandler("update");
+ cmCTestGenericHandler* handler = m_CTest->GetInitializedHandler("update");
if ( !handler )
{
this->SetError("internal CTest error. Cannot instantiate update handler");
diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx
index 10856d307..a7a5f1a18 100644
--- a/Source/CTest/cmCTestUpdateHandler.cxx
+++ b/Source/CTest/cmCTestUpdateHandler.cxx
@@ -178,6 +178,7 @@ cmCTestUpdateHandler::cmCTestUpdateHandler()
//----------------------------------------------------------------------
void cmCTestUpdateHandler::Initialize()
{
+ this->Superclass::Initialize();
}
//----------------------------------------------------------------------
@@ -252,7 +253,7 @@ int cmCTestUpdateHandler::ProcessHandler()
cmGeneratedFileStream ofs;
if ( !m_CTest->GetShowOnly() )
{
- m_CTest->OpenOutputFile("Temporary", "LastUpdate.log", ofs);
+ this->StartLogFile("Update", ofs);
}
cmCTestLog(m_CTest, HANDLER_OUTPUT, "Updating the repository" << std::endl);
@@ -439,7 +440,7 @@ int cmCTestUpdateHandler::ProcessHandler()
// Now update repository and remember what files were updated
//
cmGeneratedFileStream os;
- if ( !m_CTest->OpenOutputFile(m_CTest->GetCurrentTag(), "Update.xml", os, true) )
+ if ( !this->StartResultingXML("Update", os) )
{
cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open log file" << std::endl);
}
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 0d5a2bf68..1d4ac2195 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -228,6 +228,7 @@ cmCTest::cmCTest()
m_OutputLogFile = 0;
m_OutputLogFileLastTag = -1;
m_SuppressUpdatingCTestConfiguration = false;
+ m_DartVersion = 1;
int cc;
for ( cc=0; cc < cmCTest::LAST_TEST; cc ++ )
@@ -280,6 +281,10 @@ int cmCTest::Initialize(const char* binary_dir, bool new_tag, bool verbose_tag)
if ( m_ProduceXML )
{
+ cmCTestLog(this, OUTPUT,
+ " Site: " << this->GetCTestConfiguration("Site") << std::endl
+ << " Build name: " << this->GetCTestConfiguration("BuildName") << std::endl
+ );
cmCTestLog(this, DEBUG, "Produce XML is on" << std::endl);
if ( this->GetCTestConfiguration("NightlyStartTime").empty() )
{
@@ -393,6 +398,8 @@ bool cmCTest::InitializeFromCommand(cmCTestCommand* command, bool first)
const char* src_dir = this->GetCTestConfiguration("SourceDirectory").c_str();
const char* bld_dir = this->GetCTestConfiguration("BuildDirectory").c_str();
+ m_DartVersion = 1;
+ m_SubmitFiles.clear();
cmMakefile* mf = command->GetMakefile();
std::string fname = src_dir;
@@ -424,6 +431,16 @@ bool cmCTest::InitializeFromCommand(cmCTestCommand* command, bool first)
this->SetCTestConfigurationFromCMakeVariable(mf, "NightlyStartTime", "CTEST_NIGHTLY_START_TIME");
this->SetCTestConfigurationFromCMakeVariable(mf, "Site", "CTEST_SITE");
this->SetCTestConfigurationFromCMakeVariable(mf, "BuildName", "CTEST_BUILD_NAME");
+ const char* dartVersion = mf->GetDefinition("CTEST_DART_SERVER_VERSION");
+ if ( dartVersion )
+ {
+ m_DartVersion = atoi(dartVersion);
+ if ( m_DartVersion < 0 )
+ {
+ cmCTestLog(this, ERROR_MESSAGE, "Invalid Dart server version: " << dartVersion << ". Please specify the version number." << std::endl);
+ return false;
+ }
+ }
if ( !this->Initialize(bld_dir, true, false) )
{
@@ -630,11 +647,11 @@ bool cmCTest::OpenOutputFile(const std::string& path,
}
//----------------------------------------------------------------------
-bool cmCTest::AddIfExists(tm_VectorOfStrings& files, const char* file)
+bool cmCTest::AddIfExists(tm_SetOfStrings& files, const char* file)
{
if ( this->CTestFileExists(file) )
{
- files.push_back(file);
+ files.insert(file);
}
else
{
@@ -642,7 +659,7 @@ bool cmCTest::AddIfExists(tm_VectorOfStrings& files, const char* file)
name += ".gz";
if ( this->CTestFileExists(name.c_str()) )
{
- files.push_back(name.c_str());
+ files.insert(name.c_str());
}
else
{
@@ -660,6 +677,18 @@ bool cmCTest::CTestFileExists(const std::string& filename)
return cmSystemTools::FileExists(testingDir.c_str());
}
+//----------------------------------------------------------------------
+cmCTestGenericHandler* cmCTest::GetInitializedHandler(const char* handler)
+{
+ cmCTest::t_TestingHandlers::iterator it = m_TestingHandlers.find(handler);
+ if ( it == m_TestingHandlers.end() )
+ {
+ return 0;
+ }
+ it->second->Initialize();
+ return it->second;
+}
+
//----------------------------------------------------------------------
cmCTestGenericHandler* cmCTest::GetHandler(const char* handler)
{
@@ -1858,6 +1887,12 @@ bool cmCTest::GetProduceXML()
return m_ProduceXML;
}
+//----------------------------------------------------------------------
+void cmCTest::AddSubmitFile(const char* name)
+{
+ m_SubmitFiles.insert(name);
+}
+
//----------------------------------------------------------------------
bool cmCTest::SetCTestConfigurationFromCMakeVariable(cmMakefile* mf, const char* dconfig, const char* cmake_var)
{
diff --git a/Source/cmCTest.h b/Source/cmCTest.h
index bd7d74b32..3cc3fe49c 100644
--- a/Source/cmCTest.h
+++ b/Source/cmCTest.h
@@ -49,6 +49,7 @@ class cmCTest
{
public:
typedef std::vector tm_VectorOfStrings;
+ typedef std::set tm_SetOfStrings;
///! Process Command line arguments
int Run(std::vectorconst&, std::string* output = 0);
@@ -96,7 +97,7 @@ public:
* Check if CTest file exists
*/
bool CTestFileExists(const std::string& filename);
- bool AddIfExists(tm_VectorOfStrings& files, const char* file);
+ bool AddIfExists(tm_SetOfStrings& files, const char* file);
/**
* Set the cmake test
@@ -231,6 +232,7 @@ public:
* Get the handler object
*/
cmCTestGenericHandler* GetHandler(const char* handler);
+ cmCTestGenericHandler* GetInitializedHandler(const char* handler);
/*
* Set the CTest variable from CMake variable
@@ -267,6 +269,13 @@ public:
//! Add log to the output
void Log(int logType, const char* file, int line, const char* msg);
+ //! Get the version of dart server
+ int GetDartVersion() { return m_DartVersion; }
+
+ //! Add file to be submitted
+ void AddSubmitFile(const char* name);
+ tm_SetOfStrings* GetSubmitFiles() { return &m_SubmitFiles; }
+
private:
std::string m_ConfigType;
bool m_Verbose;
@@ -350,6 +359,10 @@ private:
bool m_ShowLineNumbers;
bool m_Quiet;
+ int m_DartVersion;
+
+ std::set m_SubmitFiles;
+
cmGeneratedFileStream* m_OutputLogFile;
int m_OutputLogFileLastTag;
diff --git a/Source/kwsys/CTestConfig.cmake b/Source/kwsys/CTestConfig.cmake
index 38e6cf5a1..23a5bd172 100644
--- a/Source/kwsys/CTestConfig.cmake
+++ b/Source/kwsys/CTestConfig.cmake
@@ -1,2 +1,3 @@
SET (CTEST_PROJECT_NAME "kwsys")
SET (CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
+SET (CTEST_DART_SERVER_VERSION "2")