Revise C++ coding style using clang-format

Run the `Utilities/Scripts/clang-format.bash` script to update
all our C++ code to a new style defined by `.clang-format`.
Use `clang-format` version 3.8.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.

1 files changed, 962 insertions, 1236 deletions

diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index ed15834..550a774 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -34,95 +34,82 @@
 #include <math.h>
 #include <stdlib.h>
 
-#define SAFEDIV(x,y) (((y)!=0)?((x)/(y)):(0))
+#define SAFEDIV(x, y) (((y) != 0) ? ((x) / (y)) : (0))
 
 class cmCTestRunProcess
 {
 public:
   cmCTestRunProcess()
-    {
-      this->Process = cmsysProcess_New();
-      this->PipeState = -1;
-      this->TimeOut = -1;
-    }
+  {
+    this->Process = cmsysProcess_New();
+    this->PipeState = -1;
+    this->TimeOut = -1;
+  }
   ~cmCTestRunProcess()
-    {
-      if(!(this->PipeState == -1)
-         && !(this->PipeState == cmsysProcess_Pipe_None )
-         && !(this->PipeState == cmsysProcess_Pipe_Timeout))
-        {
-        this->WaitForExit();
-        }
-      cmsysProcess_Delete(this->Process);
+  {
+    if (!(this->PipeState == -1) &&
+        !(this->PipeState == cmsysProcess_Pipe_None) &&
+        !(this->PipeState == cmsysProcess_Pipe_Timeout)) {
+      this->WaitForExit();
     }
+    cmsysProcess_Delete(this->Process);
+  }
   void SetCommand(const char* command)
-    {
-      this->CommandLineStrings.clear();
-      this->CommandLineStrings.push_back(command);;
-    }
+  {
+    this->CommandLineStrings.clear();
+    this->CommandLineStrings.push_back(command);
+    ;
+  }
   void AddArgument(const char* arg)
-    {
-      if(arg)
-        {
-        this->CommandLineStrings.push_back(arg);
-        }
-    }
-  void SetWorkingDirectory(const char* dir)
-    {
-      this->WorkingDirectory = dir;
-    }
-  void SetTimeout(double t)
-    {
-      this->TimeOut = t;
+  {
+    if (arg) {
+      this->CommandLineStrings.push_back(arg);
     }
+  }
+  void SetWorkingDirectory(const char* dir) { this->WorkingDirectory = dir; }
+  void SetTimeout(double t) { this->TimeOut = t; }
   bool StartProcess()
-    {
-      std::vector<const char*> args;
-      for(std::vector<std::string>::iterator i =
-            this->CommandLineStrings.begin();
-          i != this->CommandLineStrings.end(); ++i)
-        {
-        args.push_back(i->c_str());
-        }
-      args.push_back(0); // null terminate
-      cmsysProcess_SetCommand(this->Process, &*args.begin());
-      if(!this->WorkingDirectory.empty())
-        {
-        cmsysProcess_SetWorkingDirectory(this->Process,
-                                         this->WorkingDirectory.c_str());
-        }
-
-      cmsysProcess_SetOption(this->Process,
-                             cmsysProcess_Option_HideWindow, 1);
-      if(this->TimeOut != -1)
-        {
-        cmsysProcess_SetTimeout(this->Process, this->TimeOut);
-        }
-      cmsysProcess_Execute(this->Process);
-      this->PipeState = cmsysProcess_GetState(this->Process);
-      // if the process is running or exited return true
-      if(this->PipeState == cmsysProcess_State_Executing
-         || this->PipeState == cmsysProcess_State_Exited)
-        {
-        return true;
-        }
-      return false;
+  {
+    std::vector<const char*> args;
+    for (std::vector<std::string>::iterator i =
+           this->CommandLineStrings.begin();
+         i != this->CommandLineStrings.end(); ++i) {
+      args.push_back(i->c_str());
+    }
+    args.push_back(0); // null terminate
+    cmsysProcess_SetCommand(this->Process, &*args.begin());
+    if (!this->WorkingDirectory.empty()) {
+      cmsysProcess_SetWorkingDirectory(this->Process,
+                                       this->WorkingDirectory.c_str());
+    }
+
+    cmsysProcess_SetOption(this->Process, cmsysProcess_Option_HideWindow, 1);
+    if (this->TimeOut != -1) {
+      cmsysProcess_SetTimeout(this->Process, this->TimeOut);
+    }
+    cmsysProcess_Execute(this->Process);
+    this->PipeState = cmsysProcess_GetState(this->Process);
+    // if the process is running or exited return true
+    if (this->PipeState == cmsysProcess_State_Executing ||
+        this->PipeState == cmsysProcess_State_Exited) {
+      return true;
     }
+    return false;
+  }
   void SetStdoutFile(const char* fname)
-    {
+  {
     cmsysProcess_SetPipeFile(this->Process, cmsysProcess_Pipe_STDOUT, fname);
-    }
+  }
   void SetStderrFile(const char* fname)
-    {
+  {
     cmsysProcess_SetPipeFile(this->Process, cmsysProcess_Pipe_STDERR, fname);
-    }
-  int WaitForExit(double* timeout =0)
-    {
-      this->PipeState = cmsysProcess_WaitForExit(this->Process,
-                                                 timeout);
-      return this->PipeState;
-    }
-  int GetProcessState() { return this->PipeState;}
+  }
+  int WaitForExit(double* timeout = 0)
+  {
+    this->PipeState = cmsysProcess_WaitForExit(this->Process, timeout);
+    return this->PipeState;
+  }
+  int GetProcessState() { return this->PipeState; }
 private:
   int PipeState;
   cmsysProcess* Process;
@@ -131,8 +118,6 @@ private:
   double TimeOut;
 };
 
-
-
 cmCTestCoverageHandler::cmCTestCoverageHandler()
 {
 }
@@ -157,12 +142,11 @@ void cmCTestCoverageHandler::CleanCoverageLogFiles(std::ostream& log)
   cmsys::Glob gl;
   gl.FindFiles(logGlob);
   std::vector<std::string> const& files = gl.GetFiles();
-  for(std::vector<std::string>::const_iterator fi = files.begin();
-      fi != files.end(); ++fi)
-    {
+  for (std::vector<std::string>::const_iterator fi = files.begin();
+       fi != files.end(); ++fi) {
     log << "Removing old coverage log: " << *fi << "\n";
     cmSystemTools::RemoveFile(*fi);
-    }
+  }
 }
 
 bool cmCTestCoverageHandler::StartCoverageLogFile(
@@ -170,25 +154,26 @@ bool cmCTestCoverageHandler::StartCoverageLogFile(
 {
   char covLogFilename[1024];
   sprintf(covLogFilename, "CoverageLog-%d", logFileCount);
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Open file: "
-    << covLogFilename << std::endl, this->Quiet);
-  if(!this->StartResultingXML(cmCTest::PartCoverage,
-                              covLogFilename, covLogFile))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open log file: "
-      << covLogFilename << std::endl);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Open file: " << covLogFilename << std::endl,
+                     this->Quiet);
+  if (!this->StartResultingXML(cmCTest::PartCoverage, covLogFilename,
+                               covLogFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Cannot open log file: " << covLogFilename << std::endl);
     return false;
-    }
+  }
   return true;
 }
 
 void cmCTestCoverageHandler::EndCoverageLogFile(cmGeneratedFileStream& ostr,
-  int logFileCount)
+                                                int logFileCount)
 {
   char covLogFilename[1024];
   sprintf(covLogFilename, "CoverageLog-%d.xml", logFileCount);
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Close file: "
-    << covLogFilename << std::endl, this->Quiet);
+  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                     "Close file: " << covLogFilename << std::endl,
+                     this->Quiet);
   ostr.Close();
 }
 
@@ -198,7 +183,7 @@ void cmCTestCoverageHandler::StartCoverageLogXML(cmXMLWriter& xml)
   xml.StartElement("CoverageLog");
   xml.Element("StartDateTime", this->CTest->CurrentTime());
   xml.Element("StartTime",
-    static_cast<unsigned int>(cmSystemTools::GetTime()));
+              static_cast<unsigned int>(cmSystemTools::GetTime()));
 }
 
 void cmCTestCoverageHandler::EndCoverageLogXML(cmXMLWriter& xml)
@@ -210,138 +195,117 @@ void cmCTestCoverageHandler::EndCoverageLogXML(cmXMLWriter& xml)
 }
 
 bool cmCTestCoverageHandler::ShouldIDoCoverage(const char* file,
-  const char* srcDir,
-  const char* binDir)
+                                               const char* srcDir,
+                                               const char* binDir)
 {
-  if(this->IsFilteredOut(file))
-    {
+  if (this->IsFilteredOut(file)) {
     return false;
-    }
+  }
 
   std::vector<cmsys::RegularExpression>::iterator sit;
-  for ( sit = this->CustomCoverageExcludeRegex.begin();
-    sit != this->CustomCoverageExcludeRegex.end(); ++ sit )
-    {
-    if ( sit->find(file) )
-      {
-      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "  File " << file
-        << " is excluded in CTestCustom.ctest" << std::endl;, this->Quiet);
+  for (sit = this->CustomCoverageExcludeRegex.begin();
+       sit != this->CustomCoverageExcludeRegex.end(); ++sit) {
+    if (sit->find(file)) {
+      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "  File "
+                           << file << " is excluded in CTestCustom.ctest"
+                           << std::endl;
+                         , this->Quiet);
       return false;
-      }
     }
+  }
 
   std::string fSrcDir = cmSystemTools::CollapseFullPath(srcDir);
   std::string fBinDir = cmSystemTools::CollapseFullPath(binDir);
   std::string fFile = cmSystemTools::CollapseFullPath(file);
-  bool sourceSubDir = cmSystemTools::IsSubDirectory(fFile,
-    fSrcDir);
-  bool buildSubDir = cmSystemTools::IsSubDirectory(fFile,
-    fBinDir);
+  bool sourceSubDir = cmSystemTools::IsSubDirectory(fFile, fSrcDir);
+  bool buildSubDir = cmSystemTools::IsSubDirectory(fFile, fBinDir);
   // Always check parent directory of the file.
   std::string fileDir = cmSystemTools::GetFilenamePath(fFile);
   std::string checkDir;
 
   // We also need to check the binary/source directory pair.
-  if ( sourceSubDir && buildSubDir )
-    {
-    if ( fSrcDir.size() > fBinDir.size() )
-      {
+  if (sourceSubDir && buildSubDir) {
+    if (fSrcDir.size() > fBinDir.size()) {
       checkDir = fSrcDir;
-      }
-    else
-      {
+    } else {
       checkDir = fBinDir;
-      }
     }
-  else if ( sourceSubDir )
-    {
+  } else if (sourceSubDir) {
     checkDir = fSrcDir;
-    }
-  else if ( buildSubDir )
-    {
+  } else if (buildSubDir) {
     checkDir = fBinDir;
-    }
-  std::string ndc
-    = cmSystemTools::FileExistsInParentDirectories(".NoDartCoverage",
-      fFile.c_str(), checkDir.c_str());
-  if (!ndc.empty())
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc
-      << " so skip coverage of " << file << std::endl, this->Quiet);
+  }
+  std::string ndc = cmSystemTools::FileExistsInParentDirectories(
+    ".NoDartCoverage", fFile.c_str(), checkDir.c_str());
+  if (!ndc.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Found: " << ndc << " so skip coverage of " << file
+                                 << std::endl,
+                       this->Quiet);
     return false;
-    }
+  }
 
   // By now checkDir should be set to parent directory of the file.
   // Get the relative path to the file an apply it to the opposite directory.
   // If it is the same as fileDir, then ignore, otherwise check.
   std::string relPath;
-  if(!checkDir.empty())
-    {
-    relPath = cmSystemTools::RelativePath(checkDir.c_str(),
-                                          fFile.c_str());
-    }
-  else
-    {
+  if (!checkDir.empty()) {
+    relPath = cmSystemTools::RelativePath(checkDir.c_str(), fFile.c_str());
+  } else {
     relPath = fFile;
-    }
-  if ( checkDir == fSrcDir )
-    {
+  }
+  if (checkDir == fSrcDir) {
     checkDir = fBinDir;
-    }
-  else
-    {
+  } else {
     checkDir = fSrcDir;
-    }
+  }
   fFile = checkDir + "/" + relPath;
   fFile = cmSystemTools::GetFilenamePath(fFile);
 
-  if ( fileDir == fFile )
-    {
+  if (fileDir == fFile) {
     // This is in-source build, so we trust the previous check.
     return true;
-    }
+  }
 
-  ndc = cmSystemTools::FileExistsInParentDirectories(".NoDartCoverage",
-    fFile.c_str(), checkDir.c_str());
-  if (!ndc.empty())
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Found: " << ndc
-      << " so skip coverage of: " << file << std::endl, this->Quiet);
+  ndc = cmSystemTools::FileExistsInParentDirectories(
+    ".NoDartCoverage", fFile.c_str(), checkDir.c_str());
+  if (!ndc.empty()) {
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       "Found: " << ndc << " so skip coverage of: " << file
+                                 << std::endl,
+                       this->Quiet);
     return false;
-    }
+  }
   // Ok, nothing in source tree, nothing in binary tree
   return true;
 }
 
