cmCTestTestHandler: Consolidate Output options into cmCTestTestOptions

Source/CMakeLists.txt

@@ -1109,6 +1109,7 @@ add_library(
   CTest/cmCTestTestCommand.cxx
   CTest/cmCTestTestHandler.cxx
   CTest/cmCTestTestMeasurementXMLParser.cxx
+  CTest/cmCTestTypes.cxx
   CTest/cmCTestUpdateCommand.cxx
   CTest/cmCTestUpdateHandler.cxx
   CTest/cmCTestUploadCommand.cxx

Source/CTest/cmCTestMemCheckHandler.cxx

@@ -121,8 +121,8 @@ public:
 cmCTestMemCheckHandler::cmCTestMemCheckHandler()
 {
   this->MemCheck = true;
-  this->CustomMaximumPassedTestOutputSize = 0;
+  this->TestOptions.OutputSizePassed = 0;
-  this->CustomMaximumFailedTestOutputSize = 0;
+  this->TestOptions.OutputSizeFailed = 0;
   this->LogWithPID = false;
 }
 
@@ -130,8 +130,8 @@ void cmCTestMemCheckHandler::Initialize(cmCTest* ctest)
 {
   this->Superclass::Initialize(ctest);
   this->LogWithPID = false;
-  this->CustomMaximumPassedTestOutputSize = 0;
+  this->TestOptions.OutputSizePassed = 0;
-  this->CustomMaximumFailedTestOutputSize = 0;
+  this->TestOptions.OutputSizeFailed = 0;
   this->MemoryTester.clear();
   this->MemoryTesterDynamicOptions.clear();
   this->MemoryTesterOptions.clear();
@@ -371,9 +371,8 @@ void cmCTestMemCheckHandler::GenerateCTestXML(cmXMLWriter& xml)
       continue;
     }
     this->CleanTestOutput(
-      memcheckstr,
+      memcheckstr, static_cast<size_t>(this->TestOptions.OutputSizeFailed),
-      static_cast<size_t>(this->CustomMaximumFailedTestOutputSize),
+      this->TestOptions.OutputTruncation);
-      this->TestOutputTruncation);
     this->WriteTestResultHeader(xml, result);
     xml.StartElement("Results");
     int memoryErrors = 0;
@@ -929,7 +928,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
   cmsys::SystemTools::Split(str, lines);
   bool unlimitedOutput = false;
   if (str.find("CTEST_FULL_OUTPUT") != std::string::npos ||
-      this->CustomMaximumFailedTestOutputSize == 0) {
+      this->TestOptions.OutputSizeFailed == 0) {
     unlimitedOutput = true;
   }
 
