1 files changed, 38 insertions, 323 deletions

diff --git a/Source/CTest/cmCTestLaunch.cxx b/Source/CTest/cmCTestLaunch.cxx
index 647f5ff..b9ed033 100644
--- a/Source/CTest/cmCTestLaunch.cxx
+++ b/Source/CTest/cmCTestLaunch.cxx
@@ -2,7 +2,6 @@
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmCTestLaunch.h"
 
-#include <cstdlib>
 #include <cstring>
 #include <iostream>
 
@@ -10,8 +9,7 @@
 #include "cmsys/Process.h"
 #include "cmsys/RegularExpression.hxx"
 
-#include "cmCryptoHash.h"
-#include "cmGeneratedFileStream.h"
+#include "cmCTestLaunchReporter.h"
 #include "cmGlobalGenerator.h"
 #include "cmMakefile.h"
 #include "cmProcessOutput.h"
@@ -19,7 +17,6 @@
 #include "cmStateSnapshot.h"
 #include "cmStringAlgorithms.h"
 #include "cmSystemTools.h"
-#include "cmXMLWriter.h"
 #include "cmake.h"
 
 #ifdef _WIN32
@@ -30,16 +27,14 @@
 
 cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv)
 {
-  this->Passthru = true;
   this->Process = nullptr;
-  this->ExitCode = 1;
-  this->CWD = cmSystemTools::GetCurrentWorkingDirectory();
 
   if (!this->ParseArguments(argc, argv)) {
     return;
   }
 
-  this->ComputeFileNames();
+  this->Reporter.RealArgs = this->RealArgs;
+  this->Reporter.ComputeFileNames();
 
   this->ScrapeRulesLoaded = false;
   this->HaveOut = false;
@@ -50,10 +45,6 @@ cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv)
 cmCTestLaunch::~cmCTestLaunch()
 {
   cmsysProcess_Delete(this->Process);
-  if (!this->Passthru) {
-    cmSystemTools::RemoveFile(this->LogOut);
-    cmSystemTools::RemoveFile(this->LogErr);
-  }
 }
 
 bool cmCTestLaunch::ParseArguments(int argc, const char* const* argv)
@@ -93,28 +84,28 @@ bool cmCTestLaunch::ParseArguments(int argc, const char* const* argv)
     } else if (strcmp(arg, "--filter-prefix") == 0) {
       doing = DoingFilterPrefix;
     } else if (doing == DoingOutput) {
-      this->OptionOutput = arg;
+      this->Reporter.OptionOutput = arg;
       doing = DoingNone;
     } else if (doing == DoingSource) {
-      this->OptionSource = arg;
+      this->Reporter.OptionSource = arg;
       doing = DoingNone;
     } else if (doing == DoingLanguage) {
-      this->OptionLanguage = arg;
-      if (this->OptionLanguage == "CXX") {
-        this->OptionLanguage = "C++";
+      this->Reporter.OptionLanguage = arg;
+      if (this->Reporter.OptionLanguage == "CXX") {
+        this->Reporter.OptionLanguage = "C++";
       }
       doing = DoingNone;
     } else if (doing == DoingTargetName) {
-      this->OptionTargetName = arg;
+      this->Reporter.OptionTargetName = arg;
       doing = DoingNone;
     } else if (doing == DoingTargetType) {
-      this->OptionTargetType = arg;
+      this->Reporter.OptionTargetType = arg;
       doing = DoingNone;
     } else if (doing == DoingBuildDir) {
-      this->OptionBuildDir = arg;
+      this->Reporter.OptionBuildDir = arg;
       doing = DoingNone;
     } else if (doing == DoingFilterPrefix) {
-      this->OptionFilterPrefix = arg;
+      this->Reporter.OptionFilterPrefix = arg;
       doing = DoingNone;
     }
   }
@@ -150,42 +141,11 @@ void cmCTestLaunch::HandleRealArg(const char* arg)
   this->RealArgs.emplace_back(arg);
 }
 