-//clearly it would be nice if this were broken up into a few smaller
-//functions and commented...
+// clearly it would be nice if this were broken up into a few smaller
+// functions and commented...
 int cmCTestCoverageHandler::ProcessHandler()
 {
   this->CTest->ClearSubmitFiles(cmCTest::PartCoverage);
   int error = 0;
   // do we have time for this
-  if (this->CTest->GetRemainingTimeAllowed() < 120)
-    {
+  if (this->CTest->GetRemainingTimeAllowed() < 120) {
     return error;
-    }
+  }
 
   std::string coverage_start_time = this->CTest->CurrentTime();
-  unsigned int coverage_start_time_time = static_cast<unsigned int>(
-    cmSystemTools::GetTime());
-  std::string sourceDir
-    = this->CTest->GetCTestConfiguration("SourceDirectory");
-  std::string binaryDir
-    = this->CTest->GetCTestConfiguration("BuildDirectory");
+  unsigned int coverage_start_time_time =
+    static_cast<unsigned int>(cmSystemTools::GetTime());
+  std::string sourceDir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
+  std::string binaryDir = this->CTest->GetCTestConfiguration("BuildDirectory");
 
   this->LoadLabels();
 
   cmGeneratedFileStream ofs;
   double elapsed_time_start = cmSystemTools::GetTime();
-  if ( !this->StartLogFile("Coverage", ofs) )
-    {
+  if (!this->StartLogFile("Coverage", ofs)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot create LastCoverage.log file" << std::endl);
-    }
+               "Cannot create LastCoverage.log file" << std::endl);
+  }
 
   ofs << "Performing coverage: " << elapsed_time_start << std::endl;
   this->CleanCoverageLogFiles(ofs);
@@ -350,7 +314,7 @@ int cmCTestCoverageHandler::ProcessHandler()
   cmSystemTools::ConvertToUnixSlashes(binaryDir);
 
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-    "Performing coverage" << std::endl, this->Quiet);
+                     "Performing coverage" << std::endl, this->Quiet);
 
   cmCTestCoverageHandlerContainer cont;
   cont.Error = error;
@@ -362,97 +326,86 @@ int cmCTestCoverageHandler::ProcessHandler()
   // setup the regex exclude stuff
   this->CustomCoverageExcludeRegex.clear();
   std::vector<std::string>::iterator rexIt;
-  for ( rexIt = this->CustomCoverageExclude.begin();
-    rexIt != this->CustomCoverageExclude.end();
-    ++ rexIt )
-    {
+  for (rexIt = this->CustomCoverageExclude.begin();
+       rexIt != this->CustomCoverageExclude.end(); ++rexIt) {
     this->CustomCoverageExcludeRegex.push_back(
       cmsys::RegularExpression(rexIt->c_str()));
-    }
+  }
 
-  if(this->HandleBullseyeCoverage(&cont))
-    {
+  if (this->HandleBullseyeCoverage(&cont)) {
     return cont.Error;
-    }
+  }
   int file_count = 0;
   file_count += this->HandleGCovCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   file_count += this->HandleLCovCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   file_count += this->HandleTracePyCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   file_count += this->HandlePHPCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   file_count += this->HandleCoberturaCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
 
   file_count += this->HandleMumpsCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
 
   file_count += this->HandleJacocoCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
 
   file_count += this->HandleBlanketJSCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
 
-    file_count += this->HandleDelphiCoverage(&cont);
+  file_count += this->HandleDelphiCoverage(&cont);
   error = cont.Error;
-  if ( file_count < 0 )
-    {
+  if (file_count < 0) {
     return error;
-    }
+  }
   std::set<std::string> uncovered = this->FindUncoveredFiles(&cont);
 
-  if (file_count == 0 && this->ExtraCoverageGlobs.empty())
-    {
-    cmCTestOptionalLog(this->CTest, WARNING,
+  if (file_count == 0 && this->ExtraCoverageGlobs.empty()) {
+    cmCTestOptionalLog(
+      this->CTest, WARNING,
       " Cannot find any coverage files. Ignoring Coverage request."
-      << std::endl, this->Quiet);
+        << std::endl,
+      this->Quiet);
     return error;
-    }
+  }
   cmGeneratedFileStream covSumFile;
   cmGeneratedFileStream covLogFile;
   cmXMLWriter covSumXML(covSumFile);
   cmXMLWriter covLogXML(covLogFile);
 
-  if(!this->StartResultingXML(cmCTest::PartCoverage, "Coverage", covSumFile))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot open coverage summary file." << std::endl);
+  if (!this->StartResultingXML(cmCTest::PartCoverage, "Coverage",
+                               covSumFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
+                 << std::endl);
     return -1;
-    }
+  }
   covSumFile.setf(std::ios::fixed, std::ios::floatfield);
   covSumFile.precision(2);
 
@@ -463,19 +416,19 @@ int cmCTestCoverageHandler::ProcessHandler()
   covSumXML.Element("StartDateTime", coverage_start_time);
   covSumXML.Element("StartTime", coverage_start_time_time);
   int logFileCount = 0;
-  if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
-    {
+  if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
     return -1;
-    }
+  }
   this->StartCoverageLogXML(covLogXML);
   cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator fileIterator;
   int cnt = 0;
   long total_tested = 0;
   long total_untested = 0;
-  //std::string fullSourceDir = sourceDir + "/";
-  //std::string fullBinaryDir = binaryDir + "/";
+  // std::string fullSourceDir = sourceDir + "/";
+  // std::string fullBinaryDir = binaryDir + "/";
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, std::endl, this->Quiet);
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT,
     "   Accumulating results (each . represents one file):" << std::endl,
     this->Quiet);
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
@@ -483,77 +436,68 @@ int cmCTestCoverageHandler::ProcessHandler()
   std::vector<std::string> errorsWhileAccumulating;
 
   file_count = 0;
-  for ( fileIterator = cont.TotalCoverage.begin();
-    fileIterator != cont.TotalCoverage.end();
-    ++fileIterator )
-    {
+  for (fileIterator = cont.TotalCoverage.begin();
+       fileIterator != cont.TotalCoverage.end(); ++fileIterator) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "." << std::flush,
-      this->Quiet);
-    file_count ++;
-    if ( file_count % 50 == 0 )
-      {
+                       this->Quiet);
+    file_count++;
+    if (file_count % 50 == 0) {
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " processed: "
-        << file_count
-        << " out of "
-        << cont.TotalCoverage.size() << std::endl, this->Quiet);
+                           << file_count << " out of "
+                           << cont.TotalCoverage.size() << std::endl,
+                         this->Quiet);
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
-      }
+    }
 
     const std::string fullFileName = fileIterator->first;
-    bool shouldIDoCoverage
-      = this->ShouldIDoCoverage(fullFileName.c_str(),
-        sourceDir.c_str(), binaryDir.c_str());
-    if ( !shouldIDoCoverage )
-      {
+    bool shouldIDoCoverage = this->ShouldIDoCoverage(
+      fullFileName.c_str(), sourceDir.c_str(), binaryDir.c_str());
+    if (!shouldIDoCoverage) {
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        ".NoDartCoverage found, so skip coverage check for: "
-        << fullFileName
-        << std::endl, this->Quiet);
+                         ".NoDartCoverage found, so skip coverage check for: "
+                           << fullFileName << std::endl,
+                         this->Quiet);
       continue;
-      }
+    }
 
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Process file: " << fullFileName << std::endl, this->Quiet);
+                       "Process file: " << fullFileName << std::endl,
+                       this->Quiet);
 
-    if ( !cmSystemTools::FileExists(fullFileName.c_str()) )
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find file: "
-        << fullFileName << std::endl);
+    if (!cmSystemTools::FileExists(fullFileName.c_str())) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Cannot find file: " << fullFileName << std::endl);
       continue;
-      }
+    }
 
-    if ( ++cnt % 100 == 0 )
-      {
+    if (++cnt % 100 == 0) {
       this->EndCoverageLogXML(covLogXML);
       this->EndCoverageLogFile(covLogFile, logFileCount);
-      logFileCount ++;
-      if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
-        {
+      logFileCount++;
+      if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
         return -1;
-        }
-      this->StartCoverageLogXML(covLogXML);
       }
+      this->StartCoverageLogXML(covLogXML);
+    }
 
-    const std::string fileName
-      = cmSystemTools::GetFilenameName(fullFileName);
+    const std::string fileName = cmSystemTools::GetFilenameName(fullFileName);
     std::string shortFileName =
       this->CTest->GetShortPathToFile(fullFileName.c_str());
-    const cmCTestCoverageHandlerContainer::SingleFileCoverageVector& fcov
-      = fileIterator->second;
+    const cmCTestCoverageHandlerContainer::SingleFileCoverageVector& fcov =
+      fileIterator->second;
     covLogXML.StartElement("File");
     covLogXML.Attribute("Name", fileName);
     covLogXML.Attribute("FullPath", shortFileName);
     covLogXML.StartElement("Report");
 
     cmsys::ifstream ifs(fullFileName.c_str());
-    if ( !ifs)
-      {
+    if (!ifs) {
       std::ostringstream ostr;
-      ostr <<  "Cannot open source file: " << fullFileName;
+      ostr << "Cannot open source file: " << fullFileName;
       errorsWhileAccumulating.push_back(ostr.str());
-      error ++;
+      error++;
       continue;
-      }
+    }
 
     int tested = 0;
     int untested = 0;
@@ -561,49 +505,43 @@ int cmCTestCoverageHandler::ProcessHandler()
     cmCTestCoverageHandlerContainer::SingleFileCoverageVector::size_type cc;
     std::string line;
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Actually performing coverage for: " << fullFileName << std::endl,
-      this->Quiet);
-    for ( cc= 0; cc < fcov.size(); cc ++ )
-      {
-      if ( !cmSystemTools::GetLineFromStream(ifs, line) &&
-        cc != fcov.size() -1 )
-        {
+                       "Actually performing coverage for: " << fullFileName
+                                                            << std::endl,
+                       this->Quiet);
+    for (cc = 0; cc < fcov.size(); cc++) {
+      if (!cmSystemTools::GetLineFromStream(ifs, line) &&
+          cc != fcov.size() - 1) {
         std::ostringstream ostr;
         ostr << "Problem reading source file: " << fullFileName
-             << " line:" << cc << "  out total: " << fcov.size()-1;
+             << " line:" << cc << "  out total: " << fcov.size() - 1;
         errorsWhileAccumulating.push_back(ostr.str());
-        error ++;
+        error++;
         break;
-        }
+      }
       covLogXML.StartElement("Line");
       covLogXML.Attribute("Number", cc);
       covLogXML.Attribute("Count", fcov[cc]);
       covLogXML.Content(line);
       covLogXML.EndElement(); // Line
-      if ( fcov[cc] == 0 )
-        {
-        untested ++;
-        }
-      else if ( fcov[cc] > 0 )
-        {
-        tested ++;
-        }
+      if (fcov[cc] == 0) {
+        untested++;
+      } else if (fcov[cc] > 0) {
+        tested++;
       }
-    if ( cmSystemTools::GetLineFromStream(ifs, line) )
-      {
+    }
+    if (cmSystemTools::GetLineFromStream(ifs, line)) {
       std::ostringstream ostr;
-      ostr <<  "Looks like there are more lines in the file: " << fullFileName;
+      ostr << "Looks like there are more lines in the file: " << fullFileName;
       errorsWhileAccumulating.push_back(ostr.str());
-      }
+    }
     float cper = 0;
     float cmet = 0;
-    if ( tested + untested > 0 )
-      {
+    if (tested + untested > 0) {
       cper = (100 * SAFEDIV(static_cast<float>(tested),
-          static_cast<float>(tested + untested)));
-      cmet = ( SAFEDIV(static_cast<float>(tested + 10),
-          static_cast<float>(tested + untested + 10)));
-      }
+                            static_cast<float>(tested + untested)));
+      cmet = (SAFEDIV(static_cast<float>(tested + 10),
+                      static_cast<float>(tested + untested + 10)));
+    }
     total_tested += tested;
     total_untested += untested;
     covLogXML.EndElement(); // Report
@@ -611,7 +549,7 @@ int cmCTestCoverageHandler::ProcessHandler()
     covSumXML.StartElement("File");
     covSumXML.Attribute("Name", fileName);
     covSumXML.Attribute("FullPath",
-      this->CTest->GetShortPathToFile(fullFileName.c_str()));
+                        this->CTest->GetShortPathToFile(fullFileName.c_str()));
     covSumXML.Attribute("Covered", tested + untested > 0 ? "true" : "false");
     covSumXML.Element("LOCTested", tested);
     covSumXML.Element("LOCUnTested", untested);
@@ -619,12 +557,11 @@ int cmCTestCoverageHandler::ProcessHandler()
     covSumXML.Element("CoverageMetric", cmet);
     this->WriteXMLLabels(covSumXML, shortFileName);
     covSumXML.EndElement(); // File
-    }
+  }
 
-  //Handle all the files in the extra coverage globs that have no cov data
-  for(std::set<std::string>::iterator i = uncovered.begin();
-      i != uncovered.end(); ++i)
-    {
+  // Handle all the files in the extra coverage globs that have no cov data
+  for (std::set<std::string>::iterator i = uncovered.begin();
+       i != uncovered.end(); ++i) {
     std::string fileName = cmSystemTools::GetFilenameName(*i);
     std::string fullPath = cont.SourceDir + "/" + *i;
 
@@ -634,27 +571,26 @@ int cmCTestCoverageHandler::ProcessHandler()
     covLogXML.StartElement("Report");
 
     cmsys::ifstream ifs(fullPath.c_str());
-    if (!ifs)
-      {
+    if (!ifs) {
       std::ostringstream ostr;
-      ostr <<  "Cannot open source file: " << fullPath;
+      ostr << "Cannot open source file: " << fullPath;
       errorsWhileAccumulating.push_back(ostr.str());
-      error ++;
+      error++;
       continue;
-      }
+    }
     int untested = 0;
     std::string line;
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Actually performing coverage for: " << *i << std::endl, this->Quiet);
-    while (cmSystemTools::GetLineFromStream(ifs, line))
-      {
+                       "Actually performing coverage for: " << *i << std::endl,
+                       this->Quiet);
+    while (cmSystemTools::GetLineFromStream(ifs, line)) {
       covLogXML.StartElement("Line");
       covLogXML.Attribute("Number", untested);
       covLogXML.Attribute("Count", 0);
       covLogXML.Content(line);
       covLogXML.EndElement(); // Line
-      untested ++;
-      }
+      untested++;
+    }
     covLogXML.EndElement(); // Report
     covLogXML.EndElement(); // File
 
@@ -669,33 +605,28 @@ int cmCTestCoverageHandler::ProcessHandler()
     covSumXML.Element("CoverageMetric", 0);
     this->WriteXMLLabels(covSumXML, *i);
     covSumXML.EndElement(); // File
-    }
+  }
 
   this->EndCoverageLogXML(covLogXML);
   this->EndCoverageLogFile(covLogFile, logFileCount);
 
