Merge topic 'ctest-handler-refactoring-pre'

f5a314cc35 cmCTestGenericHandler: Add cmCTest* argument to Initialize function
20b35ef622 cmCTestBuildCommand: Make use of ProcessAdditionalValues
b3c01f70b5 ctest: Print documentation without creating a cmCTest instance
66460dc4d7 cmCTest: Cleanup ReadCustomConfigurationFileTree function
812f8cce5a cmCTest: Cleanup PopulateCustomVectors calls
e279ba06dc cmCTest: Inline InitializeTesting at its call site

Acked-by: Kitware Robot <[email protected]>
Tested-by: buildbot <[email protected]>
Merge-request: !9934

Source/CTest/cmCTestBuildCommand.cxx

@@ -18,8 +18,6 @@
 #include "cmValue.h"
 #include "cmake.h"
 
-class cmExecutionStatus;
-
 std::unique_ptr<cmCommand> cmCTestBuildCommand::Clone()
 {
   auto ni = cm::make_unique<cmCTestBuildCommand>();
@@ -44,9 +42,7 @@ cmCTestBuildCommand::~cmCTestBuildCommand() = default;
 cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
 {
   cmCTestBuildHandler* handler = this->CTest->GetBuildHandler();
-  handler->Initialize();
-
-  this->Handler = handler;
+  handler->Initialize(this->CTest);
 
   cmValue ctestBuildCommand =
     this->Makefile->GetDefinition("CTEST_BUILD_COMMAND");
@@ -140,17 +136,16 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler()
   return handler;
 }
 
-bool cmCTestBuildCommand::InitialPass(std::vector<std::string> const& args,
-                                      cmExecutionStatus& status)
+void cmCTestBuildCommand::ProcessAdditionalValues(
+  cmCTestGenericHandler* generic)
 {
-  bool ret = this->cmCTestHandlerCommand::InitialPass(args, status);
+  auto const* handler = static_cast<cmCTestBuildHandler*>(generic);
   if (!this->NumberErrors.empty()) {
-    this->Makefile->AddDefinition(
-      this->NumberErrors, std::to_string(this->Handler->GetTotalErrors()));
+    this->Makefile->AddDefinition(this->NumberErrors,
+                                  std::to_string(handler->GetTotalErrors()));
   }
   if (!this->NumberWarnings.empty()) {
-    this->Makefile->AddDefinition(
-      this->NumberWarnings, std::to_string(this->Handler->GetTotalWarnings()));
+    this->Makefile->AddDefinition(this->NumberWarnings,
+                                  std::to_string(handler->GetTotalWarnings()));
   }
-  return ret;
 }

Source/CTest/cmCTestBuildCommand.h

@@ -5,16 +5,13 @@
 #include "cmConfigure.h" // IWYU pragma: keep
 
 #include <string>
-#include <vector>
 
 #include <cm/memory>
 
 #include "cmCTestHandlerCommand.h"
 
 class cmCommand;
-class cmCTestBuildHandler;
 class cmCTestGenericHandler;
-class cmExecutionStatus;
 class cmGlobalGenerator;
 
 /** \class cmCTestBuild
@@ -37,13 +34,10 @@ public:
    */
   std::string GetName() const override { return "ctest_build"; }
 
-  bool InitialPass(std::vector<std::string> const& args,
-                   cmExecutionStatus& status) override;
-
   std::unique_ptr<cmGlobalGenerator> GlobalGenerator;
 
 protected:
-  cmCTestBuildHandler* Handler;
+  void ProcessAdditionalValues(cmCTestGenericHandler* handler) override;
   void BindArguments() override;
   cmCTestGenericHandler* InitializeHandler() override;
 

Source/CTest/cmCTestBuildHandler.cxx

@@ -189,9 +189,9 @@ cmCTestBuildHandler::cmCTestBuildHandler()
   this->UseCTestLaunch = false;
 }
 
