summaryrefslogtreecommitdiffstats
path: root/Source/CTest/cmCTestCoverageHandler.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'Source/CTest/cmCTestCoverageHandler.cxx')
-rw-r--r--Source/CTest/cmCTestCoverageHandler.cxx275
1 files changed, 172 insertions, 103 deletions
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index 2b5f1ca..0eacc42 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -9,8 +9,8 @@
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
- This software is distributed WITHOUT ANY WARRANTY; without even
- the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ This software is distributed WITHOUT ANY WARRANTY; without even
+ the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
@@ -25,7 +25,7 @@
#include <cmsys/Process.h>
#include <cmsys/RegularExpression.hxx>
-#include <stdlib.h>
+#include <stdlib.h>
#include <math.h>
#include <float.h>
@@ -44,25 +44,30 @@ void cmCTestCoverageHandler::Initialize()
}
//----------------------------------------------------------------------
-bool cmCTestCoverageHandler::StartCoverageLogFile(cmGeneratedFileStream& covLogFile, int logFileCount)
+bool cmCTestCoverageHandler::StartCoverageLogFile(
+ cmGeneratedFileStream& covLogFile, int logFileCount)
{
char covLogFilename[1024];
sprintf(covLogFilename, "CoverageLog-%d", logFileCount);
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Open file: " << covLogFilename << std::endl);
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Open file: " << covLogFilename
+ << std::endl);
if (!this->StartResultingXML(covLogFilename, covLogFile) )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open log file: " << covLogFilename << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open log file: "
+ << covLogFilename << std::endl);
return false;
}
std::string local_start_time = m_CTest->CurrentTime();
m_CTest->StartXML(covLogFile);
covLogFile << "<CoverageLog>" << std::endl
- << "\t<StartDateTime>" << local_start_time << "</StartDateTime>" << std::endl;
+ << "\t<StartDateTime>" << local_start_time << "</StartDateTime>"
+ << std::endl;
return true;
}
//----------------------------------------------------------------------
-void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr, int logFileCount)
+void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr,
+ int logFileCount)
{
std::string local_end_time = m_CTest->CurrentTime();
ostr << "\t<EndDateTime>" << local_end_time << "</EndDateTime>" << std::endl
@@ -70,12 +75,14 @@ void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr, int
m_CTest->EndXML(ostr);
char covLogFilename[1024];
sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount);
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Close file: " << covLogFilename << std::endl);
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Close file: "
+ << covLogFilename << std::endl);
ostr.Close();
}
//----------------------------------------------------------------------
-bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, const char* srcDir,
+bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file,
+ const char* srcDir,
const char* binDir)
{
std::vector<cmsys::RegularExpression>::iterator sit;
@@ -93,8 +100,10 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, const char* src
std::string fSrcDir = cmSystemTools::CollapseFullPath(srcDir);
std::string fBinDir = cmSystemTools::CollapseFullPath(binDir);
std::string fFile = cmSystemTools::CollapseFullPath(file);
- bool sourceSubDir = cmSystemTools::IsSubDirectory(fFile.c_str(), fSrcDir.c_str());
- bool buildSubDir = cmSystemTools::IsSubDirectory(fFile.c_str(), fBinDir.c_str());
+ bool sourceSubDir = cmSystemTools::IsSubDirectory(fFile.c_str(),
+ fSrcDir.c_str());
+ bool buildSubDir = cmSystemTools::IsSubDirectory(fFile.c_str(),
+ fBinDir.c_str());
// Always check parent directory of the file.
std::string fileDir = cmSystemTools::GetFilenamePath(fFile.c_str());
std::string checkDir;
@@ -124,7 +133,8 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, const char* src
fFile.c_str(), checkDir.c_str());
if ( ndc.size() )
{
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str() << " so skip coverage of " << file << std::endl);
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str()
+ << " so skip coverage of " << file << std::endl);
return false;
}
@@ -154,7 +164,8 @@ bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file, const char* src
fFile.c_str(), checkDir.c_str());
if ( ndc.size() )
{
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str() << " so skip coverage of: " << file << std::endl);
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc.c_str()
+ << " so skip coverage of: " << file << std::endl);
return false;
}
// Ok, nothing in source tree, nothing in binary tree
@@ -176,7 +187,8 @@ int cmCTestCoverageHandler::ProcessHandler()
double elapsed_time_start = cmSystemTools::GetTime();
if ( !this->StartLogFile("Coverage", ofs) )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create LastCoverage.log file" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot create LastCoverage.log file"
+ << std::endl);
}
ofs << "Performing coverage: " << elapsed_time_start << std::endl;
@@ -186,39 +198,42 @@ int cmCTestCoverageHandler::ProcessHandler()
std::string asfGlob = sourceDir + "/*";
std::string abfGlob = binaryDir + "/*";
-
-
+
+
// Style 1
- std::string st1gcovOutputRex1 = "[0-9]+\\.[0-9]+% of [0-9]+ (source |)lines executed in file (.*)$";
+ std::string st1gcovOutputRex1
+ = "[0-9]+\\.[0-9]+% of [0-9]+ (source |)lines executed in file (.*)$";
std::string st1gcovOutputRex2 = "^Creating (.*\\.gcov)\\.";
cmsys::RegularExpression st1re1(st1gcovOutputRex1.c_str());
cmsys::RegularExpression st1re2(st1gcovOutputRex2.c_str());
-
-
+
+
// Style 2
std::string st2gcovOutputRex1 = "^File *[`'](.*)'$";
- std::string st2gcovOutputRex2 = "Lines executed: *[0-9]+\\.[0-9]+% of [0-9]+$";
+ std::string st2gcovOutputRex2
+ = "Lines executed: *[0-9]+\\.[0-9]+% of [0-9]+$";
std::string st2gcovOutputRex3 = "^(.*):creating [`'](.*\\.gcov)'";
std::string st2gcovOutputRex4 = "^(.*):unexpected EOF *$";
std::string st2gcovOutputRex5 = "^(.*):cannot open source file*$";
- std::string st2gcovOutputRex6 = "^(.*):source file is newer than graph file `(.*)'$";
+ std::string st2gcovOutputRex6
+ = "^(.*):source file is newer than graph file `(.*)'$";
cmsys::RegularExpression st2re1(st2gcovOutputRex1.c_str());
cmsys::RegularExpression st2re2(st2gcovOutputRex2.c_str());
cmsys::RegularExpression st2re3(st2gcovOutputRex3.c_str());
cmsys::RegularExpression st2re4(st2gcovOutputRex4.c_str());
cmsys::RegularExpression st2re5(st2gcovOutputRex5.c_str());
cmsys::RegularExpression st2re6(st2gcovOutputRex6.c_str());
-
+
cmCTestLog(m_CTest, HANDLER_OUTPUT, "Performing coverage" << std::endl);
-
+
std::string coverage_start_time = m_CTest->CurrentTime();
-
+
std::string testingDir = m_CTest->GetBinaryDir() + "/Testing";
std::string tempDir = testingDir + "/CoverageInfo";
std::string currentDirectory = cmSystemTools::GetCurrentWorkingDirectory();
cmSystemTools::MakeDirectory(tempDir.c_str());
cmSystemTools::ChangeDirectory(tempDir.c_str());
-
+
cmGlob gl;
gl.RecurseOn();
std::string daGlob = binaryDir + "/*.da";
@@ -229,10 +244,11 @@ int cmCTestCoverageHandler::ProcessHandler()
std::vector<std::string>& moreFiles = gl.GetFiles();
files.insert(files.end(), moreFiles.begin(), moreFiles.end());
std::vector<std::string>::iterator it;
-
+
if ( files.size() == 0 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, " Cannot find any coverage files." << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, " Cannot find any coverage files."
+ << std::endl);
// No coverage files is a valid thing, so the exit code is 0
return 0;
}
@@ -243,27 +259,30 @@ int cmCTestCoverageHandler::ProcessHandler()
rexIt != m_CustomCoverageExclude.end();
++ rexIt )
{
- m_CustomCoverageExcludeRegex.push_back(cmsys::RegularExpression(rexIt->c_str()));
+ m_CustomCoverageExcludeRegex.push_back(
+ cmsys::RegularExpression(rexIt->c_str()));
}
-
+
typedef std::vector<int> singleFileCoverageVector;
typedef std::map<std::string, singleFileCoverageVector> totalCoverageMap;
-
+
totalCoverageMap totalCoverage;
-
+
int gcovStyle = 0;
std::set<std::string> missingFiles;
-
+
std::string actualSourceFile = "";
- cmCTestLog(m_CTest, HANDLER_OUTPUT, " Processing coverage (each . represents one file):" << std::endl);
+ cmCTestLog(m_CTest, HANDLER_OUTPUT,
+ " Processing coverage (each . represents one file):" << std::endl);
cmCTestLog(m_CTest, HANDLER_OUTPUT, " ");
int file_count = 0;
for ( it = files.begin(); it != files.end(); ++ it )
{
cmCTestLog(m_CTest, HANDLER_OUTPUT, "." << std::flush);
std::string fileDir = cmSystemTools::GetFilenamePath(it->c_str());
- std::string command = "\"" + gcovCommand + "\" -l -o \"" + fileDir + "\" \"" + *it + "\"";
+ std::string command = "\"" + gcovCommand + "\" -l -o \"" + fileDir
+ + "\" \"" + *it + "\"";
cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, command.c_str() << std::endl);
std::string output = "";
std::string errors = "";
@@ -272,36 +291,43 @@ int cmCTestCoverageHandler::ProcessHandler()
ofs << " Command: " << command.c_str() << std::endl;
int res = m_CTest->RunCommand(command.c_str(), &output, &errors,
&retVal, tempDir.c_str(), 0 /*m_TimeOut*/);
-
+
ofs << " Output: " << output.c_str() << std::endl;
ofs << " Errors: " << errors.c_str() << std::endl;
if ( ! res )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Problem running coverage on file: " << it->c_str() << std::endl);
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Command produced error: " << errors << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Problem running coverage on file: "
+ << it->c_str() << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Command produced error: " << errors
+ << std::endl);
error ++;
continue;
}
if ( retVal != 0 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Coverage command returned: " << retVal << " while processing: " << it->c_str() << std::endl);
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Command produced error: " << error << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Coverage command returned: "
+ << retVal << " while processing: " << it->c_str() << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Command produced error: " << error
+ << std::endl);
}
cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
- "--------------------------------------------------------------" << std::endl
+ "--------------------------------------------------------------"
+ << std::endl
<< output << std::endl
- << "--------------------------------------------------------------" << std::endl);
+ << "--------------------------------------------------------------"
+ << std::endl);
std::vector<cmStdString> lines;
std::vector<cmStdString>::iterator line;
-
-
+
+
// Globals for storing current source file and current gcov file;
cmSystemTools::Split(output.c_str(), lines);
for ( line = lines.begin(); line != lines.end(); ++line)
{
std::string sourceFile;
std::string gcovFile;
- cmCTestLog(m_CTest, DEBUG, "Line: [" << line->c_str() << "]" << std::endl);
+ cmCTestLog(m_CTest, DEBUG, "Line: [" << line->c_str() << "]"
+ << std::endl);
if ( line->size() == 0 )
{
// Ignore empty line; probably style 2
@@ -312,13 +338,14 @@ int cmCTestCoverageHandler::ProcessHandler()
{
if ( gcovStyle != 1 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+ << std::endl);
error ++;
break;
}
gcovStyle = 1;
}
-
+
actualSourceFile = "";
sourceFile = st1re1.match(2);
}
@@ -328,13 +355,14 @@ int cmCTestCoverageHandler::ProcessHandler()
{
if ( gcovStyle != 1 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+ << std::endl);
error ++;
break;
}
gcovStyle = 1;
}
-
+
gcovFile = st1re2.match(1);
}
else if ( st2re1.find(line->c_str() ) )
@@ -343,13 +371,14 @@ int cmCTestCoverageHandler::ProcessHandler()
{
if ( gcovStyle != 2 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+ << std::endl);
error ++;
break;
}
gcovStyle = 2;
}
-
+
actualSourceFile = "";
sourceFile = st2re1.match(1);
}
@@ -359,7 +388,8 @@ int cmCTestCoverageHandler::ProcessHandler()
{
if ( gcovStyle != 2 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+ << std::endl);
error ++;
break;
}
@@ -372,13 +402,14 @@ int cmCTestCoverageHandler::ProcessHandler()
{
if ( gcovStyle != 2 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+ << std::endl);
error ++;
break;
}
gcovStyle = 2;
}
-
+
gcovFile = st2re3.match(2);
}
else if ( st2re4.find(line->c_str() ) )
@@ -387,14 +418,16 @@ int cmCTestCoverageHandler::ProcessHandler()
{
if ( gcovStyle != 2 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+ << std::endl);
error ++;
break;
}
gcovStyle = 2;
}
-
- cmCTestLog(m_CTest, WARNING, "Warning: " << st2re4.match(1) << " had unexpected EOF" << std::endl);
+
+ cmCTestLog(m_CTest, WARNING, "Warning: " << st2re4.match(1)
+ << " had unexpected EOF" << std::endl);
}
else if ( st2re5.find(line->c_str() ) )
{
@@ -402,14 +435,16 @@ int cmCTestCoverageHandler::ProcessHandler()
{
if ( gcovStyle != 2 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+ << std::endl);
error ++;
break;
}
gcovStyle = 2;
}
-
- cmCTestLog(m_CTest, WARNING, "Warning: Cannot open file: " << st2re5.match(1) << std::endl);
+
+ cmCTestLog(m_CTest, WARNING, "Warning: Cannot open file: "
+ << st2re5.match(1) << std::endl);
}
else if ( st2re6.find(line->c_str() ) )
{
@@ -417,30 +452,34 @@ int cmCTestCoverageHandler::ProcessHandler()
{
if ( gcovStyle != 2 )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown gcov output style"
+ << std::endl);
error ++;
break;
}
gcovStyle = 2;
}
-
+
cmCTestLog(m_CTest, WARNING, "Warning: File: " << st2re6.match(1)
<< " is newer than " << st2re6.match(2) << std::endl);
}
else
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown line: [" << line->c_str() << "]" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Unknown line: [" << line->c_str()
+ << "]" << std::endl);
error ++;
//abort();
}
if ( !gcovFile.empty() && actualSourceFile.size() )
{
singleFileCoverageVector* vec = &totalCoverage[actualSourceFile];
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " in file: " << gcovFile << std::endl);
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " in file: "
+ << gcovFile << std::endl);
std::ifstream ifile(gcovFile.c_str());
if ( ! ifile )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open file: " << gcovFile << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open file: "
+ << gcovFile << std::endl);
}
else
{
@@ -449,30 +488,33 @@ int cmCTestCoverageHandler::ProcessHandler()
while ( cmSystemTools::GetLineFromStream(ifile, nl) )
{
cnt ++;
-
+
//TODO: Handle gcov 3.0 non-coverage lines
-
+
// Skip empty lines
if ( !nl.size() )
{
continue;
}
-
+
// Skip unused lines
if ( nl.size() < 12 )
{
continue;
}
- // Read the coverage count from the beginning of the gcov output line
+ // Read the coverage count from the beginning of the gcov output
+ // line
std::string prefix = nl.substr(0, 12);
int cov = atoi(prefix.c_str());
- // Read the line number starting at the 10th character of the gcov output line
+ // Read the line number starting at the 10th character of the gcov
+ // output line
std::string lineNumber = nl.substr(10, 5);
int lineIdx = atoi(lineNumber.c_str())-1;
if ( lineIdx >= 0 )
{
- while ( vec->size() <= static_cast<singleFileCoverageVector::size_type>(lineIdx) )
+ while ( vec->size() <=
+ static_cast<singleFileCoverageVector::size_type>(lineIdx) )
{
vec->push_back(-1);
}
@@ -499,28 +541,39 @@ int cmCTestCoverageHandler::ProcessHandler()
sourceFile.substr(0, sourceDir.size()) == sourceDir &&
sourceFile[sourceDir.size()] == '/' )
{
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " produced s: " << sourceFile.c_str() << std::endl);
- ofs << " produced in source dir: " << sourceFile.c_str() << std::endl;
- actualSourceFile = cmSystemTools::CollapseFullPath(sourceFile.c_str());
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " produced s: "
+ << sourceFile.c_str() << std::endl);
+ ofs << " produced in source dir: " << sourceFile.c_str()
+ << std::endl;
+ actualSourceFile
+ = cmSystemTools::CollapseFullPath(sourceFile.c_str());
}
// Binary dir?
if ( sourceFile.size() > binaryDir.size() &&
sourceFile.substr(0, binaryDir.size()) == binaryDir &&
sourceFile[binaryDir.size()] == '/' )
{
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " produced b: " << sourceFile.c_str() << std::endl);
- ofs << " produced in binary dir: " << sourceFile.c_str() << std::endl;
- actualSourceFile = cmSystemTools::CollapseFullPath(sourceFile.c_str());
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " produced b: "
+ << sourceFile.c_str() << std::endl);
+ ofs << " produced in binary dir: " << sourceFile.c_str()
+ << std::endl;
+ actualSourceFile
+ = cmSystemTools::CollapseFullPath(sourceFile.c_str());
}
if ( actualSourceFile.empty() )
{
if ( missingFiles.find(actualSourceFile) == missingFiles.end() )
{
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Something went wrong" << std::endl);
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "File: [" << sourceFile.c_str() << "]" << std::endl);
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "s: [" << sourceFile.substr(0, sourceDir.size()) << "]" << std::endl);
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "b: [" << sourceFile.substr(0, binaryDir.size()) << "]" << std::endl);
- ofs << " Something went wrong. Cannot find: " << sourceFile.c_str()
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Something went wrong"
+ << std::endl);
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "File: ["
+ << sourceFile.c_str() << "]" << std::endl);
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "s: ["
+ << sourceFile.substr(0, sourceDir.size()) << "]" << std::endl);
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "b: ["
+ << sourceFile.substr(0, binaryDir.size()) << "]" << std::endl);
+ ofs << " Something went wrong. Cannot find: "
+ << sourceFile.c_str()
<< " in source dir: " << sourceDir.c_str()
<< " or binary dir: " << binaryDir.c_str() << std::endl;
missingFiles.insert(actualSourceFile);
@@ -531,17 +584,19 @@ int cmCTestCoverageHandler::ProcessHandler()
file_count ++;
if ( file_count % 50 == 0 )
{
- cmCTestLog(m_CTest, HANDLER_OUTPUT, " processed: " << file_count << " out of " << files.size() << std::endl);
+ cmCTestLog(m_CTest, HANDLER_OUTPUT, " processed: " << file_count
+ << " out of " << files.size() << std::endl);
cmCTestLog(m_CTest, HANDLER_OUTPUT, " ");
}
}
-
+
cmGeneratedFileStream covSumFile;
cmGeneratedFileStream covLogFile;
if (!this->StartResultingXML("Coverage", covSumFile))
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open coverage summary file." << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
+ << std::endl);
return -1;
}
@@ -550,7 +605,8 @@ int cmCTestCoverageHandler::ProcessHandler()
// Produce output xml files
covSumFile << "<Coverage>" << std::endl
- << "\t<StartDateTime>" << coverage_start_time << "</StartDateTime>" << std::endl;
+ << "\t<StartDateTime>" << coverage_start_time << "</StartDateTime>"
+ << std::endl;
int logFileCount = 0;
if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
{
@@ -563,7 +619,8 @@ int cmCTestCoverageHandler::ProcessHandler()
//std::string fullSourceDir = sourceDir + "/";
//std::string fullBinaryDir = binaryDir + "/";
cmCTestLog(m_CTest, HANDLER_OUTPUT, std::endl);
- cmCTestLog(m_CTest, HANDLER_OUTPUT, " Acumulating results (each . represents one file):" << std::endl);
+ cmCTestLog(m_CTest, HANDLER_OUTPUT,
+ " Acumulating results (each . represents one file):" << std::endl);
cmCTestLog(m_CTest, HANDLER_OUTPUT, " ");
std::vector<std::string> errorsWhileAccumulating;
@@ -577,7 +634,8 @@ int cmCTestCoverageHandler::ProcessHandler()
file_count ++;
if ( file_count % 50 == 0 )
{
- cmCTestLog(m_CTest, HANDLER_OUTPUT, " processed: " << file_count << " out of "
+ cmCTestLog(m_CTest, HANDLER_OUTPUT, " processed: " << file_count
+ << " out of "
<< totalCoverage.size() << std::endl);
cmCTestLog(m_CTest, HANDLER_OUTPUT, " ");
}
@@ -591,15 +649,19 @@ int cmCTestCoverageHandler::ProcessHandler()
}
}
const std::string fullFileName = fileIterator->first;
- const std::string fileName = cmSystemTools::GetFilenameName(fullFileName.c_str());
- std::string fullFilePath = cmSystemTools::GetFilenamePath(fullFileName.c_str());
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Process file: " << fullFileName << std::endl);
+ const std::string fileName
+ = cmSystemTools::GetFilenameName(fullFileName.c_str());
+ std::string fullFilePath
+ = cmSystemTools::GetFilenamePath(fullFileName.c_str());
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, "Process file: "
+ << fullFileName << std::endl);
cmSystemTools::ConvertToUnixSlashes(fullFilePath);
if ( !cmSystemTools::FileExists(fullFileName.c_str()) )
{
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot find file: " << fullFileName.c_str() << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Cannot find file: "
+ << fullFileName.c_str() << std::endl);
continue;
}
@@ -608,7 +670,8 @@ int cmCTestCoverageHandler::ProcessHandler()
sourceDir.c_str(), binaryDir.c_str());
if ( !shouldIDoCoverage )
{
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, ".NoDartCoverage found, so skip coverage check for: "
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+ ".NoDartCoverage found, so skip coverage check for: "
<< fullFileName.c_str()
<< std::endl);
continue;
@@ -641,12 +704,14 @@ int cmCTestCoverageHandler::ProcessHandler()
if ( !cmSystemTools::GetLineFromStream(ifs, line) )
{
cmOStringStream ostr;
- ostr << "Problem reading source file: " << fullFileName.c_str() << " line:" << cc;
+ ostr << "Problem reading source file: " << fullFileName.c_str()
+ << " line:" << cc;
errorsWhileAccumulating.push_back(ostr.str());
error ++;
break;
}
- covLogFile << "\t\t<Line Number=\"" << cc << "\" Count=\"" << fcov[cc] << "\">"
+ covLogFile << "\t\t<Line Number=\"" << cc << "\" Count=\"" << fcov[cc]
+ << "\">"
<< m_CTest->MakeXMLSafe(line.c_str()) << "</Line>" << std::endl;
if ( fcov[cc] == 0 )
{
@@ -698,7 +763,8 @@ int cmCTestCoverageHandler::ProcessHandler()
if ( errorsWhileAccumulating.size() > 0 )
{
cmCTestLog(m_CTest, ERROR_MESSAGE, std::endl);
- cmCTestLog(m_CTest, ERROR_MESSAGE, "Error(s) while acumulating results:" << std::endl);
+ cmCTestLog(m_CTest, ERROR_MESSAGE, "Error(s) while acumulating results:"
+ << std::endl);
std::vector<std::string>::iterator erIt;
for ( erIt = errorsWhileAccumulating.begin();
erIt != errorsWhileAccumulating.end();
@@ -726,16 +792,17 @@ int cmCTestCoverageHandler::ProcessHandler()
covSumFile.precision(2);
covSumFile << (percent_coverage)<< "</PercentCoverage>\n"
<< "\t<EndDateTime>" << end_time << "</EndDateTime>\n";
- covSumFile << "<ElapsedMinutes>" <<
+ covSumFile << "<ElapsedMinutes>" <<
static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0
<< "</ElapsedMinutes>"
<< "</Coverage>" << std::endl;
m_CTest->EndXML(covSumFile);
- cmCTestLog(m_CTest, HANDLER_OUTPUT, "\tCovered LOC: " << total_tested << std::endl
+ cmCTestLog(m_CTest, HANDLER_OUTPUT, "\tCovered LOC: "
+ << total_tested << std::endl
<< "\tNot covered LOC: " << total_untested << std::endl
<< "\tTotal LOC: " << total_lines << std::endl
- << "\tPercentage Coverage: "
+ << "\tPercentage Coverage: "
<< std::setiosflags(std::ios::fixed)
<< std::setprecision(2)
<< (percent_coverage) << "%" << std::endl);
@@ -743,7 +810,7 @@ int cmCTestCoverageHandler::ProcessHandler()
ofs << "\tCovered LOC: " << total_tested << std::endl
<< "\tNot covered LOC: " << total_untested << std::endl
<< "\tTotal LOC: " << total_lines << std::endl
- << "\tPercentage Coverage: "
+ << "\tPercentage Coverage: "
<< std::setiosflags(std::ios::fixed)
<< std::setprecision(2)
<< (percent_coverage) << "%" << std::endl;
@@ -760,14 +827,16 @@ int cmCTestCoverageHandler::ProcessHandler()
//----------------------------------------------------------------------
void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
{
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " Add coverage exclude regular expressions." << std::endl);
- cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_COVERAGE_EXCLUDE",
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT,
+ " Add coverage exclude regular expressions." << std::endl);
+ cmCTest::PopulateCustomVector(mf, "CTEST_CUSTOM_COVERAGE_EXCLUDE",
m_CustomCoverageExclude);
std::vector<cmStdString>::iterator it;
for ( it = m_CustomCoverageExclude.begin();
it != m_CustomCoverageExclude.end();
++ it )
{
- cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " Add coverage exclude: " << it->c_str() << std::endl);
+ cmCTestLog(m_CTest, HANDLER_VERBOSE_OUTPUT, " Add coverage exclude: "
+ << it->c_str() << std::endl);
}
}
generated by cgit v0.12 at 2024-11-11 21:22:24 (GMT)