-  if (!errorsWhileAccumulating.empty())
-    {
+  if (!errorsWhileAccumulating.empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, std::endl);
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Error(s) while accumulating results:" << std::endl);
+               "Error(s) while accumulating results:" << std::endl);
     std::vector<std::string>::iterator erIt;
-    for ( erIt = errorsWhileAccumulating.begin();
-      erIt != errorsWhileAccumulating.end();
-      ++ erIt )
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "  " << *erIt << std::endl);
-      }
+    for (erIt = errorsWhileAccumulating.begin();
+         erIt != errorsWhileAccumulating.end(); ++erIt) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "  " << *erIt << std::endl);
     }
+  }
 
   long total_lines = total_tested + total_untested;
-  float percent_coverage = 100 * SAFEDIV(static_cast<float>(total_tested),
-    static_cast<float>(total_lines));
-  if ( total_lines == 0 )
-    {
+  float percent_coverage = 100 *
+    SAFEDIV(static_cast<float>(total_tested), static_cast<float>(total_lines));
+  if (total_lines == 0) {
     percent_coverage = 0;
-    }
+  }
 
   std::string end_time = this->CTest->CurrentTime();
 
@@ -705,60 +636,57 @@ int cmCTestCoverageHandler::ProcessHandler()
   covSumXML.Element("PercentCoverage", percent_coverage);
   covSumXML.Element("EndDateTime", end_time);
   covSumXML.Element("EndTime",
-    static_cast<unsigned int>(cmSystemTools::GetTime()));
-  covSumXML.Element("ElapsedMinutes",
-    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0);
+                    static_cast<unsigned int>(cmSystemTools::GetTime()));
+  covSumXML.Element(
+    "ElapsedMinutes",
+    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start) / 6) /
+      10.0);
   covSumXML.EndElement(); // Coverage
   this->CTest->EndXML(covSumXML);
 
-  cmCTestLog(this->CTest, HANDLER_OUTPUT, "" << std::endl
-    << "\tCovered LOC:         "
-    << total_tested << std::endl
-    << "\tNot covered LOC:     " << total_untested << std::endl
-    << "\tTotal LOC:           " << total_lines << std::endl
-    << "\tPercentage Coverage: "
-    << std::setiosflags(std::ios::fixed)
-    << std::setprecision(2)
-    << (percent_coverage) << "%" << std::endl);
+  cmCTestLog(this->CTest, HANDLER_OUTPUT, ""
+               << std::endl
+               << "\tCovered LOC:         " << total_tested << std::endl
+               << "\tNot covered LOC:     " << total_untested << std::endl
+               << "\tTotal LOC:           " << total_lines << std::endl
+               << "\tPercentage Coverage: "
+               << std::setiosflags(std::ios::fixed) << std::setprecision(2)
+               << (percent_coverage) << "%" << std::endl);
 
   ofs << "\tCovered LOC:         " << total_tested << std::endl
-    << "\tNot covered LOC:     " << total_untested << std::endl
-    << "\tTotal LOC:           " << total_lines << std::endl
-    << "\tPercentage Coverage: "
-    << std::setiosflags(std::ios::fixed)
-    << std::setprecision(2)
-    << (percent_coverage) << "%" << std::endl;
-
+      << "\tNot covered LOC:     " << total_untested << std::endl
+      << "\tTotal LOC:           " << total_lines << std::endl
+      << "\tPercentage Coverage: " << std::setiosflags(std::ios::fixed)
+      << std::setprecision(2) << (percent_coverage) << "%" << std::endl;
 
-  if ( error )
-    {
+  if (error) {
     return -1;
-    }
+  }
   return 0;
 }
 
-void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
+void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile* mf)
 {
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " Add coverage exclude regular expressions." << std::endl, this->Quiet);
+                     " Add coverage exclude regular expressions." << std::endl,
+                     this->Quiet);
   this->CTest->PopulateCustomVector(mf, "CTEST_CUSTOM_COVERAGE_EXCLUDE",
-                                this->CustomCoverageExclude);
+                                    this->CustomCoverageExclude);
   this->CTest->PopulateCustomVector(mf, "CTEST_EXTRA_COVERAGE_GLOB",
-                                this->ExtraCoverageGlobs);
+                                    this->ExtraCoverageGlobs);
   std::vector<std::string>::iterator it;
-  for ( it = this->CustomCoverageExclude.begin();
-    it != this->CustomCoverageExclude.end();
-    ++ it )
-    {
+  for (it = this->CustomCoverageExclude.begin();
+       it != this->CustomCoverageExclude.end(); ++it) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Add coverage exclude: " << *it << std::endl, this->Quiet);
-    }
-  for ( it = this->ExtraCoverageGlobs.begin();
-    it != this->ExtraCoverageGlobs.end(); ++it)
-    {
+                       " Add coverage exclude: " << *it << std::endl,
+                       this->Quiet);
+  }
+  for (it = this->ExtraCoverageGlobs.begin();
+       it != this->ExtraCoverageGlobs.end(); ++it) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Add coverage glob: " << *it << std::endl, this->Quiet);
-    }
+                       " Add coverage glob: " << *it << std::endl,
+                       this->Quiet);
+  }
 }
 
 // Fix for issue #4971 where the case of the drive letter component of
@@ -772,19 +700,16 @@ void cmCTestCoverageHandler::PopulateCustomVectors(cmMakefile *mf)
 #define fnc(s) s
 #endif
 
-bool IsFileInDir(const std::string &infile, const std::string &indir)
+bool IsFileInDir(const std::string& infile, const std::string& indir)
 {
   std::string file = cmSystemTools::CollapseFullPath(infile);
   std::string dir = cmSystemTools::CollapseFullPath(indir);
 
-  if (
-    file.size() > dir.size() &&
-    (fnc(file.substr(0, dir.size())) == fnc(dir)) &&
-    file[dir.size()] == '/'
-    )
-    {
+  if (file.size() > dir.size() &&
+      (fnc(file.substr(0, dir.size())) == fnc(dir)) &&
+      file[dir.size()] == '/') {
     return true;
-    }
+  }
 
   return false;
 }
@@ -794,10 +719,9 @@ int cmCTestCoverageHandler::HandlePHPCoverage(
 {
   cmParsePHPCoverage cov(*cont, this->CTest);
   std::string coverageDir = this->CTest->GetBinaryDir() + "/xdebugCoverage";
-  if(cmSystemTools::FileIsDirectory(coverageDir))
-    {
+  if (cmSystemTools::FileIsDirectory(coverageDir)) {
     cov.ReadPHPCoverageDirectory(coverageDir.c_str());
-    }
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
@@ -812,31 +736,27 @@ int cmCTestCoverageHandler::HandleCoberturaCoverage(
   // binary directory is used.
   std::string coverageXMLFile;
   const char* covDir = cmSystemTools::GetEnv("COBERTURADIR");
-  if(covDir && strlen(covDir) != 0)
-    {
-      coverageXMLFile = std::string(covDir);
-    }
-  else
-    {
-      coverageXMLFile = this->CTest->GetBinaryDir();
-    }
+  if (covDir && strlen(covDir) != 0) {
+    coverageXMLFile = std::string(covDir);
+  } else {
+    coverageXMLFile = this->CTest->GetBinaryDir();
+  }
   // build the find file string with the directory from above
   coverageXMLFile += "/coverage.xml";
 
-  if(cmSystemTools::FileExists(coverageXMLFile.c_str()))
-    {
+  if (cmSystemTools::FileExists(coverageXMLFile.c_str())) {
     // If file exists, parse it
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               "Parsing Cobertura XML file: " << coverageXMLFile
-               << std::endl, this->Quiet);
+                       "Parsing Cobertura XML file: " << coverageXMLFile
+                                                      << std::endl,
+                       this->Quiet);
     cov.ReadCoverageXML(coverageXMLFile.c_str());
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               " Cannot find Cobertura XML file: " << coverageXMLFile
-               << std::endl, this->Quiet);
-    }
+                       " Cannot find Cobertura XML file: " << coverageXMLFile
+                                                           << std::endl,
+                       this->Quiet);
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
@@ -845,82 +765,71 @@ int cmCTestCoverageHandler::HandleMumpsCoverage(
 {
   // try gtm coverage
   cmParseGTMCoverage cov(*cont, this->CTest);
-  std::string coverageFile = this->CTest->GetBinaryDir() +
-    "/gtm_coverage.mcov";
-  if(cmSystemTools::FileExists(coverageFile.c_str()))
-    {
+  std::string coverageFile =
+    this->CTest->GetBinaryDir() + "/gtm_coverage.mcov";
+  if (cmSystemTools::FileExists(coverageFile.c_str())) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               "Parsing Cache Coverage: " << coverageFile
-               << std::endl, this->Quiet);
+                       "Parsing Cache Coverage: " << coverageFile << std::endl,
+                       this->Quiet);
     cov.ReadCoverageFile(coverageFile.c_str());
     return static_cast<int>(cont->TotalCoverage.size());
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               " Cannot find GTM coverage file: " << coverageFile
-               << std::endl, this->Quiet);
-    }
+                       " Cannot find GTM coverage file: " << coverageFile
+                                                          << std::endl,
+                       this->Quiet);
+  }
   cmParseCacheCoverage ccov(*cont, this->CTest);
-  coverageFile = this->CTest->GetBinaryDir() +
-    "/cache_coverage.cmcov";
-  if(cmSystemTools::FileExists(coverageFile.c_str()))
-    {
+  coverageFile = this->CTest->GetBinaryDir() + "/cache_coverage.cmcov";
+  if (cmSystemTools::FileExists(coverageFile.c_str())) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               "Parsing Cache Coverage: " << coverageFile
-               << std::endl, this->Quiet);
+                       "Parsing Cache Coverage: " << coverageFile << std::endl,
+                       this->Quiet);
     ccov.ReadCoverageFile(coverageFile.c_str());
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               " Cannot find Cache coverage file: " << coverageFile
-               << std::endl, this->Quiet);
-    }
+                       " Cannot find Cache coverage file: " << coverageFile
+                                                            << std::endl,
+                       this->Quiet);
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
 struct cmCTestCoverageHandlerLocale
 {
   cmCTestCoverageHandlerLocale()
-    {
-    if(const char* l = cmSystemTools::GetEnv("LC_ALL"))
-      {
+  {
+    if (const char* l = cmSystemTools::GetEnv("LC_ALL")) {
       lc_all = l;
-      }
-    if(lc_all != "C")
-      {
+    }
+    if (lc_all != "C") {
       cmSystemTools::PutEnv("LC_ALL=C");
-      }
     }
+  }
   ~cmCTestCoverageHandlerLocale()
-    {
-    if(!lc_all.empty())
-      {
+  {
+    if (!lc_all.empty()) {
       cmSystemTools::PutEnv("LC_ALL=" + lc_all);
-      }
-    else
-      {
+    } else {
       cmSystemTools::UnsetEnv("LC_ALL");
-      }
     }
+  }
   std::string lc_all;
 };
 
 int cmCTestCoverageHandler::HandleJacocoCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
-  cmParseJacocoCoverage cov =
-   cmParseJacocoCoverage(*cont, this->CTest);
+  cmParseJacocoCoverage cov = cmParseJacocoCoverage(*cont, this->CTest);
 
   // Search in the source directory.
   cmsys::Glob g1;
   std::vector<std::string> files;
   g1.SetRecurse(true);
 
-  std::string SourceDir
-    = this->CTest->GetCTestConfiguration("SourceDirectory");
-  std::string coverageFile = SourceDir+ "/*jacoco.xml";
+  std::string SourceDir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
+  std::string coverageFile = SourceDir + "/*jacoco.xml";
 
   g1.FindFiles(coverageFile);
   files = g1.GetFiles();
@@ -929,147 +838,132 @@ int cmCTestCoverageHandler::HandleJacocoCoverage(
   cmsys::Glob g2;
   std::vector<std::string> binFiles;
   g2.SetRecurse(true);
-  std::string binaryDir
-    = this->CTest->GetCTestConfiguration("BuildDirectory");
-  std::string binCoverageFile = binaryDir+ "/*jacoco.xml";
+  std::string binaryDir = this->CTest->GetCTestConfiguration("BuildDirectory");
+  std::string binCoverageFile = binaryDir + "/*jacoco.xml";
   g2.FindFiles(binCoverageFile);
   binFiles = g2.GetFiles();
-  if (!binFiles.empty())
-    {
+  if (!binFiles.empty()) {
     files.insert(files.end(), binFiles.begin(), binFiles.end());
-    }
+  }
 
-  if (!files.empty())
-    {
+  if (!files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Found Jacoco Files, Performing Coverage" << std::endl, this->Quiet);
+                       "Found Jacoco Files, Performing Coverage" << std::endl,
+                       this->Quiet);
     cov.LoadCoverageData(files);
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find Jacoco coverage files: " << coverageFile
-      << std::endl, this->Quiet);
-    }
+                       " Cannot find Jacoco coverage files: " << coverageFile
+                                                              << std::endl,
+                       this->Quiet);
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
 int cmCTestCoverageHandler::HandleDelphiCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
-  cmParseDelphiCoverage cov =
-   cmParseDelphiCoverage(*cont, this->CTest);
+  cmParseDelphiCoverage cov = cmParseDelphiCoverage(*cont, this->CTest);
   cmsys::Glob g;
   std::vector<std::string> files;
   g.SetRecurse(true);
 
-
-  std::string BinDir
-    = this->CTest->GetBinaryDir();
-  std::string coverageFile = BinDir+ "/*(*.pas).html";
-
+  std::string BinDir = this->CTest->GetBinaryDir();
+  std::string coverageFile = BinDir + "/*(*.pas).html";
 
   g.FindFiles(coverageFile);
-  files=g.GetFiles();
-  if (!files.empty())
-    {
+  files = g.GetFiles();
+  if (!files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Found Delphi HTML Files, Performing Coverage" << std::endl,
-      this->Quiet);
+                       "Found Delphi HTML Files, Performing Coverage"
+                         << std::endl,
+                       this->Quiet);
     cov.LoadCoverageData(files);
-    }
-  else
-    {
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find Delphi coverage files: " << coverageFile
-      << std::endl, this->Quiet);
-    }
+                       " Cannot find Delphi coverage files: " << coverageFile
+                                                              << std::endl,
+                       this->Quiet);
+  }
   return static_cast<int>(cont->TotalCoverage.size());
 }
 
 int cmCTestCoverageHandler::HandleBlanketJSCoverage(
   cmCTestCoverageHandlerContainer* cont)