-void cmCTestBuildHandler::Initialize()
+void cmCTestBuildHandler::Initialize(cmCTest* ctest)
 {
-  this->Superclass::Initialize();
+  this->Superclass::Initialize(ctest);
   this->StartBuild.clear();
   this->EndBuild.clear();
   this->CustomErrorMatches.clear();

Source/CTest/cmCTestBuildHandler.h

@@ -20,6 +20,7 @@
 class cmMakefile;
 class cmStringReplaceHelper;
 class cmXMLWriter;
+class cmCTest;
 
 /** \class cmCTestBuildHandler
  * \brief A class that handles ctest -S invocations
@@ -43,10 +44,10 @@ public:
   /**
    * Initialize handler
    */
-  void Initialize() override;
+  void Initialize(cmCTest* ctest) override;
 
-  int GetTotalErrors() { return this->TotalErrors; }
-  int GetTotalWarnings() { return this->TotalWarnings; }
+  int GetTotalErrors() const { return this->TotalErrors; }
+  int GetTotalWarnings() const { return this->TotalWarnings; }
 
 private:
   std::string GetMakeCommand();

Source/CTest/cmCTestConfigureCommand.cxx

@@ -150,7 +150,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler()
   }
 
   cmCTestConfigureHandler* handler = this->CTest->GetConfigureHandler();
-  handler->Initialize();
+  handler->Initialize(this->CTest);
   handler->SetQuiet(this->Quiet);
   return handler;
 }

Source/CTest/cmCTestConfigureHandler.cxx

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

Source/CTest/cmCTestConfigureHandler.h

@@ -6,6 +6,8 @@
 
 #include "cmCTestGenericHandler.h"
 
+class cmCTest;
+
 /** \class cmCTestConfigureHandler
  * \brief A class that handles ctest -S invocations
  *
@@ -22,5 +24,5 @@ public:
 
   cmCTestConfigureHandler();
 
-  void Initialize() override;
+  void Initialize(cmCTest* ctest) override;
 };

Source/CTest/cmCTestCoverageCommand.cxx

@@ -25,7 +25,7 @@ cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler()
     this->Makefile, "CoverageExtraFlags", "CTEST_COVERAGE_EXTRA_FLAGS",
     this->Quiet);
   cmCTestCoverageHandler* handler = this->CTest->GetCoverageHandler();
-  handler->Initialize();
+  handler->Initialize(this->CTest);
 
   // If a LABELS option was given, select only files with the labels.
   if (this->Labels) {

Source/CTest/cmCTestCoverageHandler.cxx

@@ -42,9 +42,9 @@ class cmMakefile;
 
 cmCTestCoverageHandler::cmCTestCoverageHandler() = default;
 
-void cmCTestCoverageHandler::Initialize()
+void cmCTestCoverageHandler::Initialize(cmCTest* ctest)
 {
-  this->Superclass::Initialize();
+  this->Superclass::Initialize(ctest);
   this->CustomCoverageExclude.clear();
   this->SourceLabels.clear();
   this->TargetDirs.clear();

Source/CTest/cmCTestCoverageHandler.h

@@ -17,6 +17,7 @@
 class cmGeneratedFileStream;
 class cmMakefile;
 class cmXMLWriter;
+class cmCTest;
 
 class cmCTestCoverageHandlerContainer
 {
@@ -46,7 +47,7 @@ public:
 
   cmCTestCoverageHandler();
 
-  void Initialize() override;
+  void Initialize(cmCTest* ctest) override;
 
   /**
    * This method is called when reading CTest custom file

Source/CTest/cmCTestGenericHandler.cxx

@@ -82,8 +82,9 @@ void cmCTestGenericHandler::AddPersistentMultiOption(const std::string& op,
   }
 }
 
-void cmCTestGenericHandler::Initialize()
+void cmCTestGenericHandler::Initialize(cmCTest* ctest)
 {
+  this->CTest = ctest;
   this->AppendXML = false;
   this->TestLoad = 0;
   this->Options = this->PersistentOptions;

Source/CTest/cmCTestGenericHandler.h

@@ -45,12 +45,11 @@ public:
   /**
    * Initialize handler
    */
-  virtual void Initialize();
+  virtual void Initialize(cmCTest* ctest);
 
   /**
-   * Set the CTest instance
+   * Get the CTest instance
    */
