Merge topic 'ctest-cmd-line-vars'

361696a CTest: Add test to verify -D variable definitions work
c77b57b CTest: Allow -Dvar=value with no space between the D and the var
93d084c CTest: Extend -D command line arg handling for variable definitions
af29848 CTest: Rename local variable for clarity
24ba0fd CTest: Refactor error output into ErrorMessageUnknownDashDValue

Source/CTest/cmCTestScriptHandler.cxx

@@ -435,6 +435,15 @@ int cmCTestScriptHandler::ReadInScript(const std::string& total_script_arg)
     return 2;
     }
 
+  // Add definitions of variables passed in on the command line:
+  const std::map<std::string, std::string> &defs =
+    this->CTest->GetDefinitions();
+  for (std::map<std::string, std::string>::const_iterator it = defs.begin();
+       it != defs.end(); ++it)
+    {
+    this->Makefile->AddDefinition(it->first.c_str(), it->second.c_str());
+    }
+
   // finally read in the script
   if (!this->Makefile->ReadListFile(0, script.c_str()) ||
     cmSystemTools::GetErrorOccuredFlag())

Source/cmCTest.cxx

@@ -1944,35 +1944,33 @@ bool cmCTest::AddTestsForDashboardType(std::string &targ)
     }
   else
     {
-    cmCTestLog(this, ERROR_MESSAGE,
-               "CTest -D called with incorrect option: "
-               << targ << std::endl);
-    cmCTestLog(this, ERROR_MESSAGE, "Available options are:" << std::endl
-               << "  " << "ctest" << " -D Continuous" << std::endl
-               << "  " << "ctest"
-               << " -D Continuous(Start|Update|Configure|Build)" << std::endl
-               << "  " << "ctest"
-               << " -D Continuous(Test|Coverage|MemCheck|Submit)"
-               << std::endl
-               << "  " << "ctest" << " -D Experimental" << std::endl
-               << "  " << "ctest"
-               << " -D Experimental(Start|Update|Configure|Build)"
-               << std::endl
-               << "  " << "ctest"
-               << " -D Experimental(Test|Coverage|MemCheck|Submit)"
-               << std::endl
-               << "  " << "ctest" << " -D Nightly" << std::endl
-               << "  " << "ctest"
-               << " -D Nightly(Start|Update|Configure|Build)" << std::endl
-               << "  " << "ctest"
-               << " -D Nightly(Test|Coverage|MemCheck|Submit)" << std::endl
-               << "  " << "ctest" << " -D NightlyMemoryCheck" << std::endl);
     return false;
     }
   return true;
 }
 
 
+//----------------------------------------------------------------------
+void cmCTest::ErrorMessageUnknownDashDValue(std::string &val)
+{
+  cmCTestLog(this, ERROR_MESSAGE,
+    "CTest -D called with incorrect option: " << val << std::endl);
+
+  cmCTestLog(this, ERROR_MESSAGE,
+    "Available options are:" << std::endl
+    << "  ctest -D Continuous" << std::endl
+    << "  ctest -D Continuous(Start|Update|Configure|Build)" << std::endl
+    << "  ctest -D Continuous(Test|Coverage|MemCheck|Submit)" << std::endl
+    << "  ctest -D Experimental" << std::endl
+    << "  ctest -D Experimental(Start|Update|Configure|Build)" << std::endl
+    << "  ctest -D Experimental(Test|Coverage|MemCheck|Submit)" << std::endl
+    << "  ctest -D Nightly" << std::endl
+    << "  ctest -D Nightly(Start|Update|Configure|Build)" << std::endl
+    << "  ctest -D Nightly(Test|Coverage|MemCheck|Submit)" << std::endl
+    << "  ctest -D NightlyMemoryCheck" << std::endl);
+}
+
+
 //----------------------------------------------------------------------
 bool cmCTest::CheckArgument(const std::string& arg, const char* varg1,
   const char* varg2)
@@ -2231,6 +2229,22 @@ void cmCTest::HandleScriptArguments(size_t &i,
     }
 }
 
+//----------------------------------------------------------------------
+bool cmCTest::AddVariableDefinition(const std::string &arg)
+{
+  std::string name;
+  std::string value;
+  cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED;
+
+  if (cmCacheManager::ParseEntry(arg.c_str(), name, value, type))
+    {
+    this->Definitions[name] = value;
+    return true;
+    }
+
+  return false;
+}
+
 //----------------------------------------------------------------------
 // the main entry point of ctest, called from main
 int cmCTest::Run(std::vector<std::string> &args, std::string* output)
@@ -2238,7 +2252,7 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
   this->FindRunningCMake();
   const char* ctestExec = "ctest";
   bool cmakeAndTest = false;
-  bool performSomeTest = true;
+  bool executeTests = true;
   bool SRArgumentSpecified = false;
 
   // copy the command line
@@ -2263,13 +2277,28 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
       this->ProduceXML = true;
       i++;
       std::string targ = args[i];
-      // AddTestsForDashboard parses the dashborad type and converts it
+      // AddTestsForDashboard parses the dashboard type and converts it
       // into the separate stages
       if (!this->AddTestsForDashboardType(targ))
         {
-        performSomeTest = false;
+        if (!this->AddVariableDefinition(targ))
+          {
+          this->ErrorMessageUnknownDashDValue(targ);
+          executeTests = false;
           }
         }