-  {
-  cmParseBlanketJSCoverage cov =
-   cmParseBlanketJSCoverage(*cont, this->CTest);
-  std::string SourceDir
-    = this->CTest->GetCTestConfiguration("SourceDirectory");
+{
+  cmParseBlanketJSCoverage cov = cmParseBlanketJSCoverage(*cont, this->CTest);
+  std::string SourceDir =
+    this->CTest->GetCTestConfiguration("SourceDirectory");
 
-  //Look for something other than output.json, still JSON extension.
-  std::string coverageFile = SourceDir+ "/*.json";
+  // Look for something other than output.json, still JSON extension.
+  std::string coverageFile = SourceDir + "/*.json";
   cmsys::Glob g;
   std::vector<std::string> files;
   std::vector<std::string> blanketFiles;
   g.FindFiles(coverageFile);
-  files=g.GetFiles();
+  files = g.GetFiles();
   // Ensure that the JSON files found are the result of the
   // Blanket.js output. Check for the "node-jscoverage"
   // string on the second line
   std::string line;
-  for(unsigned int fileEntry=0;fileEntry<files.size();fileEntry++)
-    {
+  for (unsigned int fileEntry = 0; fileEntry < files.size(); fileEntry++) {
     cmsys::ifstream in(files[fileEntry].c_str());
     cmSystemTools::GetLineFromStream(in, line);
     cmSystemTools::GetLineFromStream(in, line);
-    if (line.find("node-jscoverage") != line.npos)
-      {
+    if (line.find("node-jscoverage") != line.npos) {
       blanketFiles.push_back(files[fileEntry]);
-      }
     }
+  }
   //  Take all files with the node-jscoverage string and parse those
-  if (!blanketFiles.empty())
-    {
+  if (!blanketFiles.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Found BlanketJS output JSON, Performing Coverage" << std::endl,
-      this->Quiet);
+                       "Found BlanketJS output JSON, Performing Coverage"
+                         << std::endl,
+                       this->Quiet);
     cov.LoadCoverageData(files);
-    }
-  else
-    {
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-       " Cannot find BlanketJS coverage files: " << coverageFile
-       << std::endl, this->Quiet);
-    }
-  return static_cast<int>(cont->TotalCoverage.size());
+  } else {
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
+      " Cannot find BlanketJS coverage files: " << coverageFile << std::endl,
+      this->Quiet);
   }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
 int cmCTestCoverageHandler::HandleGCovCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
-  std::string gcovCommand
-    = this->CTest->GetCTestConfiguration("CoverageCommand");
-  if (gcovCommand.empty())
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Could not find gcov." << std::endl);
+  std::string gcovCommand =
+    this->CTest->GetCTestConfiguration("CoverageCommand");
+  if (gcovCommand.empty()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Could not find gcov."
+                 << std::endl);
     return 0;
-    }
-  std::string gcovExtraFlags
-    = this->CTest->GetCTestConfiguration("CoverageExtraFlags");
+  }
+  std::string gcovExtraFlags =
+    this->CTest->GetCTestConfiguration("CoverageExtraFlags");
 
   // Immediately skip to next coverage option since codecov is only for Intel
   // compiler
-  if ( gcovCommand == "codecov" )
-    {
+  if (gcovCommand == "codecov") {
     return 0;
-    }
+  }
 
   // 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 = "^(.*)reating [`'](.*\\.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());
@@ -1081,14 +975,13 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
   this->FindGCovFiles(files);
   std::vector<std::string>::iterator it;
 
-  if (files.empty())
-    {
+  if (files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find any GCov coverage files."
-      << std::endl, this->Quiet);
+                       " Cannot find any GCov coverage files." << std::endl,
+                       this->Quiet);
     // No coverage files is a valid thing, so the exit code is 0
     return 0;
-    }
+  }
 
   std::string testingDir = this->CTest->GetBinaryDir() + "/Testing";
   std::string tempDir = testingDir + "/CoverageInfo";
@@ -1101,7 +994,8 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
   std::set<std::string> missingFiles;
 
   std::string actualSourceFile = "";
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT,
     "   Processing coverage (each . represents one file):" << std::endl,
     this->Quiet);
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
@@ -1115,259 +1009,216 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
   // These are binary files that you give as input to gcov so that it will
   // give us text output we can analyze to summarize coverage.
   //
-  for ( it = files.begin(); it != files.end(); ++ it )
-    {
+  for (it = files.begin(); it != files.end(); ++it) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "." << std::flush,
-      this->Quiet);
+                       this->Quiet);
 
     // Call gcov to get coverage data for this *.gcda file:
     //
     std::string fileDir = cmSystemTools::GetFilenamePath(*it);
-    std::string command = "\"" + gcovCommand + "\" " +
-      gcovExtraFlags + " " +
-      "-o \"" + fileDir + "\" " +
-      "\"" + *it + "\"";
+    std::string command = "\"" + gcovCommand + "\" " + gcovExtraFlags + " " +
+      "-o \"" + fileDir + "\" " + "\"" + *it + "\"";
 
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, command.c_str()
-      << std::endl, this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       command.c_str() << std::endl, this->Quiet);
 
     std::string output = "";
     std::string errors = "";
     int retVal = 0;
     *cont->OFS << "* Run coverage for: " << fileDir << std::endl;
     *cont->OFS << "  Command: " << command << std::endl;
-    int res = this->CTest->RunCommand(command.c_str(), &output, &errors,
-      &retVal, tempDir.c_str(), 0 /*this->TimeOut*/);
+    int res =
+      this->CTest->RunCommand(command.c_str(), &output, &errors, &retVal,
+                              tempDir.c_str(), 0 /*this->TimeOut*/);
 
     *cont->OFS << "  Output: " << output << std::endl;
     *cont->OFS << "  Errors: " << errors << std::endl;
-    if ( ! res )
-      {
+    if (!res) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Problem running coverage on file: " << *it << std::endl);
+                 "Problem running coverage on file: " << *it << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Command produced error: " << errors << std::endl);
-      cont->Error ++;
+                 "Command produced error: " << errors << std::endl);
+      cont->Error++;
       continue;
-      }
-    if ( retVal != 0 )
-      {
+    }
+    if (retVal != 0) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "Coverage command returned: "
-        << retVal << " while processing: " << *it << std::endl);
+                   << retVal << " while processing: " << *it << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Command produced error: " << cont->Error << std::endl);
-      }
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                 "Command produced error: " << cont->Error << std::endl);
+    }
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
       "--------------------------------------------------------------"
-      << std::endl
-      << output << std::endl
-      << "--------------------------------------------------------------"
-      << std::endl, this->Quiet);
+        << std::endl
+        << output << std::endl
+        << "--------------------------------------------------------------"
+        << std::endl,
+      this->Quiet);
 
     std::vector<std::string> lines;
     std::vector<std::string>::iterator line;
 
     cmSystemTools::Split(output.c_str(), lines);
 
-    for ( line = lines.begin(); line != lines.end(); ++line)
-      {
+    for (line = lines.begin(); line != lines.end(); ++line) {
       std::string sourceFile;
       std::string gcovFile;
 
-      cmCTestOptionalLog(this->CTest, DEBUG, "Line: [" << *line << "]"
-        << std::endl, this->Quiet);
+      cmCTestOptionalLog(this->CTest, DEBUG,
+                         "Line: [" << *line << "]" << std::endl, this->Quiet);
 
-      if (line->empty())
-        {
+      if (line->empty()) {
         // Ignore empty line; probably style 2
-        }
-      else if ( st1re1.find(line->c_str()) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st1re1.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 1;
-          }
-        if ( gcovStyle != 1 )
-          {
+        }
+        if (gcovStyle != 1) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e1"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         actualSourceFile = "";
         sourceFile = st1re1.match(2);
-        }
-      else if ( st1re2.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st1re2.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 1;
-          }
-        if ( gcovStyle != 1 )
-          {
+        }
+        if (gcovStyle != 1) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e2"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         gcovFile = st1re2.match(1);
-        }
-      else if ( st2re1.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st2re1.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e3"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         actualSourceFile = "";
         sourceFile = st2re1.match(1);
-        }
-      else if ( st2re2.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st2re2.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e4"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
         }
-      else if ( st2re3.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st2re3.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e5"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         gcovFile = st2re3.match(2);
-        }
-      else if ( st2re4.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+      } else if (st2re4.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e6"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
-
-        cmCTestOptionalLog(this->CTest, WARNING, "Warning: " << st2re4.match(1)
-          << " had unexpected EOF" << std::endl, this->Quiet);
         }
-      else if ( st2re5.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+
+        cmCTestOptionalLog(this->CTest, WARNING,
+                           "Warning: " << st2re4.match(1)
+                                       << " had unexpected EOF" << std::endl,
+                           this->Quiet);
+      } else if (st2re5.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e7"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         cmCTestOptionalLog(this->CTest, WARNING, "Warning: Cannot open file: "
-          << st2re5.match(1) << std::endl, this->Quiet);
-        }
-      else if ( st2re6.find(line->c_str() ) )
-        {
-        if ( gcovStyle == 0 )
-          {
+                             << st2re5.match(1) << std::endl,
+                           this->Quiet);
+      } else if (st2re6.find(line->c_str())) {
+        if (gcovStyle == 0) {
           gcovStyle = 2;
-          }
-        if ( gcovStyle != 2 )
-          {
+        }
+        if (gcovStyle != 2) {
           cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output style e8"
-            << std::endl);
-          cont->Error ++;
+                       << std::endl);
+          cont->Error++;
           break;
-          }
+        }
 
         cmCTestOptionalLog(this->CTest, WARNING, "Warning: File: "
-          << st2re6.match(1)
-          << " is newer than " << st2re6.match(2) << std::endl, this->Quiet);
-        }
-      else
-        {
+                             << st2re6.match(1) << " is newer than "
+                             << st2re6.match(2) << std::endl,
+                           this->Quiet);
+      } else {
         // gcov 4.7 can have output lines saying "No executable lines" and
         // "Removing 'filename.gcov'"... Don't log those as "errors."
-        if(*line != "No executable lines" &&
-           !cmSystemTools::StringStartsWith(line->c_str(), "Removing "))
-          {
-          cmCTestLog(this->CTest, ERROR_MESSAGE,
-            "Unknown gcov output line: [" << *line << "]"
-            << std::endl);
-          cont->Error ++;
-          //abort();
-          }
+        if (*line != "No executable lines" &&
+            !cmSystemTools::StringStartsWith(line->c_str(), "Removing ")) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE, "Unknown gcov output line: ["
+                       << *line << "]" << std::endl);
+          cont->Error++;
+          // abort();
         }
-
+      }
 
       // If the last line of gcov output gave us a valid value for gcovFile,
       // and we have an actualSourceFile, then insert a (or add to existing)
       // SingleFileCoverageVector for actualSourceFile:
       //
-      if ( !gcovFile.empty() && !actualSourceFile.empty() )
-        {
-        cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec
-          = cont->TotalCoverage[actualSourceFile];
+      if (!gcovFile.empty() && !actualSourceFile.empty()) {
+        cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec =
+          cont->TotalCoverage[actualSourceFile];
 
         cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          "   in gcovFile: " << gcovFile << std::endl, this->Quiet);
+                           "   in gcovFile: " << gcovFile << std::endl,
+                           this->Quiet);
 
         cmsys::ifstream ifile(gcovFile.c_str());
