/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying

   file LICENSE.rst or https://cmake.org/licensing for details.  */

#include "cmTestGenerator.h"

#include <cstddef> // IWYU pragma: keep

#include <memory>

#include <ostream>

#include <set>

#include <string>

#include <utility>

#include <vector>

#include "cmGeneratorExpression.h"

#include "cmGeneratorTarget.h"

#include "cmGlobalGenerator.h"

#include "cmList.h"

#include "cmListFileCache.h"

#include "cmLocalGenerator.h"

#include "cmMakefile.h"

#include "cmPolicies.h"

#include "cmPropertyMap.h"

#include "cmRange.h"

#include "cmScriptGenerator.h"

#include "cmStringAlgorithms.h"

#include "cmSystemTools.h"

#include "cmTargetTypes.h"

#include "cmTest.h"

#include "cmValue.h"

namespace /* anonymous */

{

bool needToQuoteTestName(cmMakefile const& mf, std::string const& name)

{

  // Determine if policy CMP0110 is set to NEW.

  switch (mf.GetPolicyStatus(cmPolicies::CMP0110)) {

    case cmPolicies::WARN:

      // Only warn if a forbidden character is used in the name.

      if (name.find_first_of("$[] #;\t\n\"\\") != std::string::npos) {

        mf.IssuePolicyWarning(

          cmPolicies::CMP0110, {},

          cmStrCat("The following name given to add_test() is invalid if "

                   "CMP0110 is not set or set to OLD:\n  `",

                   name, "´\n"));

      }

      CM_FALLTHROUGH;

    case cmPolicies::OLD:

      // OLD behavior is to not quote the test's name.

      return false;

    case cmPolicies::NEW:

    default:

      // NEW behavior is to quote the test's name.

      return true;

  }

}

std::string TestName(cmTest* test)

{

  std::string name = test->GetName();

  if (needToQuoteTestName(*test->GetMakefile(), name)) {

    name = cmScriptGenerator::Quote(name);

  }

  return name;

}

} // End: anonymous namespace

cmTestGenerator::cmTestGenerator(

  cmTest* test, std::vector<std::string> const& configurations)

  : cmScriptGenerator("CTEST_CONFIGURATION_TYPE", configurations)

  , Test(test)

{

  this->ActionsPerConfig = test == nullptr || !test->GetOldStyle();

  this->TestGenerated = false;

  this->LG = nullptr;

}

cmTestGenerator::~cmTestGenerator() = default;

void cmTestGenerator::Compute(cmLocalGenerator* lg)

{

  this->LG = lg;

}

bool cmTestGenerator::TestsForConfig(std::string const& config)

{

  return this->Test != nullptr && this->GeneratesForConfig(config);

}

cmTest* cmTestGenerator::GetTest() const

{

  return this->Test;

}

bool cmTestGenerator::EvaluateBuildDependencies(

  cmLocalGenerator* lg, std::string const& config,

  cmListFileBacktrace const& backtrace, std::string const& testName,

  std::vector<std::string> const& command,

  std::vector<std::string> const& buildDepends, BuildDependencies& info,

  cmMakefile* mf)

{

  if (!cmGeneratorExpression::IsValidTargetName(testName) ||

      cmGlobalGenerator::IsReservedTarget(testName)) {

    return false;

  }

  std::set<cmGeneratorTarget*> dependencies;

  // Get dependencies from generator expressions

  cmGeneratorExpression ge(*mf->GetCMakeInstance(), backtrace);

  std::string exe;

  for (std::string const& arg : command) {

    auto parsed = ge.Parse(arg);

    std::string const& evaluated = parsed->Evaluate(lg, config);

    if (exe.empty()) {

      exe = evaluated;

    }

    for (cmGeneratorTarget* dep : parsed->GetTargets()) {

      if (dep && !dep->IsImported()) {

        dependencies.insert(dep);

      }

    }

  }

  // Add target executed by test

  if (!exe.empty()) {

    cmGeneratorTarget* target = lg->FindGeneratorTargetToUse(exe);

    if (target && target->GetType() == cm::TargetType::EXECUTABLE &&

        !target->IsImported()) {

      dependencies.insert(target);

    }

  }

  // Add dependencies from BUILD_DEPENDS keyword

  for (std::string const& depName : buildDepends) {

    if (depName.empty()) {

      continue;

    }

    cmGeneratorTarget* depTarget = lg->FindGeneratorTargetToUse(depName);

    if (!depTarget) {

      cmGlobalGenerator* gg = lg->GetGlobalGenerator();

      BuildDependencies::FileDependency file;

      file.Path = lg->GetRealFileDependency(depName);

      file.Owner = gg->FindOutputOwningTarget(file.Path);

      file.Generated = gg->IsGeneratedByBuild(file.Path);

      info.Files.push_back(std::move(file));

      continue;

    }

    dependencies.insert(depTarget);

  }

  for (cmGeneratorTarget* gt : dependencies) {

    if (gt->IsInBuildSystem()) {

      info.Targets.push_back(gt);

    }

  }

  return true;

}