-void cmCTestLaunch::ComputeFileNames()
-{
-  // We just passthru the behavior of the real command unless the
-  // CTEST_LAUNCH_LOGS environment variable is set.
-  const char* d = getenv("CTEST_LAUNCH_LOGS");
-  if (!(d && *d)) {
-    return;
-  }
-  this->Passthru = false;
-
-  // The environment variable specifies the directory into which we
-  // generate build logs.
-  this->LogDir = d;
-  cmSystemTools::ConvertToUnixSlashes(this->LogDir);
-  this->LogDir += "/";
-
-  // We hash the input command working dir and command line to obtain
-  // a repeatable and (probably) unique name for log files.
-  cmCryptoHash md5(cmCryptoHash::AlgoMD5);
-  md5.Initialize();
-  md5.Append(this->CWD);
-  for (std::string const& realArg : this->RealArgs) {
-    md5.Append(realArg);
-  }
-  this->LogHash = md5.FinalizeHex();
-
-  // We store stdout and stderr in temporary log files.
-  this->LogOut = cmStrCat(this->LogDir, "launch-", this->LogHash, "-out.txt");
-  this->LogErr = cmStrCat(this->LogDir, "launch-", this->LogHash, "-err.txt");
-}
-
 void cmCTestLaunch::RunChild()
 {
   // Ignore noopt make rules
   if (this->RealArgs.empty() || this->RealArgs[0] == ":") {
-    this->ExitCode = 0;
+    this->Reporter.ExitCode = 0;
     return;
   }
 
@@ -195,14 +155,14 @@ void cmCTestLaunch::RunChild()
 
   cmsys::ofstream fout;
   cmsys::ofstream ferr;
-  if (this->Passthru) {
+  if (this->Reporter.Passthru) {
     // In passthru mode we just share the output pipes.
     cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDOUT, 1);
     cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDERR, 1);
   } else {
     // In full mode we record the child output pipes to log files.
-    fout.open(this->LogOut.c_str(), std::ios::out | std::ios::binary);
-    ferr.open(this->LogErr.c_str(), std::ios::out | std::ios::binary);
+    fout.open(this->Reporter.LogOut.c_str(), std::ios::out | std::ios::binary);
+    ferr.open(this->Reporter.LogErr.c_str(), std::ios::out | std::ios::binary);
   }
 
 #ifdef _WIN32
@@ -216,7 +176,7 @@ void cmCTestLaunch::RunChild()
   cmsysProcess_Execute(cp);
 
   // Record child stdout and stderr if necessary.