+      }
+
+    // If it's not exactly -D, but it starts with -D, then try to parse out
+    // a variable definition from it, same as CMake does. Unsuccessful
+    // attempts are simply ignored since previous ctest versions ignore
+    // this too. (As well as many other unknown command line args.)
+    //
+    if(arg != "-D" && cmSystemTools::StringStartsWith(arg.c_str(), "-D"))
+      {
+      std::string input = arg.substr(2);
+      this->AddVariableDefinition(input);
+      }
 
     if(this->CheckArgument(arg, "-T", "--test-action") &&
       (i < args.size() -1) )
@@ -2278,7 +2307,7 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
       i++;
       if ( !this->SetTest(args[i].c_str(), false) )
         {
-        performSomeTest = false;
+        executeTests = false;
         cmCTestLog(this, ERROR_MESSAGE,
           "CTest -T called with incorrect option: "
           << args[i].c_str() << std::endl);
@@ -2316,7 +2345,7 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
         }
       else
         {
-        performSomeTest = false;
+        executeTests = false;
         cmCTestLog(this, ERROR_MESSAGE,
           "CTest -M called with incorrect option: " << str.c_str()
           << std::endl);
@@ -2387,8 +2416,7 @@ int cmCTest::Run(std::vector<std::string> &args, std::string* output)
     return retv;
     }
 
-  // if some tests must be run 
-  if(performSomeTest)
+  if(executeTests)
     {
     int res;
     // call process directory

Source/cmCTest.h

@@ -417,6 +417,12 @@ public:
   bool GetLabelSummary() { return this->LabelSummary;}
 
   std::string GetCostDataFile();
+
+  const std::map<std::string, std::string> &GetDefinitions()
+    {
+    return this->Definitions;
+    }
+
 private:
   std::string ConfigType;
   std::string ScheduleType;
@@ -516,6 +522,12 @@ private:
   //! parse the option after -D and convert it into the appropriate steps
   bool AddTestsForDashboardType(std::string &targ);
 
+  //! read as "emit an error message for an unknown -D value"
+  void ErrorMessageUnknownDashDValue(std::string &val);
+
+  //! add a variable definition from a command line -D value
+  bool AddVariableDefinition(const std::string &arg);
+
   //! parse and process most common command line arguments
   void HandleCommandLineArguments(size_t &i, 
                                   std::vector<std::string> &args);
@@ -558,6 +570,8 @@ private:
   int OutputLogFileLastTag;
 
   bool OutputTestOutputOnTestFailure;
+
+  std::map<std::string, std::string> Definitions;
 };
 
 class cmCTestLogWrite

Source/ctest.cxx

@@ -103,6 +103,12 @@ static const char * cmDocumentationOptions[][3] =
    "a dashboard test. All tests are <Mode><Test>, where Mode can be "
    "Experimental, Nightly, and Continuous, and Test can be Start, Update, "
    "Configure, Build, Test, Coverage, and Submit."},
+  {"-D <var>:<type>=<value>", "Define a variable for script mode",
+   "Pass in variable values on the command line. Use in "
+   "conjunction with -S to pass variable values to a dashboard script. "
+   "Parsing -D arguments as variable values is only attempted if "
+   "the value following -D does not match any of the known dashboard "
+   "types."},
   {"-M <model>, --test-model <model>", "Sets the model for a dashboard",
    "This option tells ctest to act as a Dart client "
    "where the TestModel can be Experimental, "

Tests/CMakeLists.txt

@@ -1822,6 +1822,19 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
   add_config_tests(Release)
   add_config_tests(RelWithDebInfo)
 
+  # Test -S script with some -D variable definition args to ctest:
+  add_test(CTestConfig.ScriptWithArgs ${CMAKE_CTEST_COMMAND}
+    -C "Release"
+    -D arg1=this
+    -D arg2=that
+    -D "arg3=the other"
+    "-Darg4=this is the fourth"
+    -Darg5=the_fifth
+    -Darg6:STRING=value-with-type
+    -S "${CMake_SOURCE_DIR}/Tests/CTestConfig/ScriptWithArgs.cmake" -VV
+    --output-log "${CMake_BINARY_DIR}/Tests/CTestConfig/ScriptWithArgs.log"
+    )
+
   ADD_TEST_MACRO(CMakeCommands.target_link_libraries target_link_libraries)
 
   CONFIGURE_FILE(

Tests/CTestConfig/ScriptWithArgs.cmake

@@ -0,0 +1,16 @@
+set(CTEST_RUN_CURRENT_SCRIPT 0)
+
+macro(check_arg name expected_value)
+  message("${name}='${${name}}'")
+  if(NOT "${${name}}" STREQUAL "${expected_value}")
+    message(FATAL_ERROR "unexpected ${name} value '${${name}}', expected '${expected_value}'")
+  endif()
+endmacro()
+
+check_arg(arg1 "this")
+check_arg(arg2 "that")
+check_arg(arg3 "the other")
+check_arg(arg4 "this is the fourth")
+check_arg(arg5 "the_fifth")
+check_arg(arg6 "value-with-type")
+check_arg(arg7 "")