-  void SetCTestInstance(cmCTest* ctest) { this->CTest = ctest; }
   cmCTest* GetCTestInstance() { return this->CTest; }
 
   /**

Source/CTest/cmCTestHandlerCommand.cxx

@@ -223,10 +223,6 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args,
   return true;
 }
 
-void cmCTestHandlerCommand::ProcessAdditionalValues(cmCTestGenericHandler*)
-{
-}
-
 void cmCTestHandlerCommand::BindArguments()
 {
   this->BindParsedKeywords(this->ParsedKeywords);

Source/CTest/cmCTestHandlerCommand.h

@@ -40,7 +40,7 @@ public:
 protected:
   virtual cmCTestGenericHandler* InitializeHandler() = 0;
 
-  virtual void ProcessAdditionalValues(cmCTestGenericHandler* handler);
+  virtual void ProcessAdditionalValues(cmCTestGenericHandler* /*handler*/) {}
 
   // Command argument handling.
   virtual void BindArguments();
@@ -55,8 +55,3 @@ protected:
   std::string Source;
   std::string SubmitIndex;
 };
-
-#define CTEST_COMMAND_APPEND_OPTION_DOCS                                      \
-  "The APPEND option marks results for append to those previously "           \
-  "submitted to a dashboard server since the last ctest_start.  "             \
-  "Append semantics are defined by the dashboard server in use."

Source/CTest/cmCTestMemCheckCommand.cxx

@@ -17,7 +17,7 @@ void cmCTestMemCheckCommand::BindArguments()
 cmCTestTestHandler* cmCTestMemCheckCommand::InitializeActualHandler()
 {
   cmCTestMemCheckHandler* handler = this->CTest->GetMemCheckHandler();
-  handler->Initialize();
+  handler->Initialize(this->CTest);
 
   this->CTest->SetCTestConfigurationFromCMakeVariable(
     this->Makefile, "MemoryCheckType", "CTEST_MEMORYCHECK_TYPE", this->Quiet);

Source/CTest/cmCTestMemCheckHandler.cxx

@@ -126,9 +126,9 @@ cmCTestMemCheckHandler::cmCTestMemCheckHandler()
   this->LogWithPID = false;
 }
 
-void cmCTestMemCheckHandler::Initialize()
+void cmCTestMemCheckHandler::Initialize(cmCTest* ctest)
 {
-  this->Superclass::Initialize();
+  this->Superclass::Initialize(ctest);
   this->LogWithPID = false;
   this->CustomMaximumPassedTestOutputSize = 0;
   this->CustomMaximumFailedTestOutputSize = 0;

Source/CTest/cmCTestMemCheckHandler.h

@@ -11,6 +11,7 @@
 
 class cmMakefile;
 class cmXMLWriter;
+class cmCTest;
 
 /** \class cmCTestMemCheckHandler
  * \brief A class that handles ctest -S invocations
@@ -27,7 +28,7 @@ public:
 
   cmCTestMemCheckHandler();
 
-  void Initialize() override;
+  void Initialize(cmCTest* ctest) override;
 
   int GetDefectCount() const;
 

Source/CTest/cmCTestScriptHandler.cxx

@@ -42,9 +42,9 @@
 
 cmCTestScriptHandler::cmCTestScriptHandler() = default;
 
-void cmCTestScriptHandler::Initialize()
+void cmCTestScriptHandler::Initialize(cmCTest* ctest)
 {
-  this->Superclass::Initialize();
+  this->Superclass::Initialize(ctest);
 
   // what time in seconds did this script start running
   this->ScriptStartTime = std::chrono::steady_clock::time_point();
@@ -362,7 +362,7 @@ bool cmCTestScriptHandler::RunScript(cmCTest* ctest, cmMakefile* mf,
                                      int* returnValue)
 {
   auto sh = cm::make_unique<cmCTestScriptHandler>();
-  sh->SetCTestInstance(ctest);
+  sh->Initialize(ctest);
   sh->ParentMakefile = mf;
   sh->AddConfigurationScript(sname, InProcess);
   int res = sh->ProcessHandler();

Source/CTest/cmCTestScriptHandler.h

@@ -60,7 +60,7 @@ public:
   const cmCTestScriptHandler& operator=(const cmCTestScriptHandler&) = delete;
   ~cmCTestScriptHandler() override;
 
-  void Initialize() override;
+  void Initialize(cmCTest* ctest) override;
 
   void CreateCMake();
   cmake* GetCMake() { return this->CMake.get(); }

Source/CTest/cmCTestSubmitCommand.cxx

@@ -122,7 +122,7 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler()
   }
 
   cmCTestSubmitHandler* handler = this->CTest->GetSubmitHandler();
-  handler->Initialize();
+  handler->Initialize(this->CTest);
 
   // If no FILES or PARTS given, *all* PARTS are submitted by default.
   //

Source/CTest/cmCTestSubmitHandler.cxx

@@ -117,13 +117,11 @@ static size_t cmCTestSubmitHandlerCurlDebugCallback(CURL* /*unused*/,
   return 0;
 }
 
