cmCTest*Command: Declare member functions const

Source/CTest/cmCTestBuildCommand.cxx

@@ -48,7 +48,7 @@ bool cmCTestBuildCommand::InitialPass(std::vector<std::string> const& args,
 }
 
 std::unique_ptr<cmCTestGenericHandler> cmCTestBuildCommand::InitializeHandler(
-  HandlerArguments& arguments, cmExecutionStatus& status)
+  HandlerArguments& arguments, cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto const& args = static_cast<BuildArguments&>(arguments);
@@ -137,7 +137,7 @@ std::unique_ptr<cmCTestGenericHandler> cmCTestBuildCommand::InitializeHandler(
 
 void cmCTestBuildCommand::ProcessAdditionalValues(
   cmCTestGenericHandler* generic, HandlerArguments const& arguments,
-  cmExecutionStatus& status)
+  cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto const& args = static_cast<BuildArguments const&>(arguments);

Source/CTest/cmCTestBuildCommand.h

@@ -37,11 +37,11 @@ private:
   std::string GetName() const override { return "ctest_build"; }
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
-    HandlerArguments& arguments, cmExecutionStatus& status) override;
+    HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   void ProcessAdditionalValues(cmCTestGenericHandler* handler,
                                HandlerArguments const& arguments,
-                               cmExecutionStatus& status) override;
+                               cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
                    cmExecutionStatus& status) override;

Source/CTest/cmCTestConfigureCommand.cxx

@@ -33,7 +33,7 @@ std::unique_ptr<cmCommand> cmCTestConfigureCommand::Clone()
 
 std::unique_ptr<cmCTestGenericHandler>
 cmCTestConfigureCommand::InitializeHandler(HandlerArguments& arguments,
-                                           cmExecutionStatus& status)
+                                           cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto const& args = static_cast<ConfigureArguments&>(arguments);

Source/CTest/cmCTestConfigureCommand.h

@@ -31,7 +31,7 @@ private:
   std::string GetName() const override { return "ctest_configure"; }
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
-    HandlerArguments& arguments, cmExecutionStatus& status) override;
+    HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
                    cmExecutionStatus& status) override;

Source/CTest/cmCTestCoverageCommand.cxx

@@ -26,7 +26,7 @@ std::unique_ptr<cmCommand> cmCTestCoverageCommand::Clone()
 
 std::unique_ptr<cmCTestGenericHandler>
 cmCTestCoverageCommand::InitializeHandler(HandlerArguments& arguments,
-                                          cmExecutionStatus& status)
+                                          cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto& args = static_cast<CoverageArguments&>(arguments);

Source/CTest/cmCTestCoverageCommand.h

@@ -34,7 +34,7 @@ private:
   std::string GetName() const override { return "ctest_coverage"; }
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
-    HandlerArguments& arguments, cmExecutionStatus& status) override;
+    HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
                    cmExecutionStatus& status) override;

Source/CTest/cmCTestHandlerCommand.cxx

@@ -71,7 +71,7 @@ private:
 
 bool cmCTestHandlerCommand::InvokeImpl(
   BasicArguments& args, std::vector<std::string> const& unparsed,
-  cmExecutionStatus& status, std::function<bool()> handler)
+  cmExecutionStatus& status, std::function<bool()> handler) const
 {
   // save error state and restore it if needed
   SaveRestoreErrorState errorState;
@@ -116,8 +116,8 @@ bool cmCTestHandlerCommand::InvokeImpl(
   return true;
 }
 
-bool cmCTestHandlerCommand::ExecuteHandlerCommand(HandlerArguments& args,
-                                                  cmExecutionStatus& status)
+bool cmCTestHandlerCommand::ExecuteHandlerCommand(
+  HandlerArguments& args, cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
 
@@ -200,18 +200,19 @@ bool cmCTestHandlerCommand::ExecuteHandlerCommand(HandlerArguments& args,
 }
 
 void cmCTestHandlerCommand::CheckArguments(HandlerArguments&,
-                                           cmExecutionStatus&)
+                                           cmExecutionStatus&) const
 {
 }
 
 std::unique_ptr<cmCTestGenericHandler>
-cmCTestHandlerCommand::InitializeHandler(HandlerArguments&, cmExecutionStatus&)
+cmCTestHandlerCommand::InitializeHandler(HandlerArguments&,
+                                         cmExecutionStatus&) const
 {
   return nullptr;
 };
 
 void cmCTestHandlerCommand::ProcessAdditionalValues(cmCTestGenericHandler*,
                                                     HandlerArguments const&,
-                                                    cmExecutionStatus&)
+                                                    cmExecutionStatus&) const
 {
 }

