1 files changed, 56 insertions, 66 deletions

diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx
index cfd5e3dd2..978421405 100644
--- a/Source/CTest/cmCTestTestCommand.cxx
+++ b/Source/CTest/cmCTestTestCommand.cxx
@@ -2,36 +2,37 @@
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmCTestTestCommand.h"
 
+#include <chrono>
+#include <cstdlib>
+#include <sstream>
+
+#include "cm_static_string_view.hxx"
+
 #include "cmCTest.h"
 #include "cmCTestGenericHandler.h"
 #include "cmCTestTestHandler.h"
 #include "cmDuration.h"
 #include "cmMakefile.h"
-#include "cmSystemTools.h"
+#include "cmStringAlgorithms.h"
 
-#include <chrono>
-#include <sstream>
-#include <stdlib.h>
-#include <vector>
-
-cmCTestTestCommand::cmCTestTestCommand()
+void cmCTestTestCommand::BindArguments()
 {
-  this->Arguments[ctt_START] = "START";
-  this->Arguments[ctt_END] = "END";
-  this->Arguments[ctt_STRIDE] = "STRIDE";
-  this->Arguments[ctt_EXCLUDE] = "EXCLUDE";
-  this->Arguments[ctt_INCLUDE] = "INCLUDE";
-  this->Arguments[ctt_EXCLUDE_LABEL] = "EXCLUDE_LABEL";
-  this->Arguments[ctt_INCLUDE_LABEL] = "INCLUDE_LABEL";
-  this->Arguments[ctt_EXCLUDE_FIXTURE] = "EXCLUDE_FIXTURE";
-  this->Arguments[ctt_EXCLUDE_FIXTURE_SETUP] = "EXCLUDE_FIXTURE_SETUP";
-  this->Arguments[ctt_EXCLUDE_FIXTURE_CLEANUP] = "EXCLUDE_FIXTURE_CLEANUP";
-  this->Arguments[ctt_PARALLEL_LEVEL] = "PARALLEL_LEVEL";
-  this->Arguments[ctt_SCHEDULE_RANDOM] = "SCHEDULE_RANDOM";
-  this->Arguments[ctt_STOP_TIME] = "STOP_TIME";
-  this->Arguments[ctt_TEST_LOAD] = "TEST_LOAD";
-  this->Arguments[ctt_LAST] = nullptr;
-  this->Last = ctt_LAST;
+  this->cmCTestHandlerCommand::BindArguments();
+  this->Bind("START"_s, this->Start);
+  this->Bind("END"_s, this->End);
+  this->Bind("STRIDE"_s, this->Stride);
+  this->Bind("EXCLUDE"_s, this->Exclude);
+  this->Bind("INCLUDE"_s, this->Include);
+  this->Bind("EXCLUDE_LABEL"_s, this->ExcludeLabel);
+  this->Bind("INCLUDE_LABEL"_s, this->IncludeLabel);
+  this->Bind("EXCLUDE_FIXTURE"_s, this->ExcludeFixture);
+  this->Bind("EXCLUDE_FIXTURE_SETUP"_s, this->ExcludeFixtureSetup);
+  this->Bind("EXCLUDE_FIXTURE_CLEANUP"_s, this->ExcludeFixtureCleanup);
+  this->Bind("PARALLEL_LEVEL"_s, this->ParallelLevel);
+  this->Bind("SCHEDULE_RANDOM"_s, this->ScheduleRandom);
+  this->Bind("STOP_TIME"_s, this->StopTime);
+  this->Bind("TEST_LOAD"_s, this->TestLoad);
+  this->Bind("RESOURCE_SPEC_FILE"_s, this->ResourceSpecFile);
 }
 
 cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
@@ -51,57 +52,47 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
   }
   this->CTest->SetTimeOut(timeout);
   cmCTestGenericHandler* handler = this->InitializeActualHandler();
