diff options
Diffstat (limited to 'Source/CTest')
31 files changed, 0 insertions, 374 deletions
diff --git a/Source/CTest/cmCTestBZR.cxx b/Source/CTest/cmCTestBZR.cxx index eb18b70..6dd17b0 100644 --- a/Source/CTest/cmCTestBZR.cxx +++ b/Source/CTest/cmCTestBZR.cxx @@ -19,7 +19,6 @@ #include <cm_expat.h> -//---------------------------------------------------------------------------- extern "C" int cmBZRXMLParserUnknownEncodingHandler(void*, const XML_Char *name, @@ -75,7 +74,6 @@ int cmBZRXMLParserUnknownEncodingHandler(void*, return 0; } -//---------------------------------------------------------------------------- cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log): cmCTestGlobalVC(ct, log) { @@ -86,12 +84,10 @@ cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log): cmSystemTools::PutEnv("BZR_PROGRESS_BAR=none"); } -//---------------------------------------------------------------------------- cmCTestBZR::~cmCTestBZR() { } -//---------------------------------------------------------------------------- class cmCTestBZR::InfoParser: public cmCTestVC::LineParser { public: @@ -122,7 +118,6 @@ private: } }; -//---------------------------------------------------------------------------- class cmCTestBZR::RevnoParser: public cmCTestVC::LineParser { public: @@ -145,7 +140,6 @@ private: } }; -//---------------------------------------------------------------------------- std::string cmCTestBZR::LoadInfo() { // Run "bzr info" to get the repository info from the work tree. @@ -174,7 +168,6 @@ void cmCTestBZR::NoteOldRevision() this->PriorRev.Rev = this->OldRevision; } -//---------------------------------------------------------------------------- void cmCTestBZR::NoteNewRevision() { this->NewRevision = this->LoadInfo(); @@ -184,7 +177,6 @@ void cmCTestBZR::NoteNewRevision() this->Log << "URL = " << this->URL << "\n"; } -//---------------------------------------------------------------------------- class cmCTestBZR::LogParser: public cmCTestVC::OutputLogger, private cmXMLParser { @@ -314,7 +306,6 @@ private: } }; -//---------------------------------------------------------------------------- class cmCTestBZR::UpdateParser: public cmCTestVC::LineParser { public: @@ -399,7 +390,6 @@ private: } }; -//---------------------------------------------------------------------------- bool cmCTestBZR::UpdateImpl() { // Get user-specified update options. @@ -433,7 +423,6 @@ bool cmCTestBZR::UpdateImpl() return this->RunUpdateCommand(&bzr_update[0], &out, &err); } -//---------------------------------------------------------------------------- void cmCTestBZR::LoadRevisions() { cmCTestLog(this->CTest, HANDLER_OUTPUT, @@ -465,7 +454,6 @@ void cmCTestBZR::LoadRevisions() cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl); } -//---------------------------------------------------------------------------- class cmCTestBZR::StatusParser: public cmCTestVC::LineParser { public: @@ -510,7 +498,6 @@ private: } }; -//---------------------------------------------------------------------------- void cmCTestBZR::LoadModifications() { // Run "bzr status" which reports local modifications. diff --git a/Source/CTest/cmCTestBatchTestHandler.cxx b/Source/CTest/cmCTestBatchTestHandler.cxx index 41f4f12..6127551 100644 --- a/Source/CTest/cmCTestBatchTestHandler.cxx +++ b/Source/CTest/cmCTestBatchTestHandler.cxx @@ -22,14 +22,12 @@ cmCTestBatchTestHandler::~cmCTestBatchTestHandler() { } -//--------------------------------------------------------- void cmCTestBatchTestHandler::RunTests() { this->WriteBatchScript(); this->SubmitBatchScript(); } -//--------------------------------------------------------- void cmCTestBatchTestHandler::WriteBatchScript() { this->Script = this->CTest->GetBinaryDir() @@ -48,7 +46,6 @@ void cmCTestBatchTestHandler::WriteBatchScript() fout.close(); } -//--------------------------------------------------------- void cmCTestBatchTestHandler::WriteSrunArgs(int test, cmsys::ofstream& fout) { cmCTestTestHandler::cmCTestTestProperties* properties = @@ -79,7 +76,6 @@ void cmCTestBatchTestHandler::WriteSrunArgs(int test, cmsys::ofstream& fout) } } -//--------------------------------------------------------- void cmCTestBatchTestHandler::WriteTestCommand(int test, cmsys::ofstream& fout) { std::vector<std::string> args = this->Properties[test]->Args; @@ -121,7 +117,6 @@ void cmCTestBatchTestHandler::WriteTestCommand(int test, cmsys::ofstream& fout) //this->TestResult.FullCommandLine = this->TestCommand; } -//--------------------------------------------------------- void cmCTestBatchTestHandler::SubmitBatchScript() { cmProcess sbatch; diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx index 52433da..6ea9a89 100644 --- a/Source/CTest/cmCTestBuildAndTestHandler.cxx +++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx @@ -19,7 +19,6 @@ #include "cmake.h" #include <cmsys/Process.h> -//---------------------------------------------------------------------- cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler() { this->BuildTwoConfig = false; @@ -28,19 +27,16 @@ cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler() this->Timeout = 0; } -//---------------------------------------------------------------------- void cmCTestBuildAndTestHandler::Initialize() { this->BuildTargets.clear(); this->Superclass::Initialize(); } -//---------------------------------------------------------------------- const char* cmCTestBuildAndTestHandler::GetOutput() { return this->Output.c_str(); } -//---------------------------------------------------------------------- int cmCTestBuildAndTestHandler::ProcessHandler() { this->Output = ""; @@ -51,7 +47,6 @@ int cmCTestBuildAndTestHandler::ProcessHandler() return retv; } -//---------------------------------------------------------------------- int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring, std::ostringstream &out, std::string &cmakeOutString, std::string &cwd, cmake *cm) @@ -144,7 +139,6 @@ int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring, return 0; } -//---------------------------------------------------------------------- void CMakeMessageCallback(const char* m, const char*, bool&, void* s) { std::string* out = (std::string*)s; @@ -159,14 +153,12 @@ void CMakeProgressCallback(const char*msg, float , void * s) *out += "\n"; } -//---------------------------------------------------------------------- void CMakeOutputCallback(const char* m, size_t len, void* s) { std::string* out = (std::string*)s; out->append(m, len); } -//---------------------------------------------------------------------- class cmCTestBuildAndTestCaptureRAII { cmake& CM; @@ -187,7 +179,6 @@ public: } }; -//---------------------------------------------------------------------- int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring) { // if the generator and make program are not specified then it is an error @@ -436,7 +427,6 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring) return retval; } -//---------------------------------------------------------------------- int cmCTestBuildAndTestHandler::ProcessCommandLineArguments( const std::string& currentArg, size_t& idx, const std::vector<std::string>& allArgs) diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx index 957e3e4..ca3960f 100644 --- a/Source/CTest/cmCTestBuildCommand.cxx +++ b/Source/CTest/cmCTestBuildCommand.cxx @@ -18,7 +18,6 @@ #include "cmake.h" -//---------------------------------------------------------------------------- cmCTestBuildCommand::cmCTestBuildCommand() { this->GlobalGenerator = 0; @@ -32,7 +31,6 @@ cmCTestBuildCommand::cmCTestBuildCommand() this->Last = ctb_LAST; } -//---------------------------------------------------------------------------- cmCTestBuildCommand::~cmCTestBuildCommand() { if ( this->GlobalGenerator ) @@ -42,7 +40,6 @@ cmCTestBuildCommand::~cmCTestBuildCommand() } } -//---------------------------------------------------------------------------- cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler() { cmCTestGenericHandler* handler diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx index 1b31533..9647968 100644 --- a/Source/CTest/cmCTestBuildHandler.cxx +++ b/Source/CTest/cmCTestBuildHandler.cxx @@ -174,7 +174,6 @@ cmCTestWarningErrorFileLine[] = { { 0, 0, 0 } }; -//---------------------------------------------------------------------- cmCTestBuildHandler::cmCTestBuildHandler() { this->MaxPreContext = 10; @@ -188,7 +187,6 @@ cmCTestBuildHandler::cmCTestBuildHandler() this->UseCTestLaunch = false; } -//---------------------------------------------------------------------- void cmCTestBuildHandler::Initialize() { this->Superclass::Initialize(); @@ -234,7 +232,6 @@ void cmCTestBuildHandler::Initialize() this->UseCTestLaunch = false; } -//---------------------------------------------------------------------- void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf) { this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_ERROR_MATCH", @@ -281,7 +278,6 @@ void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile *mf) } } -//---------------------------------------------------------------------- std::string cmCTestBuildHandler::GetMakeCommand() { std::string makeCommand @@ -307,7 +303,6 @@ std::string cmCTestBuildHandler::GetMakeCommand() return makeCommand; } -//---------------------------------------------------------------------- //clearly it would be nice if this were broken up into a few smaller //functions and commented... int cmCTestBuildHandler::ProcessHandler() @@ -551,7 +546,6 @@ int cmCTestBuildHandler::ProcessHandler() return retVal; } -//---------------------------------------------------------------------------- void cmCTestBuildHandler::GenerateXMLHeader(cmXMLWriter& xml) { this->CTest->StartXML(xml, this->AppendXML); @@ -562,7 +556,6 @@ void cmCTestBuildHandler::GenerateXMLHeader(cmXMLWriter& xml) xml.Element("BuildCommand", this->GetMakeCommand()); } -//---------------------------------------------------------------------------- class cmCTestBuildHandler::FragmentCompare { public: @@ -587,7 +580,6 @@ private: cmFileTimeComparison* FTC; }; -//---------------------------------------------------------------------------- void cmCTestBuildHandler::GenerateXMLLaunched(cmXMLWriter& xml) { if(this->CTestLaunchDir.empty()) @@ -633,7 +625,6 @@ void cmCTestBuildHandler::GenerateXMLLaunched(cmXMLWriter& xml) } } -//---------------------------------------------------------------------------- void cmCTestBuildHandler::GenerateXMLLogScraped(cmXMLWriter& xml) { std::vector<cmCTestBuildErrorWarning>& ew = this->ErrorsAndWarnings; @@ -730,7 +721,6 @@ void cmCTestBuildHandler::GenerateXMLLogScraped(cmXMLWriter& xml) } } -//---------------------------------------------------------------------------- void cmCTestBuildHandler::GenerateXMLFooter(cmXMLWriter& xml, double elapsed_build_time) { @@ -746,7 +736,6 @@ void cmCTestBuildHandler::GenerateXMLFooter(cmXMLWriter& xml, this->CTest->EndXML(xml); } -//---------------------------------------------------------------------------- bool cmCTestBuildHandler::IsLaunchedErrorFile(const char* fname) { // error-{hash}.xml @@ -754,7 +743,6 @@ bool cmCTestBuildHandler::IsLaunchedErrorFile(const char* fname) strcmp(fname+strlen(fname)-4, ".xml") == 0); } -//---------------------------------------------------------------------------- bool cmCTestBuildHandler::IsLaunchedWarningFile(const char* fname) { // warning-{hash}.xml @@ -767,7 +755,6 @@ bool cmCTestBuildHandler::IsLaunchedWarningFile(const char* fname) //###################################################################### //###################################################################### -//---------------------------------------------------------------------------- class cmCTestBuildHandler::LaunchHelper { public: @@ -782,7 +769,6 @@ private: std::vector<std::string> const& matchers); }; -//---------------------------------------------------------------------------- cmCTestBuildHandler::LaunchHelper::LaunchHelper(cmCTestBuildHandler* handler): Handler(handler), CTest(handler->CTest) { @@ -823,7 +809,6 @@ cmCTestBuildHandler::LaunchHelper::LaunchHelper(cmCTestBuildHandler* handler): } } -//---------------------------------------------------------------------------- cmCTestBuildHandler::LaunchHelper::~LaunchHelper() { if(this->Handler->UseCTestLaunch) @@ -832,7 +817,6 @@ cmCTestBuildHandler::LaunchHelper::~LaunchHelper() } } -//---------------------------------------------------------------------------- void cmCTestBuildHandler::LaunchHelper::WriteLauncherConfig() { this->WriteScrapeMatchers("Warning", @@ -848,7 +832,6 @@ void cmCTestBuildHandler::LaunchHelper::WriteLauncherConfig() fout << "set(CTEST_SOURCE_DIRECTORY \"" << srcdir << "\")\n"; } -//---------------------------------------------------------------------------- void cmCTestBuildHandler::LaunchHelper ::WriteScrapeMatchers(const char* purpose, @@ -870,7 +853,6 @@ cmCTestBuildHandler::LaunchHelper } } -//---------------------------------------------------------------------- int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal, const char* dir, int timeout, std::ostream& ofs) { @@ -1039,7 +1021,6 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command, //###################################################################### //###################################################################### -//---------------------------------------------------------------------- void cmCTestBuildHandler::ProcessBuffer(const char* data, int length, size_t& tick, size_t tick_len, std::ostream& ofs, t_BuildProcessingQueueType* queue) @@ -1197,7 +1178,6 @@ void cmCTestBuildHandler::ProcessBuffer(const char* data, int length, ofs << cmCTestLogWrite(data, length); } -//---------------------------------------------------------------------- int cmCTestBuildHandler::ProcessSingleLine(const char* data) { if(this->UseCTestLaunch) diff --git a/Source/CTest/cmCTestCVS.cxx b/Source/CTest/cmCTestCVS.cxx index 01bc1c4..7ab87c2 100644 --- a/Source/CTest/cmCTestCVS.cxx +++ b/Source/CTest/cmCTestCVS.cxx @@ -18,17 +18,14 @@ #include <cmsys/FStream.hxx> #include <cmsys/RegularExpression.hxx> -//---------------------------------------------------------------------------- cmCTestCVS::cmCTestCVS(cmCTest* ct, std::ostream& log): cmCTestVC(ct, log) { } -//---------------------------------------------------------------------------- cmCTestCVS::~cmCTestCVS() { } -//---------------------------------------------------------------------------- class cmCTestCVS::UpdateParser: public cmCTestVC::LineParser { public: @@ -86,7 +83,6 @@ private: } }; -//---------------------------------------------------------------------------- bool cmCTestCVS::UpdateImpl() { // Get user-specified update options. @@ -124,7 +120,6 @@ bool cmCTestCVS::UpdateImpl() return this->RunUpdateCommand(&cvs_update[0], &out, &err); } -//---------------------------------------------------------------------------- class cmCTestCVS::LogParser: public cmCTestVC::LineParser { public: @@ -220,7 +215,6 @@ private: } }; -//---------------------------------------------------------------------------- std::string cmCTestCVS::ComputeBranchFlag(std::string const& dir) { // Compute the tag file location for this directory. @@ -250,7 +244,6 @@ std::string cmCTestCVS::ComputeBranchFlag(std::string const& dir) } } -//---------------------------------------------------------------------------- void cmCTestCVS::LoadRevisions(std::string const& file, const char* branchFlag, std::vector<Revision>& revisions) @@ -267,7 +260,6 @@ void cmCTestCVS::LoadRevisions(std::string const& file, this->RunChild(cvs_log, &out, &err); } -//---------------------------------------------------------------------------- void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml, std::string const& path, Directory const& dir) @@ -303,7 +295,6 @@ void cmCTestCVS::WriteXMLDirectory(cmXMLWriter& xml, xml.EndElement(); // Directory } -//---------------------------------------------------------------------------- bool cmCTestCVS::WriteXMLUpdates(cmXMLWriter& xml) { cmCTestLog(this->CTest, HANDLER_OUTPUT, diff --git a/Source/CTest/cmCTestConfigureHandler.cxx b/Source/CTest/cmCTestConfigureHandler.cxx index e9f8f39..ea4cf72 100644 --- a/Source/CTest/cmCTestConfigureHandler.cxx +++ b/Source/CTest/cmCTestConfigureHandler.cxx @@ -19,18 +19,15 @@ #include <cmsys/Process.h> -//---------------------------------------------------------------------- cmCTestConfigureHandler::cmCTestConfigureHandler() { } -//---------------------------------------------------------------------- void cmCTestConfigureHandler::Initialize() { this->Superclass::Initialize(); } -//---------------------------------------------------------------------- //clearly it would be nice if this were broken up into a few smaller //functions and commented... int cmCTestConfigureHandler::ProcessHandler() diff --git a/Source/CTest/cmCTestCoverageCommand.cxx b/Source/CTest/cmCTestCoverageCommand.cxx index f1f935b..bf6a321 100644 --- a/Source/CTest/cmCTestCoverageCommand.cxx +++ b/Source/CTest/cmCTestCoverageCommand.cxx @@ -14,13 +14,11 @@ #include "cmCTest.h" #include "cmCTestCoverageHandler.h" -//---------------------------------------------------------------------------- cmCTestCoverageCommand::cmCTestCoverageCommand() { this->LabelsMentioned = false; } -//---------------------------------------------------------------------------- cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler() { this->CTest->SetCTestConfigurationFromCMakeVariable(this->Makefile, @@ -45,7 +43,6 @@ cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler() return handler; } -//---------------------------------------------------------------------------- bool cmCTestCoverageCommand::CheckArgumentKeyword(std::string const& arg) { // Look for arguments specific to this command. @@ -60,7 +57,6 @@ bool cmCTestCoverageCommand::CheckArgumentKeyword(std::string const& arg) return this->Superclass::CheckArgumentKeyword(arg); } -//---------------------------------------------------------------------------- bool cmCTestCoverageCommand::CheckArgumentValue(std::string const& arg) { // Handle states specific to this command. diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx index 79eb346..ed15834 100644 --- a/Source/CTest/cmCTestCoverageHandler.cxx +++ b/Source/CTest/cmCTestCoverageHandler.cxx @@ -132,14 +132,11 @@ private: }; -//---------------------------------------------------------------------- -//---------------------------------------------------------------------- cmCTestCoverageHandler::cmCTestCoverageHandler() { } -//---------------------------------------------------------------------- void cmCTestCoverageHandler::Initialize() { this->Superclass::Initialize(); @@ -151,7 +148,6 @@ void cmCTestCoverageHandler::Initialize() this->LabelFilter.clear(); } -//---------------------------------------------------------------------------- void cmCTestCoverageHandler::CleanCoverageLogFiles(std::ostream& log) { std::string logGlob = this->CTest->GetCTestConfiguration("BuildDirectory"); @@ -169,7 +165,6 @@ void cmCTestCoverageHandler::CleanCoverageLogFiles(std::ostream& log) } } -//---------------------------------------------------------------------- bool cmCTestCoverageHandler::StartCoverageLogFile( cmGeneratedFileStream& covLogFile, int logFileCount) { @@ -187,7 +182,6 @@ bool cmCTestCoverageHandler::StartCoverageLogFile( return true; } -//---------------------------------------------------------------------- void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount) { @@ -198,7 +192,6 @@ void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr, ostr.Close(); } -//---------------------------------------------------------------------- void cmCTestCoverageHandler::StartCoverageLogXML(cmXMLWriter& xml) { this->CTest->StartXML(xml, this->AppendXML); @@ -208,7 +201,6 @@ void cmCTestCoverageHandler::StartCoverageLogXML(cmXMLWriter& xml) static_cast<unsigned int>(cmSystemTools::GetTime())); } -//---------------------------------------------------------------------- void cmCTestCoverageHandler::EndCoverageLogXML(cmXMLWriter& xml) { xml.Element("EndDateTime", this->CTest->CurrentTime()); @@ -217,7 +209,6 @@ void cmCTestCoverageHandler::EndCoverageLogXML(cmXMLWriter& xml) this->CTest->EndXML(xml); } -//---------------------------------------------------------------------- bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, const char* srcDir, const char* binDir) @@ -322,7 +313,6 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, return true; } -//---------------------------------------------------------------------- //clearly it would be nice if this were broken up into a few smaller //functions and commented... int cmCTestCoverageHandler::ProcessHandler() @@ -747,7 +737,6 @@ int cmCTestCoverageHandler::ProcessHandler() return 0; } -//---------------------------------------------------------------------- void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf) { cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, @@ -772,7 +761,6 @@ void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf) } } -//---------------------------------------------------------------------- // Fix for issue #4971 where the case of the drive letter component of // the filenames might be different when analyzing gcov output. // @@ -784,7 +772,6 @@ void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf) #define fnc(s) s #endif -//---------------------------------------------------------------------- bool IsFileInDir(const std::string &infile, const std::string &indir) { std::string file = cmSystemTools::CollapseFullPath(infile); @@ -802,7 +789,6 @@ bool IsFileInDir(const std::string &infile, const std::string &indir) return false; } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandlePHPCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -815,7 +801,6 @@ int cmCTestCoverageHandler::HandlePHPCoverage( return static_cast<int>(cont->TotalCoverage.size()); } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandleCoberturaCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -855,7 +840,6 @@ int cmCTestCoverageHandler::HandleCoberturaCoverage( return static_cast<int>(cont->TotalCoverage.size()); } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandleMumpsCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -923,7 +907,6 @@ struct cmCTestCoverageHandlerLocale std::string lc_all; }; -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandleJacocoCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -971,7 +954,6 @@ int cmCTestCoverageHandler::HandleJacocoCoverage( return static_cast<int>(cont->TotalCoverage.size()); } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandleDelphiCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -1005,7 +987,6 @@ int cmCTestCoverageHandler::HandleDelphiCoverage( return static_cast<int>(cont->TotalCoverage.size()); } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandleBlanketJSCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -1051,7 +1032,6 @@ int cmCTestCoverageHandler::HandleBlanketJSCoverage( } return static_cast<int>(cont->TotalCoverage.size()); } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandleGCovCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -1493,7 +1473,6 @@ int cmCTestCoverageHandler::HandleGCovCoverage( return file_count; } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandleLCovCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -1765,7 +1744,6 @@ int cmCTestCoverageHandler::HandleLCovCoverage( return file_count; } -//---------------------------------------------------------------------------- void cmCTestCoverageHandler::FindGCovFiles(std::vector<std::string>& files) { cmsys::Glob gl; @@ -1796,7 +1774,6 @@ void cmCTestCoverageHandler::FindGCovFiles(std::vector<std::string>& files) } } -//---------------------------------------------------------------------------- bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files) { cmsys::Glob gl; @@ -1840,7 +1817,6 @@ bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files) return true; } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandleTracePyCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -1974,7 +1950,6 @@ int cmCTestCoverageHandler::HandleTracePyCoverage( return file_count; } -//---------------------------------------------------------------------- std::string cmCTestCoverageHandler::FindFile( cmCTestCoverageHandlerContainer* cont, std::string fileName) @@ -2014,7 +1989,6 @@ namespace 0}; } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::RunBullseyeCoverageBranch( cmCTestCoverageHandlerContainer* cont, std::set<std::string>& coveredFileNames, @@ -2163,7 +2137,6 @@ int cmCTestCoverageHandler::RunBullseyeCoverageBranch( return 1; } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::RunBullseyeCommand( cmCTestCoverageHandlerContainer* cont, const char* cmd, @@ -2213,7 +2186,6 @@ int cmCTestCoverageHandler::RunBullseyeCommand( return 1; } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::RunBullseyeSourceSummary( cmCTestCoverageHandlerContainer* cont) { @@ -2390,7 +2362,6 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary( coveredFilesFullPath); } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::HandleBullseyeCoverage( cmCTestCoverageHandlerContainer* cont) { @@ -2487,7 +2458,6 @@ bool cmCTestCoverageHandler::ParseBullsEyeCovsrcLine( return true; } -//---------------------------------------------------------------------- int cmCTestCoverageHandler::GetLabelId(std::string const& label) { LabelIdMapType::iterator i = this->LabelIdMap.find(label); @@ -2501,7 +2471,6 @@ int cmCTestCoverageHandler::GetLabelId(std::string const& label) return i->second; } -//---------------------------------------------------------------------- void cmCTestCoverageHandler::LoadLabels() { std::string fileList = this->CTest->GetBinaryDir(); @@ -2517,7 +2486,6 @@ void cmCTestCoverageHandler::LoadLabels() } } -//---------------------------------------------------------------------- void cmCTestCoverageHandler::LoadLabels(const char* dir) { LabelSet& dirLabels = this->TargetDirs[dir]; @@ -2572,7 +2540,6 @@ void cmCTestCoverageHandler::LoadLabels(const char* dir) } } -//---------------------------------------------------------------------- void cmCTestCoverageHandler::WriteXMLLabels(cmXMLWriter& xml, std::string const& source) { @@ -2589,7 +2556,6 @@ void cmCTestCoverageHandler::WriteXMLLabels(cmXMLWriter& xml, } } -//---------------------------------------------------------------------------- void cmCTestCoverageHandler::SetLabelFilter(std::set<std::string> const& labels) { @@ -2601,7 +2567,6 @@ cmCTestCoverageHandler::SetLabelFilter(std::set<std::string> const& labels) } } -//---------------------------------------------------------------------- bool cmCTestCoverageHandler::IntersectsFilter(LabelSet const& labels) { // If there is no label filter then nothing is filtered out. @@ -2618,7 +2583,6 @@ bool cmCTestCoverageHandler::IntersectsFilter(LabelSet const& labels) return !ids.empty(); } -//---------------------------------------------------------------------- bool cmCTestCoverageHandler::IsFilteredOut(std::string const& source) { // If there is no label filter then nothing is filtered out. @@ -2638,7 +2602,6 @@ bool cmCTestCoverageHandler::IsFilteredOut(std::string const& source) return true; } -//---------------------------------------------------------------------- std::set<std::string> cmCTestCoverageHandler::FindUncoveredFiles( cmCTestCoverageHandlerContainer* cont) { diff --git a/Source/CTest/cmCTestGIT.cxx b/Source/CTest/cmCTestGIT.cxx index 19d869c..6d70be9 100644 --- a/Source/CTest/cmCTestGIT.cxx +++ b/Source/CTest/cmCTestGIT.cxx @@ -23,7 +23,6 @@ #include <sys/types.h> #include <time.h> -//---------------------------------------------------------------------------- static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major, unsigned int minor, unsigned int fix) { @@ -31,7 +30,6 @@ static unsigned int cmCTestGITVersion(unsigned int epic, unsigned int major, return fix + minor*1000 + major*100000 + epic*10000000; } -//---------------------------------------------------------------------------- cmCTestGIT::cmCTestGIT(cmCTest* ct, std::ostream& log): cmCTestGlobalVC(ct, log) { @@ -39,12 +37,10 @@ cmCTestGIT::cmCTestGIT(cmCTest* ct, std::ostream& log): this->CurrentGitVersion = 0; } -//---------------------------------------------------------------------------- cmCTestGIT::~cmCTestGIT() { } -//---------------------------------------------------------------------------- class cmCTestGIT::OneLineParser: public cmCTestVC::LineParser { public: @@ -63,7 +59,6 @@ private: } }; -//---------------------------------------------------------------------------- std::string cmCTestGIT::GetWorkingRevision() { // Run plumbing "git rev-list" to get work tree revision. @@ -76,7 +71,6 @@ std::string cmCTestGIT::GetWorkingRevision() return rev; } -//---------------------------------------------------------------------------- void cmCTestGIT::NoteOldRevision() { this->OldRevision = this->GetWorkingRevision(); @@ -85,7 +79,6 @@ void cmCTestGIT::NoteOldRevision() this->PriorRev.Rev = this->OldRevision; } -//---------------------------------------------------------------------------- void cmCTestGIT::NoteNewRevision() { this->NewRevision = this->GetWorkingRevision(); @@ -93,7 +86,6 @@ void cmCTestGIT::NoteNewRevision() << this->NewRevision << "\n"); } -//---------------------------------------------------------------------------- std::string cmCTestGIT::FindGitDir() { std::string git_dir; @@ -141,7 +133,6 @@ std::string cmCTestGIT::FindGitDir() return git_dir; } -//---------------------------------------------------------------------------- std::string cmCTestGIT::FindTopDir() { std::string top_dir = this->SourceDirectory; @@ -162,7 +153,6 @@ std::string cmCTestGIT::FindTopDir() return top_dir; } -//---------------------------------------------------------------------------- bool cmCTestGIT::UpdateByFetchAndReset() { const char* git = this->CommandLineTool.c_str(); @@ -233,7 +223,6 @@ bool cmCTestGIT::UpdateByFetchAndReset() return this->RunChild(&git_reset[0], &reset_out, &reset_err); } -//---------------------------------------------------------------------------- bool cmCTestGIT::UpdateByCustom(std::string const& custom) { std::vector<std::string> git_custom_command; @@ -251,7 +240,6 @@ bool cmCTestGIT::UpdateByCustom(std::string const& custom) return this->RunUpdateCommand(&git_custom[0], &custom_out, &custom_err); } -//---------------------------------------------------------------------------- bool cmCTestGIT::UpdateInternal() { std::string custom = this->CTest->GetCTestConfiguration("GITUpdateCustom"); @@ -262,7 +250,6 @@ bool cmCTestGIT::UpdateInternal() return this->UpdateByFetchAndReset(); } -//---------------------------------------------------------------------------- bool cmCTestGIT::UpdateImpl() { if(!this->UpdateInternal()) @@ -331,7 +318,6 @@ bool cmCTestGIT::UpdateImpl() top_dir.c_str()); } -//---------------------------------------------------------------------------- unsigned int cmCTestGIT::GetGitVersion() { if(!this->CurrentGitVersion) @@ -352,7 +338,6 @@ unsigned int cmCTestGIT::GetGitVersion() return this->CurrentGitVersion; } -//---------------------------------------------------------------------------- /* Diff format: :src-mode dst-mode src-sha1 dst-sha1 status\0 @@ -470,7 +455,6 @@ protected: } }; -//---------------------------------------------------------------------------- /* Commit format: commit ...\n @@ -637,7 +621,6 @@ private: char const cmCTestGIT::CommitParser::SectionSep[SectionCount] = {'\n', '\n', '\0'}; -//---------------------------------------------------------------------------- void cmCTestGIT::LoadRevisions() { // Use 'git rev-list ... | git diff-tree ...' to get revisions. @@ -666,7 +649,6 @@ void cmCTestGIT::LoadRevisions() cmsysProcess_Delete(cp); } -//---------------------------------------------------------------------------- void cmCTestGIT::LoadModifications() { const char* git = this->CommandLineTool.c_str(); diff --git a/Source/CTest/cmCTestGenericHandler.cxx b/Source/CTest/cmCTestGenericHandler.cxx index 7eccb9c..2e9dd1f 100644 --- a/Source/CTest/cmCTestGenericHandler.cxx +++ b/Source/CTest/cmCTestGenericHandler.cxx @@ -16,7 +16,6 @@ #include "cmCTest.h" -//---------------------------------------------------------------------- cmCTestGenericHandler::cmCTestGenericHandler() { this->HandlerVerbose = cmSystemTools::OUTPUT_NONE; @@ -27,12 +26,10 @@ cmCTestGenericHandler::cmCTestGenericHandler() this->TestLoad = 0; } -//---------------------------------------------------------------------- cmCTestGenericHandler::~cmCTestGenericHandler() { } -//---------------------------------------------------------------------- void cmCTestGenericHandler::SetOption(const std::string& op, const char* value) { if ( !value ) @@ -49,7 +46,6 @@ void cmCTestGenericHandler::SetOption(const std::string& op, const char* value) this->Options[op] = value; } -//---------------------------------------------------------------------- void cmCTestGenericHandler::SetPersistentOption(const std::string& op, const char* value) { @@ -68,7 +64,6 @@ void cmCTestGenericHandler::SetPersistentOption(const std::string& op, this->PersistentOptions[op] = value; } -//---------------------------------------------------------------------- void cmCTestGenericHandler::Initialize() { this->AppendXML = false; @@ -83,7 +78,6 @@ void cmCTestGenericHandler::Initialize() } } -//---------------------------------------------------------------------- const char* cmCTestGenericHandler::GetOption(const std::string& op) { cmCTestGenericHandler::t_StringToString::iterator remit @@ -95,7 +89,6 @@ const char* cmCTestGenericHandler::GetOption(const std::string& op) return remit->second.c_str(); } -//---------------------------------------------------------------------- bool cmCTestGenericHandler::StartResultingXML(cmCTest::Part part, const char* name, cmGeneratedFileStream& xofs) @@ -136,7 +129,6 @@ bool cmCTestGenericHandler::StartResultingXML(cmCTest::Part part, return true; } -//---------------------------------------------------------------------- bool cmCTestGenericHandler::StartLogFile(const char* name, cmGeneratedFileStream& xofs) { diff --git a/Source/CTest/cmCTestGlobalVC.cxx b/Source/CTest/cmCTestGlobalVC.cxx index b66793a..7c565fb 100644 --- a/Source/CTest/cmCTestGlobalVC.cxx +++ b/Source/CTest/cmCTestGlobalVC.cxx @@ -17,25 +17,21 @@ #include <cmsys/RegularExpression.hxx> -//---------------------------------------------------------------------------- cmCTestGlobalVC::cmCTestGlobalVC(cmCTest* ct, std::ostream& log): cmCTestVC(ct, log) { this->PriorRev = this->Unknown; } -//---------------------------------------------------------------------------- cmCTestGlobalVC::~cmCTestGlobalVC() { } -//---------------------------------------------------------------------------- const char* cmCTestGlobalVC::LocalPath(std::string const& path) { return path.c_str(); } -//---------------------------------------------------------------------------- void cmCTestGlobalVC::DoRevision(Revision const& revision, std::vector<Change> const& changes) { @@ -76,7 +72,6 @@ void cmCTestGlobalVC::DoRevision(Revision const& revision, } } -//---------------------------------------------------------------------------- void cmCTestGlobalVC::DoModification(PathStatus status, std::string const& path) { @@ -92,7 +87,6 @@ void cmCTestGlobalVC::DoModification(PathStatus status, } } -//---------------------------------------------------------------------------- void cmCTestGlobalVC::WriteXMLDirectory(cmXMLWriter& xml, std::string const& path, Directory const& dir) @@ -108,7 +102,6 @@ void cmCTestGlobalVC::WriteXMLDirectory(cmXMLWriter& xml, xml.EndElement(); // Directory } -//---------------------------------------------------------------------------- void cmCTestGlobalVC::WriteXMLGlobal(cmXMLWriter& xml) { if(!this->NewRevision.empty()) @@ -121,7 +114,6 @@ void cmCTestGlobalVC::WriteXMLGlobal(cmXMLWriter& xml) } } -//---------------------------------------------------------------------------- bool cmCTestGlobalVC::WriteXMLUpdates(cmXMLWriter& xml) { cmCTestLog(this->CTest, HANDLER_OUTPUT, diff --git a/Source/CTest/cmCTestHG.cxx b/Source/CTest/cmCTestHG.cxx index 0f79d68..4dcd805 100644 --- a/Source/CTest/cmCTestHG.cxx +++ b/Source/CTest/cmCTestHG.cxx @@ -17,19 +17,16 @@ #include <cmsys/RegularExpression.hxx> -//---------------------------------------------------------------------------- cmCTestHG::cmCTestHG(cmCTest* ct, std::ostream& log): cmCTestGlobalVC(ct, log) { this->PriorRev = this->Unknown; } -//---------------------------------------------------------------------------- cmCTestHG::~cmCTestHG() { } -//---------------------------------------------------------------------------- class cmCTestHG::IdentifyParser: public cmCTestVC::LineParser { public: @@ -54,7 +51,6 @@ private: } }; -//---------------------------------------------------------------------------- class cmCTestHG::StatusParser: public cmCTestVC::LineParser { public: @@ -94,7 +90,6 @@ private: } }; -//---------------------------------------------------------------------------- std::string cmCTestHG::GetWorkingRevision() { // Run plumbing "hg identify" to get work tree revision. @@ -107,7 +102,6 @@ std::string cmCTestHG::GetWorkingRevision() return rev; } -//---------------------------------------------------------------------------- void cmCTestHG::NoteOldRevision() { this->OldRevision = this->GetWorkingRevision(); @@ -116,7 +110,6 @@ void cmCTestHG::NoteOldRevision() this->PriorRev.Rev = this->OldRevision; } -//---------------------------------------------------------------------------- void cmCTestHG::NoteNewRevision() { this->NewRevision = this->GetWorkingRevision(); @@ -124,7 +117,6 @@ void cmCTestHG::NoteNewRevision() << this->NewRevision << "\n"); } -//---------------------------------------------------------------------------- bool cmCTestHG::UpdateImpl() { // Use "hg pull" followed by "hg update" to update the working tree. @@ -164,7 +156,6 @@ bool cmCTestHG::UpdateImpl() return this->RunUpdateCommand(&hg_update[0], &out, &err); } -//---------------------------------------------------------------------------- class cmCTestHG::LogParser: public cmCTestVC::OutputLogger, private cmXMLParser { @@ -293,7 +284,6 @@ private: } }; -//---------------------------------------------------------------------------- void cmCTestHG::LoadRevisions() { // Use 'hg log' to get revisions in a xml format. @@ -326,7 +316,6 @@ void cmCTestHG::LoadRevisions() out.Process("</log>\n"); } -//---------------------------------------------------------------------------- void cmCTestHG::LoadModifications() { // Use 'hg status' to get modified files. diff --git a/Source/CTest/cmCTestHandlerCommand.cxx b/Source/CTest/cmCTestHandlerCommand.cxx index 3579aee..4b24a199 100644 --- a/Source/CTest/cmCTestHandlerCommand.cxx +++ b/Source/CTest/cmCTestHandlerCommand.cxx @@ -158,7 +158,6 @@ bool cmCTestHandlerCommand return true; } -//---------------------------------------------------------------------------- bool cmCTestHandlerCommand::CheckArgumentKeyword(std::string const& arg) { // Look for non-value arguments common to all commands. @@ -188,7 +187,6 @@ bool cmCTestHandlerCommand::CheckArgumentKeyword(std::string const& arg) return false; } -//---------------------------------------------------------------------------- bool cmCTestHandlerCommand::CheckArgumentValue(std::string const& arg) { if(this->ArgumentDoing == ArgumentDoingKeyword) diff --git a/Source/CTest/cmCTestLaunch.cxx b/Source/CTest/cmCTestLaunch.cxx index 03b06f8..7da81ec 100644 --- a/Source/CTest/cmCTestLaunch.cxx +++ b/Source/CTest/cmCTestLaunch.cxx @@ -27,7 +27,6 @@ #include <stdio.h> // for std{out,err} and fileno #endif -//---------------------------------------------------------------------------- cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv) { this->Passthru = true; @@ -48,7 +47,6 @@ cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv) this->Process = cmsysProcess_New(); } -//---------------------------------------------------------------------------- cmCTestLaunch::~cmCTestLaunch() { cmsysProcess_Delete(this->Process); @@ -59,7 +57,6 @@ cmCTestLaunch::~cmCTestLaunch() } } -//---------------------------------------------------------------------------- bool cmCTestLaunch::ParseArguments(int argc, const char* const* argv) { // Launcher options occur first and are separated from the real @@ -171,7 +168,6 @@ bool cmCTestLaunch::ParseArguments(int argc, const char* const* argv) } } -//---------------------------------------------------------------------------- void cmCTestLaunch::HandleRealArg(const char* arg) { #ifdef _WIN32 @@ -190,7 +186,6 @@ void cmCTestLaunch::HandleRealArg(const char* arg) this->RealArgs.push_back(arg); } -//---------------------------------------------------------------------------- void cmCTestLaunch::ComputeFileNames() { // We just passthru the behavior of the real command unless the @@ -234,7 +229,6 @@ void cmCTestLaunch::ComputeFileNames() this->LogErr += "-err.txt"; } -//---------------------------------------------------------------------------- void cmCTestLaunch::RunChild() { // Ignore noopt make rules @@ -302,7 +296,6 @@ void cmCTestLaunch::RunChild() this->ExitCode = cmsysProcess_GetExitValue(cp); } -//---------------------------------------------------------------------------- int cmCTestLaunch::Run() { if(!this->Process) @@ -324,7 +317,6 @@ int cmCTestLaunch::Run() return this->ExitCode; } -//---------------------------------------------------------------------------- void cmCTestLaunch::LoadLabels() { if(this->OptionBuildDir.empty() || this->OptionTargetName.empty()) @@ -379,7 +371,6 @@ void cmCTestLaunch::LoadLabels() } } -//---------------------------------------------------------------------------- bool cmCTestLaunch::SourceMatches(std::string const& lhs, std::string const& rhs) { @@ -390,13 +381,11 @@ bool cmCTestLaunch::SourceMatches(std::string const& lhs, return lhs == rhs; } -//---------------------------------------------------------------------------- bool cmCTestLaunch::IsError() const { return this->ExitCode != 0; } -//---------------------------------------------------------------------------- void cmCTestLaunch::WriteXML() { // Name the xml file. @@ -417,7 +406,6 @@ void cmCTestLaunch::WriteXML() xml.EndElement(); // Failure } -//---------------------------------------------------------------------------- void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml) { xml.Comment("Meta-information about the build action"); @@ -493,7 +481,6 @@ void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml) xml.EndElement(); // Action } -//---------------------------------------------------------------------------- void cmCTestLaunch::WriteXMLCommand(cmXMLWriter& xml) { xml.Comment("Details of command"); @@ -510,7 +497,6 @@ void cmCTestLaunch::WriteXMLCommand(cmXMLWriter& xml) xml.EndElement(); // Command } -//---------------------------------------------------------------------------- void cmCTestLaunch::WriteXMLResult(cmXMLWriter& xml) { xml.Comment("Result of command"); @@ -556,7 +542,6 @@ void cmCTestLaunch::WriteXMLResult(cmXMLWriter& xml) xml.EndElement(); // Result } -//---------------------------------------------------------------------------- void cmCTestLaunch::WriteXMLLabels(cmXMLWriter& xml) { this->LoadLabels(); @@ -573,7 +558,6 @@ void cmCTestLaunch::WriteXMLLabels(cmXMLWriter& xml) } } -//---------------------------------------------------------------------------- void cmCTestLaunch::DumpFileToXML(cmXMLWriter& xml, std::string const& fname) { @@ -595,7 +579,6 @@ void cmCTestLaunch::DumpFileToXML(cmXMLWriter& xml, } } -//---------------------------------------------------------------------------- bool cmCTestLaunch::CheckResults() { // Skip XML in passthru mode. @@ -619,7 +602,6 @@ bool cmCTestLaunch::CheckResults() return true; } -//---------------------------------------------------------------------------- void cmCTestLaunch::LoadScrapeRules() { if(this->ScrapeRulesLoaded) @@ -640,7 +622,6 @@ void cmCTestLaunch::LoadScrapeRules() this->LoadScrapeRules("WarningSuppress", this->RegexWarningSuppress); } -//---------------------------------------------------------------------------- void cmCTestLaunch ::LoadScrapeRules(const char* purpose, @@ -662,7 +643,6 @@ cmCTestLaunch } } -//---------------------------------------------------------------------------- bool cmCTestLaunch::ScrapeLog(std::string const& fname) { this->LoadScrapeRules(); @@ -687,7 +667,6 @@ bool cmCTestLaunch::ScrapeLog(std::string const& fname) return false; } -//---------------------------------------------------------------------------- bool cmCTestLaunch::Match(std::string const& line, std::vector<cmsys::RegularExpression>& regexps) { @@ -702,7 +681,6 @@ bool cmCTestLaunch::Match(std::string const& line, return false; } -//---------------------------------------------------------------------------- bool cmCTestLaunch::MatchesFilterPrefix(std::string const& line) const { if(!this->OptionFilterPrefix.empty() && cmSystemTools::StringStartsWith( @@ -713,7 +691,6 @@ bool cmCTestLaunch::MatchesFilterPrefix(std::string const& line) const return false; } -//---------------------------------------------------------------------------- int cmCTestLaunch::Main(int argc, const char* const argv[]) { if(argc == 2) @@ -726,7 +703,6 @@ int cmCTestLaunch::Main(int argc, const char* const argv[]) return self.Run(); } -//---------------------------------------------------------------------------- #include "cmGlobalGenerator.h" #include "cmMakefile.h" #include "cmake.h" diff --git a/Source/CTest/cmCTestMemCheckHandler.cxx b/Source/CTest/cmCTestMemCheckHandler.cxx index 9e3ba57..dd2a5b8 100644 --- a/Source/CTest/cmCTestMemCheckHandler.cxx +++ b/Source/CTest/cmCTestMemCheckHandler.cxx @@ -141,7 +141,6 @@ public: -//---------------------------------------------------------------------- cmCTestMemCheckHandler::cmCTestMemCheckHandler() { this->MemCheck = true; @@ -150,7 +149,6 @@ cmCTestMemCheckHandler::cmCTestMemCheckHandler() this->LogWithPID = false; } -//---------------------------------------------------------------------- void cmCTestMemCheckHandler::Initialize() { this->Superclass::Initialize(); @@ -164,7 +162,6 @@ void cmCTestMemCheckHandler::Initialize() this->MemoryTesterOutputFile = ""; } -//---------------------------------------------------------------------- int cmCTestMemCheckHandler::PreProcessHandler() { if ( !this->InitializeMemoryChecking() ) @@ -181,7 +178,6 @@ int cmCTestMemCheckHandler::PreProcessHandler() return 1; } -//---------------------------------------------------------------------- int cmCTestMemCheckHandler::PostProcessHandler() { if ( !this->ExecuteCommands(this->CustomPostMemCheck) ) @@ -193,7 +189,6 @@ int cmCTestMemCheckHandler::PostProcessHandler() return 1; } -//---------------------------------------------------------------------- void cmCTestMemCheckHandler::GenerateTestCommand( std::vector<std::string>& args, int test) { @@ -256,7 +251,6 @@ void cmCTestMemCheckHandler::GenerateTestCommand( "Memory check command: " << memcheckcommand << std::endl, this->Quiet); } -//---------------------------------------------------------------------- void cmCTestMemCheckHandler::InitializeResultsVectors() { // fill these members @@ -300,7 +294,6 @@ void cmCTestMemCheckHandler::InitializeResultsVectors() "UMR", 0 }; -//---------------------------------------------------------------------- static const char* cmCTestMemCheckResultLongStrings[] = { "Threading Problem", "ABW", @@ -335,7 +328,6 @@ void cmCTestMemCheckHandler::InitializeResultsVectors() } } -//---------------------------------------------------------------------- void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile *mf) { this->cmCTestTestHandler::PopulateCustomVectors(mf); @@ -352,7 +344,6 @@ void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile *mf) this->Quiet); } -//---------------------------------------------------------------------- void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml) { if ( !this->CTest->GetProduceXML() ) @@ -483,7 +474,6 @@ void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml) this->CTest->EndXML(xml); } -//---------------------------------------------------------------------- bool cmCTestMemCheckHandler::InitializeMemoryChecking() { this->MemoryTesterEnvironmentVariable = ""; @@ -747,7 +737,6 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking() return true; } -//---------------------------------------------------------------------- bool cmCTestMemCheckHandler:: ProcessMemCheckOutput(const std::string& str, std::string& log, std::vector<int>& results) @@ -801,7 +790,6 @@ std::vector<int>::size_type cmCTestMemCheckHandler::FindOrAddWarning( this->ResultStringsLong.push_back(warning); return this->ResultStrings.size()-1; } -//---------------------------------------------------------------------- bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput( const std::string& str, std::string& log, std::vector<int>& result) @@ -866,7 +854,6 @@ bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput( } return true; } -//---------------------------------------------------------------------- bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput( const std::string& str, std::string& log, std::vector<int>& results) @@ -920,7 +907,6 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput( return true; } -//---------------------------------------------------------------------- bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput( const std::string& str, std::string& log, std::vector<int>& results) @@ -1095,7 +1081,6 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput( -//---------------------------------------------------------------------- bool cmCTestMemCheckHandler::ProcessMemCheckBoundsCheckerOutput( const std::string& str, std::string& log, std::vector<int>& results) diff --git a/Source/CTest/cmCTestMultiProcessHandler.cxx b/Source/CTest/cmCTestMultiProcessHandler.cxx index 07c7806..d92ac77 100644 --- a/Source/CTest/cmCTestMultiProcessHandler.cxx +++ b/Source/CTest/cmCTestMultiProcessHandler.cxx @@ -94,7 +94,6 @@ void cmCTestMultiProcessHandler::SetTestLoad(unsigned long load) this->TestLoad = load; } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::RunTests() { this->CheckResume(); @@ -121,7 +120,6 @@ void cmCTestMultiProcessHandler::RunTests() this->UpdateCostData(); } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::StartTestProcess(int test) { cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, @@ -177,7 +175,6 @@ void cmCTestMultiProcessHandler::StartTestProcess(int test) cmSystemTools::ChangeDirectory(current_dir); } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::LockResources(int index) { this->LockedResources.insert( @@ -190,7 +187,6 @@ void cmCTestMultiProcessHandler::LockResources(int index) } } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::UnlockResources(int index) { for(std::set<std::string>::iterator i = @@ -205,7 +201,6 @@ void cmCTestMultiProcessHandler::UnlockResources(int index) } } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::EraseTest(int test) { this->Tests.erase(test); @@ -213,7 +208,6 @@ void cmCTestMultiProcessHandler::EraseTest(int test) std::find(this->SortedTests.begin(), this->SortedTests.end(), test)); } -//--------------------------------------------------------- inline size_t cmCTestMultiProcessHandler::GetProcessorsUsed(int test) { size_t processors = @@ -232,7 +226,6 @@ std::string cmCTestMultiProcessHandler::GetName(int test) return this->Properties[test]->Name; } -//--------------------------------------------------------- bool cmCTestMultiProcessHandler::StartTest(int test) { //Check for locked resources @@ -257,7 +250,6 @@ bool cmCTestMultiProcessHandler::StartTest(int test) return false; } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::StartNextTests() { size_t numToStart = 0; @@ -407,7 +399,6 @@ void cmCTestMultiProcessHandler::StartNextTests() } } -//--------------------------------------------------------- bool cmCTestMultiProcessHandler::CheckOutput() { // no more output we are done @@ -463,7 +454,6 @@ bool cmCTestMultiProcessHandler::CheckOutput() return true; } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::UpdateCostData() { std::string fname = this->CTest->GetCostDataFile(); @@ -527,7 +517,6 @@ void cmCTestMultiProcessHandler::UpdateCostData() cmSystemTools::RenameFile(tmpout.c_str(), fname.c_str()); } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::ReadCostData() { std::string fname = this->CTest->GetCostDataFile(); @@ -579,7 +568,6 @@ void cmCTestMultiProcessHandler::ReadCostData() } } -//--------------------------------------------------------- int cmCTestMultiProcessHandler::SearchByName(std::string name) { int index = -1; @@ -595,7 +583,6 @@ int cmCTestMultiProcessHandler::SearchByName(std::string name) return index; } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::CreateTestCostList() { if(this->ParallelLevel > 1) @@ -608,7 +595,6 @@ void cmCTestMultiProcessHandler::CreateTestCostList() } } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::CreateParallelTestCostList() { TestSet alreadySortedTests; @@ -688,7 +674,6 @@ void cmCTestMultiProcessHandler::CreateParallelTestCostList() } } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::GetAllTestDependencies( int test, TestList& dependencies) { @@ -701,7 +686,6 @@ void cmCTestMultiProcessHandler::GetAllTestDependencies( } } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::CreateSerialTestCostList() { TestList presortedList; @@ -747,7 +731,6 @@ void cmCTestMultiProcessHandler::CreateSerialTestCostList() } } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::WriteCheckpoint(int index) { std::string fname = this->CTest->GetBinaryDir() @@ -758,7 +741,6 @@ void cmCTestMultiProcessHandler::WriteCheckpoint(int index) fout.close(); } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::MarkFinished() { std::string fname = this->CTest->GetBinaryDir() @@ -766,7 +748,6 @@ void cmCTestMultiProcessHandler::MarkFinished() cmSystemTools::RemoveFile(fname); } -//--------------------------------------------------------- //For ShowOnly mode void cmCTestMultiProcessHandler::PrintTestList() { @@ -858,7 +839,6 @@ void cmCTestMultiProcessHandler::PrintLabels() } } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::CheckResume() { std::string fname = this->CTest->GetBinaryDir() @@ -889,7 +869,6 @@ void cmCTestMultiProcessHandler::CheckResume() } } -//--------------------------------------------------------- void cmCTestMultiProcessHandler::RemoveTest(int index) { this->EraseTest(index); @@ -899,7 +878,6 @@ void cmCTestMultiProcessHandler::RemoveTest(int index) this->Completed++; } -//--------------------------------------------------------- int cmCTestMultiProcessHandler::FindMaxIndex() { int max = 0; diff --git a/Source/CTest/cmCTestP4.cxx b/Source/CTest/cmCTestP4.cxx index b801cfc..e05b77a 100644 --- a/Source/CTest/cmCTestP4.cxx +++ b/Source/CTest/cmCTestP4.cxx @@ -21,19 +21,16 @@ #include <sys/types.h> #include <time.h> -//---------------------------------------------------------------------------- cmCTestP4::cmCTestP4(cmCTest* ct, std::ostream& log): cmCTestGlobalVC(ct, log) { this->PriorRev = this->Unknown; } -//---------------------------------------------------------------------------- cmCTestP4::~cmCTestP4() { } -//---------------------------------------------------------------------------- class cmCTestP4::IdentifyParser: public cmCTestVC::LineParser { public: @@ -58,7 +55,6 @@ private: } }; -//---------------------------------------------------------------------------- class cmCTestP4::ChangesParser: public cmCTestVC::LineParser { public: @@ -81,7 +77,6 @@ private: } }; -//---------------------------------------------------------------------------- class cmCTestP4::UserParser: public cmCTestVC::LineParser { public: @@ -112,7 +107,6 @@ private: } }; -//---------------------------------------------------------------------------- /* Diff format: ==== //depot/file#rev - /absolute/path/to/file ==== (diff data) @@ -157,7 +151,6 @@ private: } }; -//---------------------------------------------------------------------------- cmCTestP4::User cmCTestP4::GetUserData(const std::string& username) { std::map<std::string, cmCTestP4::User>::const_iterator it = @@ -188,7 +181,6 @@ cmCTestP4::User cmCTestP4::GetUserData(const std::string& username) return it->second; } -//---------------------------------------------------------------------------- /* Commit format: Change 1111111 by user@client on 2013/09/26 11:50:36 @@ -319,7 +311,6 @@ private: } }; -//---------------------------------------------------------------------------- void cmCTestP4::SetP4Options(std::vector<char const*> &CommandOptions) { if(P4Options.empty()) @@ -358,7 +349,6 @@ void cmCTestP4::SetP4Options(std::vector<char const*> &CommandOptions) } } -//---------------------------------------------------------------------------- std::string cmCTestP4::GetWorkingRevision() { std::vector<char const*> p4_identify; @@ -395,7 +385,6 @@ std::string cmCTestP4::GetWorkingRevision() } } -//---------------------------------------------------------------------------- void cmCTestP4::NoteOldRevision() { this->OldRevision = this->GetWorkingRevision(); @@ -405,7 +394,6 @@ void cmCTestP4::NoteOldRevision() this->PriorRev.Rev = this->OldRevision; } -//---------------------------------------------------------------------------- void cmCTestP4::NoteNewRevision() { this->NewRevision = this->GetWorkingRevision(); @@ -414,7 +402,6 @@ void cmCTestP4::NoteNewRevision() << this->NewRevision << "\n"); } -//---------------------------------------------------------------------------- void cmCTestP4::LoadRevisions() { std::vector<char const*> p4_changes; @@ -465,7 +452,6 @@ void cmCTestP4::LoadRevisions() } } -//---------------------------------------------------------------------------- void cmCTestP4::LoadModifications() { std::vector<char const*> p4_diff; @@ -484,7 +470,6 @@ void cmCTestP4::LoadModifications() this->RunChild(&p4_diff[0], &out, &err); } -//---------------------------------------------------------------------------- bool cmCTestP4::UpdateCustom(const std::string& custom) { std::vector<std::string> p4_custom_command; @@ -504,7 +489,6 @@ bool cmCTestP4::UpdateCustom(const std::string& custom) return this->RunUpdateCommand(&p4_custom[0], &custom_out, &custom_err); } -//---------------------------------------------------------------------------- bool cmCTestP4::UpdateImpl() { std::string custom = this->CTest->GetCTestConfiguration("P4UpdateCustom"); diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx index 5d159c1..1fa008d 100644 --- a/Source/CTest/cmCTestRunTest.cxx +++ b/Source/CTest/cmCTestRunTest.cxx @@ -43,7 +43,6 @@ cmCTestRunTest::~cmCTestRunTest() { } -//---------------------------------------------------------------------------- bool cmCTestRunTest::CheckOutput() { // Read lines for up to 0.1 seconds of total time. @@ -98,7 +97,6 @@ bool cmCTestRunTest::CheckOutput() return true; } -//--------------------------------------------------------- // Streamed compression of test output. The compressed data // is appended to this->CompressedOutput void cmCTestRunTest::CompressOutput() @@ -161,7 +159,6 @@ void cmCTestRunTest::CompressOutput() delete [] out; } -//--------------------------------------------------------- bool cmCTestRunTest::EndTest(size_t completed, size_t total, bool started) { if ((!this->TestHandler->MemCheck && @@ -428,7 +425,6 @@ bool cmCTestRunTest::NeedsToRerun() } return false; } -//---------------------------------------------------------------------- void cmCTestRunTest::ComputeWeightedCost() { double prev = static_cast<double>(this->TestProperties->PreviousRuns); @@ -443,7 +439,6 @@ void cmCTestRunTest::ComputeWeightedCost() } } -//---------------------------------------------------------------------- void cmCTestRunTest::MemCheckPostProcess() { if(!this->TestHandler->MemCheck) @@ -460,7 +455,6 @@ void cmCTestRunTest::MemCheckPostProcess() handler->PostProcessTest(this->TestResult, this->Index); } -//---------------------------------------------------------------------- // Starts the execution of a test. Returns once it has started bool cmCTestRunTest::StartTest(size_t total) { @@ -556,7 +550,6 @@ bool cmCTestRunTest::StartTest(size_t total) &this->TestProperties->Environment); } -//---------------------------------------------------------------------- void cmCTestRunTest::ComputeArguments() { this->Arguments.clear(); // reset becaue this might be a rerun @@ -623,7 +616,6 @@ void cmCTestRunTest::ComputeArguments() } } -//---------------------------------------------------------------------- void cmCTestRunTest::DartProcessing() { if (!this->ProcessOutput.empty() && @@ -643,7 +635,6 @@ void cmCTestRunTest::DartProcessing() } } -//---------------------------------------------------------------------- double cmCTestRunTest::ResolveTimeout() { double timeout = this->TestProperties->Timeout; @@ -708,7 +699,6 @@ double cmCTestRunTest::ResolveTimeout() (timeout < stop_timeout ? timeout : stop_timeout); } -//---------------------------------------------------------------------- bool cmCTestRunTest::ForkProcess(double testTimeOut, bool explicitTimeout, std::vector<std::string>* environment) { diff --git a/Source/CTest/cmCTestSVN.cxx b/Source/CTest/cmCTestSVN.cxx index f7bd1f9..507ec29 100644 --- a/Source/CTest/cmCTestSVN.cxx +++ b/Source/CTest/cmCTestSVN.cxx @@ -23,19 +23,16 @@ struct cmCTestSVN::Revision: public cmCTestVC::Revision cmCTestSVN::SVNInfo* SVNInfo; }; -//---------------------------------------------------------------------------- cmCTestSVN::cmCTestSVN(cmCTest* ct, std::ostream& log): cmCTestGlobalVC(ct, log) { this->PriorRev = this->Unknown; } -//---------------------------------------------------------------------------- cmCTestSVN::~cmCTestSVN() { } -//---------------------------------------------------------------------------- void cmCTestSVN::CleanupImpl() { std::vector<const char*> svn_cleanup; @@ -45,7 +42,6 @@ void cmCTestSVN::CleanupImpl() this->RunSVNCommand(svn_cleanup, &out, &err); } -//---------------------------------------------------------------------------- class cmCTestSVN::InfoParser: public cmCTestVC::LineParser { public: @@ -84,7 +80,6 @@ private: } }; -//---------------------------------------------------------------------------- static bool cmCTestSVNPathStarts(std::string const& p1, std::string const& p2) { // Does path p1 start with path p2? @@ -102,7 +97,6 @@ static bool cmCTestSVNPathStarts(std::string const& p1, std::string const& p2) } } -//---------------------------------------------------------------------------- std::string cmCTestSVN::LoadInfo(SVNInfo& svninfo) { // Run "svn info" to get the repository info from the work tree. @@ -116,7 +110,6 @@ std::string cmCTestSVN::LoadInfo(SVNInfo& svninfo) return rev; } -//---------------------------------------------------------------------------- void cmCTestSVN::NoteOldRevision() { // Info for root repository @@ -145,7 +138,6 @@ void cmCTestSVN::NoteOldRevision() this->PriorRev.Rev = this->OldRevision; } -//---------------------------------------------------------------------------- void cmCTestSVN::NoteNewRevision() { // Get info for the external repositories @@ -186,7 +178,6 @@ void cmCTestSVN::NoteNewRevision() this->NewRevision = this->RootInfo->NewRevision; } -//---------------------------------------------------------------------------- void cmCTestSVN::GuessBase(SVNInfo& svninfo, std::vector<Change> const& changes) { @@ -220,7 +211,6 @@ void cmCTestSVN::GuessBase(SVNInfo& svninfo, this->Log << "Guessed Base = " << svninfo.Base << "\n"; } -//---------------------------------------------------------------------------- class cmCTestSVN::UpdateParser: public cmCTestVC::LineParser { public: @@ -268,7 +258,6 @@ private: } }; -//---------------------------------------------------------------------------- bool cmCTestSVN::UpdateImpl() { // Get user-specified update options. @@ -298,7 +287,6 @@ bool cmCTestSVN::UpdateImpl() return this->RunSVNCommand(svn_update, &out, &err); } -//---------------------------------------------------------------------------- bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters, OutputParser* out, OutputParser* err) { @@ -334,7 +322,6 @@ bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters, } } -//---------------------------------------------------------------------------- class cmCTestSVN::LogParser: public cmCTestVC::OutputLogger, private cmXMLParser { @@ -423,7 +410,6 @@ private: } }; -//---------------------------------------------------------------------------- void cmCTestSVN::LoadRevisions() { // Get revisions for all the external repositories @@ -436,7 +422,6 @@ void cmCTestSVN::LoadRevisions() } } -//---------------------------------------------------------------------------- void cmCTestSVN::LoadRevisions(SVNInfo &svninfo) { // We are interested in every revision included in the update. @@ -462,7 +447,6 @@ void cmCTestSVN::LoadRevisions(SVNInfo &svninfo) this->RunSVNCommand(svn_log, &out, &err); } -//---------------------------------------------------------------------------- void cmCTestSVN::DoRevisionSVN(Revision const& revision, std::vector<Change> const& changes) { @@ -482,7 +466,6 @@ void cmCTestSVN::DoRevisionSVN(Revision const& revision, this->cmCTestGlobalVC::DoRevision(revision, changes); } -//---------------------------------------------------------------------------- class cmCTestSVN::StatusParser: public cmCTestVC::LineParser { public: @@ -523,7 +506,6 @@ private: } }; -//---------------------------------------------------------------------------- void cmCTestSVN::LoadModifications() { // Run "svn status" which reports local modifications. @@ -534,7 +516,6 @@ void cmCTestSVN::LoadModifications() this->RunSVNCommand(svn_status, &out, &err); } -//---------------------------------------------------------------------------- void cmCTestSVN::WriteXMLGlobal(cmXMLWriter& xml) { this->cmCTestGlobalVC::WriteXMLGlobal(xml); @@ -542,7 +523,6 @@ void cmCTestSVN::WriteXMLGlobal(cmXMLWriter& xml) xml.Element("SVNPath", this->RootInfo->Base); } -//---------------------------------------------------------------------------- class cmCTestSVN::ExternalParser: public cmCTestVC::LineParser { public: @@ -581,7 +561,6 @@ private: } }; -//---------------------------------------------------------------------------- void cmCTestSVN::LoadExternals() { // Run "svn status" to get the list of external repositories @@ -592,7 +571,6 @@ void cmCTestSVN::LoadExternals() this->RunSVNCommand(svn_status, &out, &err); } -//---------------------------------------------------------------------------- std::string cmCTestSVN::SVNInfo::BuildLocalPath(std::string const& path) const { std::string local_path; diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx index 4485d34..bde7a6d 100644 --- a/Source/CTest/cmCTestScriptHandler.cxx +++ b/Source/CTest/cmCTestScriptHandler.cxx @@ -78,7 +78,6 @@ IsFunctionBlocked(const cmListFileFunction& , cmMakefile &, return false; } -//---------------------------------------------------------------------- cmCTestScriptHandler::cmCTestScriptHandler() { this->Backup = false; @@ -95,7 +94,6 @@ cmCTestScriptHandler::cmCTestScriptHandler() this->ContinuousDuration = -1; } -//---------------------------------------------------------------------- void cmCTestScriptHandler::Initialize() { this->Superclass::Initialize(); @@ -132,7 +130,6 @@ void cmCTestScriptHandler::Initialize() delete this->CMake; } -//---------------------------------------------------------------------- cmCTestScriptHandler::~cmCTestScriptHandler() { delete this->Makefile; @@ -141,7 +138,6 @@ cmCTestScriptHandler::~cmCTestScriptHandler() } -//---------------------------------------------------------------------- // just adds an argument to the vector void cmCTestScriptHandler::AddConfigurationScript(const char *script, bool pscope) @@ -151,7 +147,6 @@ void cmCTestScriptHandler::AddConfigurationScript(const char *script, } -//---------------------------------------------------------------------- // the generic entry point for handling scripts, this routine will run all // the scripts provides a -S arguments int cmCTestScriptHandler::ProcessHandler() @@ -184,7 +179,6 @@ void cmCTestScriptHandler::UpdateElapsedTime() } } -//---------------------------------------------------------------------- void cmCTestScriptHandler::AddCTestCommand(cmCTestCommand* command) { cmCTestCommand* newCom = command; @@ -348,7 +342,6 @@ void cmCTestScriptHandler::CreateCMake() this->AddCTestCommand(new cmCTestUploadCommand); } -//---------------------------------------------------------------------- // this sets up some variables for the script to use, creates the required // cmake instance and generators, and then reads in the script int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg) @@ -443,7 +436,6 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg) } -//---------------------------------------------------------------------- // extract variabels from the script to set ivars int cmCTestScriptHandler::ExtractVariables() { @@ -560,7 +552,6 @@ int cmCTestScriptHandler::ExtractVariables() return 0; } -//---------------------------------------------------------------------- void cmCTestScriptHandler::SleepInSeconds(unsigned int secondsToWait) { #if defined(_WIN32) @@ -570,7 +561,6 @@ void cmCTestScriptHandler::SleepInSeconds(unsigned int secondsToWait) #endif } -//---------------------------------------------------------------------- // run a specific script int cmCTestScriptHandler::RunConfigurationScript (const std::string& total_script_arg, bool pscope) @@ -610,7 +600,6 @@ int cmCTestScriptHandler::RunConfigurationScript return result; } -//---------------------------------------------------------------------- int cmCTestScriptHandler::RunCurrentScript() { int result; @@ -673,7 +662,6 @@ int cmCTestScriptHandler::RunCurrentScript() return result; } -//---------------------------------------------------------------------- int cmCTestScriptHandler::CheckOutSourceDir() { std::string command; @@ -702,7 +690,6 @@ int cmCTestScriptHandler::CheckOutSourceDir() return 0; } -//---------------------------------------------------------------------- int cmCTestScriptHandler::BackupDirectories() { int retVal; @@ -743,7 +730,6 @@ int cmCTestScriptHandler::BackupDirectories() } -//---------------------------------------------------------------------- int cmCTestScriptHandler::PerformExtraUpdates() { std::string command; @@ -786,7 +772,6 @@ int cmCTestScriptHandler::PerformExtraUpdates() } -//---------------------------------------------------------------------- // run a single dashboard entry int cmCTestScriptHandler::RunConfigurationDashboard() { @@ -977,7 +962,6 @@ int cmCTestScriptHandler::RunConfigurationDashboard() return 0; } -//------------------------------------------------------------------------- bool cmCTestScriptHandler::WriteInitialCache(const char* directory, const char* text) { @@ -1002,7 +986,6 @@ bool cmCTestScriptHandler::WriteInitialCache(const char* directory, return true; } -//------------------------------------------------------------------------- void cmCTestScriptHandler::RestoreBackupDirectories() { // if we backed up the dirs and the build failed, then restore @@ -1074,7 +1057,6 @@ bool cmCTestScriptHandler::EmptyBinaryDirectory(const char *sname) return false; } -//------------------------------------------------------------------------- bool cmCTestScriptHandler::TryToRemoveBinaryDirectoryOnce( const std::string& directoryPath) { @@ -1114,7 +1096,6 @@ bool cmCTestScriptHandler::TryToRemoveBinaryDirectoryOnce( return cmSystemTools::RemoveADirectory(directoryPath); } -//------------------------------------------------------------------------- double cmCTestScriptHandler::GetRemainingTimeAllowed() { if (!this->Makefile) diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx index 4a38dc6..fef5637 100644 --- a/Source/CTest/cmCTestStartCommand.cxx +++ b/Source/CTest/cmCTestStartCommand.cxx @@ -154,7 +154,6 @@ bool cmCTestStartCommand return this->CTest->InitializeFromCommand(this); } -//---------------------------------------------------------------------------- bool cmCTestStartCommand::InitialCheckout( std::ostream& ofs, std::string const& sourceDir) { diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx index 5a8090c..6174624 100644 --- a/Source/CTest/cmCTestSubmitCommand.cxx +++ b/Source/CTest/cmCTestSubmitCommand.cxx @@ -161,7 +161,6 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler() return handler; } -//---------------------------------------------------------------------------- bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args, cmExecutionStatus& status) { @@ -169,7 +168,6 @@ bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args, return this->cmCTestHandlerCommand::InitialPass(args, status); } -//---------------------------------------------------------------------------- bool cmCTestSubmitCommand::CheckArgumentKeyword(std::string const& arg) { if (this->CDashUpload) @@ -227,7 +225,6 @@ bool cmCTestSubmitCommand::CheckArgumentKeyword(std::string const& arg) } -//---------------------------------------------------------------------------- bool cmCTestSubmitCommand::CheckArgumentValue(std::string const& arg) { // Handle states specific to this command. diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx index 8621577..2153b8f 100644 --- a/Source/CTest/cmCTestSubmitHandler.cxx +++ b/Source/CTest/cmCTestSubmitHandler.cxx @@ -37,7 +37,6 @@ typedef std::vector<char> cmCTestSubmitHandlerVectorOfChar; -//---------------------------------------------------------------------------- class cmCTestSubmitHandler::ResponseParser: public cmXMLParser { public: @@ -146,13 +145,11 @@ cmCTestSubmitHandlerCurlDebugCallback(CURL *, curl_infotype, char *chPtr, return size; } -//---------------------------------------------------------------------------- cmCTestSubmitHandler::cmCTestSubmitHandler() : HTTPProxy(), FTPProxy() { this->Initialize(); } -//---------------------------------------------------------------------------- void cmCTestSubmitHandler::Initialize() { // We submit all available parts by default. @@ -174,7 +171,6 @@ void cmCTestSubmitHandler::Initialize() this->Files.clear(); } -//---------------------------------------------------------------------------- bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix, const std::set<std::string>& files, const std::string& remoteprefix, @@ -328,7 +324,6 @@ bool cmCTestSubmitHandler::SubmitUsingFTP(const std::string& localprefix, return true; } -//---------------------------------------------------------------------------- // Uploading files is simpler bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix, const std::set<std::string>& files, @@ -643,7 +638,6 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix, return true; } -//---------------------------------------------------------------------------- void cmCTestSubmitHandler ::ParseResponse(cmCTestSubmitHandlerVectorOfChar chunk) { @@ -680,7 +674,6 @@ void cmCTestSubmitHandler } } -//---------------------------------------------------------------------------- bool cmCTestSubmitHandler::TriggerUsingHTTP( const std::set<std::string>& files, const std::string& remoteprefix, @@ -821,7 +814,6 @@ bool cmCTestSubmitHandler::TriggerUsingHTTP( return true; } -//---------------------------------------------------------------------------- bool cmCTestSubmitHandler::SubmitUsingSCP( const std::string& scp_command, const std::string& localprefix, @@ -923,7 +915,6 @@ bool cmCTestSubmitHandler::SubmitUsingSCP( return true; } -//---------------------------------------------------------------------------- bool cmCTestSubmitHandler::SubmitUsingCP( const std::string& localprefix, const std::set<std::string>& files, @@ -967,7 +958,6 @@ bool cmCTestSubmitHandler::SubmitUsingCP( } -//---------------------------------------------------------------------------- #if defined(CTEST_USE_XMLRPC) bool cmCTestSubmitHandler::SubmitUsingXMLRPC(const std::string& localprefix, const std::set<std::string>& files, @@ -1238,7 +1228,6 @@ int cmCTestSubmitHandler::HandleCDashUploadFile(std::string const& file, return 0; } -//---------------------------------------------------------------------------- int cmCTestSubmitHandler::ProcessHandler() { const char* cdashUploadFile = this->GetOption("CDashUploadFile"); @@ -1664,7 +1653,6 @@ int cmCTestSubmitHandler::ProcessHandler() return -1; } -//---------------------------------------------------------------------------- std::string cmCTestSubmitHandler::GetSubmitResultsPrefix() { std::string buildname = cmCTest::SafeBuildIdField( @@ -1676,7 +1664,6 @@ std::string cmCTestSubmitHandler::GetSubmitResultsPrefix() return name; } -//---------------------------------------------------------------------------- void cmCTestSubmitHandler::SelectParts(std::set<cmCTest::Part> const& parts) { // Check whether each part is selected. @@ -1688,7 +1675,6 @@ void cmCTestSubmitHandler::SelectParts(std::set<cmCTest::Part> const& parts) } } -//---------------------------------------------------------------------------- void cmCTestSubmitHandler::SelectFiles(cmCTest::SetOfStrings const& files) { this->Files.insert(files.begin(), files.end()); diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index d8229da..b477f5f 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -36,7 +36,6 @@ #include <set> -//---------------------------------------------------------------------- class cmCTestSubdirCommand : public cmCommand { public: @@ -67,7 +66,6 @@ public: cmCTestTestHandler* TestHandler; }; -//---------------------------------------------------------------------- bool cmCTestSubdirCommand ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &) { @@ -131,7 +129,6 @@ bool cmCTestSubdirCommand return true; } -//---------------------------------------------------------------------- class cmCTestAddSubdirectoryCommand : public cmCommand { public: @@ -162,7 +159,6 @@ public: cmCTestTestHandler* TestHandler; }; -//---------------------------------------------------------------------- bool cmCTestAddSubdirectoryCommand ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &) { @@ -215,7 +211,6 @@ bool cmCTestAddSubdirectoryCommand return true; } -//---------------------------------------------------------------------- class cmCTestAddTestCommand : public cmCommand { public: @@ -246,7 +241,6 @@ public: cmCTestTestHandler* TestHandler; }; -//---------------------------------------------------------------------- bool cmCTestAddTestCommand ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &) { @@ -258,7 +252,6 @@ bool cmCTestAddTestCommand return this->TestHandler->AddTest(args); } -//---------------------------------------------------------------------- class cmCTestSetTestsPropertiesCommand : public cmCommand { public: @@ -290,14 +283,12 @@ public: cmCTestTestHandler* TestHandler; }; -//---------------------------------------------------------------------- bool cmCTestSetTestsPropertiesCommand ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &) { return this->TestHandler->SetTestsProperties(args); } -//---------------------------------------------------------------------- // get the next number in a string with numbers separated by , // pos is the start of the search and pos2 is the end of the search // pos becomes pos2 after a call to GetNextNumber. @@ -335,7 +326,6 @@ inline int GetNextNumber(std::string const& in, } } -//---------------------------------------------------------------------- // get the next number in a string with numbers separated by , // pos is the start of the search and pos2 is the end of the search // pos becomes pos2 after a call to GetNextNumber. @@ -374,7 +364,6 @@ inline int GetNextRealNumber(std::string const& in, } -//---------------------------------------------------------------------- cmCTestTestHandler::cmCTestTestHandler() { this->UseUnion = false; @@ -400,7 +389,6 @@ cmCTestTestHandler::cmCTestTestHandler() "(<DartMeasurement[^<]*</DartMeasurement[a-zA-Z]*>)"); } -//---------------------------------------------------------------------- void cmCTestTestHandler::Initialize() { this->Superclass::Initialize(); @@ -435,7 +423,6 @@ void cmCTestTestHandler::Initialize() this->TestList.clear(); } -//---------------------------------------------------------------------- void cmCTestTestHandler::PopulateCustomVectors(cmMakefile *mf) { this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_TEST", @@ -453,7 +440,6 @@ void cmCTestTestHandler::PopulateCustomVectors(cmMakefile *mf) this->CustomMaximumFailedTestOutputSize); } -//---------------------------------------------------------------------- int cmCTestTestHandler::PreProcessHandler() { if ( !this->ExecuteCommands(this->CustomPreTest) ) @@ -465,7 +451,6 @@ int cmCTestTestHandler::PreProcessHandler() return 1; } -//---------------------------------------------------------------------- int cmCTestTestHandler::PostProcessHandler() { if ( !this->ExecuteCommands(this->CustomPostTest) ) @@ -477,7 +462,6 @@ int cmCTestTestHandler::PostProcessHandler() return 1; } -//---------------------------------------------------------------------- //clearly it would be nice if this were broken up into a few smaller //functions and commented... int cmCTestTestHandler::ProcessHandler() @@ -652,7 +636,6 @@ int cmCTestTestHandler::ProcessHandler() return 0; } -//---------------------------------------------------------------------- void cmCTestTestHandler::PrintLabelSummary() { cmCTestTestHandler::ListOfTests::iterator it = this->TestList.begin(); @@ -739,7 +722,6 @@ void cmCTestTestHandler::PrintLabelSummary() } -//---------------------------------------------------------------------- void cmCTestTestHandler::CheckLabelFilterInclude(cmCTestTestProperties& it) { // if not using Labels to filter then return @@ -773,7 +755,6 @@ void cmCTestTestHandler::CheckLabelFilterInclude(cmCTestTestProperties& it) } -//---------------------------------------------------------------------- void cmCTestTestHandler::CheckLabelFilterExclude(cmCTestTestProperties& it) { // if not using Labels to filter then return @@ -805,14 +786,12 @@ void cmCTestTestHandler::CheckLabelFilterExclude(cmCTestTestProperties& it) } } -//---------------------------------------------------------------------- void cmCTestTestHandler::CheckLabelFilter(cmCTestTestProperties& it) { this->CheckLabelFilterInclude(it); this->CheckLabelFilterExclude(it); } -//---------------------------------------------------------------------- void cmCTestTestHandler::ComputeTestList() { this->TestList.clear(); // clear list of test @@ -1060,7 +1039,6 @@ bool cmCTestTestHandler::GetValue(const char* tag, return ret; } -//--------------------------------------------------------------------- void cmCTestTestHandler::ProcessDirectory(std::vector<std::string> &passed, std::vector<std::string> &failed) { @@ -1158,12 +1136,10 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<std::string> &passed, << this->CTest->CurrentTime() << std::endl; } -//---------------------------------------------------------------------- void cmCTestTestHandler::GenerateTestCommand(std::vector<std::string>&, int) { } -//---------------------------------------------------------------------- void cmCTestTestHandler::GenerateDartOutput(cmXMLWriter& xml) { if ( !this->CTest->GetProduceXML() ) @@ -1271,7 +1247,6 @@ void cmCTestTestHandler::GenerateDartOutput(cmXMLWriter& xml) this->CTest->EndXML(xml); } -//---------------------------------------------------------------------------- void cmCTestTestHandler::WriteTestResultHeader(cmXMLWriter& xml, cmCTestTestResult* result) { @@ -1295,7 +1270,6 @@ void cmCTestTestHandler::WriteTestResultHeader(cmXMLWriter& xml, xml.Element("FullCommandLine", result->FullCommandLine); } -//---------------------------------------------------------------------------- void cmCTestTestHandler::WriteTestResultFooter(cmXMLWriter& xml, cmCTestTestResult* result) { @@ -1314,7 +1288,6 @@ void cmCTestTestHandler::WriteTestResultFooter(cmXMLWriter& xml, xml.EndElement(); // Test } -//---------------------------------------------------------------------- void cmCTestTestHandler::AttachFiles(cmXMLWriter& xml, cmCTestTestResult* result) { @@ -1343,7 +1316,6 @@ void cmCTestTestHandler::AttachFiles(cmXMLWriter& xml, } } -//---------------------------------------------------------------------- int cmCTestTestHandler::ExecuteCommands(std::vector<std::string>& vec) { std::vector<std::string>::iterator it; @@ -1365,7 +1337,6 @@ int cmCTestTestHandler::ExecuteCommands(std::vector<std::string>& vec) } -//---------------------------------------------------------------------- // Find the appropriate executable to run for a test std::string cmCTestTestHandler::FindTheExecutable(const char *exe) { @@ -1455,7 +1426,6 @@ void cmCTestTestHandler } -//---------------------------------------------------------------------- // Find the appropriate executable to run for a test std::string cmCTestTestHandler ::FindExecutable(cmCTest *ctest, @@ -1565,7 +1535,6 @@ std::string cmCTestTestHandler } -//---------------------------------------------------------------------- void cmCTestTestHandler::GetListOfTests() { if ( !this->IncludeLabelRegExp.empty() ) @@ -1648,20 +1617,17 @@ void cmCTestTestHandler::GetListOfTests() "Done constructing a list of tests" << std::endl, this->Quiet); } -//---------------------------------------------------------------------- void cmCTestTestHandler::UseIncludeRegExp() { this->UseIncludeRegExpFlag = true; } -//---------------------------------------------------------------------- void cmCTestTestHandler::UseExcludeRegExp() { this->UseExcludeRegExpFlag = true; this->UseExcludeRegExpFirst = this->UseIncludeRegExpFlag ? false : true; } -//---------------------------------------------------------------------- const char* cmCTestTestHandler::GetTestStatus(int status) { static const char statuses[][100] = { @@ -1685,7 +1651,6 @@ const char* cmCTestTestHandler::GetTestStatus(int status) return statuses[status]; } -//---------------------------------------------------------------------- void cmCTestTestHandler::ExpandTestsToRunInformation(size_t numTests) { if (this->TestsToRunString.empty()) @@ -1841,10 +1806,8 @@ void cmCTestTestHandler::ExpandTestsToRunInformationForRerunFailed() } } -//---------------------------------------------------------------------- // Just for convenience #define SPACE_REGEX "[ \t\r\n]" -//---------------------------------------------------------------------- void cmCTestTestHandler::GenerateRegressionImages( cmXMLWriter& xml, const std::string& dart) { @@ -2031,19 +1994,16 @@ void cmCTestTestHandler::GenerateRegressionImages( } } -//---------------------------------------------------------------------- void cmCTestTestHandler::SetIncludeRegExp(const char *arg) { this->IncludeRegExp = arg; } -//---------------------------------------------------------------------- void cmCTestTestHandler::SetExcludeRegExp(const char *arg) { this->ExcludeRegExp = arg; } -//---------------------------------------------------------------------- void cmCTestTestHandler::SetTestsToRunInformation(const char* in) { if ( !in ) @@ -2065,7 +2025,6 @@ void cmCTestTestHandler::SetTestsToRunInformation(const char* in) } } -//---------------------------------------------------------------------------- bool cmCTestTestHandler::CleanTestOutput(std::string& output, size_t length) { if(!length || length >= output.size() || @@ -2107,7 +2066,6 @@ bool cmCTestTestHandler::CleanTestOutput(std::string& output, size_t length) return true; } -//---------------------------------------------------------------------- bool cmCTestTestHandler::SetTestsProperties( const std::vector<std::string>& args) { @@ -2287,7 +2245,6 @@ bool cmCTestTestHandler::SetTestsProperties( return true; } -//---------------------------------------------------------------------- bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args) { const std::string& testname = args[0]; diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx index b1b0a21..85624e0 100644 --- a/Source/CTest/cmCTestUpdateHandler.cxx +++ b/Source/CTest/cmCTestUpdateHandler.cxx @@ -44,7 +44,6 @@ #include <math.h> #include <stdlib.h> -//---------------------------------------------------------------------- static const char* cmCTestUpdateHandlerUpdateStrings[] = { "Unknown", @@ -66,12 +65,10 @@ static const char* cmCTestUpdateHandlerUpdateToString(int type) return cmCTestUpdateHandlerUpdateStrings[type]; } -//---------------------------------------------------------------------- cmCTestUpdateHandler::cmCTestUpdateHandler() { } -//---------------------------------------------------------------------- void cmCTestUpdateHandler::Initialize() { this->Superclass::Initialize(); @@ -79,7 +76,6 @@ void cmCTestUpdateHandler::Initialize() this->UpdateType = e_CVS; } -//---------------------------------------------------------------------- int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type) { cmCTestOptionalLog(this->CTest, DEBUG, @@ -148,7 +144,6 @@ int cmCTestUpdateHandler::DetermineType(const char* cmd, const char* type) return cmCTestUpdateHandler::e_UNKNOWN; } -//---------------------------------------------------------------------- //clearly it would be nice if this were broken up into a few smaller //functions and commented... int cmCTestUpdateHandler::ProcessHandler() @@ -291,7 +286,6 @@ int cmCTestUpdateHandler::ProcessHandler() return updated? numUpdated : -1; } -//---------------------------------------------------------------------- int cmCTestUpdateHandler::DetectVCS(const char* dir) { std::string sourceDirectory = dir; @@ -341,7 +335,6 @@ int cmCTestUpdateHandler::DetectVCS(const char* dir) return cmCTestUpdateHandler::e_UNKNOWN; } -//---------------------------------------------------------------------- bool cmCTestUpdateHandler::SelectVCS() { // Get update command diff --git a/Source/CTest/cmCTestUploadCommand.cxx b/Source/CTest/cmCTestUploadCommand.cxx index f5000dd..7c24e62 100644 --- a/Source/CTest/cmCTestUploadCommand.cxx +++ b/Source/CTest/cmCTestUploadCommand.cxx @@ -31,7 +31,6 @@ cmCTestGenericHandler* cmCTestUploadCommand::InitializeHandler() } -//---------------------------------------------------------------------------- bool cmCTestUploadCommand::CheckArgumentKeyword(std::string const& arg) { if(arg == "FILES") @@ -49,7 +48,6 @@ bool cmCTestUploadCommand::CheckArgumentKeyword(std::string const& arg) } -//---------------------------------------------------------------------------- bool cmCTestUploadCommand::CheckArgumentValue(std::string const& arg) { if(this->ArgumentDoing == ArgumentDoingFiles) diff --git a/Source/CTest/cmCTestUploadHandler.cxx b/Source/CTest/cmCTestUploadHandler.cxx index 5c6b229..6f0a024 100644 --- a/Source/CTest/cmCTestUploadHandler.cxx +++ b/Source/CTest/cmCTestUploadHandler.cxx @@ -15,13 +15,11 @@ #include "cmVersion.h" #include "cmXMLWriter.h" -//---------------------------------------------------------------------------- cmCTestUploadHandler::cmCTestUploadHandler() { this->Initialize(); } -//---------------------------------------------------------------------------- void cmCTestUploadHandler::Initialize() { this->Superclass::Initialize(); @@ -33,7 +31,6 @@ void cmCTestUploadHandler::SetFiles(const cmCTest::SetOfStrings& files) this->Files = files; } -//---------------------------------------------------------------------------- int cmCTestUploadHandler::ProcessHandler() { cmGeneratedFileStream ofs; diff --git a/Source/CTest/cmCTestVC.cxx b/Source/CTest/cmCTestVC.cxx index 8eff4d6..f3d699b 100644 --- a/Source/CTest/cmCTestVC.cxx +++ b/Source/CTest/cmCTestVC.cxx @@ -17,7 +17,6 @@ #include <cmsys/Process.h> -//---------------------------------------------------------------------------- cmCTestVC::cmCTestVC(cmCTest* ct, std::ostream& log): CTest(ct), Log(log) { this->PathCount[PathUpdated] = 0; @@ -28,24 +27,20 @@ cmCTestVC::cmCTestVC(cmCTest* ct, std::ostream& log): CTest(ct), Log(log) this->Unknown.Rev = "Unknown"; } -//---------------------------------------------------------------------------- cmCTestVC::~cmCTestVC() { } -//---------------------------------------------------------------------------- void cmCTestVC::SetCommandLineTool(std::string const& tool) { this->CommandLineTool = tool; } -//---------------------------------------------------------------------------- void cmCTestVC::SetSourceDirectory(std::string const& dir) { this->SourceDirectory = dir; } -//---------------------------------------------------------------------------- bool cmCTestVC::InitialCheckout(const char* command) { cmCTestLog(this->CTest, HANDLER_OUTPUT, @@ -86,7 +81,6 @@ bool cmCTestVC::InitialCheckout(const char* command) return result; } -//---------------------------------------------------------------------------- bool cmCTestVC::RunChild(char const* const* cmd, OutputParser* out, OutputParser* err, const char* workDir) { @@ -102,7 +96,6 @@ bool cmCTestVC::RunChild(char const* const* cmd, OutputParser* out, return result == 0; } -//---------------------------------------------------------------------------- std::string cmCTestVC::ComputeCommandLine(char const* const* cmd) { std::ostringstream line; @@ -115,7 +108,6 @@ std::string cmCTestVC::ComputeCommandLine(char const* const* cmd) return line.str(); } -//---------------------------------------------------------------------------- bool cmCTestVC::RunUpdateCommand(char const* const* cmd, OutputParser* out, OutputParser* err) { @@ -131,7 +123,6 @@ bool cmCTestVC::RunUpdateCommand(char const* const* cmd, return this->RunChild(cmd, out, err); } -//---------------------------------------------------------------------------- std::string cmCTestVC::GetNightlyTime() { // Get the nightly start time corresponding to the current dau. @@ -149,7 +140,6 @@ std::string cmCTestVC::GetNightlyTime() return std::string(current_time); } -//---------------------------------------------------------------------------- void cmCTestVC::Cleanup() { this->Log << "--- Begin Cleanup ---\n"; @@ -157,13 +147,11 @@ void cmCTestVC::Cleanup() this->Log << "--- End Cleanup ---\n"; } -//---------------------------------------------------------------------------- void cmCTestVC::CleanupImpl() { // We do no cleanup by default. } -//---------------------------------------------------------------------------- bool cmCTestVC::Update() { bool result = true; @@ -181,19 +169,16 @@ bool cmCTestVC::Update() return result; } -//---------------------------------------------------------------------------- void cmCTestVC::NoteOldRevision() { // We do nothing by default. } -//---------------------------------------------------------------------------- void cmCTestVC::NoteNewRevision() { // We do nothing by default. } -//---------------------------------------------------------------------------- bool cmCTestVC::UpdateImpl() { cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, @@ -201,7 +186,6 @@ bool cmCTestVC::UpdateImpl() return true; } -//---------------------------------------------------------------------------- bool cmCTestVC::WriteXML(cmXMLWriter& xml) { this->Log << "--- Begin Revisions ---\n"; @@ -210,7 +194,6 @@ bool cmCTestVC::WriteXML(cmXMLWriter& xml) return result; } -//---------------------------------------------------------------------------- bool cmCTestVC::WriteXMLUpdates(cmXMLWriter&) { cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, @@ -218,7 +201,6 @@ bool cmCTestVC::WriteXMLUpdates(cmXMLWriter&) return true; } -//---------------------------------------------------------------------------- void cmCTestVC::WriteXMLEntry(cmXMLWriter& xml, std::string const& path, std::string const& name, diff --git a/Source/CTest/cmParseCoberturaCoverage.cxx b/Source/CTest/cmParseCoberturaCoverage.cxx index 5b4a376..d3b99fb 100644 --- a/Source/CTest/cmParseCoberturaCoverage.cxx +++ b/Source/CTest/cmParseCoberturaCoverage.cxx @@ -5,7 +5,6 @@ #include <cmsys/Directory.hxx> #include <cmsys/FStream.hxx> -//---------------------------------------------------------------------------- class cmParseCoberturaCoverage::XMLParser: public cmXMLParser { public: diff --git a/Source/CTest/cmProcess.cxx b/Source/CTest/cmProcess.cxx index c9a4618..d385677 100644 --- a/Source/CTest/cmProcess.cxx +++ b/Source/CTest/cmProcess.cxx @@ -69,7 +69,6 @@ bool cmProcess::StartProcess() == cmsysProcess_State_Executing); } -//---------------------------------------------------------------------------- bool cmProcess::Buffer::GetLine(std::string& line) { // Scan for the next newline. @@ -106,7 +105,6 @@ bool cmProcess::Buffer::GetLine(std::string& line) return false; } -//---------------------------------------------------------------------------- bool cmProcess::Buffer::GetLast(std::string& line) { // Return the partial last line, if any. @@ -120,7 +118,6 @@ bool cmProcess::Buffer::GetLast(std::string& line) return false; } -//---------------------------------------------------------------------------- int cmProcess::GetNextOutputLine(std::string& line, double timeout) { for(;;) |