Source/CTest/cmCTestHandlerCommand.h

@@ -67,7 +67,7 @@ protected:
   template <typename Args, typename Handler>
   bool Invoke(cmArgumentParser<Args> const& parser,
               std::vector<std::string> const& arguments,
-              cmExecutionStatus& status, Handler handler)
+              cmExecutionStatus& status, Handler handler) const
   {
     std::vector<std::string> unparsed;
     Args args = parser.Parse(arguments, &unparsed);
@@ -76,22 +76,23 @@ protected:
   };
 
   bool ExecuteHandlerCommand(HandlerArguments& args,
-                             cmExecutionStatus& status);
+                             cmExecutionStatus& status) const;
 
 private:
   bool InvokeImpl(BasicArguments& args,
                   std::vector<std::string> const& unparsed,
-                  cmExecutionStatus& status, std::function<bool()> handler);
+                  cmExecutionStatus& status,
+                  std::function<bool()> handler) const;
 
   virtual std::string GetName() const = 0;
 
   virtual void CheckArguments(HandlerArguments& arguments,
-                              cmExecutionStatus& status);
+                              cmExecutionStatus& status) const;
 
   virtual std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
-    HandlerArguments& arguments, cmExecutionStatus& status);
+    HandlerArguments& arguments, cmExecutionStatus& status) const;
 
   virtual void ProcessAdditionalValues(cmCTestGenericHandler*,
                                        HandlerArguments const& arguments,
-                                       cmExecutionStatus& status);
+                                       cmExecutionStatus& status) const;
 };

Source/CTest/cmCTestMemCheckCommand.cxx

@@ -23,8 +23,8 @@ std::unique_ptr<cmCommand> cmCTestMemCheckCommand::Clone()
 }
 
 std::unique_ptr<cmCTestTestHandler>
-cmCTestMemCheckCommand::InitializeActualHandler(HandlerArguments& args,
-                                                cmExecutionStatus& status)
+cmCTestMemCheckCommand::InitializeActualHandler(
+  HandlerArguments& args, cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto handler = cm::make_unique<cmCTestMemCheckHandler>(this->CTest);
@@ -49,7 +49,7 @@ cmCTestMemCheckCommand::InitializeActualHandler(HandlerArguments& args,
 
 void cmCTestMemCheckCommand::ProcessAdditionalValues(
   cmCTestGenericHandler* handler, HandlerArguments const& arguments,
-  cmExecutionStatus& status)
+  cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto const& args = static_cast<MemCheckArguments const&>(arguments);

Source/CTest/cmCTestMemCheckCommand.h

@@ -32,11 +32,11 @@ private:
   std::string GetName() const override { return "ctest_memcheck"; }
 
   std::unique_ptr<cmCTestTestHandler> InitializeActualHandler(
-    HandlerArguments& arguments, cmExecutionStatus& status) override;
+    HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   void ProcessAdditionalValues(cmCTestGenericHandler* handler,
                                HandlerArguments const& arguments,
-                               cmExecutionStatus& status) override;
+                               cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
                    cmExecutionStatus& status) override;

Source/CTest/cmCTestSubmitCommand.cxx

@@ -31,7 +31,7 @@ std::unique_ptr<cmCommand> cmCTestSubmitCommand::Clone()
 }
 
 std::unique_ptr<cmCTestGenericHandler> cmCTestSubmitCommand::InitializeHandler(
-  HandlerArguments& arguments, cmExecutionStatus& status)
+  HandlerArguments& arguments, cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto const& args = static_cast<SubmitArguments&>(arguments);
@@ -208,7 +208,7 @@ bool cmCTestSubmitCommand::InitialPass(std::vector<std::string> const& args,
 }
 
 void cmCTestSubmitCommand::CheckArguments(HandlerArguments& arguments,
-                                          cmExecutionStatus& status)
+                                          cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto& args = static_cast<SubmitArguments&>(arguments);
@@ -241,7 +241,7 @@ void cmCTestSubmitCommand::CheckArguments(HandlerArguments& arguments,
 
 void cmCTestSubmitCommand::ProcessAdditionalValues(
   cmCTestGenericHandler*, HandlerArguments const& arguments,
-  cmExecutionStatus& status)
+  cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto const& args = static_cast<SubmitArguments const&>(arguments);

Source/CTest/cmCTestSubmitCommand.h

@@ -46,14 +46,14 @@ private:
   std::string GetName() const override { return "ctest_submit"; }
 
   void CheckArguments(HandlerArguments& arguments,
-                      cmExecutionStatus& status) override;
+                      cmExecutionStatus& status) const override;
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
-    HandlerArguments& arguments, cmExecutionStatus& status) override;
+    HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   void ProcessAdditionalValues(cmCTestGenericHandler* handler,
                                HandlerArguments const& arguments,
-                               cmExecutionStatus& status) override;
+                               cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
                    cmExecutionStatus& status) override;

