cmCTest: Remove handler instances

Source/CTest/cmCTestBuildCommand.cxx

@@ -9,6 +9,7 @@
 
 #include "cmCTest.h"
 #include "cmCTestBuildHandler.h"
+#include "cmCTestGenericHandler.h"
 #include "cmCommand.h"
 #include "cmGlobalGenerator.h"
 #include "cmMakefile.h"
@@ -39,10 +40,9 @@ void cmCTestBuildCommand::BindArguments()
 
 cmCTestBuildCommand::~cmCTestBuildCommand() = default;
 
-cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
+std::unique_ptr<cmCTestGenericHandler> cmCTestBuildCommand::InitializeHandler()
 {
-  cmCTestBuildHandler* handler = this->CTest->GetBuildHandler();
-  handler->Initialize(this->CTest);
+  auto handler = cm::make_unique<cmCTestBuildHandler>(this->CTest);
 
   cmValue ctestBuildCommand =
     this->Makefile->GetDefinition("CTEST_BUILD_COMMAND");
@@ -133,7 +133,7 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
   }
 
   handler->SetQuiet(this->Quiet);
-  return handler;
+  return std::unique_ptr<cmCTestGenericHandler>(std::move(handler));
 }
 
 void cmCTestBuildCommand::ProcessAdditionalValues(

Source/CTest/cmCTestBuildCommand.h

@@ -39,7 +39,7 @@ public:
 protected:
   void ProcessAdditionalValues(cmCTestGenericHandler* handler) override;
   void BindArguments() override;
-  cmCTestGenericHandler* InitializeHandler() override;
+  std::unique_ptr<cmCTestGenericHandler> InitializeHandler() override;
 
   std::string NumberErrors;
   std::string NumberWarnings;

Source/CTest/cmCTestBuildHandler.cxx

@@ -176,7 +176,8 @@ static cmCTestBuildCompileErrorWarningRex cmCTestWarningErrorFileLine[] = {
   { nullptr, 0, 0 }
 };
 
-cmCTestBuildHandler::cmCTestBuildHandler()
+cmCTestBuildHandler::cmCTestBuildHandler(cmCTest* ctest)
+  : Superclass(ctest)
 {
   this->MaxPreContext = 10;
   this->MaxPostContext = 10;
@@ -187,39 +188,10 @@ cmCTestBuildHandler::cmCTestBuildHandler()
   this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
 
   this->UseCTestLaunch = false;
-}
 
-void cmCTestBuildHandler::Initialize(cmCTest* ctest)
-{
-  this->Superclass::Initialize(ctest);
-  this->StartBuild.clear();
-  this->EndBuild.clear();
-  this->CustomErrorMatches.clear();
-  this->CustomErrorExceptions.clear();
-  this->CustomWarningMatches.clear();
-  this->CustomWarningExceptions.clear();
-  this->ReallyCustomWarningMatches.clear();
-  this->ReallyCustomWarningExceptions.clear();
-  this->ErrorWarningFileLineRegex.clear();
-
-  this->ErrorMatchRegex.clear();
-  this->ErrorExceptionRegex.clear();
-  this->WarningMatchRegex.clear();
-  this->WarningExceptionRegex.clear();
-  this->BuildProcessingQueue.clear();
-  this->BuildProcessingErrorQueue.clear();
   this->BuildOutputLogSize = 0;
-  this->CurrentProcessingLine.clear();
-
-  this->SimplifySourceDir.clear();
-  this->SimplifyBuildDir.clear();
   this->OutputLineCounter = 0;
-  this->ErrorsAndWarnings.clear();
-  this->LastErrorOrWarning = this->ErrorsAndWarnings.end();
   this->PostContextCount = 0;
-  this->MaxPreContext = 10;
-  this->MaxPostContext = 10;
-  this->PreContext.clear();
 
   this->TotalErrors = 0;
   this->TotalWarnings = 0;
@@ -227,11 +199,6 @@ void cmCTestBuildHandler::Initialize(cmCTest* ctest)
 
   this->ErrorQuotaReached = false;
   this->WarningQuotaReached = false;
-
-  this->MaxErrors = 50;
-  this->MaxWarnings = 50;
-
-  this->UseCTestLaunch = false;
 }
 
 void cmCTestBuildHandler::PopulateCustomVectors(cmMakefile* mf)

Source/CTest/cmCTestBuildHandler.h

@@ -37,15 +37,10 @@ public:
    */
   int ProcessHandler() override;
 
-  cmCTestBuildHandler();
+  cmCTestBuildHandler(cmCTest* ctest);
 
   void PopulateCustomVectors(cmMakefile* mf) override;
 
-  /**
-   * Initialize handler
-   */
-  void Initialize(cmCTest* ctest) override;
-
   int GetTotalErrors() const { return this->TotalErrors; }
   int GetTotalWarnings() const { return this->TotalWarnings; }
 

Source/CTest/cmCTestConfigureCommand.cxx

@@ -10,6 +10,7 @@
 
 #include "cmCTest.h"
 #include "cmCTestConfigureHandler.h"
+#include "cmCTestGenericHandler.h"
 #include "cmGlobalGenerator.h"
 #include "cmList.h"
 #include "cmMakefile.h"
@@ -24,7 +25,8 @@ void cmCTestConfigureCommand::BindArguments()
   this->Bind("OPTIONS"_s, this->Options);
 }
 
-cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
+std::unique_ptr<cmCTestGenericHandler>
+cmCTestConfigureCommand::InitializeHandler()
 {
   cmList options;
 
@@ -149,8 +151,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
                                        *labelsForSubprojects, this->Quiet);
   }
 
-  cmCTestConfigureHandler* handler = this->CTest->GetConfigureHandler();
-  handler->Initialize(this->CTest);
+  auto handler = cm::make_unique<cmCTestConfigureHandler>(this->CTest);
   handler->SetQuiet(this->Quiet);
-  return handler;
+  return std::unique_ptr<cmCTestGenericHandler>(std::move(handler));
 }

Source/CTest/cmCTestConfigureCommand.h

@@ -39,7 +39,7 @@ public:
 
 protected:
   void BindArguments() override;
-  cmCTestGenericHandler* InitializeHandler() override;
+  std::unique_ptr<cmCTestGenericHandler> InitializeHandler() override;
 
   std::string Options;
 };

Source/CTest/cmCTestConfigureHandler.cxx

@@ -11,11 +11,9 @@
 #include "cmGeneratedFileStream.h"
 #include "cmXMLWriter.h"
 
-cmCTestConfigureHandler::cmCTestConfigureHandler() = default;
-
-void cmCTestConfigureHandler::Initialize(cmCTest* ctest)
+cmCTestConfigureHandler::cmCTestConfigureHandler(cmCTest* ctest)
+  : Superclass(ctest)
 {
-  this->Superclass::Initialize(ctest);
 }
 
 // clearly it would be nice if this were broken up into a few smaller

Source/CTest/cmCTestConfigureHandler.h

@@ -22,7 +22,5 @@ public:
    */
   int ProcessHandler() override;
 
-  cmCTestConfigureHandler();
-
-  void Initialize(cmCTest* ctest) override;
+  cmCTestConfigureHandler(cmCTest* ctest);
 };

Source/CTest/cmCTestCoverageCommand.cxx

@@ -8,8 +8,7 @@
 
 #include "cmCTest.h"
 #include "cmCTestCoverageHandler.h"
-
-class cmCTestGenericHandler;
+#include "cmCTestGenericHandler.h"
 
 void cmCTestCoverageCommand::BindArguments()
 {
@@ -17,15 +16,15 @@ void cmCTestCoverageCommand::BindArguments()
   this->Bind("LABELS"_s, this->Labels);
 }
 
-cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
+std::unique_ptr<cmCTestGenericHandler>
+cmCTestCoverageCommand::InitializeHandler()
 {
   this->CTest->SetCTestConfigurationFromCMakeVariable(
     this->Makefile, "CoverageCommand", "CTEST_COVERAGE_COMMAND", this->Quiet);
   this->CTest->SetCTestConfigurationFromCMakeVariable(
     this->Makefile, "CoverageExtraFlags", "CTEST_COVERAGE_EXTRA_FLAGS",
     this->Quiet);
-  cmCTestCoverageHandler* handler = this->CTest->GetCoverageHandler();
-  handler->Initialize(this->CTest);
+  auto handler = cm::make_unique<cmCTestCoverageHandler>(this->CTest);
 
   // If a LABELS option was given, select only files with the labels.
   if (this->Labels) {
@@ -34,5 +33,5 @@ cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
   }
 
   handler->SetQuiet(this->Quiet);
-  return handler;
+  return std::unique_ptr<cmCTestGenericHandler>(std::move(handler));
 }

Source/CTest/cmCTestCoverageCommand.h

@@ -42,7 +42,7 @@ public:
 
 protected:
   void BindArguments() override;
-  cmCTestGenericHandler* InitializeHandler() override;
+  std::unique_ptr<cmCTestGenericHandler> InitializeHandler() override;
 
   cm::optional<ArgumentParser::MaybeEmpty<std::vector<std::string>>> Labels;
 };

Source/CTest/cmCTestCoverageHandler.cxx