bool cmTestGenerator::GetBuildDependencies(cmLocalGenerator* lg,

                                           std::string const& config,

                                           BuildDependencies& info)

{

  if (this->Test == nullptr) {

    return false;

  }

  return EvaluateBuildDependencies(

    lg, config, this->Test->GetBacktrace(), this->Test->GetName(),

    this->Test->GetCommand(), this->Test->GetDependencies(), info,

    this->Test->GetMakefile());

}

void cmTestGenerator::GenerateScriptActions(std::ostream& os, Indent indent)

{

  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 {

    // This is an old-style test, so there is only one config.

    // assert(this->Test->GetOldStyle());

    this->GenerateOldStyle(os, indent);

  }

}

void cmTestGenerator::GenerateCommand(std::ostream& os,

                                      std::vector<std::string> const& command,

                                      std::string const& config, bool expand,

                                      cmGeneratorExpression& ge,

                                      cmPolicies::PolicyStatus cmp0158,

                                      cmPolicies::PolicyStatus cmp0178)

{

  // Evaluate command line arguments

  cmList argv{

    this->EvaluateCommandLineArguments(command, ge, config),

    // Expand arguments if COMMAND_EXPAND_LISTS is set

    expand ? cmList::ExpandElements::Yes : cmList::ExpandElements::No,

    cmList::EmptyElements::Yes,

  };

  // Expanding lists on an empty command may have left it empty

  if (argv.empty()) {

    argv.emplace_back();

  }

  // Check whether the command executable is a target whose name is to

  // be translated.

  std::string exe = argv[0];

  cmGeneratorTarget* target = this->LG->FindGeneratorTargetToUse(exe);

  if (target && target->GetType() == cm::TargetType::EXECUTABLE) {

    // Use the target file on disk.

    exe = target->GetFullPath(config);

    auto addLauncher = [&](std::string const& propertyName) {

      cmValue launcher = target->GetProperty(propertyName);

      if (!cmNonempty(launcher)) {

        return;

      }

      auto const propVal = ge.Parse(*launcher)->Evaluate(this->LG, config);

      cmList launcherWithArgs(propVal, cmList::ExpandElements::Yes,

                              cmp0178 == cmPolicies::NEW

                                ? cmList::EmptyElements::Yes

                                : cmList::EmptyElements::No);

      if (!launcherWithArgs.empty() && !launcherWithArgs[0].empty()) {

        if (cmp0178 == cmPolicies::WARN) {

          cmList argsWithEmptyValuesPreserved(

            propVal, cmList::ExpandElements::Yes, cmList::EmptyElements::Yes);

          if (launcherWithArgs != argsWithEmptyValuesPreserved) {

            this->LG->GetMakefile()->IssuePolicyWarning(

              cmPolicies::CMP0178,

              cmStrCat("The ", propertyName, " property of target '",

                       target->GetName(),

                       "' contains empty list items. Those empty items are "

                       "being silently discarded to preserve backward "

                       "compatibility."));

          }

        }

        std::string launcherExe(launcherWithArgs[0]);

        cmSystemTools::ConvertToUnixSlashes(launcherExe);

        os << cmScriptGenerator::Quote(launcherExe) << " ";

        for (std::string const& arg :

             cmMakeRange(launcherWithArgs).advance(1)) {

          os << cmScriptGenerator::Quote(arg) << " ";

        }

      }

    };

    // Prepend with the test launcher if specified.

    addLauncher("TEST_LAUNCHER");

    // Prepend with the emulator when cross compiling if required.

    if (cmp0158 != cmPolicies::NEW ||

        this->LG->GetMakefile()->IsOn("CMAKE_CROSSCOMPILING")) {

      addLauncher("CROSSCOMPILING_EMULATOR");

    }

  } else {

    // Use the command name given.

    cmSystemTools::ConvertToUnixSlashes(exe);

  }

  // Generate the command line with full escapes.

  os << cmScriptGenerator::Quote(exe);

  for (auto const& arg : cmMakeRange(argv).advance(1)) {

    os << " " << cmScriptGenerator::Quote(arg);

  }

}

void cmTestGenerator::GenerateScriptForConfig(std::ostream& os,

                                              std::string const& config,

                                              Indent indent)