-        if ( ! ifile )
-          {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open file: "
-            << gcovFile << std::endl);
-          }
-        else
-          {
+        if (!ifile) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Cannot open file: " << gcovFile << std::endl);
+        } else {
           long cnt = -1;
           std::string nl;
-          while ( cmSystemTools::GetLineFromStream(ifile, nl) )
-            {
-            cnt ++;
+          while (cmSystemTools::GetLineFromStream(ifile, nl)) {
+            cnt++;
 
-            //TODO: Handle gcov 3.0 non-coverage lines
+            // TODO: Handle gcov 3.0 non-coverage lines
 
             // Skip empty lines
-            if (nl.empty())
-              {
+            if (nl.empty()) {
               continue;
-              }
+            }
 
             // Skip unused lines
-            if ( nl.size() < 12 )
-              {
+            if (nl.size() < 12) {
               continue;
-              }
+            }
 
             // Read the coverage count from the beginning of the gcov output
             // line
@@ -1378,96 +1229,86 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
             // output line
             std::string lineNumber = nl.substr(10, 5);
 
-            int lineIdx = atoi(lineNumber.c_str())-1;
-            if ( lineIdx >= 0 )
-              {
-              while ( vec.size() <= static_cast<size_t>(lineIdx) )
-                {
+            int lineIdx = atoi(lineNumber.c_str()) - 1;
+            if (lineIdx >= 0) {
+              while (vec.size() <= static_cast<size_t>(lineIdx)) {
                 vec.push_back(-1);
-                }
+              }
 
               // Initially all entries are -1 (not used). If we get coverage
               // information, increment it to 0 first.
-              if ( vec[lineIdx] < 0 )
-                {
-                if ( cov > 0 || prefix.find("#") != prefix.npos )
-                  {
+              if (vec[lineIdx] < 0) {
+                if (cov > 0 || prefix.find("#") != prefix.npos) {
                   vec[lineIdx] = 0;
-                  }
                 }
+              }
 
               vec[lineIdx] += cov;
-              }
             }
           }
-
-        actualSourceFile = "";
         }
 
+        actualSourceFile = "";
+      }
 
-      if ( !sourceFile.empty() && actualSourceFile.empty() )
-        {
+      if (!sourceFile.empty() && actualSourceFile.empty()) {
         gcovFile = "";
 
         // Is it in the source dir or the binary dir?
         //
-        if ( IsFileInDir(sourceFile, cont->SourceDir) )
-          {
+        if (IsFileInDir(sourceFile, cont->SourceDir)) {
           cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-            "   produced s: " << sourceFile << std::endl, this->Quiet);
+                             "   produced s: " << sourceFile << std::endl,
+                             this->Quiet);
           *cont->OFS << "  produced in source dir: " << sourceFile
-            << std::endl;
-          actualSourceFile
-            = cmSystemTools::CollapseFullPath(sourceFile);
-          }
-        else if ( IsFileInDir(sourceFile, cont->BinaryDir) )
-          {
+                     << std::endl;
+          actualSourceFile = cmSystemTools::CollapseFullPath(sourceFile);
+        } else if (IsFileInDir(sourceFile, cont->BinaryDir)) {
           cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-            "   produced b: " << sourceFile << std::endl, this->Quiet);
+                             "   produced b: " << sourceFile << std::endl,
+                             this->Quiet);
           *cont->OFS << "  produced in binary dir: " << sourceFile
-            << std::endl;
-          actualSourceFile
-            = cmSystemTools::CollapseFullPath(sourceFile);
-          }
+                     << std::endl;
+          actualSourceFile = cmSystemTools::CollapseFullPath(sourceFile);
+        }
 
-        if ( actualSourceFile.empty() )
-          {
-          if ( missingFiles.find(sourceFile) == missingFiles.end() )
-            {
+        if (actualSourceFile.empty()) {
+          if (missingFiles.find(sourceFile) == missingFiles.end()) {
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              "Something went wrong" << std::endl, this->Quiet);
+                               "Something went wrong" << std::endl,
+                               this->Quiet);
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              "Cannot find file: ["
-              << sourceFile << "]" << std::endl, this->Quiet);
+                               "Cannot find file: [" << sourceFile << "]"
+                                                     << std::endl,
+                               this->Quiet);
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              " in source dir: ["
-              << cont->SourceDir << "]"
-              << std::endl, this->Quiet);
+                               " in source dir: [" << cont->SourceDir << "]"
+                                                   << std::endl,
+                               this->Quiet);
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              " or binary dir: ["
-              << cont->BinaryDir.size() << "]"
-              << std::endl, this->Quiet);
+                               " or binary dir: [" << cont->BinaryDir.size()
+                                                   << "]" << std::endl,
+                               this->Quiet);
             *cont->OFS << "  Something went wrong. Cannot find file: "
-              << sourceFile
-              << " in source dir: " << cont->SourceDir
-              << " or binary dir: " << cont->BinaryDir << std::endl;
+                       << sourceFile << " in source dir: " << cont->SourceDir
+                       << " or binary dir: " << cont->BinaryDir << std::endl;
 
             missingFiles.insert(sourceFile);
-            }
           }
         }
       }
+    }
 
     file_count++;
 
-    if ( file_count % 50 == 0 )
-      {
-      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, " processed: "
-        << file_count
-        << " out of " << files.size() << std::endl, this->Quiet);
+    if (file_count % 50 == 0) {
+      cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+                         " processed: " << file_count << " out of "
+                                        << files.size() << std::endl,
+                         this->Quiet);
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
-      }
     }
+  }
 
   cmSystemTools::ChangeDirectory(currentDirectory);
   return file_count;
@@ -1476,46 +1317,44 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
 int cmCTestCoverageHandler::HandleLCovCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
-  std::string lcovCommand
-    = this->CTest->GetCTestConfiguration("CoverageCommand");
-  std::string lcovExtraFlags
-    = this->CTest->GetCTestConfiguration("CoverageExtraFlags");
-  if ( lcovCommand != "codecov" )
-    {
+  std::string lcovCommand =
+    this->CTest->GetCTestConfiguration("CoverageCommand");
+  std::string lcovExtraFlags =
+    this->CTest->GetCTestConfiguration("CoverageExtraFlags");
+  if (lcovCommand != "codecov") {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-               " Not a valid Intel Coverage command."
-               << std::endl, this->Quiet);
+                       " Not a valid Intel Coverage command." << std::endl,
+                       this->Quiet);
     return 0;
-    }
+  }
   // There is only percentage completed output from LCOV
   std::string st2lcovOutputRex3 = "[0-9]+%";
   cmsys::RegularExpression st2re3(st2lcovOutputRex3.c_str());
 
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " This is coverage command: " << lcovCommand
-    << std::endl, this->Quiet);
+                     " This is coverage command: " << lcovCommand << std::endl,
+                     this->Quiet);
 
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " These are coverage command flags: " << lcovExtraFlags
-    << std::endl, this->Quiet);
+                     " These are coverage command flags: " << lcovExtraFlags
+                                                           << std::endl,
+                     this->Quiet);
 
   std::vector<std::string> files;
-  if (!this->FindLCovFiles(files))
-    {
+  if (!this->FindLCovFiles(files)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Error while finding LCov files.\n");
     return 0;
-    }
+  }
   std::vector<std::string>::iterator it;
 
-  if (files.empty())
-    {
+  if (files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find any LCov coverage files."
-      << std::endl, this->Quiet);
+                       " Cannot find any LCov coverage files." << std::endl,
+                       this->Quiet);
     // No coverage files is a valid thing, so the exit code is 0
     return 0;
-    }
+  }
   std::string testingDir = this->CTest->GetBinaryDir();
   std::string tempDir = testingDir;
   std::string currentDirectory = cmSystemTools::GetCurrentWorkingDirectory();
@@ -1523,7 +1362,8 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
   std::set<std::string> missingFiles;
 
   std::string actualSourceFile = "";
-  cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_OUTPUT,
     "   Processing coverage (each . represents one file):" << std::endl,
     this->Quiet);
   cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
@@ -1535,67 +1375,65 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
 
   // In intel compiler we have to call codecov only once in each executable
   // directory. It collects all *.dyn files to generate .dpi file.
-  for ( it = files.begin(); it != files.end(); ++ it )
-    {
+  for (it = files.begin(); it != files.end(); ++it) {
     cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "." << std::flush,
-      this->Quiet);
+                       this->Quiet);
     std::string fileDir = cmSystemTools::GetFilenamePath(*it);
     cmSystemTools::ChangeDirectory(fileDir);
-    std::string command = "\"" + lcovCommand + "\" " +
-      lcovExtraFlags + " ";
+    std::string command = "\"" + lcovCommand + "\" " + lcovExtraFlags + " ";
 
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Current coverage dir: " << fileDir << std::endl, this->Quiet);
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, command.c_str()
-      << std::endl, this->Quiet);
+                       "Current coverage dir: " << fileDir << std::endl,
+                       this->Quiet);
+    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                       command.c_str() << std::endl, this->Quiet);
 
     std::string output = "";
     std::string errors = "";
     int retVal = 0;
     *cont->OFS << "* Run coverage for: " << fileDir << std::endl;
     *cont->OFS << "  Command: " << command << std::endl;
-    int res = this->CTest->RunCommand(command.c_str(), &output, &errors,
-                &retVal, fileDir.c_str(), 0 /*this->TimeOut*/);
+    int res =
+      this->CTest->RunCommand(command.c_str(), &output, &errors, &retVal,
+                              fileDir.c_str(), 0 /*this->TimeOut*/);
 
     *cont->OFS << "  Output: " << output << std::endl;
     *cont->OFS << "  Errors: " << errors << std::endl;
-    if ( ! res )
-      {
+    if (!res) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Problem running coverage on file: " << *it << std::endl);
+                 "Problem running coverage on file: " << *it << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Command produced error: " << errors << std::endl);
-      cont->Error ++;
+                 "Command produced error: " << errors << std::endl);
+      cont->Error++;
       continue;
-      }
-    if ( retVal != 0 )
-      {
+    }
+    if (retVal != 0) {
       cmCTestLog(this->CTest, ERROR_MESSAGE, "Coverage command returned: "
-        << retVal << " while processing: " << *it << std::endl);
+                   << retVal << " while processing: " << *it << std::endl);
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Command produced error: " << cont->Error << std::endl);
-      }
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                 "Command produced error: " << cont->Error << std::endl);
+    }
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
       "--------------------------------------------------------------"
-      << std::endl
-      << output << std::endl
-      << "--------------------------------------------------------------"
-      << std::endl, this->Quiet);
+        << std::endl
+        << output << std::endl
+        << "--------------------------------------------------------------"
+        << std::endl,
+      this->Quiet);
 
     std::vector<std::string> lines;
     std::vector<std::string>::iterator line;
 
     cmSystemTools::Split(output.c_str(), lines);
 
-    for ( line = lines.begin(); line != lines.end(); ++line)
-      {
+    for (line = lines.begin(); line != lines.end(); ++line) {
       std::string sourceFile;
       std::string lcovFile;
 
-      if (line->empty())
-        {
+      if (line->empty()) {
         // Ignore empty line
-        }
+      }
       // Look for LCOV files in binary directory
       // Intel Compiler creates a CodeCoverage dir for each subfolder and
       // each subfolder has LCOV files
@@ -1608,89 +1446,84 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
       std::string daGlob;
       daGlob = dir;
       daGlob += "/*.LCOV";
-      cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+      cmCTestOptionalLog(
+        this->CTest, HANDLER_VERBOSE_OUTPUT,
         "   looking for LCOV files in: " << daGlob << std::endl, this->Quiet);
       gl.FindFiles(daGlob);
       // Keep a list of all LCOV files
       lcovFiles.insert(lcovFiles.end(), gl.GetFiles().begin(),
                        gl.GetFiles().end());
 
-      for(std::vector<std::string>::iterator a = lcovFiles.begin();
-          a != lcovFiles.end(); ++a)
-        {
+      for (std::vector<std::string>::iterator a = lcovFiles.begin();
+           a != lcovFiles.end(); ++a) {
         lcovFile = *a;
         cmsys::ifstream srcead(lcovFile.c_str());
-        if ( ! srcead )
-          {
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open file: "
-                     << lcovFile << std::endl);
-          }
+        if (!srcead) {
+          cmCTestLog(this->CTest, ERROR_MESSAGE,
+                     "Cannot open file: " << lcovFile << std::endl);
+        }
         std::string srcname;
 
         int success = cmSystemTools::GetLineFromStream(srcead, srcname);
-        if ( !success )
-          {
+        if (!success) {
           cmCTestLog(this->CTest, ERROR_MESSAGE,
-                     "Error while parsing lcov file '" << lcovFile << "':"
-                     << " No source file name found!" << std::endl);
+                     "Error while parsing lcov file '"
+                       << lcovFile << "':"
+                       << " No source file name found!" << std::endl);
           return 0;
-          }
+        }
         srcname = srcname.substr(18);
         // We can directly read found LCOV files to determine the source
         // files
         sourceFile = srcname;
         actualSourceFile = srcname;
 
-        for(std::vector<std::string>::iterator t = lcovFiles.begin();
-            t != lcovFiles.end(); ++t)
-          {
+        for (std::vector<std::string>::iterator t = lcovFiles.begin();
+             t != lcovFiles.end(); ++t) {
           cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-            "Found LCOV File: " << *t << std::endl, this->Quiet);
-          }
-        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "SourceFile: "
-          << sourceFile << std::endl, this->Quiet);
-        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "lCovFile: "
-        << lcovFile << std::endl, this->Quiet);
+                             "Found LCOV File: " << *t << std::endl,
+                             this->Quiet);
+        }
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "SourceFile: " << sourceFile << std::endl,
+                           this->Quiet);
+        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                           "lCovFile: " << lcovFile << std::endl, this->Quiet);
 
         // If we have some LCOV files to process
-        if ( !lcovFile.empty() && !actualSourceFile.empty() )
-          {
-          cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec
-            = cont->TotalCoverage[actualSourceFile];
+        if (!lcovFile.empty() && !actualSourceFile.empty()) {
+          cmCTestCoverageHandlerContainer::SingleFileCoverageVector& vec =
+            cont->TotalCoverage[actualSourceFile];
 
           cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-            "   in lcovFile: " << lcovFile << std::endl, this->Quiet);
+                             "   in lcovFile: " << lcovFile << std::endl,
+                             this->Quiet);
 
           cmsys::ifstream ifile(lcovFile.c_str());