@@ -1029,7 +1028,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckValgrindOutput(
     ostr << lines[i] << std::endl;
     if (!unlimitedOutput &&
         totalOutputSize >
-          static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)) {
+          static_cast<size_t>(this->TestOptions.OutputSizeFailed)) {
       ostr << "....\n";
       ostr << "Test Output for this test has been truncated see testing"
               " machine logs for full output,\n";
@@ -1143,7 +1142,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckCudaOutput(
   cmsys::SystemTools::Split(str, lines);
   bool unlimitedOutput = false;
   if (str.find("CTEST_FULL_OUTPUT") != std::string::npos ||
-      this->CustomMaximumFailedTestOutputSize == 0) {
+      this->TestOptions.OutputSizeFailed == 0) {
     unlimitedOutput = true;
   }
 
@@ -1243,7 +1242,7 @@ bool cmCTestMemCheckHandler::ProcessMemCheckCudaOutput(
     ostr << lines[i] << std::endl;
     if (!unlimitedOutput &&
         totalOutputSize >
-          static_cast<size_t>(this->CustomMaximumFailedTestOutputSize)) {
+          static_cast<size_t>(this->TestOptions.OutputSizeFailed)) {
       ostr << "....\n";
       ostr << "Test Output for this test has been truncated see testing"
               " machine logs for full output,\n";

Source/CTest/cmCTestRunTest.cxx

@@ -296,11 +296,11 @@ cmCTestRunTest::EndTestResult cmCTestRunTest::EndTest(size_t completed,
   if (!this->TestHandler->MemCheck && started) {
     this->TestHandler->CleanTestOutput(
       this->ProcessOutput,
-      static_cast<size_t>(
+      static_cast<size_t>(this->TestResult.Status ==
-        this->TestResult.Status == cmCTestTestHandler::COMPLETED
+                              cmCTestTestHandler::COMPLETED
-          ? this->TestHandler->CustomMaximumPassedTestOutputSize
+                            ? this->TestHandler->TestOptions.OutputSizePassed
-          : this->TestHandler->CustomMaximumFailedTestOutputSize),
+                            : this->TestHandler->TestOptions.OutputSizeFailed),
-      this->TestHandler->TestOutputTruncation);
+      this->TestHandler->TestOptions.OutputTruncation);
   }
   this->TestResult.Reason = reason;
   if (this->TestHandler->LogFile) {

Source/CTest/cmCTestTestHandler.cxx

@@ -282,10 +282,6 @@ cmCTestTestHandler::cmCTestTestHandler()
   this->UseExcludeRegExpFlag = false;
   this->UseExcludeRegExpFirst = false;
 
-  this->CustomMaximumPassedTestOutputSize = 1 * 1024;
-  this->CustomMaximumFailedTestOutputSize = 300 * 1024;
-  this->TestOutputTruncation = cmCTestTypes::TruncationMode::Tail;
-
   this->MemCheck = false;
 
   this->LogFile = nullptr;
@@ -316,6 +312,7 @@ cmCTestTestHandler::cmCTestTestHandler()
 void cmCTestTestHandler::Initialize(cmCTest* ctest)
 {
   this->Superclass::Initialize(ctest);
+  this->TestOptions = ctest->GetTestOptions();
 
   this->ElapsedTestingTime = cmDuration();
 
@@ -327,9 +324,6 @@ void cmCTestTestHandler::Initialize(cmCTest* ctest)
 
   this->CustomPreTest.clear();
   this->CustomPostTest.clear();
-  this->CustomMaximumPassedTestOutputSize = 1 * 1024;
-  this->CustomMaximumFailedTestOutputSize = 300 * 1024;
-  this->TestOutputTruncation = cmCTestTypes::TruncationMode::Tail;
 
   this->TestsToRun.clear();
 
@@ -363,14 +357,14 @@ void cmCTestTestHandler::PopulateCustomVectors(cmMakefile* mf)
                                     this->CustomTestsIgnore);
   this->CTest->PopulateCustomInteger(
     mf, "CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE",
-    this->CustomMaximumPassedTestOutputSize);
+    this->TestOptions.OutputSizePassed);
   this->CTest->PopulateCustomInteger(
     mf, "CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE",
-    this->CustomMaximumFailedTestOutputSize);
+    this->TestOptions.OutputSizeFailed);
 
   cmValue dval = mf->GetDefinition("CTEST_CUSTOM_TEST_OUTPUT_TRUNCATION");
   if (dval) {
-    if (!this->SetTestOutputTruncation(*dval)) {
+    if (!SetTruncationMode(this->TestOptions.OutputTruncation, *dval)) {
       cmCTestLog(this->CTest, ERROR_MESSAGE,
                  "Invalid value for CTEST_CUSTOM_TEST_OUTPUT_TRUNCATION: "
                    << *dval << std::endl);
@@ -386,23 +380,6 @@ void cmCTestTestHandler::SetCMakeVariables(cmMakefile& mf)
                    cmList(this->CustomPostTest).to_string());
   mf.AddDefinition("CTEST_CUSTOM_TESTS_IGNORE",
                    cmList(this->CustomTestsIgnore).to_string());
-  mf.AddDefinition("CTEST_CUSTOM_MAXIMUM_PASSED_TEST_OUTPUT_SIZE",
-                   std::to_string(this->CustomMaximumPassedTestOutputSize));
-  mf.AddDefinition("CTEST_CUSTOM_MAXIMUM_FAILED_TEST_OUTPUT_SIZE",
-                   std::to_string(this->CustomMaximumFailedTestOutputSize));
-  mf.AddDefinition("CTEST_CUSTOM_TEST_OUTPUT_TRUNCATION",
-                   [this]() -> cm::string_view {
-                     switch (this->TestOutputTruncation) {
-                       case cmCTestTypes::TruncationMode::Tail:
-                         return "tail"_s;
-                       case cmCTestTypes::TruncationMode::Middle:
-                         return "middle"_s;
-                       case cmCTestTypes::TruncationMode::Head:
-                         return "head"_s;
-                       default:
-                         return ""_s;
-                     }
-                   }());
 }
 
 int cmCTestTestHandler::PreProcessHandler()
@@ -2188,20 +2165,6 @@ void cmCTestTestHandler::SetExcludeRegExp(const std::string& arg)
   this->ExcludeRegExp = arg;
 }
 
-bool cmCTestTestHandler::SetTestOutputTruncation(const std::string& mode)
-{
-  if (mode == "tail") {
-    this->TestOutputTruncation = cmCTestTypes::TruncationMode::Tail;
-  } else if (mode == "middle") {
-    this->TestOutputTruncation = cmCTestTypes::TruncationMode::Middle;
-  } else if (mode == "head") {
-    this->TestOutputTruncation = cmCTestTypes::TruncationMode::Head;
-  } else {
-    return false;
-  }
-  return true;
-}
-
 void cmCTestTestHandler::SetTestsToRunInformation(cmValue in)
 {
   if (!in) {

Source/CTest/cmCTestTestHandler.h

@@ -29,6 +29,14 @@
 class cmMakefile;
 class cmXMLWriter;
 
+struct cmCTestTestOptions
+{
+  int OutputSizePassed = 1 * 1024;
+  int OutputSizeFailed = 300 * 1024;
+  cmCTestTypes::TruncationMode OutputTruncation =
+    cmCTestTypes::TruncationMode::Tail;
+};
+
 /** \class cmCTestTestHandler
  * \brief A class that handles ctest -S invocations
  *
@@ -75,18 +83,6 @@ public:
   void SetMaxIndex(int n) { this->MaxIndex = n; }
   int GetMaxIndex() { return this->MaxIndex; }
 
-  void SetTestOutputSizePassed(int n)
-  {
-    this->CustomMaximumPassedTestOutputSize = n;
-  }
-  void SetTestOutputSizeFailed(int n)
-  {
-    this->CustomMaximumFailedTestOutputSize = n;
-  }
-
-  //! Set test output truncation mode. Return false if unknown mode.
-  bool SetTestOutputTruncation(const std::string& mode);
-
   //! pass the -I argument down
   void SetTestsToRunInformation(cmValue);
 
@@ -265,6 +261,8 @@ protected:
   void CleanTestOutput(std::string& output, size_t length,
                        cmCTestTypes::TruncationMode truncate);
 
+  cmCTestTestOptions TestOptions;
+
   cmDuration ElapsedTestingTime;
 
   using TestResultsVector = std::vector<cmCTestTestResult>;
@@ -276,9 +274,6 @@ protected:
   std::chrono::system_clock::time_point StartTestTime;
   std::chrono::system_clock::time_point EndTestTime;
   bool MemCheck;
-  int CustomMaximumPassedTestOutputSize;
-  int CustomMaximumFailedTestOutputSize;
-  cmCTestTypes::TruncationMode TestOutputTruncation;
   int MaxIndex;
 
 public:
@@ -395,4 +390,6 @@ private:
   bool RerunFailed;
 
   std::string JUnitXMLFileName;
+
+  friend class cmCTestTestCommand;
 };

Source/CTest/cmCTestTypes.cxx

@@ -0,0 +1,24 @@
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
+
+#include "cmCTestTypes.h"
+
+#include <string>
+
+namespace cmCTestTypes {
+
+bool SetTruncationMode(TruncationMode& mode, cm::string_view str)
+{
+  if (str == "tail") {
+    mode = cmCTestTypes::TruncationMode::Tail;
+  } else if (str == "middle") {
+    mode = cmCTestTypes::TruncationMode::Middle;
+  } else if (str == "head") {
+    mode = cmCTestTypes::TruncationMode::Head;
+  } else {
+    return false;
+  }
+  return true;
+}
+
+} // namespace cmCTestTypes

Source/CTest/cmCTestTypes.h

@@ -5,12 +5,18 @@
 
 #include "cmConfigure.h" // IWYU pragma: keep
 
+#include <cm/string_view>
+
 namespace cmCTestTypes {
 
+// Test output truncation mode
 enum class TruncationMode
-{ // Test output truncation mode
+{
   Tail,
   Middle,
   Head
 };
-}
+
+bool SetTruncationMode(TruncationMode& mode, cm::string_view str);
+
+} // namespace cmCTestTypes

Source/cmCTest.cxx

@@ -49,6 +49,7 @@
 #include "cmCTestScriptHandler.h"
 #include "cmCTestSubmitHandler.h"
 #include "cmCTestTestHandler.h"
+#include "cmCTestTypes.h"
 #include "cmCTestUpdateHandler.h"
 #include "cmCTestUploadHandler.h"
 #include "cmCommandLineArgument.h"
@@ -204,6 +205,8 @@ struct cmCTest::Private
 
   cmCTest::NoTests NoTestsMode = cmCTest::NoTests::Legacy;
   bool NoTestsModeSetInCli = false;
+
+  cmCTestTestOptions TestOptions;
 };
 
 struct tm* cmCTest::GetNightlyTime(std::string const& str, bool tomorrowtag)
@@ -1769,17 +1772,17 @@ bool cmCTest::SetArgsFromPreset(const std::string& presetName,
       expandedPreset->Output->SubprojectSummary.value_or(true);
 
     if (expandedPreset->Output->MaxPassedTestOutputSize) {
-      this->Impl->TestHandler.SetTestOutputSizePassed(
+      this->Impl->TestOptions.OutputSizePassed =
-        *expandedPreset->Output->MaxPassedTestOutputSize);
+        *expandedPreset->Output->MaxPassedTestOutputSize;
     }
 
     if (expandedPreset->Output->MaxFailedTestOutputSize) {
-      this->Impl->TestHandler.SetTestOutputSizeFailed(
+      this->Impl->TestOptions.OutputSizeFailed =
-        *expandedPreset->Output->MaxFailedTestOutputSize);
+        *expandedPreset->Output->MaxFailedTestOutputSize;
     }
 
     if (expandedPreset->Output->TestOutputTruncation) {
-      this->Impl->TestHandler.TestOutputTruncation =
+      this->Impl->TestOptions.OutputTruncation =
         *expandedPreset->Output->TestOutputTruncation;
     }
 
@@ -2473,8 +2476,8 @@ int cmCTest::Run(std::vector<std::string> const& args)
                      [this](std::string const& sz) -> bool {
                        long outputSize;
                        if (cmStrToLong(sz, &outputSize)) {
-                         this->Impl->TestHandler.SetTestOutputSizePassed(
+                         this->Impl->TestOptions.OutputSizePassed =
-                           static_cast<int>(outputSize));
+                           static_cast<int>(outputSize);
                        } else {
                          cmCTestLog(
                            this, WARNING,
@@ -2487,8 +2490,8 @@ int cmCTest::Run(std::vector<std::string> const& args)
                      [this](std::string const& sz) -> bool {
                        long outputSize;
                        if (cmStrToLong(sz, &outputSize)) {
-                         this->Impl->TestHandler.SetTestOutputSizeFailed(
+                         this->Impl->TestOptions.OutputSizeFailed =
-                           static_cast<int>(outputSize));
+                           static_cast<int>(outputSize);
                        } else {
                          cmCTestLog(
                            this, WARNING,
@@ -2500,7 +2503,8 @@ int cmCTest::Run(std::vector<std::string> const& args)
     CommandArgument{
       "--test-output-truncation", CommandArgument::Values::One,
       [this](std::string const& mode) -> bool {
-        if (!this->Impl->TestHandler.SetTestOutputTruncation(mode)) {
+        if (!SetTruncationMode(this->Impl->TestOptions.OutputTruncation,
+                               mode)) {
           cmSystemTools::Error(
             cmStrCat("Invalid value for '--test-output-truncation': ", mode));
           return false;
@@ -3264,6 +3268,11 @@ std::string cmCTest::GetBuildID() const
   return this->Impl->BuildID;
 }
 
+cmCTestTestOptions const& cmCTest::GetTestOptions() const
+{
+  return this->Impl->TestOptions;
+}
+
 void cmCTest::AddSubmitFile(Part part, const std::string& name)
 {
   this->Impl->Parts[part].SubmitFiles.emplace_back(name);

Source/cmCTest.h

@@ -32,6 +32,7 @@ class cmGeneratedFileStream;
 class cmMakefile;
 class cmValue;
 class cmXMLWriter;
+struct cmCTestTestOptions;
 
 /** \class cmCTest
  * \brief Represents a ctest invocation.
@@ -444,6 +445,8 @@ public:
   /** Reread the configuration file */
   bool UpdateCTestConfiguration();
 
+  cmCTestTestOptions const& GetTestOptions() const;
+
 private:
   void SetPersistentOptionIfNotEmpty(const std::string& value,
                                      const std::string& optionName);