-  if (this->Values[ctt_START] || this->Values[ctt_END] ||
-      this->Values[ctt_STRIDE]) {
-    std::ostringstream testsToRunString;
-    if (this->Values[ctt_START]) {
-      testsToRunString << this->Values[ctt_START];
-    }
-    testsToRunString << ",";
-    if (this->Values[ctt_END]) {
-      testsToRunString << this->Values[ctt_END];
-    }
-    testsToRunString << ",";
-    if (this->Values[ctt_STRIDE]) {
-      testsToRunString << this->Values[ctt_STRIDE];
-    }
-    handler->SetOption("TestsToRunInformation",
-                       testsToRunString.str().c_str());
+  if (!this->Start.empty() || !this->End.empty() || !this->Stride.empty()) {
+    handler->SetOption(
+      "TestsToRunInformation",
+      cmStrCat(this->Start, ',', this->End, ',', this->Stride).c_str());
   }
-  if (this->Values[ctt_EXCLUDE]) {
-    handler->SetOption("ExcludeRegularExpression", this->Values[ctt_EXCLUDE]);
+  if (!this->Exclude.empty()) {
+    handler->SetOption("ExcludeRegularExpression", this->Exclude.c_str());
   }
-  if (this->Values[ctt_INCLUDE]) {
-    handler->SetOption("IncludeRegularExpression", this->Values[ctt_INCLUDE]);
+  if (!this->Include.empty()) {
+    handler->SetOption("IncludeRegularExpression", this->Include.c_str());
   }
-  if (this->Values[ctt_EXCLUDE_LABEL]) {
+  if (!this->ExcludeLabel.empty()) {
     handler->SetOption("ExcludeLabelRegularExpression",
-                       this->Values[ctt_EXCLUDE_LABEL]);
+                       this->ExcludeLabel.c_str());
   }
-  if (this->Values[ctt_INCLUDE_LABEL]) {
-    handler->SetOption("LabelRegularExpression",
-                       this->Values[ctt_INCLUDE_LABEL]);
+  if (!this->IncludeLabel.empty()) {
+    handler->SetOption("LabelRegularExpression", this->IncludeLabel.c_str());
   }
-  if (this->Values[ctt_EXCLUDE_FIXTURE]) {
+  if (!this->ExcludeFixture.empty()) {
     handler->SetOption("ExcludeFixtureRegularExpression",
-                       this->Values[ctt_EXCLUDE_FIXTURE]);
+                       this->ExcludeFixture.c_str());
   }
-  if (this->Values[ctt_EXCLUDE_FIXTURE_SETUP]) {
+  if (!this->ExcludeFixtureSetup.empty()) {
     handler->SetOption("ExcludeFixtureSetupRegularExpression",
-                       this->Values[ctt_EXCLUDE_FIXTURE_SETUP]);
+                       this->ExcludeFixtureSetup.c_str());
   }
-  if (this->Values[ctt_EXCLUDE_FIXTURE_CLEANUP]) {
+  if (!this->ExcludeFixtureCleanup.empty()) {
     handler->SetOption("ExcludeFixtureCleanupRegularExpression",
-                       this->Values[ctt_EXCLUDE_FIXTURE_CLEANUP]);
+                       this->ExcludeFixtureCleanup.c_str());
+  }
+  if (!this->ParallelLevel.empty()) {
+    handler->SetOption("ParallelLevel", this->ParallelLevel.c_str());
   }
-  if (this->Values[ctt_PARALLEL_LEVEL]) {
-    handler->SetOption("ParallelLevel", this->Values[ctt_PARALLEL_LEVEL]);
+  if (!this->ScheduleRandom.empty()) {
+    handler->SetOption("ScheduleRandom", this->ScheduleRandom.c_str());
   }
-  if (this->Values[ctt_SCHEDULE_RANDOM]) {
-    handler->SetOption("ScheduleRandom", this->Values[ctt_SCHEDULE_RANDOM]);
+  if (!this->ResourceSpecFile.empty()) {
+    handler->SetOption("ResourceSpecFile", this->ResourceSpecFile.c_str());
   }
-  if (this->Values[ctt_STOP_TIME]) {
-    this->CTest->SetStopTime(this->Values[ctt_STOP_TIME]);
+  if (!this->StopTime.empty()) {
+    this->CTest->SetStopTime(this->StopTime);
   }
 
   // Test load is determined by: TEST_LOAD argument,
@@ -109,16 +100,15 @@ cmCTestGenericHandler* cmCTestTestCommand::InitializeHandler()
   // command line argument... in that order.
   unsigned long testLoad;
   const char* ctestTestLoad = this->Makefile->GetDefinition("CTEST_TEST_LOAD");
-  if (this->Values[ctt_TEST_LOAD] && *this->Values[ctt_TEST_LOAD]) {
-    if (!cmSystemTools::StringToULong(this->Values[ctt_TEST_LOAD],
-                                      &testLoad)) {
+  if (!this->TestLoad.empty()) {
+    if (!cmStrToULong(this->TestLoad.c_str(), &testLoad)) {
       testLoad = 0;
       cmCTestLog(this->CTest, WARNING,
-                 "Invalid value for 'TEST_LOAD' : "
-                   << this->Values[ctt_TEST_LOAD] << std::endl);
+                 "Invalid value for 'TEST_LOAD' : " << this->TestLoad
+                                                    << std::endl);
     }
   } else if (ctestTestLoad && *ctestTestLoad) {
-    if (!cmSystemTools::StringToULong(ctestTestLoad, &testLoad)) {
+    if (!cmStrToULong(ctestTestLoad, &testLoad)) {
       testLoad = 0;
       cmCTestLog(this->CTest, WARNING,
                  "Invalid value for 'CTEST_TEST_LOAD' : " << ctestTestLoad