@@ -40,17 +40,9 @@ class cmMakefile;
 
 #define SAFEDIV(x, y) (((y) != 0) ? ((x) / (y)) : (0))
 
-cmCTestCoverageHandler::cmCTestCoverageHandler() = default;
-
-void cmCTestCoverageHandler::Initialize(cmCTest* ctest)
+cmCTestCoverageHandler::cmCTestCoverageHandler(cmCTest* ctest)
+  : Superclass(ctest)
 {
-  this->Superclass::Initialize(ctest);
-  this->CustomCoverageExclude.clear();
-  this->SourceLabels.clear();
-  this->TargetDirs.clear();
-  this->LabelIdMap.clear();
-  this->Labels.clear();
-  this->LabelFilter.clear();
 }
 
 void cmCTestCoverageHandler::CleanCoverageLogFiles(std::ostream& log)

Source/CTest/cmCTestCoverageHandler.h

@@ -45,9 +45,7 @@ public:
    */
   int ProcessHandler() override;
 
-  cmCTestCoverageHandler();
-
-  void Initialize(cmCTest* ctest) override;
+  cmCTestCoverageHandler(cmCTest* ctest);
 
   /**
    * This method is called when reading CTest custom file

Source/CTest/cmCTestGenericHandler.cxx

@@ -8,28 +8,21 @@
 #include "cmStringAlgorithms.h"
 #include "cmSystemTools.h"
 
-cmCTestGenericHandler::cmCTestGenericHandler()
+cmCTestGenericHandler::cmCTestGenericHandler(cmCTest* ctest)
+  : CTest(ctest)
 {
   this->HandlerVerbose = cmSystemTools::OUTPUT_NONE;
-  this->CTest = nullptr;
   this->SubmitIndex = 0;
   this->AppendXML = false;
   this->Quiet = false;
   this->TestLoad = 0;
-}
-
-cmCTestGenericHandler::~cmCTestGenericHandler() = default;
-
-void cmCTestGenericHandler::Initialize(cmCTest* ctest)
-{
-  this->CTest = ctest;
-  this->AppendXML = false;
-  this->TestLoad = 0;
 
   this->SetVerbose(ctest->GetExtraVerbose());
   this->SetSubmitIndex(ctest->GetSubmitIndex());
 }
 
+cmCTestGenericHandler::~cmCTestGenericHandler() = default;
+
 bool cmCTestGenericHandler::StartResultingXML(cmCTest::Part part,
                                               const char* name,
                                               cmGeneratedFileStream& xofs)

Source/CTest/cmCTestGenericHandler.h

@@ -41,11 +41,6 @@ public:
    */
   virtual int ProcessHandler() = 0;
 
-  /**
-   * Initialize handler
-   */
-  virtual void Initialize(cmCTest* ctest);
-
   /**
    * Get the CTest instance
    */
@@ -54,7 +49,7 @@ public:
   /**
    * Construct handler
    */
-  cmCTestGenericHandler();
+  cmCTestGenericHandler(cmCTest* ctest);
   virtual ~cmCTestGenericHandler();
 
   using t_StringToString = std::map<std::string, std::string>;

Source/CTest/cmCTestHandlerCommand.cxx

@@ -164,7 +164,7 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
   }
 
   cmCTestLog(this->CTest, DEBUG, "Initialize handler" << std::endl);