-cmCTestSubmitHandler::cmCTestSubmitHandler()
-{
-  this->Initialize();
-}
+cmCTestSubmitHandler::cmCTestSubmitHandler() = default;
 
-void cmCTestSubmitHandler::Initialize()
+void cmCTestSubmitHandler::Initialize(cmCTest* ctest)
 {
+  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)) {
@@ -131,7 +129,6 @@ void cmCTestSubmitHandler::Initialize()
   }
   this->HasWarnings = false;
   this->HasErrors = false;
-  this->Superclass::Initialize();
   this->HTTPProxy.clear();
   this->HTTPProxyType = 0;
   this->HTTPProxyAuth.clear();

Source/CTest/cmCTestSubmitHandler.h

@@ -31,7 +31,7 @@ public:
    */
   int ProcessHandler() override;
 
-  void Initialize() 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

@@ -162,6 +162,6 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
 cmCTestTestHandler* cmCTestTestCommand::InitializeActualHandler()
 {
   cmCTestTestHandler* handler = this->CTest->GetTestHandler();
-  handler->Initialize();
+  handler->Initialize(this->CTest);
   return handler;
 }

Source/CTest/cmCTestTestHandler.cxx

@@ -313,9 +313,9 @@ cmCTestTestHandler::cmCTestTestHandler()
   this->CustomLabelRegex.compile("<CTestLabel>(.*)</CTestLabel>");
 }
 