-          if ( ! ifile )
-            {
-            cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open file: "
-                       << lcovFile << std::endl);
-            }
-          else
-            {
+          if (!ifile) {
+            cmCTestLog(this->CTest, ERROR_MESSAGE,
+                       "Cannot open file: " << lcovFile << std::endl);
+          } else {
             long cnt = -1;
             std::string nl;
 
             // Skip the first line
             cmSystemTools::GetLineFromStream(ifile, nl);
             cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-              "File is ready, start reading." << std::endl, this->Quiet);
-            while ( cmSystemTools::GetLineFromStream(ifile, nl) )
-              {
-              cnt ++;
+                               "File is ready, start reading." << std::endl,
+                               this->Quiet);
+            while (cmSystemTools::GetLineFromStream(ifile, nl)) {
+              cnt++;
 
               // Skip empty lines
-              if (nl.empty())
-                {
+              if (nl.empty()) {
                 continue;
-                }
+              }
 
               // Skip unused lines
-              if ( nl.size() < 12 )
-                {
+              if (nl.size() < 12) {
                 continue;
-                }
+              }
 
               // Read the coverage count from the beginning of the lcov
               // output line
@@ -1701,44 +1534,40 @@ int cmCTestCoverageHandler::HandleLCovCoverage(
               // lcov output line
               std::string lineNumber = nl.substr(17, 7);
 
-              int lineIdx = atoi(lineNumber.c_str())-1;
-              if ( lineIdx >= 0 )
-                {
-                while ( vec.size() <= static_cast<size_t>(lineIdx) )
-                  {
+              int lineIdx = atoi(lineNumber.c_str()) - 1;
+              if (lineIdx >= 0) {
+                while (vec.size() <= static_cast<size_t>(lineIdx)) {
                   vec.push_back(-1);
-                  }
+                }
 
                 // Initially all entries are -1 (not used). If we get coverage
                 // information, increment it to 0 first.
-                if ( vec[lineIdx] < 0 )
-                  {
-                  if ( cov > 0 || prefix.find("#") != prefix.npos )
-                    {
+                if (vec[lineIdx] < 0) {
+                  if (cov > 0 || prefix.find("#") != prefix.npos) {
                     vec[lineIdx] = 0;
-                    }
                   }
+                }
 
                 vec[lineIdx] += cov;
-                }
               }
             }
+          }
 
           actualSourceFile = "";
-          }
         }
       }
+    }
 
     file_count++;
 
-    if ( file_count % 50 == 0 )
-      {
+    if (file_count % 50 == 0) {
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT,
-        " processed: " << file_count << " out of " << files.size()
-        << std::endl, this->Quiet);
+                         " processed: " << file_count << " out of "
+                                        << files.size() << std::endl,
+                         this->Quiet);
       cmCTestOptionalLog(this->CTest, HANDLER_OUTPUT, "    ", this->Quiet);
-      }
     }
+  }
 
   cmSystemTools::ChangeDirectory(currentDirectory);
   return file_count;
@@ -1750,18 +1579,17 @@ void cmCTestCoverageHandler::FindGCovFiles(std::vector<std::string>& files)
   gl.RecurseOn();
   gl.RecurseThroughSymlinksOff();
 
-  for(LabelMapType::const_iterator lmi = this->TargetDirs.begin();
-      lmi != this->TargetDirs.end(); ++lmi)
-    {
+  for (LabelMapType::const_iterator lmi = this->TargetDirs.begin();
+       lmi != this->TargetDirs.end(); ++lmi) {
     // Skip targets containing no interesting labels.
-    if(!this->IntersectsFilter(lmi->second))
-      {
+    if (!this->IntersectsFilter(lmi->second)) {
       continue;
-      }
+    }
 
     // Coverage files appear next to their object files in the target
     // support directory.
-    cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+    cmCTestOptionalLog(
+      this->CTest, HANDLER_VERBOSE_OUTPUT,
       "   globbing for coverage in: " << lmi->first << std::endl, this->Quiet);
     std::string daGlob = lmi->first;
     daGlob += "/*.da";
@@ -1771,7 +1599,7 @@ void cmCTestCoverageHandler::FindGCovFiles(std::vector<std::string>& files)
     daGlob += "/*.gcda";
     gl.FindFiles(daGlob);
     files.insert(files.end(), gl.GetFiles().begin(), gl.GetFiles().end());
-    }
+  }
 }
 
 bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
@@ -1782,20 +1610,17 @@ bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
   gl.RecurseThroughSymlinksOff();
   std::string prevBinaryDir;
   std::string buildDir = this->CTest->GetCTestConfiguration("BuildDirectory");
-  if (cmSystemTools::ChangeDirectory(buildDir))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Error changing directory to " << buildDir << std::endl);
+  if (cmSystemTools::ChangeDirectory(buildDir)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error changing directory to "
+                 << buildDir << std::endl);
     return false;
-    }
+  }
 
   // Run profmerge to merge all *.dyn files into dpi files
-  if (!cmSystemTools::RunSingleCommand("profmerge"))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Error while running profmerge.\n");
+  if (!cmSystemTools::RunSingleCommand("profmerge")) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error while running profmerge.\n");
     return false;
-    }
+  }
 
   prevBinaryDir = cmSystemTools::GetCurrentWorkingDirectory().c_str();
 
@@ -1804,16 +1629,16 @@ bool cmCTestCoverageHandler::FindLCovFiles(std::vector<std::string>& files)
   daGlob = prevBinaryDir;
   daGlob += "/*.dpi";
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "   looking for dpi files in: " << daGlob << std::endl, this->Quiet);
-  if (!gl.FindFiles(daGlob))
-    {
+                     "   looking for dpi files in: " << daGlob << std::endl,
+                     this->Quiet);
+  if (!gl.FindFiles(daGlob)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Error while finding files matching " << daGlob << std::endl);
     return false;
-    }
+  }
   files.insert(files.end(), gl.GetFiles().begin(), gl.GetFiles().end());
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "Now searching in: " << daGlob << std::endl, this->Quiet);
+                     "Now searching in: " << daGlob << std::endl, this->Quiet);
   return true;
 }
 
@@ -1827,14 +1652,14 @@ int cmCTestCoverageHandler::HandleTracePyCoverage(
   gl.FindFiles(daGlob);
   std::vector<std::string> files = gl.GetFiles();
 
-  if (files.empty())
-    {
+  if (files.empty()) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " Cannot find any Python Trace.py coverage files."
-      << std::endl, this->Quiet);
+                       " Cannot find any Python Trace.py coverage files."
+                         << std::endl,
+                       this->Quiet);
     // No coverage files is a valid thing, so the exit code is 0
     return 0;
-    }
+  }
 
   std::string testingDir = this->CTest->GetBinaryDir() + "/Testing";
   std::string tempDir = testingDir + "/CoverageInfo";
@@ -1846,319 +1671,276 @@ int cmCTestCoverageHandler::HandleTracePyCoverage(
 
   std::vector<std::string>::iterator fileIt;
   int file_count = 0;
-  for ( fileIt = files.begin(); fileIt != files.end(); ++ fileIt )
-    {
+  for (fileIt = files.begin(); fileIt != files.end(); ++fileIt) {
     std::string fileName = this->FindFile(cont, *fileIt);
-    if ( fileName.empty() )
-      {
+    if (fileName.empty()) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
-        "Cannot find source Python file corresponding to: "
-        << *fileIt << std::endl);
+                 "Cannot find source Python file corresponding to: "
+                   << *fileIt << std::endl);
       continue;
-      }
+    }
 
-    std::string actualSourceFile
-      = cmSystemTools::CollapseFullPath(fileName);
+    std::string actualSourceFile = cmSystemTools::CollapseFullPath(fileName);
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "   Check coverage for file: " << actualSourceFile
-      << std::endl, this->Quiet);
-    cmCTestCoverageHandlerContainer::SingleFileCoverageVector* vec
-      = &cont->TotalCoverage[actualSourceFile];
+                       "   Check coverage for file: " << actualSourceFile
+                                                      << std::endl,
+                       this->Quiet);
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector* vec =
+      &cont->TotalCoverage[actualSourceFile];
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "   in file: " << *fileIt << std::endl, this->Quiet);
+                       "   in file: " << *fileIt << std::endl, this->Quiet);
     cmsys::ifstream ifile(fileIt->c_str());
-    if ( ! ifile )
-      {
-      cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open file: "
-        << *fileIt << std::endl);
-      }
-    else
-      {
+    if (!ifile) {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Cannot open file: " << *fileIt << std::endl);
+    } else {
       long cnt = -1;
       std::string nl;
-      while ( cmSystemTools::GetLineFromStream(ifile, nl) )
-        {
-        cnt ++;
+      while (cmSystemTools::GetLineFromStream(ifile, nl)) {
+        cnt++;
 
         // Skip empty lines
-        if (nl.empty())
-          {
+        if (nl.empty()) {
           continue;
-          }
+        }
 
         // Skip unused lines
-        if ( nl.size() < 12 )
-          {
+        if (nl.size() < 12) {
           continue;
-          }
+        }
 
         // Read the coverage count from the beginning of the Trace.py output
         // line
         std::string prefix = nl.substr(0, 6);
-        if ( prefix[5] != ' ' && prefix[5] != ':' )
-          {
+        if (prefix[5] != ' ' && prefix[5] != ':') {
           // This is a hack. We should really do something more elaborate
           prefix = nl.substr(0, 7);
-          if ( prefix[6] != ' ' && prefix[6] != ':' )
-            {
+          if (prefix[6] != ' ' && prefix[6] != ':') {
             prefix = nl.substr(0, 8);
-            if ( prefix[7] != ' ' && prefix[7] != ':' )
-              {
+            if (prefix[7] != ' ' && prefix[7] != ':') {
               cmCTestLog(this->CTest, ERROR_MESSAGE,
-                "Currently the limit is maximum coverage of 999999"
-                << std::endl);
-              }
+                         "Currently the limit is maximum coverage of 999999"
+                           << std::endl);
             }
           }
+        }
         int cov = atoi(prefix.c_str());
-        if ( prefix[prefix.size()-1] != ':' )
-          {
+        if (prefix[prefix.size() - 1] != ':') {
           // This line does not have ':' so no coverage here. That said,
           // Trace.py does not handle not covered lines versus comments etc.
           // So, this will be set to 0.
           cov = 0;
-          }
-        cmCTestOptionalLog(this->CTest, DEBUG, "Prefix: " << prefix
-          << " cov: " << cov
-          << std::endl, this->Quiet);
+        }
+        cmCTestOptionalLog(
+          this->CTest, DEBUG,
+          "Prefix: " << prefix << " cov: " << cov << std::endl, this->Quiet);
         // Read the line number starting at the 10th character of the gcov
         // output line
         long lineIdx = cnt;
-        if ( lineIdx >= 0 )
-          {
-          while ( vec->size() <=
-            static_cast<size_t>(lineIdx) )
-            {
+        if (lineIdx >= 0) {
+          while (vec->size() <= static_cast<size_t>(lineIdx)) {
             vec->push_back(-1);
-            }
+          }
           // Initially all entries are -1 (not used). If we get coverage
           // information, increment it to 0 first.
-          if ( (*vec)[lineIdx] < 0 )
-            {
-            if ( cov >= 0 )
-              {
+          if ((*vec)[lineIdx] < 0) {
+            if (cov >= 0) {
               (*vec)[lineIdx] = 0;
-              }
             }
-          (*vec)[lineIdx] += cov;
           }
+          (*vec)[lineIdx] += cov;
         }
       }
-    ++ file_count;
     }
+    ++file_count;
+  }
   cmSystemTools::ChangeDirectory(currentDirectory);
   return file_count;
 }
 
 std::string cmCTestCoverageHandler::FindFile(
-  cmCTestCoverageHandlerContainer* cont,
-  std::string fileName)
+  cmCTestCoverageHandlerContainer* cont, std::string fileName)
 {
-  std::string fileNameNoE
-    = cmSystemTools::GetFilenameWithoutLastExtension(fileName);
+  std::string fileNameNoE =
+    cmSystemTools::GetFilenameWithoutLastExtension(fileName);
   // First check in source and binary directory
   std::string fullName = cont->SourceDir + "/" + fileNameNoE + ".py";
-  if ( cmSystemTools::FileExists(fullName.c_str()) )
-    {
+  if (cmSystemTools::FileExists(fullName.c_str())) {
     return fullName;
-    }
+  }
   fullName = cont->BinaryDir + "/" + fileNameNoE + ".py";
-  if ( cmSystemTools::FileExists(fullName.c_str()) )
-    {
+  if (cmSystemTools::FileExists(fullName.c_str())) {
     return fullName;
-    }
+  }
   return "";
 }
 
 // This is a header put on each marked up source file
-namespace
-{
-  const char* bullseyeHelp[] =
-  {"    Coverage produced by bullseye covbr tool: ",
-   "      www.bullseye.com/help/ref_covbr.html",
-   "    * An arrow --> indicates incomplete coverage.",
-   "    * An X indicates a function that was invoked, a switch label that ",
-   "      was exercised, a try-block that finished, or an exception handler ",
-   "      that was invoked.",
-   "    * A T or F indicates a boolean decision that evaluated true or false,",
-   "      respectively.",
-   "    * A t or f indicates a boolean condition within a decision if the ",
-   "      condition evaluated true or false, respectively.",
-   "    * A k indicates a constant decision or condition.",
-   "    * The slash / means this probe is excluded from summary results. ",
-   0};
+namespace {
+const char* bullseyeHelp[] = {
+  "    Coverage produced by bullseye covbr tool: ",
+  "      www.bullseye.com/help/ref_covbr.html",
+  "    * An arrow --> indicates incomplete coverage.",
+  "    * An X indicates a function that was invoked, a switch label that ",
+  "      was exercised, a try-block that finished, or an exception handler ",
+  "      that was invoked.",
+  "    * A T or F indicates a boolean decision that evaluated true or false,",
+  "      respectively.",
+  "    * A t or f indicates a boolean condition within a decision if the ",
+  "      condition evaluated true or false, respectively.",
+  "    * A k indicates a constant decision or condition.",
+  "    * The slash / means this probe is excluded from summary results. ",
+  0
+};
 }
 
 int cmCTestCoverageHandler::RunBullseyeCoverageBranch(
   cmCTestCoverageHandlerContainer* cont,
-  std::set<std::string>& coveredFileNames,
-  std::vector<std::string>& files,
+  std::set<std::string>& coveredFileNames, std::vector<std::string>& files,
   std::vector<std::string>& filesFullPath)
 {
-  if(files.size() != filesFullPath.size())
-    {
+  if (files.size() != filesFullPath.size()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Files and full path files not the same size?:\n");
     return 0;
-    }
+  }
   // create the output stream for the CoverageLog-N.xml file
   cmGeneratedFileStream covLogFile;
   cmXMLWriter covLogXML(covLogFile);
   int logFileCount = 0;
-  if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
-    {
+  if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
     return -1;
-    }
+  }
   this->StartCoverageLogXML(covLogXML);
   // for each file run covbr on that file to get the coverage
   // information for that file
   std::string outputFile;
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "run covbr: " << std::endl, this->Quiet);
+                     "run covbr: " << std::endl, this->Quiet);
 
-  if(!this->RunBullseyeCommand(cont, "covbr", 0, outputFile))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covbr for." << "\n");
+  if (!this->RunBullseyeCommand(cont, "covbr", 0, outputFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covbr for."
+                 << "\n");
     return -1;
-    }
+  }
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    "covbr output in  " << outputFile << std::endl, this->Quiet);
+                     "covbr output in  " << outputFile << std::endl,
+                     this->Quiet);
   // open the output file
   cmsys::ifstream fin(outputFile.c_str());