-  cmCTestGenericHandler* handler = this->InitializeHandler();
+  auto handler = this->InitializeHandler();
   if (!handler) {
     cmCTestLog(this->CTest, ERROR_MESSAGE,
                "Cannot instantiate test handler " << this->GetName()
@@ -208,7 +208,7 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
   if (!this->ReturnValue.empty()) {
     this->Makefile->AddDefinition(this->ReturnValue, std::to_string(res));
   }
-  this->ProcessAdditionalValues(handler);
+  this->ProcessAdditionalValues(handler.get());
   // log the error message if there was an error
   if (captureCMakeError) {
     const char* returnString = "0";

Source/CTest/cmCTestHandlerCommand.h

@@ -4,6 +4,7 @@
 
 #include "cmConfigure.h" // IWYU pragma: keep
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -38,7 +39,7 @@ public:
                    cmExecutionStatus& status) override;
 
 protected:
-  virtual cmCTestGenericHandler* InitializeHandler() = 0;
+  virtual std::unique_ptr<cmCTestGenericHandler> InitializeHandler() = 0;
 
   virtual void ProcessAdditionalValues(cmCTestGenericHandler* /*handler*/) {}
 

Source/CTest/cmCTestMemCheckCommand.cxx

@@ -6,6 +6,7 @@
 
 #include "cmCTest.h"
 #include "cmCTestMemCheckHandler.h"
+#include "cmCTestTestHandler.h"
 #include "cmMakefile.h"
 
 void cmCTestMemCheckCommand::BindArguments()
@@ -14,10 +15,10 @@ void cmCTestMemCheckCommand::BindArguments()
   this->Bind("DEFECT_COUNT"_s, this->DefectCount);
 }
 
-cmCTestTestHandler* cmCTestMemCheckCommand::InitializeActualHandler()
+std::unique_ptr<cmCTestTestHandler>
+cmCTestMemCheckCommand::InitializeActualHandler()
 {
-  cmCTestMemCheckHandler* handler = this->CTest->GetMemCheckHandler();
-  handler->Initialize(this->CTest);
+  auto handler = cm::make_unique<cmCTestMemCheckHandler>(this->CTest);
 
   this->CTest->SetCTestConfigurationFromCMakeVariable(
     this->Makefile, "MemoryCheckType", "CTEST_MEMORYCHECK_TYPE", this->Quiet);
@@ -35,7 +36,7 @@ cmCTestTestHandler* cmCTestMemCheckCommand::InitializeActualHandler()
     "CTEST_MEMORYCHECK_SUPPRESSIONS_FILE", this->Quiet);
 
   handler->SetQuiet(this->Quiet);
-  return handler;
+  return std::unique_ptr<cmCTestTestHandler>(std::move(handler));
 }
 
 void cmCTestMemCheckCommand::ProcessAdditionalValues(

Source/CTest/cmCTestMemCheckCommand.h

@@ -36,7 +36,7 @@ public:
 protected:
   void BindArguments() override;
 
-  cmCTestTestHandler* InitializeActualHandler() override;
+  std::unique_ptr<cmCTestTestHandler> InitializeActualHandler() override;
 
   void ProcessAdditionalValues(cmCTestGenericHandler* handler) override;
 

Source/CTest/cmCTestMemCheckHandler.cxx

@@ -118,25 +118,14 @@ public:
 #define BOUNDS_CHECKER_MARKER                                                 \
   "******######*****Begin BOUNDS CHECKER XML******######******"
 
-cmCTestMemCheckHandler::cmCTestMemCheckHandler()
+cmCTestMemCheckHandler::cmCTestMemCheckHandler(cmCTest* ctest)
+  : Superclass(ctest)
 {
   this->MemCheck = true;
   this->TestOptions.OutputSizePassed = 0;
   this->TestOptions.OutputSizeFailed = 0;
   this->LogWithPID = false;
-}
-
-void cmCTestMemCheckHandler::Initialize(cmCTest* ctest)
-{
-  this->Superclass::Initialize(ctest);
-  this->LogWithPID = false;
-  this->TestOptions.OutputSizePassed = 0;
-  this->TestOptions.OutputSizeFailed = 0;
-  this->MemoryTester.clear();
-  this->MemoryTesterDynamicOptions.clear();
-  this->MemoryTesterOptions.clear();
   this->MemoryTesterStyle = UNKNOWN;
-  this->MemoryTesterOutputFile.clear();
   this->DefectCount = 0;
 }
 

Source/CTest/cmCTestMemCheckHandler.h

@@ -26,9 +26,7 @@ public:
 
   void PopulateCustomVectors(cmMakefile* mf) override;
 
-  cmCTestMemCheckHandler();
-
-  void Initialize(cmCTest* ctest) override;
+  cmCTestMemCheckHandler(cmCTest* ctest);
 
   int GetDefectCount() const;
 

Source/CTest/cmCTestSubmitCommand.cxx

@@ -11,6 +11,7 @@
 #include <cmext/string_view>
 
 #include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
 #include "cmCTestSubmitHandler.h"
 #include "cmCommand.h"
 #include "cmList.h"
@@ -32,7 +33,8 @@ std::unique_ptr<cmCommand> cmCTestSubmitCommand::Clone()
   return std::unique_ptr<cmCommand>(std::move(ni));
 }
 
-cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
+std::unique_ptr<cmCTestGenericHandler>
+cmCTestSubmitCommand::InitializeHandler()
 {
   cmValue submitURL = !this->SubmitURL.empty()
     ? cmValue(this->SubmitURL)
@@ -122,8 +124,7 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
     }
   }
 
-  cmCTestSubmitHandler* handler = this->CTest->GetSubmitHandler();
-  handler->Initialize(this->CTest);
+  auto handler = cm::make_unique<cmCTestSubmitHandler>(this->CTest);
 
   // If no FILES or PARTS given, *all* PARTS are submitted by default.
   //