-void cmCTestTestHandler::Initialize()
+void cmCTestTestHandler::Initialize(cmCTest* ctest)
 {
-  this->Superclass::Initialize();
+  this->Superclass::Initialize(ctest);
 
   this->ElapsedTestingTime = cmDuration();
 

Source/CTest/cmCTestTestHandler.h

@@ -107,7 +107,7 @@ public:
    */
   bool SetDirectoryProperties(const std::vector<std::string>& args);
 
-  void Initialize() override;
+  void Initialize(cmCTest* ctest) override;
 
   struct cmCTestTestResourceRequirement
   {

Source/CTest/cmCTestUpdateCommand.cxx

@@ -74,7 +74,7 @@ cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler()
     this->Makefile, "P4Options", "CTEST_P4_OPTIONS", this->Quiet);
 
   cmCTestUpdateHandler* handler = this->CTest->GetUpdateHandler();
-  handler->Initialize();
+  handler->Initialize(this->CTest);
   if (source_dir.empty()) {
     this->SetError("source directory not specified. Please use SOURCE tag");
     return nullptr;

Source/CTest/cmCTestUpdateHandler.cxx

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

Source/CTest/cmCTestUpdateHandler.h

@@ -10,6 +10,8 @@
 
 #include "cmCTestGenericHandler.h"
 
+class cmCTest;
+
 /** \class cmCTestUpdateHandler
  * \brief A class that handles ctest -S invocations
  *
@@ -41,7 +43,7 @@ public:
   /**
    * Initialize handler
    */
-  void Initialize() override;
+  void Initialize(cmCTest* ctest) override;
 
 private:
   // Some structures needed for update

Source/CTest/cmCTestUploadCommand.cxx

@@ -38,7 +38,7 @@ void cmCTestUploadCommand::CheckArguments()
 cmCTestGenericHandler* cmCTestUploadCommand::InitializeHandler()
 {
   cmCTestUploadHandler* handler = this->CTest->GetUploadHandler();
-  handler->Initialize();
+  handler->Initialize(this->CTest);
   handler->SetFiles(
     std::set<std::string>(this->Files.begin(), this->Files.end()));
   handler->SetQuiet(this->Quiet);

Source/CTest/cmCTestUploadHandler.cxx

@@ -11,14 +11,11 @@
 #include "cmVersion.h"
 #include "cmXMLWriter.h"
 
-cmCTestUploadHandler::cmCTestUploadHandler()
-{
-  this->Initialize();
-}
+cmCTestUploadHandler::cmCTestUploadHandler() = default;
 
-void cmCTestUploadHandler::Initialize()
+void cmCTestUploadHandler::Initialize(cmCTest* ctest)
 {
-  this->Superclass::Initialize();
+  this->Superclass::Initialize(ctest);
   this->Files.clear();
 }
 

Source/CTest/cmCTestUploadHandler.h

@@ -9,6 +9,8 @@
 
 #include "cmCTestGenericHandler.h"
 
+class cmCTest;
+
 /** \class cmCTestUploadHandler
  * \brief Helper class for CTest
  *
@@ -27,7 +29,7 @@ public:
    */
   int ProcessHandler() override;
 
-  void Initialize() override;
+  void Initialize(cmCTest* ctest) override;
 
   /** Specify a set of files to submit.  */
   void SetFiles(std::set<std::string> const& files);

Source/cmCTest.cxx

@@ -10,6 +10,7 @@
 #include <cstdlib>
 #include <cstring>
 #include <ctime>
+#include <initializer_list>
 #include <iostream>
 #include <map>
 #include <ratio>
@@ -31,7 +32,6 @@
 #include "cmsys/Base64.h"
 #include "cmsys/Directory.hxx"
 #include "cmsys/FStream.hxx"
-#include "cmsys/Glob.hxx"
 #include "cmsys/RegularExpression.hxx"
 #include "cmsys/SystemInformation.hxx"
 #if defined(_WIN32)
@@ -143,19 +143,6 @@ struct cmCTest::Private
              &this->UploadHandler };
   }
 
-  std::map<std::string, cmCTestGenericHandler*> GetNamedTestingHandlers()
-  {
-    return { { "build", &this->BuildHandler },
-             { "coverage", &this->CoverageHandler },
-             { "script", &this->ScriptHandler },
-             { "test", &this->TestHandler },
-             { "update", &this->UpdateHandler },
-             { "configure", &this->ConfigureHandler },
-             { "memcheck", &this->MemCheckHandler },
-             { "submit", &this->SubmitHandler },
-             { "upload", &this->UploadHandler } };
-  }
-
   bool ShowOnly = false;
   bool OutputAsJson = false;
   int OutputAsJsonVersion = 1;
@@ -368,10 +355,6 @@ cmCTest::cmCTest()
       ->PartMap[cmSystemTools::LowerCase(this->Impl->Parts[p].GetName())] = p;
   }
 
-  for (auto& handler : this->Impl->GetTestingHandlers()) {
-    handler->SetCTestInstance(this);
-  }
-
   // Make sure we can capture the build tool output.
   cmSystemTools::EnableVSConsoleOutput();
 }
@@ -550,31 +533,6 @@ bool cmCTest::ReadExistingTag(bool quiet)
   return true;
 }
 
