diff options
Diffstat (limited to 'Source/CTest/cmCTestMemCheckHandler.cxx')
| -rw-r--r-- | Source/CTest/cmCTestMemCheckHandler.cxx | 1094 |
1 files changed, 448 insertions, 646 deletions
diff --git a/Source/CTest/cmCTestMemCheckHandler.cxx b/Source/CTest/cmCTestMemCheckHandler.cxx index dd2a5b8b64..2cbd64d62f 100644 --- a/Source/CTest/cmCTestMemCheckHandler.cxx +++ b/Source/CTest/cmCTestMemCheckHandler.cxx @@ -34,24 +34,22 @@ struct CatToErrorType int ErrorCode; }; - static CatToErrorType cmCTestMemCheckBoundsChecker[] = { // Error tags - {"Write Overrun", cmCTestMemCheckHandler::ABW}, - {"Read Overrun", cmCTestMemCheckHandler::ABR}, - {"Memory Overrun", cmCTestMemCheckHandler::ABW}, - {"Allocation Conflict", cmCTestMemCheckHandler::FMM}, - {"Bad Pointer Use", cmCTestMemCheckHandler::FMW}, - {"Dangling Pointer", cmCTestMemCheckHandler::FMR}, - {0,0} + { "Write Overrun", cmCTestMemCheckHandler::ABW }, + { "Read Overrun", cmCTestMemCheckHandler::ABR }, + { "Memory Overrun", cmCTestMemCheckHandler::ABW }, + { "Allocation Conflict", cmCTestMemCheckHandler::FMM }, + { "Bad Pointer Use", cmCTestMemCheckHandler::FMW }, + { "Dangling Pointer", cmCTestMemCheckHandler::FMR }, + { 0, 0 } }; static void xmlReportError(int line, const char* msg, void* data) { cmCTest* ctest = (cmCTest*)data; - cmCTestLog(ctest, ERROR_MESSAGE, - "Error parsing XML in stream at line " - << line << ": " << msg << std::endl); + cmCTestLog(ctest, ERROR_MESSAGE, "Error parsing XML in stream at line " + << line << ": " << msg << std::endl); } // parse the xml file containing the results of last BoundsChecker run @@ -59,87 +57,70 @@ class cmBoundsCheckerParser : public cmXMLParser { public: cmBoundsCheckerParser(cmCTest* c) - { - this->CTest = c; - this->SetErrorCallback(xmlReportError, (void*)c); - } + { + this->CTest = c; + this->SetErrorCallback(xmlReportError, (void*)c); + } void StartElement(const std::string& name, const char** atts) - { - if(name == "MemoryLeak" || - name == "ResourceLeak") - { - this->Errors.push_back(cmCTestMemCheckHandler::MLK); - } - else if(name == "Error" || - name == "Dangling Pointer") - { - this->ParseError(atts); - } - // Create the log - std::ostringstream ostr; - ostr << name << ":\n"; - int i = 0; - for(; atts[i] != 0; i+=2) - { - ostr << " " << atts[i] - << " - " << atts[i+1] << "\n"; - } - ostr << "\n"; - this->Log += ostr.str(); + { + if (name == "MemoryLeak" || name == "ResourceLeak") { + this->Errors.push_back(cmCTestMemCheckHandler::MLK); + } else if (name == "Error" || name == "Dangling Pointer") { + this->ParseError(atts); } - void EndElement(const std::string& ) - { + // Create the log + std::ostringstream ostr; + ostr << name << ":\n"; + int i = 0; + for (; atts[i] != 0; i += 2) { + ostr << " " << atts[i] << " - " << atts[i + 1] << "\n"; } + ostr << "\n"; + this->Log += ostr.str(); + } + void EndElement(const std::string&) {} const char* GetAttribute(const char* name, const char** atts) - { - int i = 0; - for(; atts[i] != 0; ++i) - { - if(strcmp(name, atts[i]) == 0) - { - return atts[i+1]; - } - } - return 0; + { + int i = 0; + for (; atts[i] != 0; ++i) { + if (strcmp(name, atts[i]) == 0) { + return atts[i + 1]; + } } + return 0; + } void ParseError(const char** atts) - { - CatToErrorType* ptr = cmCTestMemCheckBoundsChecker; - const char* cat = this->GetAttribute("ErrorCategory", atts); - if(!cat) - { - this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know - cmCTestLog(this->CTest, ERROR_MESSAGE, - "No Category found in Bounds checker XML\n" ); - return; - } - while(ptr->ErrorCategory && cat) - { - if(strcmp(ptr->ErrorCategory, cat) == 0) - { - this->Errors.push_back(ptr->ErrorCode); - return; // found it we are done - } - ptr++; - } - if(ptr->ErrorCategory) - { - this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know - cmCTestLog(this->CTest, ERROR_MESSAGE, - "Found unknown Bounds Checker error " - << ptr->ErrorCategory << std::endl); - } + { + CatToErrorType* ptr = cmCTestMemCheckBoundsChecker; + const char* cat = this->GetAttribute("ErrorCategory", atts); + if (!cat) { + this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know + cmCTestLog(this->CTest, ERROR_MESSAGE, + "No Category found in Bounds checker XML\n"); + return; + } + while (ptr->ErrorCategory && cat) { + if (strcmp(ptr->ErrorCategory, cat) == 0) { + this->Errors.push_back(ptr->ErrorCode); + return; // found it we are done + } + ptr++; } + if (ptr->ErrorCategory) { + this->Errors.push_back(cmCTestMemCheckHandler::ABW); // do not know + cmCTestLog(this->CTest, ERROR_MESSAGE, + "Found unknown Bounds Checker error " << ptr->ErrorCategory + << std::endl); + } + } cmCTest* CTest; std::vector<int> Errors; std::string Log; }; -#define BOUNDS_CHECKER_MARKER \ -"******######*****Begin BOUNDS CHECKER XML******######******" - - +#define BOUNDS_CHECKER_MARKER \ + "******######*****Begin BOUNDS CHECKER XML******######******" cmCTestMemCheckHandler::cmCTestMemCheckHandler() { @@ -164,28 +145,25 @@ void cmCTestMemCheckHandler::Initialize() int cmCTestMemCheckHandler::PreProcessHandler() { - if ( !this->InitializeMemoryChecking() ) - { + if (!this->InitializeMemoryChecking()) { return 0; - } + } - if ( !this->ExecuteCommands(this->CustomPreMemCheck) ) - { + if (!this->ExecuteCommands(this->CustomPreMemCheck)) { cmCTestLog(this->CTest, ERROR_MESSAGE, - "Problem executing pre-memcheck command(s)." << std::endl); + "Problem executing pre-memcheck command(s)." << std::endl); return 0; - } + } return 1; } int cmCTestMemCheckHandler::PostProcessHandler() { - if ( !this->ExecuteCommands(this->CustomPostMemCheck) ) - { + if (!this->ExecuteCommands(this->CustomPostMemCheck)) { cmCTestLog(this->CTest, ERROR_MESSAGE, - "Problem executing post-memcheck command(s)." << std::endl); + "Problem executing post-memcheck command(s)." << std::endl); return 0; - } + } return 1; } @@ -195,104 +173,77 @@ void cmCTestMemCheckHandler::GenerateTestCommand( std::vector<std::string>::size_type pp; std::string index; std::ostringstream stream; - std::string memcheckcommand - = cmSystemTools::ConvertToOutputPath(this->MemoryTester.c_str()); + std::string memcheckcommand = + cmSystemTools::ConvertToOutputPath(this->MemoryTester.c_str()); stream << test; index = stream.str(); - for ( pp = 0; pp < this->MemoryTesterDynamicOptions.size(); pp ++ ) - { + for (pp = 0; pp < this->MemoryTesterDynamicOptions.size(); pp++) { std::string arg = this->MemoryTesterDynamicOptions[pp]; std::string::size_type pos = arg.find("??"); - if (pos != std::string::npos) - { + if (pos != std::string::npos) { arg.replace(pos, 2, index); - } + } args.push_back(arg); memcheckcommand += " \""; memcheckcommand += arg; memcheckcommand += "\""; - } + } // Create a copy of the memory tester environment variable. // This is used for memory testing programs that pass options // via environment varaibles. std::string memTesterEnvironmentVariable = this->MemoryTesterEnvironmentVariable; - for ( pp = 0; pp < this->MemoryTesterOptions.size(); pp ++ ) - { - if(!memTesterEnvironmentVariable.empty()) - { + for (pp = 0; pp < this->MemoryTesterOptions.size(); pp++) { + if (!memTesterEnvironmentVariable.empty()) { // If we are using env to pass options, append all the options to // this string with space separation. memTesterEnvironmentVariable += " " + this->MemoryTesterOptions[pp]; - } + } // for regular options just add them to args and memcheckcommand // which is just used for display - else - { + else { args.push_back(this->MemoryTesterOptions[pp]); memcheckcommand += " \""; memcheckcommand += this->MemoryTesterOptions[pp]; memcheckcommand += "\""; - } } + } // if this is an env option type, then add the env string as a single // argument. - if(!memTesterEnvironmentVariable.empty()) - { + if (!memTesterEnvironmentVariable.empty()) { std::string::size_type pos = memTesterEnvironmentVariable.find("??"); - if (pos != std::string::npos) - { + if (pos != std::string::npos) { memTesterEnvironmentVariable.replace(pos, 2, index); - } + } memcheckcommand += " " + memTesterEnvironmentVariable; args.push_back(memTesterEnvironmentVariable); - } + } cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, - "Memory check command: " << memcheckcommand << std::endl, this->Quiet); + "Memory check command: " << memcheckcommand << std::endl, + this->Quiet); } void cmCTestMemCheckHandler::InitializeResultsVectors() { // fill these members -// cmsys::vector<std::string> ResultStrings; -// cmsys::vector<std::string> ResultStringsLong; -// cmsys::vector<int> GlobalResults; + // cmsys::vector<std::string> ResultStrings; + // cmsys::vector<std::string> ResultStringsLong; + // cmsys::vector<int> GlobalResults; this->ResultStringsLong.clear(); this->ResultStrings.clear(); this->GlobalResults.clear(); // If we are working with style checkers that dynamically fill // the results strings then return. - if(this->MemoryTesterStyle > cmCTestMemCheckHandler::BOUNDS_CHECKER) - { + if (this->MemoryTesterStyle > cmCTestMemCheckHandler::BOUNDS_CHECKER) { return; - } + } // define the standard set of errors //---------------------------------------------------------------------- static const char* cmCTestMemCheckResultStrings[] = { - "ABR", - "ABW", - "ABWL", - "COR", - "EXU", - "FFM", - "FIM", - "FMM", - "FMR", - "FMW", - "FUM", - "IPR", - "IPW", - "MAF", - "MLK", - "MPK", - "NPR", - "ODS", - "PAR", - "PLK", - "UMC", - "UMR", - 0 + "ABR", "ABW", "ABWL", "COR", "EXU", "FFM", "FIM", "FMM", + "FMR", "FMW", "FUM", "IPR", "IPW", "MAF", "MLK", "MPK", + "NPR", "ODS", "PAR", "PLK", "UMC", "UMR", 0 }; static const char* cmCTestMemCheckResultLongStrings[] = { "Threading Problem", @@ -320,40 +271,36 @@ void cmCTestMemCheckHandler::InitializeResultsVectors() 0 }; this->GlobalResults.clear(); - for(int i =0; cmCTestMemCheckResultStrings[i] != 0; ++i) - { + for (int i = 0; cmCTestMemCheckResultStrings[i] != 0; ++i) { this->ResultStrings.push_back(cmCTestMemCheckResultStrings[i]); this->ResultStringsLong.push_back(cmCTestMemCheckResultLongStrings[i]); this->GlobalResults.push_back(0); - } + } } -void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile *mf) +void cmCTestMemCheckHandler::PopulateCustomVectors(cmMakefile* mf) { this->cmCTestTestHandler::PopulateCustomVectors(mf); this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_PRE_MEMCHECK", - this->CustomPreMemCheck); + this->CustomPreMemCheck); this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_POST_MEMCHECK", - this->CustomPostMemCheck); + this->CustomPostMemCheck); - this->CTest->PopulateCustomVector(mf, - "CTEST_CUSTOM_MEMCHECK_IGNORE", - this->CustomTestsIgnore); + this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_MEMCHECK_IGNORE", + this->CustomTestsIgnore); std::string cmake = cmSystemTools::GetCMakeCommand(); this->CTest->SetCTestConfiguration("CMakeCommand", cmake.c_str(), - this->Quiet); + this->Quiet); } void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml) { - if ( !this->CTest->GetProduceXML() ) - { + if (!this->CTest->GetProduceXML()) { return; - } + } this->CTest->StartXML(xml, this->AppendXML); xml.StartElement("DynamicAnalysis"); - switch ( this->MemoryTesterStyle ) - { + switch (this->MemoryTesterStyle) { case cmCTestMemCheckHandler::VALGRIND: xml.Attribute("Checker", "Valgrind"); break; @@ -377,98 +324,91 @@ void cmCTestMemCheckHandler::GenerateDartOutput(cmXMLWriter& xml) break; default: xml.Attribute("Checker", "Unknown"); - } + } xml.Element("StartDateTime", this->StartTest); xml.Element("StartTestTime", this->StartTestTime); xml.StartElement("TestList"); cmCTestMemCheckHandler::TestResultsVector::size_type cc; - for ( cc = 0; cc < this->TestResults.size(); cc ++ ) - { - cmCTestTestResult *result = &this->TestResults[cc]; + for (cc = 0; cc < this->TestResults.size(); cc++) { + cmCTestTestResult* result = &this->TestResults[cc]; std::string testPath = result->Path + "/" + result->Name; xml.Element("Test", this->CTest->GetShortPathToFile(testPath.c_str())); - } + } xml.EndElement(); // TestList cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, - "-- Processing memory checking output: ", this->Quiet); + "-- Processing memory checking output: ", this->Quiet); size_t total = this->TestResults.size(); size_t step = total / 10; size_t current = 0; - for ( cc = 0; cc < this->TestResults.size(); cc ++ ) - { - cmCTestTestResult *result = &this->TestResults[cc]; + for (cc = 0; cc < this->TestResults.size(); cc++) { + cmCTestTestResult* result = &this->TestResults[cc]; std::string memcheckstr; std::vector<int> memcheckresults(this->ResultStrings.size(), 0); bool res = this->ProcessMemCheckOutput(result->Output, memcheckstr, - memcheckresults); - if ( res && result->Status == cmCTestMemCheckHandler::COMPLETED ) - { + memcheckresults); + if (res && result->Status == cmCTestMemCheckHandler::COMPLETED) { continue; - } - this->CleanTestOutput(memcheckstr, + } + this->CleanTestOutput( + memcheckstr, static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)); this->WriteTestResultHeader(xml, result); xml.StartElement("Results"); - for(std::vector<int>::size_type kk = 0; - kk < memcheckresults.size(); ++kk) - { - if ( memcheckresults[kk] ) - { + for (std::vector<int>::size_type kk = 0; kk < memcheckresults.size(); + ++kk) { + if (memcheckresults[kk]) { xml.StartElement("Defect"); xml.Attribute("type", this->ResultStringsLong[kk]); xml.Content(memcheckresults[kk]); xml.EndElement(); // Defect - } - this->GlobalResults[kk] += memcheckresults[kk]; } + this->GlobalResults[kk] += memcheckresults[kk]; + } xml.EndElement(); // Results xml.StartElement("Log"); - if(this->CTest->ShouldCompressMemCheckOutput()) - { + if (this->CTest->ShouldCompressMemCheckOutput()) { this->CTest->CompressString(memcheckstr); xml.Attribute("compression", "gzip"); xml.Attribute("encoding", "base64"); - } + } xml.Content(memcheckstr); xml.EndElement(); // Log this->WriteTestResultFooter(xml, result); - if ( current < cc ) - { + if (current < cc) { cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "#" << std::flush, - this->Quiet); + this->Quiet); current += step; - } } + } cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl, this->Quiet); - cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "Memory checking results:" - << std::endl, this->Quiet); + cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, + "Memory checking results:" << std::endl, this->Quiet); xml.StartElement("DefectList"); - for ( cc = 0; cc < this->GlobalResults.size(); cc ++ ) - { - if ( this->GlobalResults[cc] ) - { + for (cc = 0; cc < this->GlobalResults.size(); cc++) { + if (this->GlobalResults[cc]) { #ifdef cerr -# undef cerr +#undef cerr #endif std::cerr.width(35); #define cerr no_cerr cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, - this->ResultStringsLong[cc] << " - " - << this->GlobalResults[cc] << std::endl, this->Quiet); + this->ResultStringsLong[cc] + << " - " << this->GlobalResults[cc] << std::endl, + this->Quiet); xml.StartElement("Defect"); xml.Attribute("Type", this->ResultStringsLong[cc]); xml.EndElement(); - } } + } xml.EndElement(); // DefectList xml.Element("EndDateTime", this->EndTest); xml.Element("EndTestTime", this->EndTestTime); xml.Element("ElapsedMinutes", - static_cast<int>(this->ElapsedTestingTime/6)/10.0); + static_cast<int>(this->ElapsedTestingTime / 6) / 10.0); xml.EndElement(); // DynamicAnalysis this->CTest->EndXML(xml); @@ -479,187 +419,156 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking() this->MemoryTesterEnvironmentVariable = ""; this->MemoryTester = ""; // Setup the command - if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration( - "MemoryCheckCommand").c_str()) ) - { - this->MemoryTester - = this->CTest->GetCTestConfiguration("MemoryCheckCommand").c_str(); + if (cmSystemTools::FileExists( + this->CTest->GetCTestConfiguration("MemoryCheckCommand").c_str())) { + this->MemoryTester = + this->CTest->GetCTestConfiguration("MemoryCheckCommand").c_str(); std::string testerName = cmSystemTools::GetFilenameName(this->MemoryTester); // determine the checker type - if ( testerName.find("valgrind") != std::string::npos || - this->CTest->GetCTestConfiguration("MemoryCheckType") - == "Valgrind") - { - this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND; - } - else if ( testerName.find("purify") != std::string::npos ) - { + if (testerName.find("valgrind") != std::string::npos || + this->CTest->GetCTestConfiguration("MemoryCheckType") == "Valgrind") { + this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND; + } else if (testerName.find("purify") != std::string::npos) { this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY; - } - else if ( testerName.find("BC") != std::string::npos ) - { + } else if (testerName.find("BC") != std::string::npos) { this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER; - } - else - { + } else { this->MemoryTesterStyle = cmCTestMemCheckHandler::UNKNOWN; - } } - else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration( - "PurifyCommand").c_str()) ) - { - this->MemoryTester - = this->CTest->GetCTestConfiguration("PurifyCommand").c_str(); + } else if (cmSystemTools::FileExists( + this->CTest->GetCTestConfiguration("PurifyCommand").c_str())) { + this->MemoryTester = + this->CTest->GetCTestConfiguration("PurifyCommand").c_str(); this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY; - } - else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration( - "ValgrindCommand").c_str()) ) - { - this->MemoryTester - = this->CTest->GetCTestConfiguration("ValgrindCommand").c_str(); + } else if (cmSystemTools::FileExists( + this->CTest->GetCTestConfiguration("ValgrindCommand") + .c_str())) { + this->MemoryTester = + this->CTest->GetCTestConfiguration("ValgrindCommand").c_str(); this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND; - } - else if ( cmSystemTools::FileExists(this->CTest->GetCTestConfiguration( - "BoundsCheckerCommand").c_str()) ) - { - this->MemoryTester - = this->CTest->GetCTestConfiguration("BoundsCheckerCommand").c_str(); + } else if (cmSystemTools::FileExists( + this->CTest->GetCTestConfiguration("BoundsCheckerCommand") + .c_str())) { + this->MemoryTester = + this->CTest->GetCTestConfiguration("BoundsCheckerCommand").c_str(); this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER; - } - if ( this->CTest->GetCTestConfiguration("MemoryCheckType") - == "AddressSanitizer") - { - this->MemoryTester - = this->CTest->GetCTestConfiguration("CMakeCommand").c_str(); + } + if (this->CTest->GetCTestConfiguration("MemoryCheckType") == + "AddressSanitizer") { + this->MemoryTester = + this->CTest->GetCTestConfiguration("CMakeCommand").c_str(); this->MemoryTesterStyle = cmCTestMemCheckHandler::ADDRESS_SANITIZER; this->LogWithPID = true; // even if we give the log file the pid is added - } - if ( this->CTest->GetCTestConfiguration("MemoryCheckType") - == "ThreadSanitizer") - { - this->MemoryTester - = this->CTest->GetCTestConfiguration("CMakeCommand").c_str(); + } + if (this->CTest->GetCTestConfiguration("MemoryCheckType") == + "ThreadSanitizer") { + this->MemoryTester = + this->CTest->GetCTestConfiguration("CMakeCommand").c_str(); this->MemoryTesterStyle = cmCTestMemCheckHandler::THREAD_SANITIZER; this->LogWithPID = true; // even if we give the log file the pid is added - } - if ( this->CTest->GetCTestConfiguration("MemoryCheckType") - == "MemorySanitizer") - { - this->MemoryTester - = this->CTest->GetCTestConfiguration("CMakeCommand").c_str(); + } + if (this->CTest->GetCTestConfiguration("MemoryCheckType") == + "MemorySanitizer") { + this->MemoryTester = + this->CTest->GetCTestConfiguration("CMakeCommand").c_str(); this->MemoryTesterStyle = cmCTestMemCheckHandler::MEMORY_SANITIZER; this->LogWithPID = true; // even if we give the log file the pid is added - } - if ( this->CTest->GetCTestConfiguration("MemoryCheckType") - == "UndefinedBehaviorSanitizer") - { - this->MemoryTester - = this->CTest->GetCTestConfiguration("CMakeCommand").c_str(); + } + if (this->CTest->GetCTestConfiguration("MemoryCheckType") == + "UndefinedBehaviorSanitizer") { + this->MemoryTester = + this->CTest->GetCTestConfiguration("CMakeCommand").c_str(); this->MemoryTesterStyle = cmCTestMemCheckHandler::UB_SANITIZER; this->LogWithPID = true; // even if we give the log file the pid is added - } + } // Check the MemoryCheckType - if(this->MemoryTesterStyle == cmCTestMemCheckHandler::UNKNOWN) - { + if (this->MemoryTesterStyle == cmCTestMemCheckHandler::UNKNOWN) { std::string checkType = this->CTest->GetCTestConfiguration("MemoryCheckType"); - if(checkType == "Purify") - { + if (checkType == "Purify") { this->MemoryTesterStyle = cmCTestMemCheckHandler::PURIFY; - } - else if(checkType == "BoundsChecker") - { + } else if (checkType == "BoundsChecker") { this->MemoryTesterStyle = cmCTestMemCheckHandler::BOUNDS_CHECKER; - } - else if(checkType == "Valgrind") - { + } else if (checkType == "Valgrind") { this->MemoryTesterStyle = cmCTestMemCheckHandler::VALGRIND; - } } - if(this->MemoryTester.empty()) - { + } + if (this->MemoryTester.empty()) { cmCTestOptionalLog(this->CTest, WARNING, - "Memory checker (MemoryCheckCommand) " - "not set, or cannot find the specified program." - << std::endl, this->Quiet); + "Memory checker (MemoryCheckCommand) " + "not set, or cannot find the specified program." + << std::endl, + this->Quiet); return false; - } + } // Setup the options std::string memoryTesterOptions; - if ( this->CTest->GetCTestConfiguration( - "MemoryCheckCommandOptions").size() ) - { - memoryTesterOptions = this->CTest->GetCTestConfiguration( - "MemoryCheckCommandOptions"); - } - else if ( this->CTest->GetCTestConfiguration( - "ValgrindCommandOptions").size() ) - { - memoryTesterOptions = this->CTest->GetCTestConfiguration( - "ValgrindCommandOptions"); - } - this->MemoryTesterOptions - = cmSystemTools::ParseArguments(memoryTesterOptions.c_str()); + if (this->CTest->GetCTestConfiguration("MemoryCheckCommandOptions").size()) { + memoryTesterOptions = + this->CTest->GetCTestConfiguration("MemoryCheckCommandOptions"); + } else if (this->CTest->GetCTestConfiguration("ValgrindCommandOptions") + .size()) { + memoryTesterOptions = + this->CTest->GetCTestConfiguration("ValgrindCommandOptions"); + } + this->MemoryTesterOptions = + cmSystemTools::ParseArguments(memoryTesterOptions.c_str()); - this->MemoryTesterOutputFile - = this->CTest->GetBinaryDir() - + "/Testing/Temporary/MemoryChecker.??.log"; + this->MemoryTesterOutputFile = + this->CTest->GetBinaryDir() + "/Testing/Temporary/MemoryChecker.??.log"; - switch ( this->MemoryTesterStyle ) - { - case cmCTestMemCheckHandler::VALGRIND: - { - if ( this->MemoryTesterOptions.empty() ) - { + switch (this->MemoryTesterStyle) { + case cmCTestMemCheckHandler::VALGRIND: { + if (this->MemoryTesterOptions.empty()) { this->MemoryTesterOptions.push_back("-q"); this->MemoryTesterOptions.push_back("--tool=memcheck"); this->MemoryTesterOptions.push_back("--leak-check=yes"); this->MemoryTesterOptions.push_back("--show-reachable=yes"); this->MemoryTesterOptions.push_back("--num-callers=50"); - } - if ( this->CTest->GetCTestConfiguration( - "MemoryCheckSuppressionFile").size() ) - { - if ( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration( - "MemoryCheckSuppressionFile").c_str()) ) - { + } + if (this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile") + .size()) { + if (!cmSystemTools::FileExists( + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile") + .c_str())) { cmCTestLog(this->CTest, ERROR_MESSAGE, - "Cannot find memory checker suppression file: " - << this->CTest->GetCTestConfiguration( - "MemoryCheckSuppressionFile") << std::endl); + "Cannot find memory checker suppression file: " + << this->CTest->GetCTestConfiguration( + "MemoryCheckSuppressionFile") + << std::endl); return false; - } - std::string suppressions = "--suppressions=" - + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile"); - this->MemoryTesterOptions.push_back(suppressions); } - std::string outputFile = "--log-file=" - + this->MemoryTesterOutputFile; + std::string suppressions = "--suppressions=" + + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile"); + this->MemoryTesterOptions.push_back(suppressions); + } + std::string outputFile = "--log-file=" + this->MemoryTesterOutputFile; this->MemoryTesterDynamicOptions.push_back(outputFile); break; - } - case cmCTestMemCheckHandler::PURIFY: - { + } + case cmCTestMemCheckHandler::PURIFY: { std::string outputFile; #ifdef _WIN32 - if( this->CTest->GetCTestConfiguration( - "MemoryCheckSuppressionFile").size() ) - { - if( !cmSystemTools::FileExists(this->CTest->GetCTestConfiguration( - "MemoryCheckSuppressionFile").c_str()) ) - { - cmCTestLog(this->CTest, ERROR_MESSAGE, - "Cannot find memory checker suppression file: " - << this->CTest->GetCTestConfiguration( - "MemoryCheckSuppressionFile").c_str() << std::endl); + if (this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile") + .size()) { + if (!cmSystemTools::FileExists( + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile") + .c_str())) { + cmCTestLog( + this->CTest, ERROR_MESSAGE, + "Cannot find memory checker suppression file: " + << this->CTest + ->GetCTestConfiguration("MemoryCheckSuppressionFile") + .c_str() + << std::endl); return false; - } - std::string filterFiles = "/FilterFiles=" - + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile"); - this->MemoryTesterOptions.push_back(filterFiles); } + std::string filterFiles = "/FilterFiles=" + + this->CTest->GetCTestConfiguration("MemoryCheckSuppressionFile"); + this->MemoryTesterOptions.push_back(filterFiles); + } outputFile = "/SAVETEXTDATA="; #else outputFile = "-log-file="; @@ -667,12 +576,11 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking() outputFile += this->MemoryTesterOutputFile; this->MemoryTesterDynamicOptions.push_back(outputFile); break; - } - case cmCTestMemCheckHandler::BOUNDS_CHECKER: - { + } + case cmCTestMemCheckHandler::BOUNDS_CHECKER: { this->BoundsCheckerXMLFile = this->MemoryTesterOutputFile; - std::string dpbdFile = this->CTest->GetBinaryDir() - + "/Testing/Temporary/MemoryChecker.??.DPbd"; + std::string dpbdFile = this->CTest->GetBinaryDir() + + "/Testing/Temporary/MemoryChecker.??.DPbd"; this->BoundsCheckerDPBDFile = dpbdFile; this->MemoryTesterDynamicOptions.push_back("/B"); this->MemoryTesterDynamicOptions.push_back(dpbdFile); @@ -680,13 +588,12 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking() this->MemoryTesterDynamicOptions.push_back(this->MemoryTesterOutputFile); this->MemoryTesterOptions.push_back("/M"); break; - } - // these are almost the same but the env var used is different + } + // these are almost the same but the env var used is different case cmCTestMemCheckHandler::ADDRESS_SANITIZER: case cmCTestMemCheckHandler::THREAD_SANITIZER: case cmCTestMemCheckHandler::MEMORY_SANITIZER: - case cmCTestMemCheckHandler::UB_SANITIZER: - { + case cmCTestMemCheckHandler::UB_SANITIZER: { // To pass arguments to ThreadSanitizer the environment variable // TSAN_OPTIONS is used. This is done with the cmake -E env command. // The MemoryTesterDynamicOptions is setup with the -E env @@ -697,36 +604,31 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking() std::string envVar; std::string extraOptions = this->CTest->GetCTestConfiguration("MemoryCheckSanitizerOptions"); - if(this->MemoryTesterStyle == cmCTestMemCheckHandler::ADDRESS_SANITIZER) - { + if (this->MemoryTesterStyle == + cmCTestMemCheckHandler::ADDRESS_SANITIZER) { envVar = "ASAN_OPTIONS"; extraOptions += " detect_leaks=1"; - } - else if(this->MemoryTesterStyle == - cmCTestMemCheckHandler::THREAD_SANITIZER) - { + } else if (this->MemoryTesterStyle == + cmCTestMemCheckHandler::THREAD_SANITIZER) { envVar = "TSAN_OPTIONS"; - } - else if(this->MemoryTesterStyle == - cmCTestMemCheckHandler::MEMORY_SANITIZER) - { + } else if (this->MemoryTesterStyle == + cmCTestMemCheckHandler::MEMORY_SANITIZER) { envVar = "MSAN_OPTIONS"; - } - else if(this->MemoryTesterStyle == cmCTestMemCheckHandler::UB_SANITIZER) - { + } else if (this->MemoryTesterStyle == + cmCTestMemCheckHandler::UB_SANITIZER) { envVar = "UBSAN_OPTIONS"; - } - std::string outputFile = envVar + "=log_path=\"" - + this->MemoryTesterOutputFile + "\" "; + } + std::string outputFile = + envVar + "=log_path=\"" + this->MemoryTesterOutputFile + "\" "; this->MemoryTesterEnvironmentVariable = outputFile + extraOptions; break; - } + } default: cmCTestLog(this->CTest, ERROR_MESSAGE, - "Do not understand memory checker: " << this->MemoryTester - << std::endl); + "Do not understand memory checker: " << this->MemoryTester + << std::endl); return false; - } + } this->InitializeResultsVectors(); // std::vector<std::string>::size_type cc; @@ -737,66 +639,52 @@ bool cmCTestMemCheckHandler::InitializeMemoryChecking() return true; } -bool cmCTestMemCheckHandler:: -ProcessMemCheckOutput(const std::string& str, - std::string& log, std::vector<int>& results) +bool cmCTestMemCheckHandler::ProcessMemCheckOutput(const std::string& str, + std::string& log, + std::vector<int>& results) { - if ( this->MemoryTesterStyle == cmCTestMemCheckHandler::VALGRIND ) - { + if (this->MemoryTesterStyle == cmCTestMemCheckHandler::VALGRIND) { return this->ProcessMemCheckValgrindOutput(str, log, results); - } - else if ( this->MemoryTesterStyle == cmCTestMemCheckHandler::PURIFY ) - { + } else if (this->MemoryTesterStyle == cmCTestMemCheckHandler::PURIFY) { return this->ProcessMemCheckPurifyOutput(str, log, results); - } - else if ( this->MemoryTesterStyle == - cmCTestMemCheckHandler::ADDRESS_SANITIZER || - this->MemoryTesterStyle == - cmCTestMemCheckHandler::THREAD_SANITIZER || - this->MemoryTesterStyle == - cmCTestMemCheckHandler::MEMORY_SANITIZER || - this->MemoryTesterStyle == - cmCTestMemCheckHandler::UB_SANITIZER) - { + } else if (this->MemoryTesterStyle == + cmCTestMemCheckHandler::ADDRESS_SANITIZER || + this->MemoryTesterStyle == + cmCTestMemCheckHandler::THREAD_SANITIZER || + this->MemoryTesterStyle == + cmCTestMemCheckHandler::MEMORY_SANITIZER || + this->MemoryTesterStyle == cmCTestMemCheckHandler::UB_SANITIZER) { return this->ProcessMemCheckSanitizerOutput(str, log, results); - } - else if ( this->MemoryTesterStyle == - cmCTestMemCheckHandler::BOUNDS_CHECKER ) - { + } else if (this->MemoryTesterStyle == + cmCTestMemCheckHandler::BOUNDS_CHECKER) { return this->ProcessMemCheckBoundsCheckerOutput(str, log, results); - } - else - { + } else { log.append("\nMemory checking style used was: "); log.append("None that I know"); log = str; - } + } return true; } std::vector<int>::size_type cmCTestMemCheckHandler::FindOrAddWarning( const std::string& warning) { - for(std::vector<std::string>::size_type i =0; - i < this->ResultStrings.size(); ++i) - { - if(this->ResultStrings[i] == warning) - { + for (std::vector<std::string>::size_type i = 0; + i < this->ResultStrings.size(); ++i) { + if (this->ResultStrings[i] == warning) { return i; - } } + } this->GlobalResults.push_back(0); // this must stay the same size this->ResultStrings.push_back(warning); this->ResultStringsLong.push_back(warning); - return this->ResultStrings.size()-1; + return this->ResultStrings.size() - 1; } bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput( - const std::string& str, std::string& log, - std::vector<int>& result) + const std::string& str, std::string& log, std::vector<int>& result) { std::string regex; - switch ( this->MemoryTesterStyle ) - { + switch (this->MemoryTesterStyle) { case cmCTestMemCheckHandler::ADDRESS_SANITIZER: regex = "ERROR: AddressSanitizer: (.*) on.*"; break; @@ -811,7 +699,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput( break; default: break; - } + } cmsys::RegularExpression sanitizerWarning(regex); cmsys::RegularExpression leakWarning("(Direct|Indirect) leak of .*"); int defects = 0; @@ -819,44 +707,34 @@ bool cmCTestMemCheckHandler::ProcessMemCheckSanitizerOutput( cmSystemTools::Split(str.c_str(), lines); std::ostringstream ostr; log = ""; - for( std::vector<std::string>::iterator i = lines.begin(); - i != lines.end(); ++i) - { + for (std::vector<std::string>::iterator i = lines.begin(); i != lines.end(); + ++i) { std::string resultFound; - if(leakWarning.find(*i)) - { - resultFound = leakWarning.match(1)+" leak"; - } - else if (sanitizerWarning.find(*i)) - { + if (leakWarning.find(*i)) { + resultFound = leakWarning.match(1) + " leak"; + } else if (sanitizerWarning.find(*i)) { resultFound = sanitizerWarning.match(1); - } - if(!resultFound.empty()) - { + } + if (!resultFound.empty()) { std::vector<int>::size_type idx = this->FindOrAddWarning(resultFound); - if(result.empty() || idx > result.size()-1) - { + if (result.empty() || idx > result.size() - 1) { result.push_back(1); - } - else - { + } else { result[idx]++; - } - defects++; - ostr << "<b>" << this->ResultStrings[idx] << "</b> "; } - ostr << *i << std::endl; + defects++; + ostr << "<b>" << this->ResultStrings[idx] << "</b> "; } + ostr << *i << std::endl; + } log = ostr.str(); - if(defects) - { + if (defects) { return false; - } + } return true; } bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput( - const std::string& str, std::string& log, - std::vector<int>& results) + const std::string& str, std::string& log, std::vector<int>& results) { std::vector<std::string> lines; cmSystemTools::Split(str.c_str(), lines); @@ -867,58 +745,49 @@ bool cmCTestMemCheckHandler::ProcessMemCheckPurifyOutput( int defects = 0; - for( std::vector<std::string>::iterator i = lines.begin(); - i != lines.end(); ++i) - { + for (std::vector<std::string>::iterator i = lines.begin(); i != lines.end(); + ++i) { std::vector<int>::size_type failure = this->ResultStrings.size(); - if ( pfW.find(*i) ) - { + if (pfW.find(*i)) { std::vector<int>::size_type cc; - for ( cc = 0; cc < this->ResultStrings.size(); cc ++ ) - { - if ( pfW.match(1) == this->ResultStrings[cc] ) - { + for (cc = 0; cc < this->ResultStrings.size(); cc++) { + if (pfW.match(1) == this->ResultStrings[cc]) { failure = cc; break; - } } - if ( cc == this->ResultStrings.size() ) - { + } + if (cc == this->ResultStrings.size()) { cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown Purify memory fault: " - << pfW.match(1) << std::endl); + << pfW.match(1) << std::endl); ostr << "*** Unknown Purify memory fault: " << pfW.match(1) - << std::endl; - } - } - if ( failure != this->ResultStrings.size() ) - { - ostr << "<b>" << this->ResultStrings[failure] << "</b> "; - results[failure] ++; - defects ++; + << std::endl; } - ostr << *i << std::endl; } + if (failure != this->ResultStrings.size()) { + ostr << "<b>" << this->ResultStrings[failure] << "</b> "; + results[failure]++; + defects++; + } + ostr << *i << std::endl; + } log = ostr.str(); - if ( defects ) - { + if (defects) { return false; - } + } return true; } bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput( - const std::string& str, std::string& log, - std::vector<int>& results) + const std::string& str, std::string& log, std::vector<int>& results) { std::vector<std::string> lines; cmSystemTools::Split(str.c_str(), lines); bool unlimitedOutput = false; - if(str.find("CTEST_FULL_OUTPUT") != str.npos || - this->CustomMaximumFailedTestOutputSize == 0) - { + if (str.find("CTEST_FULL_OUTPUT") != str.npos || + this->CustomMaximumFailedTestOutputSize == 0) { unlimitedOutput = true; - } + } std::string::size_type cc; @@ -935,7 +804,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput( "== .*Mismatched free\\(\\) / delete / delete \\[\\]"); cmsys::RegularExpression vgMLK1( "== .*[0-9,]+ bytes in [0-9,]+ blocks are definitely lost" - " in loss record [0-9,]+ of [0-9,]+"); + " in loss record [0-9,]+ of [0-9,]+"); cmsys::RegularExpression vgMLK2( "== .*[0-9,]+ \\([0-9,]+ direct, [0-9,]+ indirect\\)" " bytes in [0-9,]+ blocks are definitely lost" @@ -954,298 +823,239 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput( "== .*Use of uninitialised value of size [0-9,]+"); cmsys::RegularExpression vgUMR2("== .*Invalid read of size [0-9,]+"); cmsys::RegularExpression vgUMR3("== .*Jump to the invalid address "); - cmsys::RegularExpression vgUMR4("== .*Syscall param .* contains " + cmsys::RegularExpression vgUMR4( + "== .*Syscall param .* contains " "uninitialised or unaddressable byte\\(s\\)"); cmsys::RegularExpression vgUMR5("== .*Syscall param .* uninitialised"); cmsys::RegularExpression vgIPW("== .*Invalid write of size [0-9,]+"); cmsys::RegularExpression vgABR("== .*pthread_mutex_unlock: mutex is " - "locked by a different thread"); + "locked by a different thread"); std::vector<std::string::size_type> nonValGrindOutput; double sttime = cmSystemTools::GetTime(); cmCTestOptionalLog(this->CTest, DEBUG, - "Start test: " << lines.size() << std::endl, this->Quiet); + "Start test: " << lines.size() << std::endl, this->Quiet); std::string::size_type totalOutputSize = 0; - for ( cc = 0; cc < lines.size(); cc ++ ) - { - cmCTestOptionalLog(this->CTest, DEBUG, "test line " - << lines[cc] << std::endl, this->Quiet); + for (cc = 0; cc < lines.size(); cc++) { + cmCTestOptionalLog(this->CTest, DEBUG, + "test line " << lines[cc] << std::endl, this->Quiet); - if ( valgrindLine.find(lines[cc]) ) - { - cmCTestOptionalLog(this->CTest, DEBUG, "valgrind line " - << lines[cc] << std::endl, this->Quiet); + if (valgrindLine.find(lines[cc])) { + cmCTestOptionalLog(this->CTest, DEBUG, + "valgrind line " << lines[cc] << std::endl, + this->Quiet); int failure = cmCTestMemCheckHandler::NO_MEMORY_FAULT; - if ( vgFIM.find(lines[cc]) ) - { + if (vgFIM.find(lines[cc])) { failure = cmCTestMemCheckHandler::FIM; - } - else if ( vgFMM.find(lines[cc]) ) - { + } else if (vgFMM.find(lines[cc])) { failure = cmCTestMemCheckHandler::FMM; - } - else if ( vgMLK1.find(lines[cc]) ) - { + } else if (vgMLK1.find(lines[cc])) { failure = cmCTestMemCheckHandler::MLK; - } - else if ( vgMLK2.find(lines[cc]) ) - { + } else if (vgMLK2.find(lines[cc])) { failure = cmCTestMemCheckHandler::MLK; - } - else if ( vgPAR.find(lines[cc]) ) - { + } else if (vgPAR.find(lines[cc])) { failure = cmCTestMemCheckHandler::PAR; - } - else if ( vgMPK1.find(lines[cc]) ) - { + } else if (vgMPK1.find(lines[cc])) { failure = cmCTestMemCheckHandler::MPK; - } - else if ( vgMPK2.find(lines[cc]) ) - { + } else if (vgMPK2.find(lines[cc])) { failure = cmCTestMemCheckHandler::MPK; - } - else if ( vgUMC.find(lines[cc]) ) - { + } else if (vgUMC.find(lines[cc])) { failure = cmCTestMemCheckHandler::UMC; - } - else if ( vgUMR1.find(lines[cc]) ) - { + } else if (vgUMR1.find(lines[cc])) { failure = cmCTestMemCheckHandler::UMR; - } - else if ( vgUMR2.find(lines[cc]) ) - { + } else if (vgUMR2.find(lines[cc])) { failure = cmCTestMemCheckHandler::UMR; - } - else if ( vgUMR3.find(lines[cc]) ) - { + } else if (vgUMR3.find(lines[cc])) { failure = cmCTestMemCheckHandler::UMR; - } - else if ( vgUMR4.find(lines[cc]) ) - { + } else if (vgUMR4.find(lines[cc])) { failure = cmCTestMemCheckHandler::UMR; - } - else if ( vgUMR5.find(lines[cc]) ) - { + } else if (vgUMR5.find(lines[cc])) { failure = cmCTestMemCheckHandler::UMR; - } - else if ( vgIPW.find(lines[cc]) ) - { + } else if (vgIPW.find(lines[cc])) { failure = cmCTestMemCheckHandler::IPW; - } - else if ( vgABR.find(lines[cc]) ) - { + } else if (vgABR.find(lines[cc])) { failure = cmCTestMemCheckHandler::ABR; - } + } - if ( failure != cmCTestMemCheckHandler::NO_MEMORY_FAULT ) - { + if (failure != cmCTestMemCheckHandler::NO_MEMORY_FAULT) { ostr << "<b>" << this->ResultStrings[failure] << "</b> "; - results[failure] ++; - defects ++; - } + results[failure]++; + defects++; + } totalOutputSize += lines[cc].size(); ostr << lines[cc] << std::endl; - } - else - { + } else { nonValGrindOutput.push_back(cc); - } } + } // Now put all all the non valgrind output into the test output // This should be last in case it gets truncated by the output // limiting code - for(std::vector<std::string::size_type>::iterator i = - nonValGrindOutput.begin(); i != nonValGrindOutput.end(); ++i) - { + for (std::vector<std::string::size_type>::iterator i = + nonValGrindOutput.begin(); + i != nonValGrindOutput.end(); ++i) { totalOutputSize += lines[*i].size(); ostr << lines[*i] << std::endl; - if(!unlimitedOutput && totalOutputSize > - static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)) - { + if (!unlimitedOutput && + totalOutputSize > + static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)) { ostr << "....\n"; ostr << "Test Output for this test has been truncated see testing" - " machine logs for full output,\n"; + " machine logs for full output,\n"; ostr << "or put CTEST_FULL_OUTPUT in the output of " - "this test program.\n"; - break; // stop the copy of output if we are full - } + "this test program.\n"; + break; // stop the copy of output if we are full } + } cmCTestOptionalLog(this->CTest, DEBUG, "End test (elapsed: " - << (cmSystemTools::GetTime() - sttime) << std::endl, this->Quiet); + << (cmSystemTools::GetTime() - sttime) << std::endl, + this->Quiet); log = ostr.str(); - if ( defects ) - { + if (defects) { return false; - } + } return true; } - - bool cmCTestMemCheckHandler::ProcessMemCheckBoundsCheckerOutput( - const std::string& str, std::string& log, - std::vector<int>& results) + const std::string& str, std::string& log, std::vector<int>& results) { log = ""; double sttime = cmSystemTools::GetTime(); std::vector<std::string> lines; cmSystemTools::Split(str.c_str(), lines); cmCTestOptionalLog(this->CTest, DEBUG, - "Start test: " << lines.size() << std::endl, this->Quiet); + "Start test: " << lines.size() << std::endl, this->Quiet); std::vector<std::string>::size_type cc; - for ( cc = 0; cc < lines.size(); cc ++ ) - { - if(lines[cc] == BOUNDS_CHECKER_MARKER) - { + for (cc = 0; cc < lines.size(); cc++) { + if (lines[cc] == BOUNDS_CHECKER_MARKER) { break; - } } + } cmBoundsCheckerParser parser(this->CTest); parser.InitializeParser(); - if(cc < lines.size()) - { - for(cc++; cc < lines.size(); ++cc) - { + if (cc < lines.size()) { + for (cc++; cc < lines.size(); ++cc) { std::string& theLine = lines[cc]; // check for command line arguments that are not escaped // correctly by BC - if(theLine.find("TargetArgs=") != theLine.npos) - { + if (theLine.find("TargetArgs=") != theLine.npos) { // skip this because BC gets it wrong and we can't parse it - } - else if(!parser.ParseChunk(theLine.c_str(), theLine.size())) - { + } else if (!parser.ParseChunk(theLine.c_str(), theLine.size())) { cmCTestLog(this->CTest, ERROR_MESSAGE, - "Error in ParseChunk: " << theLine - << std::endl); - } + "Error in ParseChunk: " << theLine << std::endl); } } + } int defects = 0; - for(cc =0; cc < parser.Errors.size(); ++cc) - { + for (cc = 0; cc < parser.Errors.size(); ++cc) { results[parser.Errors[cc]]++; defects++; - } + } cmCTestOptionalLog(this->CTest, DEBUG, "End test (elapsed: " - << (cmSystemTools::GetTime() - sttime) << std::endl, this->Quiet); - if(defects) - { + << (cmSystemTools::GetTime() - sttime) << std::endl, + this->Quiet); + if (defects) { // only put the output of Bounds Checker if there were // errors or leaks detected log = parser.Log; return false; - } + } return true; } // PostProcessTest memcheck results -void -cmCTestMemCheckHandler::PostProcessTest(cmCTestTestResult& res, - int test) +void cmCTestMemCheckHandler::PostProcessTest(cmCTestTestResult& res, int test) { cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, - "PostProcessTest memcheck results for : " - << res.Name << std::endl, this->Quiet); - if(this->MemoryTesterStyle - == cmCTestMemCheckHandler::BOUNDS_CHECKER) - { + "PostProcessTest memcheck results for : " << res.Name + << std::endl, + this->Quiet); + if (this->MemoryTesterStyle == cmCTestMemCheckHandler::BOUNDS_CHECKER) { this->PostProcessBoundsCheckerTest(res, test); - } - else - { + } else { std::vector<std::string> files; this->TestOutputFileNames(test, files); - for(std::vector<std::string>::iterator i = files.begin(); - i != files.end(); ++i) - { + for (std::vector<std::string>::iterator i = files.begin(); + i != files.end(); ++i) { this->AppendMemTesterOutput(res, *i); - } } + } } - // This method puts the bounds checker output file into the output // for the test -void -cmCTestMemCheckHandler::PostProcessBoundsCheckerTest(cmCTestTestResult& res, - int test) +void cmCTestMemCheckHandler::PostProcessBoundsCheckerTest( + cmCTestTestResult& res, int test) { cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, - "PostProcessBoundsCheckerTest for : " - << res.Name << std::endl, this->Quiet); + "PostProcessBoundsCheckerTest for : " << res.Name + << std::endl, + this->Quiet); std::vector<std::string> files; this->TestOutputFileNames(test, files); - if (files.empty()) - { + if (files.empty()) { return; - } + } std::string ofile = files[0]; - if ( ofile.empty() ) - { + if (ofile.empty()) { return; - } + } // put a scope around this to close ifs so the file can be removed { - cmsys::ifstream ifs(ofile.c_str()); - if ( !ifs ) - { - std::string log = "Cannot read memory tester output file: " + ofile; - cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl); - return; + cmsys::ifstream ifs(ofile.c_str()); + if (!ifs) { + std::string log = "Cannot read memory tester output file: " + ofile; + cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl); + return; } - res.Output += BOUNDS_CHECKER_MARKER; - res.Output += "\n"; - std::string line; - while ( cmSystemTools::GetLineFromStream(ifs, line) ) - { - res.Output += line; + res.Output += BOUNDS_CHECKER_MARKER; res.Output += "\n"; + std::string line; + while (cmSystemTools::GetLineFromStream(ifs, line)) { + res.Output += line; + res.Output += "\n"; } } cmSystemTools::Delay(1000); cmSystemTools::RemoveFile(this->BoundsCheckerDPBDFile); - cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Remove: " - << this->BoundsCheckerDPBDFile << std::endl, this->Quiet); + cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, + "Remove: " << this->BoundsCheckerDPBDFile << std::endl, + this->Quiet); cmSystemTools::RemoveFile(this->BoundsCheckerXMLFile); - cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Remove: " - << this->BoundsCheckerXMLFile << std::endl, this->Quiet); + cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, + "Remove: " << this->BoundsCheckerXMLFile << std::endl, + this->Quiet); } -void -cmCTestMemCheckHandler::AppendMemTesterOutput(cmCTestTestResult& res, - std::string const& ofile) +void cmCTestMemCheckHandler::AppendMemTesterOutput(cmCTestTestResult& res, + std::string const& ofile) { - if ( ofile.empty() ) - { + if (ofile.empty()) { return; - } + } // put ifs in scope so file can be deleted if needed { - cmsys::ifstream ifs(ofile.c_str()); - if ( !ifs ) - { - std::string log = "Cannot read memory tester output file: " + ofile; - cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl); - return; + cmsys::ifstream ifs(ofile.c_str()); + if (!ifs) { + std::string log = "Cannot read memory tester output file: " + ofile; + cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl); + return; } - std::string line; - while ( cmSystemTools::GetLineFromStream(ifs, line) ) - { - res.Output += line; - res.Output += "\n"; + std::string line; + while (cmSystemTools::GetLineFromStream(ifs, line)) { + res.Output += line; + res.Output += "\n"; } } - if(this->LogWithPID) - { + if (this->LogWithPID) { cmSystemTools::RemoveFile(ofile); cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, - "Remove: "<< ofile <<"\n", this->Quiet); - } + "Remove: " << ofile << "\n", this->Quiet); + } } -void cmCTestMemCheckHandler::TestOutputFileNames(int test, - std::vector<std::string>& - files) +void cmCTestMemCheckHandler::TestOutputFileNames( + int test, std::vector<std::string>& files) { std::string index; std::ostringstream stream; @@ -1254,30 +1064,22 @@ void cmCTestMemCheckHandler::TestOutputFileNames(int test, std::string ofile = this->MemoryTesterOutputFile; std::string::size_type pos = ofile.find("??"); ofile.replace(pos, 2, index); - if(this->LogWithPID) - { + if (this->LogWithPID) { ofile += ".*"; cmsys::Glob g; g.FindFiles(ofile); - if(g.GetFiles().empty()) - { - std::string log = "Cannot find memory tester output file: " - + ofile; + if (g.GetFiles().empty()) { + std::string log = "Cannot find memory tester output file: " + ofile; cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl); ofile = ""; - } - else - { + } else { files = g.GetFiles(); return; - } } - else if ( !cmSystemTools::FileExists(ofile.c_str()) ) - { - std::string log = "Cannot find memory tester output file: " - + ofile; + } else if (!cmSystemTools::FileExists(ofile.c_str())) { + std::string log = "Cannot find memory tester output file: " + ofile; cmCTestLog(this->CTest, ERROR_MESSAGE, log.c_str() << std::endl); ofile = ""; - } + } files.push_back(ofile); } |