@@ -176,7 +177,7 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
     handler->CDashUploadFile = this->CDashUploadFile;
     handler->CDashUploadType = this->CDashUploadType;
   }
-  return handler;
+  return std::unique_ptr<cmCTestGenericHandler>(std::move(handler));
 }
 
 bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args,

Source/CTest/cmCTestSubmitCommand.h

@@ -39,7 +39,7 @@ public:
 protected:
   void BindArguments() override;
   void CheckArguments() override;
-  cmCTestGenericHandler* InitializeHandler() override;
+  std::unique_ptr<cmCTestGenericHandler> InitializeHandler() override;
 
   bool CDashUpload = false;
   bool InternalTest = false;

Source/CTest/cmCTestSubmitHandler.cxx

@@ -116,11 +116,10 @@ static size_t cmCTestSubmitHandlerCurlDebugCallback(CURL* /*unused*/,
   return 0;
 }
 
-cmCTestSubmitHandler::cmCTestSubmitHandler() = default;
-
-void cmCTestSubmitHandler::Initialize(cmCTest* ctest)
+cmCTestSubmitHandler::cmCTestSubmitHandler(cmCTest* ctest)
+  : Superclass(ctest)
+  , HttpHeaders(ctest->GetCommandLineHttpHeaders())
 {
-  this->Superclass::Initialize(ctest);
   // We submit all available parts by default.
   for (cmCTest::Part p = cmCTest::PartStart; p != cmCTest::PartCount;
        p = static_cast<cmCTest::Part>(p + 1)) {
@@ -128,12 +127,8 @@ void cmCTestSubmitHandler::Initialize(cmCTest* ctest)
   }
   this->HasWarnings = false;
   this->HasErrors = false;
-  this->HTTPProxy.clear();
   this->HTTPProxyType = 0;
-  this->HTTPProxyAuth.clear();
   this->LogFile = nullptr;
-  this->Files.clear();
-  this->HttpHeaders = ctest->GetCommandLineHttpHeaders();
 }
 
 bool cmCTestSubmitHandler::SubmitUsingHTTP(

Source/CTest/cmCTestSubmitHandler.h

@@ -23,7 +23,7 @@ class cmCTestSubmitHandler : public cmCTestGenericHandler
 public:
   using Superclass = cmCTestGenericHandler;
 
-  cmCTestSubmitHandler();
+  cmCTestSubmitHandler(cmCTest* ctest);
   ~cmCTestSubmitHandler() override { this->LogFile = nullptr; }
 
   /*
@@ -31,8 +31,6 @@ public:
    */
   int ProcessHandler() override;
 
-  void Initialize(cmCTest* ctest) override;
-
   /** Specify a set of parts (by name) to submit.  */
   void SelectParts(std::set<cmCTest::Part> const& parts);
 

Source/CTest/cmCTestTestCommand.cxx

@@ -11,6 +11,7 @@
 #include <cmext/string_view>
 
 #include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
 #include "cmCTestTestHandler.h"
 #include "cmDuration.h"
 #include "cmMakefile.h"
@@ -42,7 +43,7 @@ void cmCTestTestCommand::BindArguments()
   this->Bind("OUTPUT_JUNIT"_s, this->OutputJUnit);
 }
 
-cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
+std::unique_ptr<cmCTestGenericHandler> cmCTestTestCommand::InitializeHandler()
 {
   cmValue ctestTimeout = this->Makefile->GetDefinition("CTEST_TEST_TIMEOUT");
 
@@ -64,7 +65,7 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
     this->ResourceSpecFile = *resourceSpecFile;
   }
 
-  cmCTestTestHandler* handler = this->InitializeActualHandler();
+  auto handler = this->InitializeActualHandler();
   if (!this->Start.empty() || !this->End.empty() || !this->Stride.empty()) {
     handler->TestOptions.TestsToRunInformation =
       cmStrCat(this->Start, ',', this->End, ',', this->Stride);
@@ -156,12 +157,11 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
   }
 
   handler->SetQuiet(this->Quiet);
-  return handler;
+  return std::unique_ptr<cmCTestGenericHandler>(std::move(handler));
 }
 
-cmCTestTestHandler* cmCTestTestCommand::InitializeActualHandler()
+std::unique_ptr<cmCTestTestHandler>
+cmCTestTestCommand::InitializeActualHandler()
 {
-  cmCTestTestHandler* handler = this->CTest->GetTestHandler();
-  handler->Initialize(this->CTest);
-  return handler;
+  return cm::make_unique<cmCTestTestHandler>(this->CTest);
 }

Source/CTest/cmCTestTestCommand.h

@@ -42,8 +42,8 @@ public:
 
 protected:
   void BindArguments() override;