-void cmCTest::InitializeTesting(const std::string& binary_dir)
-{
-  cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
-  if (!this->Impl->InteractiveDebugMode) {
-    this->BlockTestErrorDiagnostics();
-  } else {
-    cmSystemTools::PutEnv("CTEST_INTERACTIVE_DEBUG_MODE=1");
-  }
-
-  this->Impl->BinaryDir = binary_dir;
-  cmSystemTools::ConvertToUnixSlashes(this->Impl->BinaryDir);
-
-  this->UpdateCTestConfiguration();
-
-  cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
-
-  cmake cm(cmake::RoleScript, cmState::CTest);
-  cm.SetHomeDirectory("");
-  cm.SetHomeOutputDirectory("");
-  cm.GetCurrentSnapshot().SetDefaultDefinitions();
-  cmGlobalGenerator gg(&cm);
-  cmMakefile mf(&gg, cm.GetCurrentSnapshot());
-  this->ReadCustomConfigurationFileTree(this->Impl->BinaryDir, &mf);
-}
-
 bool cmCTest::UpdateCTestConfiguration()
 {
   if (this->Impl->SuppressUpdatingCTestConfiguration) {
@@ -834,7 +792,7 @@ int cmCTest::ProcessSteps()
 
   int res = 0;
   cmCTestScriptHandler script;
-  script.SetCTestInstance(this);
+  script.Initialize(this);
   script.CreateCMake();
   cmMakefile& mf = *script.GetMakefile();
   this->ReadCustomConfigurationFileTree(this->Impl->BinaryDir, &mf);
@@ -2828,6 +2786,7 @@ int cmCTest::RunScripts(
   }
 
   cmCTestScriptHandler* ch = this->GetScriptHandler();
+  ch->Initialize(this);
   ch->SetVerbose(this->Impl->Verbose);
   for (auto const& script : scripts) {
     ch->AddConfigurationScript(script.first, script.second);
@@ -2859,7 +2818,33 @@ int cmCTest::ExecuteTests()
     return 1;
   }
 
-  this->InitializeTesting(workDir);
+  cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
+  if (!this->Impl->InteractiveDebugMode) {
+    this->BlockTestErrorDiagnostics();
+  } else {
+    cmSystemTools::PutEnv("CTEST_INTERACTIVE_DEBUG_MODE=1");
+  }
+
+  this->Impl->BinaryDir = workDir;
+  cmSystemTools::ConvertToUnixSlashes(this->Impl->BinaryDir);
+
+  this->UpdateCTestConfiguration();
+
+  cmCTestLog(this, DEBUG, "Here: " << __LINE__ << std::endl);
+
+  this->GetTestHandler()->Initialize(this);
+
+  {
+    cmake cm(cmake::RoleScript, cmState::CTest);
+    cm.SetHomeDirectory("");
+    cm.SetHomeOutputDirectory("");
+    cm.GetCurrentSnapshot().SetDefaultDefinitions();
+    cmGlobalGenerator gg(&cm);
+    cmMakefile mf(&gg, cm.GetCurrentSnapshot());
+    this->ReadCustomConfigurationFileTree(this->Impl->BinaryDir, &mf);
+    this->GetTestHandler()->PopulateCustomVectors(&mf);
+  }
+
   this->GetTestHandler()->SetVerbose(this->Impl->Verbose);
   if (this->GetTestHandler()->ProcessHandler() < 0) {
     cmCTestLog(this, ERROR_MESSAGE, "Errors while running CTest\n");
@@ -2958,14 +2943,22 @@ void cmCTest::SetScheduleType(std::string const& type)
 void cmCTest::ReadCustomConfigurationFileTree(const std::string& dir,
                                               cmMakefile* mf)
 {
-  bool found = false;
   cmCTestLog(this, DEBUG,
              "* Read custom CTest configuration directory: " << dir
                                                              << std::endl);
 
-  std::string fname = cmStrCat(dir, "/CTestCustom.cmake");
-  cmCTestLog(this, DEBUG, "* Check for file: " << fname << std::endl);
-  if (cmSystemTools::FileExists(fname)) {
+  auto const fname = [this, &dir]() -> std::string {
+    for (char const* ext : { ".cmake", ".ctest" }) {
+      std::string path = cmStrCat(dir, "/CTestCustom", ext);
+      cmCTestLog(this, DEBUG, "* Check for file: " << path << std::endl);
+      if (cmSystemTools::FileExists(path)) {
+        return path;
+      }
+    }
+    return "";
+  }();
+
+  if (!fname.empty()) {
     cmCTestLog(this, DEBUG,
                "* Read custom CTest configuration file: " << fname
                                                           << std::endl);
@@ -2977,41 +2970,10 @@ void cmCTest::ReadCustomConfigurationFileTree(const std::string& dir,
                  "Problem reading custom configuration: " << fname
                                                           << std::endl);
     }
-    found = true;
     if (erroroc) {
       cmSystemTools::SetErrorOccurred();
     }
   }
-
-  std::string rexpr = cmStrCat(dir, "/CTestCustom.ctest");
-  cmCTestLog(this, DEBUG, "* Check for file: " << rexpr << std::endl);
-  if (!found && cmSystemTools::FileExists(rexpr)) {
-    cmsys::Glob gl;
-    gl.RecurseOn();
-    gl.FindFiles(rexpr);
-    std::vector<std::string>& files = gl.GetFiles();
-    for (const std::string& file : files) {
-      cmCTestLog(this, DEBUG,
-                 "* Read custom CTest configuration file: " << file
-                                                            << std::endl);
-      if (!mf->ReadListFile(file) || cmSystemTools::GetErrorOccurredFlag()) {
-        cmCTestLog(this, ERROR_MESSAGE,
-                   "Problem reading custom configuration: " << file
-                                                            << std::endl);
-      }
-    }
-    found = true;
-  }
-
-  if (found) {
-    for (auto& handler : this->Impl->GetNamedTestingHandlers()) {
-      cmCTestLog(this, DEBUG,
-                 "* Read custom CTest configuration vectors for handler: "
-                   << handler.first << " (" << handler.second << ")"
-                   << std::endl);
-      handler.second->PopulateCustomVectors(mf);
-    }
-  }
 }
 
 void cmCTest::PopulateCustomVector(cmMakefile* mf, const std::string& def,

Source/cmCTest.h

@@ -74,11 +74,6 @@ public:
   bool CreateNewTag(bool quiet);
   bool ReadExistingTag(bool quiet);
 
-  /**
-   * Initialize ctest for executing tests.
-   */
-  void InitializeTesting(const std::string& binary_dir);
-
   /**
    * Process the dashboard client steps.
    */

Source/ctest.cxx

@@ -15,7 +15,6 @@
 #include "cmSystemTools.h"
 
 #include "CTest/cmCTestLaunch.h"
-#include "CTest/cmCTestScriptHandler.h"
 
 namespace {
 const cmDocumentationEntry cmDocumentationName = {
@@ -183,11 +182,8 @@ int main(int argc, char const* const* argv)
     return cmCTestLaunch::Main(argc, argv);
   }
 
-  cmCTest inst;
-
   if (cmSystemTools::GetCurrentWorkingDirectory().empty()) {
-    cmCTestLog(&inst, ERROR_MESSAGE,
-               "Current working directory cannot be established.\n");
+    std::cerr << "Current working directory cannot be established.\n";
     return 1;
   }
 
@@ -198,18 +194,13 @@ int main(int argc, char const* const* argv)
       !(cmSystemTools::FileExists("CTestTestfile.cmake") ||
         cmSystemTools::FileExists("DartTestfile.txt"))) {
     if (argc == 1) {
-      cmCTestLog(&inst, ERROR_MESSAGE,
-                 "*********************************\n"
-                 "No test configuration file found!\n"
-                 "*********************************\n");
+      std::cerr << "*********************************\n"
+                   "No test configuration file found!\n"
+                   "*********************************\n";
     }
     cmDocumentation doc;
     doc.addCTestStandardDocSections();
     if (doc.CheckOptions(argc, argv)) {
-      // Construct and print requested documentation.
-      cmCTestScriptHandler* ch = inst.GetScriptHandler();
-      ch->CreateCMake();
-
       doc.SetShowGenerators(false);
       doc.SetName("ctest");
       doc.SetSection("Name", cmDocumentationName);
@@ -220,11 +211,8 @@ int main(int argc, char const* const* argv)
   }
 
   // copy the args to a vector
-  std::vector<std::string> args;
-  args.reserve(argc);
-  for (int i = 0; i < argc; ++i) {
-    args.emplace_back(argv[i]);
-  }
+  auto args = std::vector<std::string>(argv, argv + argc);
+
   // run ctest
-  return inst.Run(args);
+  return cmCTest{}.Run(args);
 }