Imported Upstream version 3.9.4upstream/3.9.4

1 files changed, 96 insertions, 98 deletions

diff --git a/Source/cmTestGenerator.cxx b/Source/cmTestGenerator.cxx
index 42f511ea3..be4b37847 100644
--- a/Source/cmTestGenerator.cxx
+++ b/Source/cmTestGenerator.cxx
@@ -1,92 +1,63 @@
-/*============================================================================
-  CMake - Cross Platform Makefile Generator
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
+/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+   file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmTestGenerator.h"
 
+#include <map>
+#include <ostream>
+#include <utility>
+
 #include "cmGeneratorExpression.h"
+#include "cmGeneratorTarget.h"
 #include "cmLocalGenerator.h"
-#include "cmMakefile.h"
+#include "cmOutputConverter.h"
+#include "cmProperty.h"
+#include "cmPropertyMap.h"
+#include "cmStateTypes.h"
 #include "cmSystemTools.h"
-#include "cmTarget.h"
 #include "cmTest.h"
 
-//----------------------------------------------------------------------------
-cmTestGenerator
-::cmTestGenerator(cmTest* test,
-                  std::vector<std::string> const& configurations):
-  cmScriptGenerator("CTEST_CONFIGURATION_TYPE", configurations),
-  Test(test)
+cmTestGenerator::cmTestGenerator(
+  cmTest* test, std::vector<std::string> const& configurations)
+  : cmScriptGenerator("CTEST_CONFIGURATION_TYPE", configurations)
+  , Test(test)
 {
   this->ActionsPerConfig = !test->GetOldStyle();
   this->TestGenerated = false;
+  this->LG = CM_NULLPTR;
 }
 
-//----------------------------------------------------------------------------
-cmTestGenerator
-::~cmTestGenerator()
+cmTestGenerator::~cmTestGenerator()
 {
 }
 
-//----------------------------------------------------------------------------
-void cmTestGenerator::GenerateScriptConfigs(std::ostream& os,
-                                            Indent const& indent)
+void cmTestGenerator::Compute(cmLocalGenerator* lg)
 {
-  // First create the tests.
-  this->cmScriptGenerator::GenerateScriptConfigs(os, indent);
+  this->LG = lg;
+}
 
-  // Now generate the test properties.
-  if(this->TestGenerated)
-    {
-    cmTest* test = this->Test;
-    cmMakefile* mf = test->GetMakefile();
-    cmLocalGenerator* lg = mf->GetLocalGenerator();
-    std::ostream& fout = os;
-    cmPropertyMap::const_iterator pit;
-    cmPropertyMap* mpit = &test->GetProperties();
-    if ( mpit->size() )
-      {
-      fout << "SET_TESTS_PROPERTIES(" << test->GetName() << " PROPERTIES ";
-      for ( pit = mpit->begin(); pit != mpit->end(); ++ pit )
-        {
-        fout << " " << pit->first
-             << " " << lg->EscapeForCMake(pit->second.GetValue());
-        }
-      fout << ")" << std::endl;
-      }
-    }
+void cmTestGenerator::GenerateScriptConfigs(std::ostream& os, Indent indent)
+{
+  // Create the tests.
+  this->cmScriptGenerator::GenerateScriptConfigs(os, indent);
 }
 
-//----------------------------------------------------------------------------
-void cmTestGenerator::GenerateScriptActions(std::ostream& os,
-                                            Indent const& indent)
+void cmTestGenerator::GenerateScriptActions(std::ostream& os, Indent indent)
 {
-  if(this->ActionsPerConfig)
-    {
+  if (this->ActionsPerConfig) {
     // This is the per-config generation in a single-configuration
     // build generator case.  The superclass will call our per-config
     // method.
     this->cmScriptGenerator::GenerateScriptActions(os, indent);
-    }
-  else
-    {
+  } else {
     // This is an old-style test, so there is only one config.
-    //assert(this->Test->GetOldStyle());
+    // assert(this->Test->GetOldStyle());
     this->GenerateOldStyle(os, indent);
-    }
+  }
 }
 
-//----------------------------------------------------------------------------
 void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
-                                              const char* config,
-                                              Indent const& indent)
+                                              const std::string& config,
+                                              Indent indent)
 {
   this->TestGenerated = true;
 
@@ -94,7 +65,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
   cmGeneratorExpression ge(this->Test->GetBacktrace());
 
   // Start the test command.
-  os << indent << "ADD_TEST(" << this->Test->GetName() << " ";
+  os << indent << "add_test(" << this->Test->GetName() << " ";
 
   // Get the test command line to be executed.
   std::vector<std::string> const& command = this->Test->GetCommand();
@@ -102,52 +73,70 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,
   // Check whether the command executable is a target whose name is to
   // be translated.
   std::string exe = command[0];
-  cmMakefile* mf = this->Test->GetMakefile();
-  cmTarget* target = mf->FindTargetToUse(exe.c_str());
-  if(target && target->GetType() == cmTarget::EXECUTABLE)
-    {
+  cmGeneratorTarget* target = this->LG->FindGeneratorTargetToUse(exe);
+  if (target && target->GetType() == cmStateEnums::EXECUTABLE) {
     // Use the target file on disk.
     exe = target->GetFullPath(config);
+
+    // Prepend with the emulator when cross compiling if required.
+    const char* emulator = target->GetProperty("CROSSCOMPILING_EMULATOR");
+    if (emulator != CM_NULLPTR) {
+      std::vector<std::string> emulatorWithArgs;
+      cmSystemTools::ExpandListArgument(emulator, emulatorWithArgs);
+      std::string emulatorExe(emulatorWithArgs[0]);
+      cmSystemTools::ConvertToUnixSlashes(emulatorExe);
+      os << cmOutputConverter::EscapeForCMake(emulatorExe) << " ";
+      for (std::vector<std::string>::const_iterator ei =
+             emulatorWithArgs.begin() + 1;
+           ei != emulatorWithArgs.end(); ++ei) {
+        os << cmOutputConverter::EscapeForCMake(*ei) << " ";
+      }
     }
-  else
-    {
+  } else {
     // Use the command name given.
-    exe = ge.Parse(exe.c_str())->Evaluate(mf, config);
+    exe = ge.Parse(exe.c_str())->Evaluate(this->LG, config);
     cmSystemTools::ConvertToUnixSlashes(exe);
-    }
+  }
 
   // Generate the command line with full escapes.
-  cmLocalGenerator* lg = mf->GetLocalGenerator();
-  os << lg->EscapeForCMake(exe.c_str());
-  for(std::vector<std::string>::const_iterator ci = command.begin()+1;
-      ci != command.end(); ++ci)
-    {
-    os << " " << lg->EscapeForCMake(ge.Parse(*ci)->Evaluate(mf, config));
-    }
+  os << cmOutputConverter::EscapeForCMake(exe);
+  for (std::vector<std::string>::const_iterator ci = command.begin() + 1;
+       ci != command.end(); ++ci) {
+    os << " " << cmOutputConverter::EscapeForCMake(
+                   ge.Parse(*ci)->Evaluate(this->LG, config));
+  }
 
   // Finish the test command.
   os << ")\n";
+
+  // Output properties for the test.
+  cmPropertyMap& pm = this->Test->GetProperties();
+  if (!pm.empty()) {
+    os << indent << "set_tests_properties(" << this->Test->GetName()
+       << " PROPERTIES ";
+    for (cmPropertyMap::const_iterator i = pm.begin(); i != pm.end(); ++i) {
+      os << " " << i->first << " "
+         << cmOutputConverter::EscapeForCMake(
+              ge.Parse(i->second.GetValue())->Evaluate(this->LG, config));
+    }
+    os << ")" << std::endl;
+  }
 }
 
-//----------------------------------------------------------------------------
-void cmTestGenerator::GenerateScriptNoConfig(std::ostream& os,
-                                             Indent const& indent)
+void cmTestGenerator::GenerateScriptNoConfig(std::ostream& os, Indent indent)
 {
-  os << indent << "ADD_TEST(" << this->Test->GetName() << " NOT_AVAILABLE)\n";
+  os << indent << "add_test(" << this->Test->GetName() << " NOT_AVAILABLE)\n";
 }
 
-//----------------------------------------------------------------------------
 bool cmTestGenerator::NeedsScriptNoConfig() const
 {
-  return (this->TestGenerated && // test generated for at least one config
+  return (this->TestGenerated &&    // test generated for at least one config
           this->ActionsPerConfig && // test is config-aware
-          this->Configurations.empty() && // test runs in all configs
+          this->Configurations.empty() &&      // test runs in all configs
           !this->ConfigurationTypes->empty()); // config-dependent command
 }
 
-//----------------------------------------------------------------------------
-void cmTestGenerator::GenerateOldStyle(std::ostream& fout,
-                                       Indent const& indent)
+void cmTestGenerator::GenerateOldStyle(std::ostream& fout, Indent indent)
 {
   this->TestGenerated = true;
 
@@ -157,28 +146,37 @@ void cmTestGenerator::GenerateOldStyle(std::ostream& fout,
   std::string exe = command[0];
   cmSystemTools::ConvertToUnixSlashes(exe);
   fout << indent;
-  fout << "ADD_TEST(";
+  fout << "add_test(";
   fout << this->Test->GetName() << " \"" << exe << "\"";
 
-  for(std::vector<std::string>::const_iterator argit = command.begin()+1;
-      argit != command.end(); ++argit)
-    {
+  for (std::vector<std::string>::const_iterator argit = command.begin() + 1;
+       argit != command.end(); ++argit) {
     // Just double-quote all arguments so they are re-parsed
     // correctly by the test system.
     fout << " \"";
-    for(std::string::const_iterator c = argit->begin();
-        c != argit->end(); ++c)
-      {
+    for (std::string::const_iterator c = argit->begin(); c != argit->end();
+         ++c) {
       // Escape quotes within arguments.  We should escape
       // backslashes too but we cannot because it makes the result
       // inconsistent with previous behavior of this command.
-      if((*c == '"'))
-        {
+      if ((*c == '"')) {
         fout << '\\';
-        }
-      fout << *c;
       }
-    fout << "\"";
+      fout << *c;
     }
+    fout << "\"";
+  }
   fout << ")" << std::endl;
+
+  // Output properties for the test.
+  cmPropertyMap& pm = this->Test->GetProperties();
+  if (!pm.empty()) {
+    fout << indent << "set_tests_properties(" << this->Test->GetName()
+         << " PROPERTIES ";
+    for (cmPropertyMap::const_iterator i = pm.begin(); i != pm.end(); ++i) {
+      fout << " " << i->first << " "
+           << cmOutputConverter::EscapeForCMake(i->second.GetValue());
+    }
+    fout << ")" << std::endl;
+  }
 }