-  virtual cmCTestTestHandler* InitializeActualHandler();
-  cmCTestGenericHandler* InitializeHandler() override;
+  virtual std::unique_ptr<cmCTestTestHandler> InitializeActualHandler();
+  std::unique_ptr<cmCTestGenericHandler> InitializeHandler() override;
 
   std::string Start;
   std::string End;

Source/CTest/cmCTestTestHandler.cxx

@@ -274,7 +274,9 @@ inline int GetNextRealNumber(std::string const& in, double& val,
 
 } // namespace
 
-cmCTestTestHandler::cmCTestTestHandler()
+cmCTestTestHandler::cmCTestTestHandler(cmCTest* ctest)
+  : Superclass(ctest)
+  , TestOptions(ctest->GetTestOptions())
 {
   this->UseIncludeRegExpFlag = false;
   this->UseExcludeRegExpFlag = false;
@@ -302,36 +304,8 @@ cmCTestTestHandler::cmCTestTestHandler()
 
   // Capture content from <CTestLabel>...</CTestLabel>
   this->CustomLabelRegex.compile("<CTestLabel>(.*)</CTestLabel>");
-}
-
-void cmCTestTestHandler::Initialize(cmCTest* ctest)
-{
-  this->Superclass::Initialize(ctest);
-  this->TestOptions = ctest->GetTestOptions();
 
   this->ElapsedTestingTime = cmDuration();
-
-  this->TestResults.clear();
-
-  this->CustomTestsIgnore.clear();
-  this->StartTest.clear();
-  this->EndTest.clear();
-
-  this->CustomPreTest.clear();
-  this->CustomPostTest.clear();
-
-  this->TestsToRun.clear();
-
-  this->UseIncludeRegExpFlag = false;
-  this->UseExcludeRegExpFlag = false;
-  this->UseExcludeRegExpFirst = false;
-  this->IncludeLabelRegularExpressions.clear();
-  this->ExcludeLabelRegularExpressions.clear();
-  this->TestsToRunByName.reset();
-  this->TestsToExcludeByName.reset();
-
-  this->TestsToRunString.clear();
-  this->TestList.clear();
 }
 
 void cmCTestTestHandler::PopulateCustomVectors(cmMakefile* mf)

Source/CTest/cmCTestTestHandler.h

@@ -91,7 +91,7 @@ public:
   //! pass the -I argument down
   void SetTestsToRunInformation(std::string const& in);
 
-  cmCTestTestHandler();
+  cmCTestTestHandler(cmCTest* ctest);
 
   /*
    * Add the test to the list of tests to be executed
@@ -108,8 +108,6 @@ public:
    */
   bool SetDirectoryProperties(const std::vector<std::string>& args);
 
-  void Initialize(cmCTest* ctest) override;
-
   struct cmCTestTestResourceRequirement
   {
     std::string ResourceType;

Source/CTest/cmCTestUpdateCommand.cxx

@@ -3,11 +3,13 @@
 #include "cmCTestUpdateCommand.h"
 
 #include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
 #include "cmCTestUpdateHandler.h"
 #include "cmMakefile.h"
 #include "cmSystemTools.h"
 
-cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler()
+std::unique_ptr<cmCTestGenericHandler>
+cmCTestUpdateCommand::InitializeHandler()
 {
   if (!this->Source.empty()) {
     this->CTest->SetCTestConfiguration(
@@ -73,13 +75,12 @@ cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler()
   this->CTest->SetCTestConfigurationFromCMakeVariable(
     this->Makefile, "P4Options", "CTEST_P4_OPTIONS", this->Quiet);
 
-  cmCTestUpdateHandler* handler = this->CTest->GetUpdateHandler();
-  handler->Initialize(this->CTest);
+  auto handler = cm::make_unique<cmCTestUpdateHandler>(this->CTest);
   if (source_dir.empty()) {
     this->SetError("source directory not specified. Please use SOURCE tag");
     return nullptr;
   }
   handler->SourceDirectory = source_dir;
   handler->SetQuiet(this->Quiet);
-  return handler;
+  return std::unique_ptr<cmCTestGenericHandler>(std::move(handler));
 }

Source/CTest/cmCTestUpdateCommand.h

@@ -38,5 +38,5 @@ public:
   std::string GetName() const override { return "ctest_update"; }
 
 protected:
-  cmCTestGenericHandler* InitializeHandler() override;
+  std::unique_ptr<cmCTestGenericHandler> InitializeHandler() override;
 };

Source/CTest/cmCTestUpdateHandler.cxx

@@ -35,12 +35,9 @@ static const char* cmCTestUpdateHandlerUpdateToString(int type)
   return cmCTestUpdateHandlerUpdateStrings[type];
 }
 
-cmCTestUpdateHandler::cmCTestUpdateHandler() = default;
-
-void cmCTestUpdateHandler::Initialize(cmCTest* ctest)
+cmCTestUpdateHandler::cmCTestUpdateHandler(cmCTest* ctest)
+  : Superclass(ctest)
 {
-  this->Superclass::Initialize(ctest);
-  this->UpdateCommand.clear();
   this->UpdateType = e_CVS;
 }
 

Source/CTest/cmCTestUpdateHandler.h

@@ -26,7 +26,7 @@ public:
    */
   int ProcessHandler() override;
 
-  cmCTestUpdateHandler();
+  cmCTestUpdateHandler(cmCTest* ctest);
 
   enum
   {
@@ -40,11 +40,6 @@ public:
     e_LAST
   };
 
-  /**
-   * Initialize handler
-   */
-  void Initialize(cmCTest* ctest) override;
-
 private:
   // Some structures needed for update
   struct StringPair : public std::pair<std::string, std::string>

Source/CTest/cmCTestUploadCommand.cxx

@@ -8,7 +8,7 @@
 #include <cm/vector>
 #include <cmext/string_view>
 
-#include "cmCTest.h"
+#include "cmCTestGenericHandler.h"
 #include "cmCTestUploadHandler.h"
 #include "cmMakefile.h"
 #include "cmMessageType.h"
@@ -35,12 +35,12 @@ void cmCTestUploadCommand::CheckArguments()
   });
 }
 