-  if(!fin)
-    {
+  if (!fin) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Cannot open coverage file: " <<
-               outputFile << std::endl);
+               "Cannot open coverage file: " << outputFile << std::endl);
     return 0;
-    }
+  }
   std::map<std::string, std::string> fileMap;
   std::vector<std::string>::iterator fp = filesFullPath.begin();
-  for(std::vector<std::string>::iterator f =  files.begin();
-      f != files.end(); ++f, ++fp)
-    {
+  for (std::vector<std::string>::iterator f = files.begin(); f != files.end();
+       ++f, ++fp) {
     fileMap[*f] = *fp;
-    }
+  }
 
-  int count =0; // keep count of the number of files
+  int count = 0; // keep count of the number of files
   // Now parse each line from the bullseye cov log file
   std::string lineIn;
   bool valid = false; // are we in a valid output file
-  int line = 0; // line of the current file
+  int line = 0;       // line of the current file
   std::string file;
-  while(cmSystemTools::GetLineFromStream(fin, lineIn))
-    {
+  while (cmSystemTools::GetLineFromStream(fin, lineIn)) {
     bool startFile = false;
-    if(lineIn.size() > 1 && lineIn[lineIn.size()-1] == ':')
-      {
-      file = lineIn.substr(0, lineIn.size()-1);
-      if(coveredFileNames.find(file) != coveredFileNames.end())
-        {
+    if (lineIn.size() > 1 && lineIn[lineIn.size() - 1] == ':') {
+      file = lineIn.substr(0, lineIn.size() - 1);
+      if (coveredFileNames.find(file) != coveredFileNames.end()) {
         startFile = true;
-        }
       }
-    if(startFile)
-      {
+    }
+    if (startFile) {
       // if we are in a valid file close it because a new one started
-      if(valid)
-        {
+      if (valid) {
         covLogXML.EndElement(); // Report
         covLogXML.EndElement(); // File
-        }
+      }
       // only allow 100 files in each log file
-      if ( count != 0 && count % 100 == 0 )
-        {
+      if (count != 0 && count % 100 == 0) {
         cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          "start a new log file: " << count << std::endl, this->Quiet);
+                           "start a new log file: " << count << std::endl,
+                           this->Quiet);
         this->EndCoverageLogXML(covLogXML);
         this->EndCoverageLogFile(covLogFile, logFileCount);
-        logFileCount ++;
-        if ( !this->StartCoverageLogFile(covLogFile, logFileCount) )
-          {
+        logFileCount++;
+        if (!this->StartCoverageLogFile(covLogFile, logFileCount)) {
           return -1;
-          }
+        }
         this->StartCoverageLogXML(covLogXML);
         count++; // move on one
-        }
-      std::map<std::string, std::string>::iterator
-        i = fileMap.find(file);
+      }
+      std::map<std::string, std::string>::iterator i = fileMap.find(file);
       // if the file should be covered write out the header for that file
-      if(i != fileMap.end())
-        {
+      if (i != fileMap.end()) {
         // we have a new file so count it in the output
         count++;
         cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          "Produce coverage for file: " << file << " " << count
-          << std::endl, this->Quiet);
+                           "Produce coverage for file: " << file << " "
+                                                         << count << std::endl,
+                           this->Quiet);
         // start the file output
         covLogXML.StartElement("File");
         covLogXML.Attribute("Name", i->first);
-        covLogXML.Attribute("FullPath",
-          this->CTest->GetShortPathToFile(i->second.c_str()));
+        covLogXML.Attribute(
+          "FullPath", this->CTest->GetShortPathToFile(i->second.c_str()));
         covLogXML.StartElement("Report");
         // write the bullseye header
-        line =0;
-        for(int k =0; bullseyeHelp[k] != 0; ++k)
-          {
+        line = 0;
+        for (int k = 0; bullseyeHelp[k] != 0; ++k) {
           covLogXML.StartElement("Line");
           covLogXML.Attribute("Number", line);
           covLogXML.Attribute("Count", -1);
           covLogXML.Content(bullseyeHelp[k]);
           covLogXML.EndElement(); // Line
           line++;
-          }
-        valid = true; // we are in a valid file section
         }
-      else
-        {
+        valid = true; // we are in a valid file section
+      } else {
         // this is not a file that we want coverage for
         valid = false;
-        }
       }
+    }
     // we are not at a start file, and we are in a valid file output the line
-    else if(valid)
-      {
+    else if (valid) {
       covLogXML.StartElement("Line");
       covLogXML.Attribute("Number", line);
       covLogXML.Attribute("Count", -1);
       covLogXML.Content(lineIn);
       covLogXML.EndElement(); // Line
       line++;
-      }
     }
+  }
   // if we ran out of lines a valid file then close that file
-  if(valid)
-    {
+  if (valid) {
     covLogXML.EndElement(); // Report
     covLogXML.EndElement(); // File
-    }
+  }
   this->EndCoverageLogXML(covLogXML);
   this->EndCoverageLogFile(covLogFile, logFileCount);
   return 1;
 }
 
 int cmCTestCoverageHandler::RunBullseyeCommand(
-  cmCTestCoverageHandlerContainer* cont,
-  const char* cmd,
-  const char* arg,
+  cmCTestCoverageHandlerContainer* cont, const char* cmd, const char* arg,
   std::string& outputFile)
 {
   std::string program = cmSystemTools::FindProgram(cmd);
-  if(program.empty())
-    {
+  if (program.empty()) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot find :" << cmd << "\n");
     return 0;
-    }
-  if(arg)
-    {
+  }
+  if (arg) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Run : " << program << " " << arg << "\n", this->Quiet);
-    }
-  else
-    {
+                       "Run : " << program << " " << arg << "\n", this->Quiet);
+  } else {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      "Run : " << program << "\n", this->Quiet);
-    }
+                       "Run : " << program << "\n", this->Quiet);
+  }
   // create a process object and start it
   cmCTestRunProcess runCoverageSrc;
   runCoverageSrc.SetCommand(program.c_str());
@@ -2172,14 +1954,13 @@ int cmCTestCoverageHandler::RunBullseyeCommand(
   stderrFile += ".stderr";
   runCoverageSrc.SetStdoutFile(stdoutFile.c_str());
   runCoverageSrc.SetStderrFile(stderrFile.c_str());
-  if(!runCoverageSrc.StartProcess())
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Could not run : "
-               << program << " " << arg << "\n"
-               << "kwsys process state : "
-               << runCoverageSrc.GetProcessState());
+  if (!runCoverageSrc.StartProcess()) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Could not run : " << program << " " << arg << "\n"
+                                  << "kwsys process state : "
+                                  << runCoverageSrc.GetProcessState());
     return 0;
-    }
+  }
   // since we set the output file names wait for it to end
   runCoverageSrc.WaitForExit();
   outputFile = stdoutFile;
@@ -2191,29 +1972,28 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
 {
   // Run the covsrc command and create a temp outputfile
   std::string outputFile;
-  if(!this->RunBullseyeCommand(cont, "covsrc", "-c", outputFile))
-    {
+  if (!this->RunBullseyeCommand(cont, "covsrc", "-c", outputFile)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covsrc:\n");
     return 0;
-    }
+  }
 
   std::ostream& tmpLog = *cont->OFS;
   // copen the Coverage.xml file in the Testing directory
   cmGeneratedFileStream covSumFile;
   cmXMLWriter xml(covSumFile);
-  if(!this->StartResultingXML(cmCTest::PartCoverage, "Coverage", covSumFile))
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE,
-      "Cannot open coverage summary file." << std::endl);
+  if (!this->StartResultingXML(cmCTest::PartCoverage, "Coverage",
+                               covSumFile)) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot open coverage summary file."
+                 << std::endl);
     return 0;
-    }
+  }
   this->CTest->StartXML(xml, this->AppendXML);
   double elapsed_time_start = cmSystemTools::GetTime();
   std::string coverage_start_time = this->CTest->CurrentTime();
   xml.StartElement("Coverage");
   xml.Element("StartDateTime", coverage_start_time);
   xml.Element("StartTime",
-    static_cast<unsigned int>(cmSystemTools::GetTime()));
+              static_cast<unsigned int>(cmSystemTools::GetTime()));
   std::string stdline;
   std::string errline;
   // expected output:
@@ -2230,66 +2010,53 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
   double total_tested = 0;
   double total_untested = 0;
   double total_functions = 0;
-  double percent_coverage =0;
-  double number_files  = 0;
+  double percent_coverage = 0;
+  double number_files = 0;
   std::vector<std::string> coveredFiles;
   std::vector<std::string> coveredFilesFullPath;
   // Read and parse the summary output file
   cmsys::ifstream fin(outputFile.c_str());
-  if(!fin)
-    {
+  if (!fin) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
-               "Cannot open coverage summary file: " <<
-               outputFile << std::endl);
+               "Cannot open coverage summary file: " << outputFile
+                                                     << std::endl);
     return 0;
-    }
+  }
   std::set<std::string> coveredFileNames;
-  while(cmSystemTools::GetLineFromStream(fin, stdline))
-    {
+  while (cmSystemTools::GetLineFromStream(fin, stdline)) {
     // if we have a line of output from stdout
-    if(!stdline.empty())
-      {
+    if (!stdline.empty()) {
       // parse the comma separated output
-      this->ParseBullsEyeCovsrcLine(stdline,
-                                    sourceFile,
-                                    functionsCalled,
-                                    totalFunctions,
-                                    percentFunction,
-                                    branchCovered,
-                                    totalBranches,
-                                    percentBranch);
+      this->ParseBullsEyeCovsrcLine(
+        stdline, sourceFile, functionsCalled, totalFunctions, percentFunction,
+        branchCovered, totalBranches, percentBranch);
       // The first line is the header
-      if(sourceFile == "Source" || sourceFile == "Total")
-        {
+      if (sourceFile == "Source" || sourceFile == "Total") {
         continue;
-        }
+      }
       std::string file = sourceFile;
       coveredFileNames.insert(file);
-      if(!cmSystemTools::FileIsFullPath(sourceFile.c_str()))
-        {
+      if (!cmSystemTools::FileIsFullPath(sourceFile.c_str())) {
         // file will be relative to the binary dir
         file = cont->BinaryDir;
         file += "/";
         file += sourceFile;
-        }
+      }
       file = cmSystemTools::CollapseFullPath(file);
-      bool shouldIDoCoverage
-        = this->ShouldIDoCoverage(file.c_str(),
-                                  cont->SourceDir.c_str(),
-                                  cont->BinaryDir.c_str());
-      if ( !shouldIDoCoverage )
-        {
-        cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-          ".NoDartCoverage found, so skip coverage check for: "
-          << file
-          << std::endl, this->Quiet);
+      bool shouldIDoCoverage = this->ShouldIDoCoverage(
+        file.c_str(), cont->SourceDir.c_str(), cont->BinaryDir.c_str());
+      if (!shouldIDoCoverage) {
+        cmCTestOptionalLog(
+          this->CTest, HANDLER_VERBOSE_OUTPUT,
+          ".NoDartCoverage found, so skip coverage check for: " << file
+                                                                << std::endl,
+          this->Quiet);
         continue;
-        }
+      }
 
       cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-        "Doing coverage for: "
-        << file
-        << std::endl, this->Quiet);
+                         "Doing coverage for: " << file << std::endl,
+                         this->Quiet);
 
       coveredFiles.push_back(sourceFile);
       coveredFilesFullPath.push_back(file);
@@ -2304,21 +2071,19 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
         this->CTest->GetShortPathToFile(file.c_str());
 
       float cper = static_cast<float>(percentBranch + percentFunction);
-      if(totalBranches > 0)
-        {
+      if (totalBranches > 0) {
         cper /= 2.0f;
-        }
+      }
       percent_coverage += static_cast<double>(cper);
       float cmet = static_cast<float>(percentFunction + percentBranch);
-      if(totalBranches > 0)
-        {
+      if (totalBranches > 0) {
         cmet /= 2.0f;
-        }
+      }
       cmet /= 100.0f;
       tmpLog << stdline << "\n";
       tmpLog << fileName << "\n";
-      tmpLog << "functionsCalled: " << functionsCalled/100 << "\n";
-      tmpLog << "totalFunctions: " << totalFunctions/100 << "\n";
+      tmpLog << "functionsCalled: " << functionsCalled / 100 << "\n";
+      tmpLog << "totalFunctions: " << totalFunctions / 100 << "\n";
       tmpLog << "percentFunction: " << percentFunction << "\n";
       tmpLog << "branchCovered: " << branchCovered << "\n";
       tmpLog << "totalBranches: " << totalBranches << "\n";
@@ -2341,8 +2106,8 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
       xml.Element("CoverageMetric", cmet);
       this->WriteXMLLabels(xml, shortFileName);
       xml.EndElement(); // File
-      }
     }