Source/CTest/cmCTestTestCommand.cxx

@@ -29,7 +29,7 @@ std::unique_ptr<cmCommand> cmCTestTestCommand::Clone()
 }
 
 std::unique_ptr<cmCTestGenericHandler> cmCTestTestCommand::InitializeHandler(
-  HandlerArguments& arguments, cmExecutionStatus& status)
+  HandlerArguments& arguments, cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto& args = static_cast<TestArguments&>(arguments);
@@ -148,7 +148,7 @@ std::unique_ptr<cmCTestGenericHandler> cmCTestTestCommand::InitializeHandler(
 
 std::unique_ptr<cmCTestTestHandler>
 cmCTestTestCommand::InitializeActualHandler(HandlerArguments&,
-                                            cmExecutionStatus&)
+                                            cmExecutionStatus&) const
 {
   return cm::make_unique<cmCTestTestHandler>(this->CTest);
 }

Source/CTest/cmCTestTestCommand.h

@@ -84,10 +84,10 @@ private:
   std::string GetName() const override { return "ctest_test"; }
 
   virtual std::unique_ptr<cmCTestTestHandler> InitializeActualHandler(
-    HandlerArguments& arguments, cmExecutionStatus& status);
+    HandlerArguments& arguments, cmExecutionStatus& status) const;
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
-    HandlerArguments& arguments, cmExecutionStatus& status) override;
+    HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
                    cmExecutionStatus& status) override;

Source/CTest/cmCTestUpdateCommand.cxx

@@ -22,7 +22,7 @@ std::unique_ptr<cmCommand> cmCTestUpdateCommand::Clone()
 }
 
 std::unique_ptr<cmCTestGenericHandler> cmCTestUpdateCommand::InitializeHandler(
-  HandlerArguments& args, cmExecutionStatus& status)
+  HandlerArguments& args, cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   if (!args.Source.empty()) {

Source/CTest/cmCTestUpdateCommand.h

@@ -25,7 +25,7 @@ private:
   std::string GetName() const override { return "ctest_update"; }
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
-    HandlerArguments& args, cmExecutionStatus& status) override;
+    HandlerArguments& args, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
                    cmExecutionStatus& status) override;

Source/CTest/cmCTestUploadCommand.cxx

@@ -27,7 +27,7 @@ std::unique_ptr<cmCommand> cmCTestUploadCommand::Clone()
 }
 
 void cmCTestUploadCommand::CheckArguments(HandlerArguments& arguments,
-                                          cmExecutionStatus& status)
+                                          cmExecutionStatus& status) const
 {
   cmMakefile& mf = status.GetMakefile();
   auto& args = static_cast<UploadArguments&>(arguments);
@@ -44,7 +44,7 @@ void cmCTestUploadCommand::CheckArguments(HandlerArguments& arguments,
 }
 
 std::unique_ptr<cmCTestGenericHandler> cmCTestUploadCommand::InitializeHandler(
-  HandlerArguments& arguments, cmExecutionStatus&)
+  HandlerArguments& arguments, cmExecutionStatus&) const
 {
   auto const& args = static_cast<UploadArguments&>(arguments);
   auto handler = cm::make_unique<cmCTestUploadHandler>(this->CTest);

Source/CTest/cmCTestUploadCommand.h

@@ -32,10 +32,10 @@ private:
   std::string GetName() const override { return "ctest_upload"; }
 
   void CheckArguments(HandlerArguments& arguments,
-                      cmExecutionStatus& status) override;
+                      cmExecutionStatus& status) const override;
 
   std::unique_ptr<cmCTestGenericHandler> InitializeHandler(
-    HandlerArguments& arguments, cmExecutionStatus& status) override;
+    HandlerArguments& arguments, cmExecutionStatus& status) const override;
 
   bool InitialPass(std::vector<std::string> const& args,
                    cmExecutionStatus& status) override;