-cmCTestGenericHandler* cmCTestUploadCommand::InitializeHandler()
+std::unique_ptr<cmCTestGenericHandler>
+cmCTestUploadCommand::InitializeHandler()
 {
-  cmCTestUploadHandler* handler = this->CTest->GetUploadHandler();
-  handler->Initialize(this->CTest);
+  auto handler = cm::make_unique<cmCTestUploadHandler>(this->CTest);
   handler->SetFiles(
     std::set<std::string>(this->Files.begin(), this->Files.end()));
   handler->SetQuiet(this->Quiet);
-  return handler;
+  return std::unique_ptr<cmCTestGenericHandler>(std::move(handler));
 }

Source/CTest/cmCTestUploadCommand.h

@@ -43,7 +43,7 @@ public:
 protected:
   void BindArguments() override;
   void CheckArguments() override;
-  cmCTestGenericHandler* InitializeHandler() override;
+  std::unique_ptr<cmCTestGenericHandler> InitializeHandler() override;
 
   ArgumentParser::MaybeEmpty<std::vector<std::string>> Files;
 };

Source/CTest/cmCTestUploadHandler.cxx

@@ -11,12 +11,9 @@
 #include "cmVersion.h"
 #include "cmXMLWriter.h"
 
-cmCTestUploadHandler::cmCTestUploadHandler() = default;
-
-void cmCTestUploadHandler::Initialize(cmCTest* ctest)
+cmCTestUploadHandler::cmCTestUploadHandler(cmCTest* ctest)
+  : Superclass(ctest)
 {
-  this->Superclass::Initialize(ctest);
-  this->Files.clear();
 }
 
 void cmCTestUploadHandler::SetFiles(std::set<std::string> const& files)

Source/CTest/cmCTestUploadHandler.h

@@ -22,15 +22,13 @@ class cmCTestUploadHandler : public cmCTestGenericHandler
 public:
   using Superclass = cmCTestGenericHandler;
 
-  cmCTestUploadHandler();
+  cmCTestUploadHandler(cmCTest* ctest);
 
   /*
    * The main entry point for this class
    */
   int ProcessHandler() override;
 
-  void Initialize(cmCTest* ctest) override;
-
   /** Specify a set of files to submit.  */
   void SetFiles(std::set<std::string> const& files);
 

Source/cmCTest.cxx

@@ -42,16 +42,9 @@
 
 #include "cmCMakePresetsGraph.h"
 #include "cmCTestBuildAndTest.h"
-#include "cmCTestBuildHandler.h"
-#include "cmCTestConfigureHandler.h"
-#include "cmCTestCoverageHandler.h"
-#include "cmCTestMemCheckHandler.h"
 #include "cmCTestScriptHandler.h"
-#include "cmCTestSubmitHandler.h"
 #include "cmCTestTestHandler.h"
 #include "cmCTestTypes.h"
-#include "cmCTestUpdateHandler.h"
-#include "cmCTestUploadHandler.h"
 #include "cmCommandLineArgument.h"
 #include "cmDynamicLoader.h"
 #include "cmExecutionStatus.h"