{

  this->TestGenerated = true;

  // Set up generator expression evaluation context.

  cmGeneratorExpression ge(*this->Test->GetMakefile()->GetCMakeInstance(),

                           this->Test->GetBacktrace());

  auto const test_name = TestName(this->Test);

  os << indent << "add_test(" << test_name << ' ';

  this->GenerateCommand(

    os, this->Test->GetCommand(), config, this->Test->GetCommandExpandLists(),

    ge, this->GetTest()->GetCMP0158(), this->Test->GetCMP0178());

  os << ")\n";

  // Output properties for the test.

  os << indent << "set_tests_properties(" << test_name << " PROPERTIES ";

  for (auto const& i : this->Test->GetProperties().GetList()) {

    os << " " << i.first << " "

       << cmScriptGenerator::Quote(

            ge.Parse(i.second)->Evaluate(this->LG, config));

  }

  BuildDependencies deps;

  if (this->GetBuildDependencies(this->LG, config, deps)) {

    cmList depList;

    for (std::string const& dep :

         this->LG->GetGlobalGenerator()->GetTestBuildDependencyPaths(config,

                                                                     deps)) {

      depList.append(dep);

    }

    os << " _CMAKE_TEST_BUILD_DEPENDS "

       << cmScriptGenerator::Quote(depList.to_string());

  }

  this->GenerateDefaultFixtureRepeatMode(os);

  os << ' ';

  this->GenerateBacktrace(os, this->Test->GetBacktrace());

  os << ")\n";

}

void cmTestGenerator::GenerateScriptNoConfig(std::ostream& os, Indent indent)

{

  os << indent << "add_test(" << TestName(this->Test) << " NOT_AVAILABLE)\n";

}

bool cmTestGenerator::NeedsScriptNoConfig() const

{

  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->ConfigurationTypes->empty()); // config-dependent command

}

void cmTestGenerator::GenerateOldStyle(std::ostream& fout, Indent indent)

{

  this->TestGenerated = true;

  auto const test_name = TestName(this->Test);

  // Get the test command line to be executed.

  std::vector<std::string> const& command = this->Test->GetCommand();

  std::string exe = command[0];

  cmSystemTools::ConvertToUnixSlashes(exe);

  fout << indent << "add_test(" << test_name << " \"" << exe << "\"";

  for (std::string const& arg : cmMakeRange(command).advance(1)) {

    // Just double-quote all arguments so they are re-parsed

    // correctly by the test system.

    fout << " \"";

    for (char c : arg) {

      // 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 == '"') {

        fout << '\\';

      }

      fout << c;

    }

    fout << '"';

  }

  fout << ")\n";

  // Output properties for the test.

  fout << indent << "set_tests_properties(" << test_name << " PROPERTIES ";

  for (auto const& i : this->Test->GetProperties().GetList()) {

    fout << " " << i.first << " " << cmScriptGenerator::Quote(i.second);

  }

  this->GenerateDefaultFixtureRepeatMode(fout);

  fout << ' ';

  this->GenerateBacktrace(fout, this->Test->GetBacktrace());

  fout << ")\n";

}

void cmTestGenerator::GenerateDefaultFixtureRepeatMode(std::ostream& os)

{

  // Nothing to choose for a test that is not part of a fixture, or that

  // names a mode itself.

  if (this->Test->GetProperty("FIXTURE_REPEAT_MODE") ||

      (!this->Test->GetProperty("FIXTURES_SETUP") &&

       !this->Test->GetProperty("FIXTURES_CLEANUP"))) {

    return;

  }

  // Write the mode the policy chose into the test file, so that ctest reads

  // a mode rather than the policy settings behind it.  Only NEW needs

  // writing: with nothing written, ctest already uses the

  // EACH_TEST_SEPARATELY behavior of CMake 4.4 and below.

  switch (this->Test->GetCMP0224()) {

    case cmPolicies::WARN:

      // Warn only on request.  Fixtures are common, and the choice of mode

      // matters only to those who run ctest --repeat.  Collect the tests

      // rather than warning about each: a project that sets its fixtures up

      // in an add_test() wrapper would fill the console.

      if (this->Test->GetMakefile()->PolicyOptionalWarningEnabled(

            "CMAKE_POLICY_WARNING_CMP0224")) {

        this->LG->GetGlobalGenerator()->AddCMP0224WarnTest(

          this->Test->GetName());

      }

      CM_FALLTHROUGH;

    case cmPolicies::OLD:

      break;

    case cmPolicies::NEW:

      os << " _CMAKE_DEFAULT_FIXTURE_REPEAT_MODE AROUND_EACH_REPEAT";

      break;

  }

}

void cmTestGenerator::GenerateBacktrace(std::ostream& os,

                                        cmListFileBacktrace bt)

{

  if (bt.Empty()) {

    return;

  }

  os << "_BACKTRACE_TRIPLES \"";

  bool prependTripleSeparator = false;

  while (!bt.Empty()) {

    auto const& entry = bt.Top();

    if (prependTripleSeparator) {

      os << ";";

    }

    os << entry.FilePath << ";" << entry.Line << ";" << entry.Name;

    bt = bt.Pop();

    prependTripleSeparator = true;

  }

  os << '"';

}

std::vector<std::string> cmTestGenerator::EvaluateCommandLineArguments(

  std::vector<std::string> const& argv, cmGeneratorExpression& ge,

  std::string const& config) const

{

  // Evaluate executable name and arguments

  auto evaluatedRange =

    cmMakeRange(argv).transform([&](std::string const& arg) {

      return ge.Parse(arg)->Evaluate(this->LG, config);

    });

  return { evaluatedRange.begin(), evaluatedRange.end() };

}