-  if (!this->Passthru) {
+  if (!this->Reporter.Passthru) {
     char* data = nullptr;
     int length = 0;
     cmProcessOutput processOutput;
@@ -248,7 +208,7 @@ void cmCTestLaunch::RunChild()
 
   // Wait for the real command to finish.
   cmsysProcess_WaitForExit(cp, nullptr);
-  this->ExitCode = cmsysProcess_GetExitValue(cp);
+  this->Reporter.ExitCode = cmsysProcess_GetExitValue(cp);
 }
 
 int cmCTestLaunch::Run()
@@ -261,255 +221,31 @@ int cmCTestLaunch::Run()
   this->RunChild();
 
   if (this->CheckResults()) {
-    return this->ExitCode;
+    return this->Reporter.ExitCode;
   }
 
   this->LoadConfig();
-  this->WriteXML();
-
-  return this->ExitCode;
-}
-
-void cmCTestLaunch::LoadLabels()
-{
-  if (this->OptionBuildDir.empty() || this->OptionTargetName.empty()) {
-    return;
-  }
-
-  // Labels are listed in per-target files.
-  std::string fname = cmStrCat(this->OptionBuildDir, "/CMakeFiles/",
-                               this->OptionTargetName, ".dir/Labels.txt");
-
-  // We are interested in per-target labels for this source file.
-  std::string source = this->OptionSource;
-  cmSystemTools::ConvertToUnixSlashes(source);
-
-  // Load the labels file.
-  cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
-  if (!fin) {
-    return;
-  }
-  bool inTarget = true;
-  bool inSource = false;
-  std::string line;
-  while (cmSystemTools::GetLineFromStream(fin, line)) {
-    if (line.empty() || line[0] == '#') {
-      // Ignore blank and comment lines.
-      continue;
-    }
-    if (line[0] == ' ') {
-      // Label lines appear indented by one space.
-      if (inTarget || inSource) {
-        this->Labels.insert(line.substr(1));
-      }
-    } else if (!this->OptionSource.empty() && !inSource) {
-      // Non-indented lines specify a source file name.  The first one
-      // is the end of the target-wide labels.  Use labels following a
-      // matching source.
-      inTarget = false;
-      inSource = this->SourceMatches(line, source);
-    } else {
-      return;
-    }
-  }
-}
-
-bool cmCTestLaunch::SourceMatches(std::string const& lhs,
-                                  std::string const& rhs)
-{
-  // TODO: Case sensitivity, UseRelativePaths, etc.  Note that both
-  // paths in the comparison get generated by CMake.  This is done for
-  // every source in the target, so it should be efficient (cannot use
-  // cmSystemTools::IsSameFile).
-  return lhs == rhs;
-}
-
-bool cmCTestLaunch::IsError() const
-{
-  return this->ExitCode != 0;
-}
-
-void cmCTestLaunch::WriteXML()
-{
-  // Name the xml file.
-  std::string logXML =
-    cmStrCat(this->LogDir, this->IsError() ? "error-" : "warning-",
-             this->LogHash, ".xml");
-
-  // Use cmGeneratedFileStream to atomically create the report file.
-  cmGeneratedFileStream fxml(logXML);
-  cmXMLWriter xml(fxml, 2);
-  cmXMLElement e2(xml, "Failure");
-  e2.Attribute("type", this->IsError() ? "Error" : "Warning");
-  this->WriteXMLAction(e2);
-  this->WriteXMLCommand(e2);
-  this->WriteXMLResult(e2);
-  this->WriteXMLLabels(e2);
-}
-
-void cmCTestLaunch::WriteXMLAction(cmXMLElement& e2)
-{
-  e2.Comment("Meta-information about the build action");
-  cmXMLElement e3(e2, "Action");
-
-  // TargetName
-  if (!this->OptionTargetName.empty()) {
-    e3.Element("TargetName", this->OptionTargetName);
-  }
-
-  // Language
-  if (!this->OptionLanguage.empty()) {
-    e3.Element("Language", this->OptionLanguage);
-  }
-
-  // SourceFile
-  if (!this->OptionSource.empty()) {
-    std::string source = this->OptionSource;
-    cmSystemTools::ConvertToUnixSlashes(source);
-
-    // If file is in source tree use its relative location.
-    if (cmSystemTools::FileIsFullPath(this->SourceDir) &&
-        cmSystemTools::FileIsFullPath(source) &&
-        cmSystemTools::IsSubDirectory(source, this->SourceDir)) {
-      source = cmSystemTools::RelativePath(this->SourceDir, source);
-    }
-
-    e3.Element("SourceFile", source);
-  }
-
-  // OutputFile
-  if (!this->OptionOutput.empty()) {
-    e3.Element("OutputFile", this->OptionOutput);
-  }
-
-  // OutputType
-  const char* outputType = nullptr;
-  if (!this->OptionTargetType.empty()) {
-    if (this->OptionTargetType == "EXECUTABLE") {
-      outputType = "executable";
-    } else if (this->OptionTargetType == "SHARED_LIBRARY") {
-      outputType = "shared library";
-    } else if (this->OptionTargetType == "MODULE_LIBRARY") {
-      outputType = "module library";
-    } else if (this->OptionTargetType == "STATIC_LIBRARY") {
-      outputType = "static library";
-    }
-  } else if (!this->OptionSource.empty()) {
-    outputType = "object file";
-  }
-  if (outputType) {
-    e3.Element("OutputType", outputType);
-  }
-}
-
-void cmCTestLaunch::WriteXMLCommand(cmXMLElement& e2)
-{
-  e2.Comment("Details of command");
-  cmXMLElement e3(e2, "Command");
-  if (!this->CWD.empty()) {
-    e3.Element("WorkingDirectory", this->CWD);
-  }
-  for (std::string const& realArg : this->RealArgs) {
-    e3.Element("Argument", realArg);
-  }
-}
-
-void cmCTestLaunch::WriteXMLResult(cmXMLElement& e2)
-{
-  e2.Comment("Result of command");
-  cmXMLElement e3(e2, "Result");
-
-  // StdOut
-  this->DumpFileToXML(e3, "StdOut", this->LogOut);
-
-  // StdErr
-  this->DumpFileToXML(e3, "StdErr", this->LogErr);
-
-  // ExitCondition
-  cmXMLElement e4(e3, "ExitCondition");
-  cmsysProcess* cp = this->Process;
-  switch (cmsysProcess_GetState(cp)) {
-    case cmsysProcess_State_Starting:
-      e4.Content("No process has been executed");
-      break;
-    case cmsysProcess_State_Executing:
-      e4.Content("The process is still executing");
-      break;
-    case cmsysProcess_State_Disowned:
-      e4.Content("Disowned");
-      break;
-    case cmsysProcess_State_Killed:
-      e4.Content("Killed by parent");
-      break;
-
-    case cmsysProcess_State_Expired:
-      e4.Content("Killed when timeout expired");
-      break;
-    case cmsysProcess_State_Exited:
-      e4.Content(this->ExitCode);
-      break;
-    case cmsysProcess_State_Exception:
-      e4.Content("Terminated abnormally: ");
-      e4.Content(cmsysProcess_GetExceptionString(cp));
-      break;
-    case cmsysProcess_State_Error:
-      e4.Content("Error administrating child process: ");
-      e4.Content(cmsysProcess_GetErrorString(cp));
-      break;
-  }
-}
+  this->Reporter.Process = this->Process;
+  this->Reporter.WriteXML();
 