@@ -123,15 +116,7 @@ struct cmCTest::Private
   bool FlushTestProgressLine = false;
 
   // these are helper classes
-  cmCTestBuildHandler BuildHandler;
   cmCTestBuildAndTest BuildAndTest;
-  cmCTestCoverageHandler CoverageHandler;
-  cmCTestTestHandler TestHandler;
-  cmCTestUpdateHandler UpdateHandler;
-  cmCTestConfigureHandler ConfigureHandler;
-  cmCTestMemCheckHandler MemCheckHandler;
-  cmCTestSubmitHandler SubmitHandler;
-  cmCTestUploadHandler UploadHandler;
 
   bool ShowOnly = false;
   bool OutputAsJson = false;
@@ -714,46 +699,6 @@ bool cmCTest::CTestFileExists(const std::string& filename)
   return cmSystemTools::FileExists(testingDir);
 }
 
-cmCTestBuildHandler* cmCTest::GetBuildHandler()
-{
-  return &this->Impl->BuildHandler;
-}
-
-cmCTestCoverageHandler* cmCTest::GetCoverageHandler()
-{
-  return &this->Impl->CoverageHandler;
-}
-
-cmCTestTestHandler* cmCTest::GetTestHandler()
-{
-  return &this->Impl->TestHandler;
-}
-
-cmCTestUpdateHandler* cmCTest::GetUpdateHandler()
-{
-  return &this->Impl->UpdateHandler;
-}
-
-cmCTestConfigureHandler* cmCTest::GetConfigureHandler()
-{
-  return &this->Impl->ConfigureHandler;
-}
-
-cmCTestMemCheckHandler* cmCTest::GetMemCheckHandler()
-{
-  return &this->Impl->MemCheckHandler;
-}
-
-cmCTestSubmitHandler* cmCTest::GetSubmitHandler()
-{
-  return &this->Impl->SubmitHandler;
-}
-
-cmCTestUploadHandler* cmCTest::GetUploadHandler()
-{
-  return &this->Impl->UploadHandler;
-}
-
 int cmCTest::ProcessSteps()
 {
   this->Impl->ExtraVerbose = this->Impl->Verbose;
@@ -2749,7 +2694,7 @@ int cmCTest::ExecuteTests()
 
   cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
 
-  this->GetTestHandler()->Initialize(this);
+  cmCTestTestHandler handler(this);
 
   {
     cmake cm(cmake::RoleScript, cmState::CTest);
@@ -2759,11 +2704,11 @@ int cmCTest::ExecuteTests()
     cmGlobalGenerator gg(&cm);
     cmMakefile mf(&gg, cm.GetCurrentSnapshot());
     this->ReadCustomConfigurationFileTree(this->Impl->BinaryDir, &mf);
-    this->GetTestHandler()->PopulateCustomVectors(&mf);
+    handler.PopulateCustomVectors(&mf);
   }
 
-  this->GetTestHandler()->SetVerbose(this->Impl->Verbose);
-  if (this->GetTestHandler()->ProcessHandler() < 0) {
+  handler.SetVerbose(this->Impl->Verbose);
+  if (handler.ProcessHandler() < 0) {
     cmCTestLog(this, ERROR_MESSAGE, "Errors while running CTest\n");
     if (!this->Impl->OutputTestOutputOnTestFailure) {
       const std::string lastTestLog =

Source/cmCTest.h

@@ -20,14 +20,6 @@
 #include "cmProcessOutput.h"
 
 class cmake;
-class cmCTestBuildHandler;
-class cmCTestCoverageHandler;
-class cmCTestTestHandler;
-class cmCTestUpdateHandler;
-class cmCTestConfigureHandler;
-class cmCTestMemCheckHandler;
-class cmCTestSubmitHandler;
-class cmCTestUploadHandler;
 class cmGeneratedFileStream;
 class cmMakefile;
 class cmValue;
@@ -289,18 +281,6 @@ public:
   bool GetProduceXML();
   void SetProduceXML(bool v);
 
-  /**
-   * Get the handler object
-   */
-  cmCTestBuildHandler* GetBuildHandler();
-  cmCTestCoverageHandler* GetCoverageHandler();
-  cmCTestTestHandler* GetTestHandler();
-  cmCTestUpdateHandler* GetUpdateHandler();
-  cmCTestConfigureHandler* GetConfigureHandler();
-  cmCTestMemCheckHandler* GetMemCheckHandler();
-  cmCTestSubmitHandler* GetSubmitHandler();
-  cmCTestUploadHandler* GetUploadHandler();
-
   /**
    * Set the CTest variable from CMake variable
    */