+  }
   std::string end_time = this->CTest->CurrentTime();
   xml.Element("LOCTested", total_tested);
   xml.Element("LOCUntested", total_untested);
@@ -2350,15 +2115,15 @@ int cmCTestCoverageHandler::RunBullseyeSourceSummary(
   xml.Element("PercentCoverage", SAFEDIV(percent_coverage, number_files));
   xml.Element("EndDateTime", end_time);
   xml.Element("EndTime", static_cast<unsigned int>(cmSystemTools::GetTime()));
-  xml.Element("ElapsedMinutes",
-    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start)/6)/10.0);
+  xml.Element(
+    "ElapsedMinutes",
+    static_cast<int>((cmSystemTools::GetTime() - elapsed_time_start) / 6) /
+      10.0);
   xml.EndElement(); // Coverage
   this->CTest->EndXML(xml);
 
   // Now create the coverage information for each file
-  return this->RunBullseyeCoverageBranch(cont,
-                                         coveredFileNames,
-                                         coveredFiles,
+  return this->RunBullseyeCoverageBranch(cont, coveredFileNames, coveredFiles,
                                          coveredFilesFullPath);
 }
 
@@ -2366,25 +2131,24 @@ int cmCTestCoverageHandler::HandleBullseyeCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
   const char* covfile = cmSystemTools::GetEnv("COVFILE");
-  if(!covfile || strlen(covfile) == 0)
-    {
+  if (!covfile || strlen(covfile) == 0) {
     cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-      " COVFILE environment variable not found, not running "
-      " bullseye\n", this->Quiet);
+                       " COVFILE environment variable not found, not running "
+                       " bullseye\n",
+                       this->Quiet);
     return 0;
-    }
-  cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " run covsrc with COVFILE=["
-    << covfile
-    << "]" << std::endl, this->Quiet);
-  if(!this->RunBullseyeSourceSummary(cont))
-    {
+  }
+  cmCTestOptionalLog(
+    this->CTest, HANDLER_VERBOSE_OUTPUT,
+    " run covsrc with COVFILE=[" << covfile << "]" << std::endl, this->Quiet);
+  if (!this->RunBullseyeSourceSummary(cont)) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Error running bullseye summary.\n");
     return 0;
-    }
-  cmCTestOptionalLog(this->CTest, DEBUG, "HandleBullseyeCoverage return 1 "
-  << std::endl, this->Quiet);
+  }
+  cmCTestOptionalLog(this->CTest, DEBUG,
+                     "HandleBullseyeCoverage return 1 " << std::endl,
+                     this->Quiet);
   return 1;
 }
 
@@ -2395,79 +2159,63 @@ bool cmCTestCoverageHandler::GetNextInt(std::string const& inputLine,
   std::string::size_type start = pos;
   pos = inputLine.find(',', start);
   value = atoi(inputLine.substr(start, pos).c_str());
-  if(pos == inputLine.npos)
-    {
+  if (pos == inputLine.npos) {
     return true;
-    }
+  }
   pos++;
   return true;
 }
 
 bool cmCTestCoverageHandler::ParseBullsEyeCovsrcLine(
-  std::string const& inputLine,
-  std::string& sourceFile,
-  int& functionsCalled,
-  int& totalFunctions,
-  int& percentFunction,
-  int& branchCovered,
-  int& totalBranches,
-  int& percentBranch)
+  std::string const& inputLine, std::string& sourceFile, int& functionsCalled,
+  int& totalFunctions, int& percentFunction, int& branchCovered,
+  int& totalBranches, int& percentBranch)
 {
   // find the first comma
   std::string::size_type pos = inputLine.find(',');
-  if(pos == inputLine.npos)
-    {
-    cmCTestLog(this->CTest, ERROR_MESSAGE, "Error parsing string : "
-               << inputLine << "\n");
+  if (pos == inputLine.npos) {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error parsing string : " << inputLine << "\n");
     return false;
-    }
+  }
   // the source file has "" around it so extract out the file name
-  sourceFile = inputLine.substr(1,pos-2);
+  sourceFile = inputLine.substr(1, pos - 2);
   pos++;
-  if(!this->GetNextInt(inputLine, pos, functionsCalled))
-    {
+  if (!this->GetNextInt(inputLine, pos, functionsCalled)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, totalFunctions))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, totalFunctions)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, percentFunction))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, percentFunction)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, branchCovered))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, branchCovered)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, totalBranches))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, totalBranches)) {
     return false;
-    }
-  if(!this->GetNextInt(inputLine, pos, percentBranch))
-    {
+  }
+  if (!this->GetNextInt(inputLine, pos, percentBranch)) {
     return false;
-    }
+  }
   // should be at the end now
-  if(pos != inputLine.npos)
-    {
+  if (pos != inputLine.npos) {
     cmCTestLog(this->CTest, ERROR_MESSAGE, "Error parsing input : "
-               << inputLine << " last pos not npos =  " << pos <<
-               "\n");
-    }
+                 << inputLine << " last pos not npos =  " << pos << "\n");
+  }
   return true;
 }
 
 int cmCTestCoverageHandler::GetLabelId(std::string const& label)
 {
   LabelIdMapType::iterator i = this->LabelIdMap.find(label);
-  if(i == this->LabelIdMap.end())
-    {
+  if (i == this->LabelIdMap.end()) {
     int n = int(this->Labels.size());
     this->Labels.push_back(label);
     LabelIdMapType::value_type entry(label, n);
     i = this->LabelIdMap.insert(entry).first;
-    }
+  }
   return i->second;
 }
 
@@ -2477,13 +2225,13 @@ void cmCTestCoverageHandler::LoadLabels()
   fileList += cmake::GetCMakeFilesDirectory();
   fileList += "/TargetDirectories.txt";
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " target directory list [" << fileList << "]\n", this->Quiet);
+                     " target directory list [" << fileList << "]\n",
+                     this->Quiet);
   cmsys::ifstream finList(fileList.c_str());
   std::string line;
-  while(cmSystemTools::GetLineFromStream(finList, line))
-    {
+  while (cmSystemTools::GetLineFromStream(finList, line)) {
     this->LoadLabels(line.c_str());
-    }
+  }
 }
 
 void cmCTestCoverageHandler::LoadLabels(const char* dir)
@@ -2492,41 +2240,31 @@ void cmCTestCoverageHandler::LoadLabels(const char* dir)
   std::string fname = dir;
   fname += "/Labels.txt";
   cmsys::ifstream fin(fname.c_str());
-  if(!fin)
-    {
+  if (!fin) {
     return;
-    }
+  }
 
   cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
-    " loading labels from [" << fname << "]\n", this->Quiet);
+                     " loading labels from [" << fname << "]\n", this->Quiet);
   bool inTarget = true;
   std::string source;
   std::string line;
   std::vector<int> targetLabels;
-  while(cmSystemTools::GetLineFromStream(fin, line))
-    {
-    if(line.empty() || line[0] == '#')
-      {
+  while (cmSystemTools::GetLineFromStream(fin, line)) {
+    if (line.empty() || line[0] == '#') {
       // Ignore blank and comment lines.
       continue;
-      }
-    else if(line[0] == ' ')
-      {
+    } else if (line[0] == ' ') {
       // Label lines appear indented by one space.
       std::string label = line.substr(1);
       int id = this->GetLabelId(label);
       dirLabels.insert(id);
-      if(inTarget)
-        {
+      if (inTarget) {
         targetLabels.push_back(id);
-        }
-      else
-        {
+      } else {
         this->SourceLabels[source].insert(id);
-        }
       }
-    else
-      {
+    } else {
       // Non-indented lines specify a source file name.  The first one
       // is the end of the target-wide labels.
       inTarget = false;
@@ -2536,69 +2274,62 @@ void cmCTestCoverageHandler::LoadLabels(const char* dir)
       // Label the source with the target labels.
       LabelSet& labelSet = this->SourceLabels[source];
       labelSet.insert(targetLabels.begin(), targetLabels.end());
-      }
     }
+  }
 }
 
 void cmCTestCoverageHandler::WriteXMLLabels(cmXMLWriter& xml,
                                             std::string const& source)
 {
   LabelMapType::const_iterator li = this->SourceLabels.find(source);
-  if(li != this->SourceLabels.end() && !li->second.empty())
-    {
+  if (li != this->SourceLabels.end() && !li->second.empty()) {
     xml.StartElement("Labels");
-    for(LabelSet::const_iterator lsi = li->second.begin();
-        lsi != li->second.end(); ++lsi)
-      {
+    for (LabelSet::const_iterator lsi = li->second.begin();
+         lsi != li->second.end(); ++lsi) {
       xml.Element("Label", this->Labels[*lsi]);
-      }
-    xml.EndElement(); // Labels
     }
+    xml.EndElement(); // Labels
+  }
 }
 
-void
-cmCTestCoverageHandler::SetLabelFilter(std::set<std::string> const& labels)
+void cmCTestCoverageHandler::SetLabelFilter(
+  std::set<std::string> const& labels)
 {
   this->LabelFilter.clear();
-  for(std::set<std::string>::const_iterator li = labels.begin();
-      li != labels.end(); ++li)
-    {
+  for (std::set<std::string>::const_iterator li = labels.begin();
+       li != labels.end(); ++li) {
     this->LabelFilter.insert(this->GetLabelId(*li));
-    }
+  }
 }
 
 bool cmCTestCoverageHandler::IntersectsFilter(LabelSet const& labels)
 {
   // If there is no label filter then nothing is filtered out.
-  if(this->LabelFilter.empty())
-    {
+  if (this->LabelFilter.empty()) {
     return true;
-    }
+  }
 
   std::vector<int> ids;
-  std::set_intersection
-    (labels.begin(), labels.end(),
-     this->LabelFilter.begin(), this->LabelFilter.end(),
-     std::back_inserter(ids));
+  std::set_intersection(labels.begin(), labels.end(),
+                        this->LabelFilter.begin(), this->LabelFilter.end(),
+                        std::back_inserter(ids));
   return !ids.empty();
 }
 
 bool cmCTestCoverageHandler::IsFilteredOut(std::string const& source)
 {
   // If there is no label filter then nothing is filtered out.
-  if(this->LabelFilter.empty())
-    {
+  if (this->LabelFilter.empty()) {
     return false;
-    }
+  }
 
   // The source is filtered out if it does not have any labels in
   // common with the filter set.
   std::string shortSrc = this->CTest->GetShortPathToFile(source.c_str());
   LabelMapType::const_iterator li = this->SourceLabels.find(shortSrc);
-  if(li != this->SourceLabels.end())
-    {
+  if (li != this->SourceLabels.end()) {
     return !this->IntersectsFilter(li->second);
-    }
+  }
   return true;
 }
 
@@ -2607,36 +2338,31 @@ std::set<std::string> cmCTestCoverageHandler::FindUncoveredFiles(
 {
   std::set<std::string> extraMatches;
 
-  for(std::vector<std::string>::iterator i = this->ExtraCoverageGlobs.begin();
-      i != this->ExtraCoverageGlobs.end(); ++i)
-    {
+  for (std::vector<std::string>::iterator i = this->ExtraCoverageGlobs.begin();
+       i != this->ExtraCoverageGlobs.end(); ++i) {
     cmsys::Glob gl;
     gl.RecurseOn();
     gl.RecurseThroughSymlinksOff();
     std::string glob = cont->SourceDir + "/" + *i;
     gl.FindFiles(glob);
     std::vector<std::string> files = gl.GetFiles();
-    for(std::vector<std::string>::iterator f = files.begin();
-        f != files.end(); ++f)
-      {
-      if(this->ShouldIDoCoverage(f->c_str(),
-         cont->SourceDir.c_str(), cont->BinaryDir.c_str()))
-        {
-        extraMatches.insert(this->CTest->GetShortPathToFile(
-          f->c_str()));
-        }
+    for (std::vector<std::string>::iterator f = files.begin();
+         f != files.end(); ++f) {
+      if (this->ShouldIDoCoverage(f->c_str(), cont->SourceDir.c_str(),
+                                  cont->BinaryDir.c_str())) {
+        extraMatches.insert(this->CTest->GetShortPathToFile(f->c_str()));
       }
     }
+  }
 
-  if(!extraMatches.empty())
-    {
-    for(cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator i =
-        cont->TotalCoverage.begin(); i != cont->TotalCoverage.end(); ++i)
-      {
-      std::string shortPath = this->CTest->GetShortPathToFile(
-        i->first.c_str());
+  if (!extraMatches.empty()) {
+    for (cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator i =
+           cont->TotalCoverage.begin();
+         i != cont->TotalCoverage.end(); ++i) {
+      std::string shortPath =
+        this->CTest->GetShortPathToFile(i->first.c_str());
       extraMatches.erase(shortPath);
-      }
     }
+  }
   return extraMatches;
 }