-void cmCTestLaunch::WriteXMLLabels(cmXMLElement& e2)
-{
-  this->LoadLabels();
-  if (!this->Labels.empty()) {
-    e2.Comment("Interested parties");
-    cmXMLElement e3(e2, "Labels");
-    for (std::string const& label : this->Labels) {
-      e3.Element("Label", label);
-    }
-  }
-}
-
-void cmCTestLaunch::DumpFileToXML(cmXMLElement& e3, const char* tag,
-                                  std::string const& fname)
-{
-  cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
-
-  std::string line;
-  const char* sep = "";
-
-  cmXMLElement e4(e3, tag);
-  while (cmSystemTools::GetLineFromStream(fin, line)) {
-    if (MatchesFilterPrefix(line)) {
-      continue;
-    }
-    if (this->Match(line, this->RegexWarningSuppress)) {
-      line = cmStrCat("[CTest: warning suppressed] ", line);
-    } else if (this->Match(line, this->RegexWarning)) {
-      line = cmStrCat("[CTest: warning matched] ", line);
-    }
-    e4.Content(sep);
-    e4.Content(line);
-    sep = "\n";
-  }
+  return this->Reporter.ExitCode;
 }
 
 bool cmCTestLaunch::CheckResults()
 {
   // Skip XML in passthru mode.
-  if (this->Passthru) {
+  if (this->Reporter.Passthru) {
     return true;
   }
 
   // We always report failure for error conditions.
-  if (this->IsError()) {
+  if (this->Reporter.IsError()) {
     return false;
   }
 
   // Scrape the output logs to look for warnings.
-  if ((this->HaveErr && this->ScrapeLog(this->LogErr)) ||
-      (this->HaveOut && this->ScrapeLog(this->LogOut))) {
+  if ((this->HaveErr && this->ScrapeLog(this->Reporter.LogErr)) ||
+      (this->HaveOut && this->ScrapeLog(this->Reporter.LogOut))) {
     return false;
   }
   return true;
@@ -522,22 +258,17 @@ void cmCTestLaunch::LoadScrapeRules()
   }
   this->ScrapeRulesLoaded = true;
 
-  // Common compiler warning formats.  These are much simpler than the
-  // full log-scraping expressions because we do not need to extract
-  // file and line information.
-  this->RegexWarning.emplace_back("(^|[ :])[Ww][Aa][Rr][Nn][Ii][Nn][Gg]");
-  this->RegexWarning.emplace_back("(^|[ :])[Rr][Ee][Mm][Aa][Rr][Kk]");
-  this->RegexWarning.emplace_back("(^|[ :])[Nn][Oo][Tt][Ee]");
-
   // Load custom match rules given to us by CTest.
-  this->LoadScrapeRules("Warning", this->RegexWarning);
-  this->LoadScrapeRules("WarningSuppress", this->RegexWarningSuppress);
+  this->LoadScrapeRules("Warning", this->Reporter.RegexWarning);
+  this->LoadScrapeRules("WarningSuppress",
+                        this->Reporter.RegexWarningSuppress);
 }
 
 void cmCTestLaunch::LoadScrapeRules(
   const char* purpose, std::vector<cmsys::RegularExpression>& regexps)
 {
-  std::string fname = cmStrCat(this->LogDir, "Custom", purpose, ".txt");
+  std::string fname =
+    cmStrCat(this->Reporter.LogDir, "Custom", purpose, ".txt");
   cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
   std::string line;
   cmsys::RegularExpression rex;
@@ -557,35 +288,18 @@ bool cmCTestLaunch::ScrapeLog(std::string const& fname)
   cmsys::ifstream fin(fname.c_str(), std::ios::in | std::ios::binary);
   std::string line;
   while (cmSystemTools::GetLineFromStream(fin, line)) {
-    if (MatchesFilterPrefix(line)) {
+    if (this->Reporter.MatchesFilterPrefix(line)) {
       continue;
     }
 
-    if (this->Match(line, this->RegexWarning) &&
-        !this->Match(line, this->RegexWarningSuppress)) {
+    if (this->Reporter.Match(line, this->Reporter.RegexWarning) &&
+        !this->Reporter.Match(line, this->Reporter.RegexWarningSuppress)) {
       return true;
     }
   }
   return false;
 }
 
-bool cmCTestLaunch::Match(std::string const& line,
-                          std::vector<cmsys::RegularExpression>& regexps)
-{
-  for (cmsys::RegularExpression& r : regexps) {
-    if (r.find(line)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-bool cmCTestLaunch::MatchesFilterPrefix(std::string const& line) const
-{
-  return !this->OptionFilterPrefix.empty() &&
-    cmHasPrefix(line, this->OptionFilterPrefix);
-}
-
 int cmCTestLaunch::Main(int argc, const char* const argv[])
 {
   if (argc == 2) {
@@ -605,9 +319,10 @@ void cmCTestLaunch::LoadConfig()
   cm.GetCurrentSnapshot().SetDefaultDefinitions();
   cmGlobalGenerator gg(&cm);
   cmMakefile mf(&gg, cm.GetCurrentSnapshot());
-  std::string fname = cmStrCat(this->LogDir, "CTestLaunchConfig.cmake");
+  std::string fname =
+    cmStrCat(this->Reporter.LogDir, "CTestLaunchConfig.cmake");
   if (cmSystemTools::FileExists(fname) && mf.ReadListFile(fname)) {
-    this->SourceDir = mf.GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
-    cmSystemTools::ConvertToUnixSlashes(this->SourceDir);
+    this->Reporter.SourceDir = mf.GetSafeDefinition("CTEST_SOURCE_DIRECTORY");
+    cmSystemTools::ConvertToUnixSlashes(this->Reporter.SourceDir);
   }
 }