CMake/Tests/CMakeLib/testDebuggerVariablesHelper.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file Copyright.txt or https://cmake.org/licensing for details.  */

#include <functional>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>

#include <cm3p/cppdap/protocol.h>
#include <cm3p/cppdap/types.h>
#include <stddef.h>
#include <stdint.h>

#include "cmDebuggerStackFrame.h"
#include "cmDebuggerVariables.h"
#include "cmDebuggerVariablesHelper.h"
#include "cmDebuggerVariablesManager.h"
#include "cmFileSet.h"
#include "cmGlobalGenerator.h"
#include "cmListFileCache.h"
#include "cmMakefile.h"
#include "cmPolicies.h"
#include "cmPropertyMap.h"
#include "cmState.h"
#include "cmStateDirectory.h"
#include "cmStateSnapshot.h"
#include "cmStateTypes.h"
#include "cmTarget.h"
#include "cmTest.h"
#include "cmake.h"

#include "testCommon.h"
#include "testDebugger.h"

static dap::VariablesRequest CreateVariablesRequest(int64_t reference)
{
  dap::VariablesRequest variableRequest;
  variableRequest.variablesReference = reference;
  return variableRequest;
}

struct Dummies
{
  std::shared_ptr<cmake> CMake;
  std::shared_ptr<cmMakefile> Makefile;
  std::shared_ptr<cmGlobalGenerator> GlobalGenerator;
};

static Dummies CreateDummies(
  std::string targetName,
  std::string currentSourceDirectory = "c:/CurrentSourceDirectory",
  std::string currentBinaryDirectory = "c:/CurrentBinaryDirectory")
{
  Dummies dummies;
  dummies.CMake =
    std::make_shared<cmake>(cmake::RoleProject, cmState::Project);
  cmState* state = dummies.CMake->GetState();
  dummies.GlobalGenerator =
    std::make_shared<cmGlobalGenerator>(dummies.CMake.get());
  cmStateSnapshot snapshot = state->CreateBaseSnapshot();
  snapshot.GetDirectory().SetCurrentSource(currentSourceDirectory);
  snapshot.GetDirectory().SetCurrentBinary(currentBinaryDirectory);
  dummies.Makefile =
    std::make_shared<cmMakefile>(dummies.GlobalGenerator.get(), snapshot);
  dummies.Makefile->CreateNewTarget(targetName, cmStateEnums::EXECUTABLE);
  return dummies;
}

static bool testCreateFromPolicyMap()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  cmPolicies::PolicyMap policyMap;
  policyMap.Set(cmPolicies::CMP0000, cmPolicies::NEW);
  policyMap.Set(cmPolicies::CMP0003, cmPolicies::WARN);
  policyMap.Set(cmPolicies::CMP0005, cmPolicies::OLD);
  auto vars = cmDebugger::cmDebuggerVariablesHelper::Create(
    variablesManager, "Locals", true, policyMap);

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));
  ASSERT_TRUE(variables.size() == 3);
  ASSERT_VARIABLE(variables[0], "CMP0000", "NEW", "string");
  ASSERT_VARIABLE(variables[1], "CMP0003", "WARN", "string");
  ASSERT_VARIABLE(variables[2], "CMP0005", "OLD", "string");

  return true;
}

static bool testCreateFromPairVector()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  std::vector<std::pair<std::string, std::string>> pairs = {
    { "Foo1", "Bar1" }, { "Foo2", "Bar2" }
  };

  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, pairs);

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(vars->GetValue() == std::to_string(pairs.size()));
  ASSERT_TRUE(variables.size() == 2);
  ASSERT_VARIABLE(variables[0], "Foo1", "Bar1", "string");
  ASSERT_VARIABLE(variables[1], "Foo2", "Bar2", "string");

  auto none = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true,
    std::vector<std::pair<std::string, std::string>>());

  ASSERT_TRUE(none == nullptr);

  return true;
}

static bool testCreateFromSet()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  std::set<std::string> set = { "Foo", "Bar" };

  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, set);

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(vars->GetValue() == std::to_string(set.size()));
  ASSERT_TRUE(variables.size() == 2);
  ASSERT_VARIABLE(variables[0], "[0]", "Bar", "string");
  ASSERT_VARIABLE(variables[1], "[1]", "Foo", "string");

  auto none = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, std::set<std::string>());

  ASSERT_TRUE(none == nullptr);

  return true;
}

static bool testCreateFromStringVector()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  std::vector<std::string> list = { "Foo", "Bar" };

  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, list);

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(vars->GetValue() == std::to_string(list.size()));
  ASSERT_TRUE(variables.size() == 2);
  ASSERT_VARIABLE(variables[0], "[0]", "Foo", "string");
  ASSERT_VARIABLE(variables[1], "[1]", "Bar", "string");

  auto none = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, std::vector<std::string>());

  ASSERT_TRUE(none == nullptr);

  return true;
}

static bool testCreateFromTarget()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  auto dummies = CreateDummies("Foo");

  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, dummies.Makefile->GetOrderedTargets());

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(variables.size() == 1);
  ASSERT_VARIABLE(variables[0], "Foo", "EXECUTABLE", "collection");

  variables = variablesManager->HandleVariablesRequest(
    CreateVariablesRequest(variables[0].variablesReference));

  ASSERT_TRUE(variables.size() == 15);
  ASSERT_VARIABLE(variables[0], "GlobalGenerator", "Generic", "collection");
  ASSERT_VARIABLE(variables[1], "IsAIX", "FALSE", "bool");
  ASSERT_VARIABLE(variables[2], "IsAndroidGuiExecutable", "FALSE", "bool");
  ASSERT_VARIABLE(variables[3], "IsAppBundleOnApple", "FALSE", "bool");
  ASSERT_VARIABLE(variables[4], "IsDLLPlatform", "FALSE", "bool");
  ASSERT_VARIABLE(variables[5], "IsExecutableWithExports", "FALSE", "bool");
  ASSERT_VARIABLE(variables[6], "IsFrameworkOnApple", "FALSE", "bool");
  ASSERT_VARIABLE(variables[7], "IsImported", "FALSE", "bool");
  ASSERT_VARIABLE(variables[8], "IsImportedGloballyVisible", "FALSE", "bool");
  ASSERT_VARIABLE(variables[9], "IsPerConfig", "TRUE", "bool");
  ASSERT_VARIABLE(variables[10], "Makefile",
                  dummies.Makefile->GetDirectoryId().String, "collection");
  ASSERT_VARIABLE(variables[11], "Name", "Foo", "string");
  ASSERT_VARIABLE(variables[12], "PolicyMap", "", "collection");
  ASSERT_VARIABLE(variables[13], "Properties",
                  std::to_string(dummies.Makefile->GetOrderedTargets()[0]
                                   ->GetProperties()
                                   .GetList()
                                   .size()),
                  "collection");
  ASSERT_VARIABLE(variables[14], "Type", "EXECUTABLE", "string");

  auto none = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, std::vector<cmTarget*>());

  ASSERT_TRUE(none == nullptr);

  return true;
}

static bool testCreateFromGlobalGenerator()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  auto dummies = CreateDummies("Foo");

  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, dummies.GlobalGenerator.get());

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(variables.size() == 10);
  ASSERT_VARIABLE(variables[0], "AllTargetName", "ALL_BUILD", "string");
  ASSERT_VARIABLE(variables[1], "ForceUnixPaths", "FALSE", "bool");
  ASSERT_VARIABLE(variables[2], "InstallTargetName", "INSTALL", "string");
  ASSERT_VARIABLE(variables[3], "IsMultiConfig", "FALSE", "bool");
  ASSERT_VARIABLE(variables[4], "MakefileEncoding", "None", "string");
  ASSERT_VARIABLE(variables[5], "Name", "Generic", "string");
  ASSERT_VARIABLE(variables[6], "NeedSymbolicMark", "FALSE", "bool");
  ASSERT_VARIABLE(variables[7], "PackageTargetName", "PACKAGE", "string");
  ASSERT_VARIABLE(variables[8], "TestTargetName", "RUN_TESTS", "string");
  ASSERT_VARIABLE(variables[9], "UseLinkScript", "FALSE", "bool");

  auto none = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true,
    static_cast<cmGlobalGenerator*>(nullptr));

  ASSERT_TRUE(none == nullptr);

  return true;
}

static bool testCreateFromTests()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  auto dummies = CreateDummies("Foo");
  cmTest test1 = cmTest(dummies.Makefile.get());
  test1.SetName("Test1");
  test1.SetOldStyle(false);
  test1.SetCommandExpandLists(true);
  test1.SetCommand(std::vector<std::string>{ "Foo1", "arg1" });
  test1.SetProperty("Prop1", "Prop1");
  cmTest test2 = cmTest(dummies.Makefile.get());
  test2.SetName("Test2");
  test2.SetOldStyle(false);
  test2.SetCommandExpandLists(false);
  test2.SetCommand(std::vector<std::string>{ "Bar1", "arg1", "arg2" });
  test2.SetProperty("Prop2", "Prop2");
  test2.SetProperty("Prop3", "Prop3");

  std::vector<cmTest*> tests = { &test1, &test2 };

  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, tests);

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(vars->GetValue() == std::to_string(tests.size()));
  ASSERT_TRUE(variables.size() == 2);
  ASSERT_VARIABLE_REFERENCE_NOT_ZERO(variables[0], test1.GetName(), "",
                                     "collection");
  ASSERT_VARIABLE_REFERENCE_NOT_ZERO(variables[1], test2.GetName(), "",
                                     "collection");

  dap::array<dap::Variable> testVariables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(variables[0].variablesReference));
  ASSERT_TRUE(testVariables.size() == 5);
  ASSERT_VARIABLE_REFERENCE_NOT_ZERO(testVariables[0], "Command",
                                     std::to_string(test1.GetCommand().size()),
                                     "collection");
  ASSERT_VARIABLE(testVariables[1], "CommandExpandLists",
                  BOOL_STRING(test1.GetCommandExpandLists()), "bool");
  ASSERT_VARIABLE(testVariables[2], "Name", test1.GetName(), "string");
  ASSERT_VARIABLE(testVariables[3], "OldStyle",
                  BOOL_STRING(test1.GetOldStyle()), "bool");
  ASSERT_VARIABLE_REFERENCE_NOT_ZERO(testVariables[4], "Properties", "1",
                                     "collection");

  dap::array<dap::Variable> commandVariables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(testVariables[0].variablesReference));
  ASSERT_TRUE(commandVariables.size() == test1.GetCommand().size());
  for (size_t i = 0; i < commandVariables.size(); ++i) {
    ASSERT_VARIABLE(commandVariables[i], "[" + std::to_string(i) + "]",
                    test1.GetCommand()[i], "string");
  }

  dap::array<dap::Variable> propertiesVariables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(testVariables[4].variablesReference));
  ASSERT_TRUE(propertiesVariables.size() == 1);
  ASSERT_VARIABLE(propertiesVariables[0], "Prop1", "Prop1", "string");

  testVariables = variablesManager->HandleVariablesRequest(
    CreateVariablesRequest(variables[1].variablesReference));
  ASSERT_TRUE(testVariables.size() == 5);
  ASSERT_VARIABLE_REFERENCE_NOT_ZERO(testVariables[0], "Command",
                                     std::to_string(test2.GetCommand().size()),
                                     "collection");
  ASSERT_VARIABLE(testVariables[1], "CommandExpandLists",
                  BOOL_STRING(test2.GetCommandExpandLists()), "bool");
  ASSERT_VARIABLE(testVariables[2], "Name", test2.GetName(), "string");
  ASSERT_VARIABLE(testVariables[3], "OldStyle",
                  BOOL_STRING(test2.GetOldStyle()), "bool");
  ASSERT_VARIABLE_REFERENCE_NOT_ZERO(testVariables[4], "Properties", "2",
                                     "collection");

  commandVariables = variablesManager->HandleVariablesRequest(
    CreateVariablesRequest(testVariables[0].variablesReference));
  ASSERT_TRUE(commandVariables.size() == test2.GetCommand().size());
  for (size_t i = 0; i < commandVariables.size(); ++i) {
    ASSERT_VARIABLE(commandVariables[i], "[" + std::to_string(i) + "]",
                    test2.GetCommand()[i], "string");
  }

  propertiesVariables = variablesManager->HandleVariablesRequest(
    CreateVariablesRequest(testVariables[4].variablesReference));
  ASSERT_TRUE(propertiesVariables.size() == 2);
  ASSERT_VARIABLE(propertiesVariables[0], "Prop2", "Prop2", "string");
  ASSERT_VARIABLE(propertiesVariables[1], "Prop3", "Prop3", "string");

  auto none = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, std::vector<cmTest*>());

  ASSERT_TRUE(none == nullptr);

  return true;
}

static bool testCreateFromMakefile()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  auto dummies = CreateDummies("Foo");
  auto snapshot = dummies.Makefile->GetStateSnapshot();
  auto state = dummies.Makefile->GetState();
  state->SetSourceDirectory("c:/HomeDirectory");
  state->SetBinaryDirectory("c:/HomeOutputDirectory");
  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, dummies.Makefile.get());

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(variables.size() == 12);
  ASSERT_VARIABLE(variables[0], "AppleSDKType", "MacOS", "string");
  ASSERT_VARIABLE(variables[1], "CurrentBinaryDirectory",
                  snapshot.GetDirectory().GetCurrentBinary(), "string");
  ASSERT_VARIABLE(variables[2], "CurrentSourceDirectory",
                  snapshot.GetDirectory().GetCurrentSource(), "string");
  ASSERT_VARIABLE(variables[3], "DefineFlags", " ", "string");
  ASSERT_VARIABLE(variables[4], "DirectoryId",
                  dummies.Makefile->GetDirectoryId().String, "string");
  ASSERT_VARIABLE(variables[5], "HomeDirectory", state->GetSourceDirectory(),
                  "string");
  ASSERT_VARIABLE(variables[6], "HomeOutputDirectory",
                  state->GetBinaryDirectory(), "string");
  ASSERT_VARIABLE(variables[7], "IsRootMakefile", "TRUE", "bool");
  ASSERT_VARIABLE(variables[8], "PlatformIs32Bit", "FALSE", "bool");
  ASSERT_VARIABLE(variables[9], "PlatformIs64Bit", "FALSE", "bool");
  ASSERT_VARIABLE(variables[10], "PlatformIsAppleEmbedded", "FALSE", "bool");
  ASSERT_VARIABLE(variables[11], "PlatformIsx32", "FALSE", "bool");

  auto none = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, static_cast<cmMakefile*>(nullptr));

  ASSERT_TRUE(none == nullptr);

  return true;
}

static bool testCreateFromStackFrame()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();
  auto dummies = CreateDummies("Foo");

  cmListFileFunction lff = cmListFileFunction("set", 99, 99, {});
  auto frame = std::make_shared<cmDebugger::cmDebuggerStackFrame>(
    dummies.Makefile.get(), "c:/CMakeLists.txt", lff);

  dummies.CMake->AddCacheEntry("CMAKE_BUILD_TYPE", "Debug", "Build Type",
                               cmStateEnums::CacheEntryType::STRING);

  auto locals = cmDebugger::cmDebuggerVariablesHelper::Create(
    variablesManager, "Locals", true, frame);

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(locals->GetId()));

  ASSERT_TRUE(variables.size() == 5);
  ASSERT_VARIABLE(variables[0], "CacheVariables", "1", "collection");
  ASSERT_VARIABLE(variables[1], "CurrentLine", std::to_string(lff.Line()),
                  "int");
  ASSERT_VARIABLE(variables[2], "Directories", "2", "collection");
  ASSERT_VARIABLE(variables[3], "Locals", "2", "collection");
  ASSERT_VARIABLE(variables[4], "Targets", "1", "collection");

  dap::array<dap::Variable> cacheVariables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(variables[0].variablesReference));
  ASSERT_TRUE(cacheVariables.size() == 1);
  ASSERT_VARIABLE(cacheVariables[0], "CMAKE_BUILD_TYPE:STRING", "Debug",
                  "collection");

  dap::array<dap::Variable> directoriesVariables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(variables[2].variablesReference));
  ASSERT_TRUE(directoriesVariables.size() == 2);
  ASSERT_VARIABLE(
    directoriesVariables[0], "CMAKE_CURRENT_BINARY_DIR",
    dummies.Makefile->GetStateSnapshot().GetDirectory().GetCurrentBinary(),
    "string");
  ASSERT_VARIABLE(
    directoriesVariables[1], "CMAKE_CURRENT_SOURCE_DIR",
    dummies.Makefile->GetStateSnapshot().GetDirectory().GetCurrentSource(),
    "string");

  dap::array<dap::Variable> propertiesVariables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(cacheVariables[0].variablesReference));
  ASSERT_TRUE(propertiesVariables.size() == 3);
  ASSERT_VARIABLE(propertiesVariables[0], "HELPSTRING", "Build Type",
                  "string");
  ASSERT_VARIABLE(propertiesVariables[1], "TYPE", "STRING", "string");
  ASSERT_VARIABLE(propertiesVariables[2], "VALUE", "Debug", "string");

  return true;
}

static bool testCreateFromBTStringVector()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  std::vector<BT<std::string>> list(2);
  list[0].Value = "Foo";
  list[1].Value = "Bar";

  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, list);

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(vars->GetValue() == std::to_string(list.size()));
  ASSERT_TRUE(variables.size() == 2);
  ASSERT_VARIABLE(variables[0], "[0]", "Foo", "string");
  ASSERT_VARIABLE(variables[1], "[1]", "Bar", "string");

  auto none = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, std::vector<std::string>());

  ASSERT_TRUE(none == nullptr);

  return true;
}

static bool testCreateFromFileSet()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  cmake cm(cmake::RoleScript, cmState::Unknown);
  cmFileSet fileSet(cm, "Foo", "HEADERS", cmFileSetVisibility::Public);
  BT<std::string> directory;
  directory.Value = "c:/";
  fileSet.AddDirectoryEntry(directory);
  BT<std::string> file;
  file.Value = "c:/foo.cxx";
  fileSet.AddFileEntry(file);

  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, &fileSet);

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(variables.size() == 5);
  ASSERT_VARIABLE_REFERENCE_NOT_ZERO(variables[0], "Directories", "1",
                                     "collection");
  ASSERT_VARIABLE_REFERENCE_NOT_ZERO(variables[1], "Files", "1", "collection");
  ASSERT_VARIABLE(variables[2], "Name", "Foo", "string");
  ASSERT_VARIABLE(variables[3], "Type", "HEADERS", "string");
  ASSERT_VARIABLE(variables[4], "Visibility", "Public", "string");

  dap::array<dap::Variable> directoriesVariables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(variables[0].variablesReference));
  ASSERT_TRUE(directoriesVariables.size() == 1);
  ASSERT_VARIABLE(directoriesVariables[0], "[0]", directory.Value, "string");

  dap::array<dap::Variable> filesVariables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(variables[1].variablesReference));
  ASSERT_TRUE(filesVariables.size() == 1);
  ASSERT_VARIABLE(filesVariables[0], "[0]", file.Value, "string");

  return true;
}

static bool testCreateFromFileSets()
{
  auto variablesManager =
    std::make_shared<cmDebugger::cmDebuggerVariablesManager>();

  cmake cm(cmake::RoleScript, cmState::Unknown);
  cmFileSet fileSet(cm, "Foo", "HEADERS", cmFileSetVisibility::Public);
  BT<std::string> directory;
  directory.Value = "c:/";
  fileSet.AddDirectoryEntry(directory);
  BT<std::string> file;
  file.Value = "c:/foo.cxx";
  fileSet.AddFileEntry(file);

  auto fileSets = std::vector<cmFileSet*>{ &fileSet };
  auto vars = cmDebugger::cmDebuggerVariablesHelper::CreateIfAny(
    variablesManager, "Locals", true, fileSets);

  dap::array<dap::Variable> variables =
    variablesManager->HandleVariablesRequest(
      CreateVariablesRequest(vars->GetId()));

  ASSERT_TRUE(variables.size() == 1);
  ASSERT_VARIABLE_REFERENCE_NOT_ZERO(variables[0], "Foo", "", "collection");

  return true;
}

int testDebuggerVariablesHelper(int, char*[])
{
  return runTests(std::vector<std::function<bool()>>{
    testCreateFromPolicyMap,
    testCreateFromPairVector,
    testCreateFromSet,
    testCreateFromStringVector,
    testCreateFromTarget,
    testCreateFromGlobalGenerator,
    testCreateFromMakefile,
    testCreateFromStackFrame,
    testCreateFromTests,
    testCreateFromBTStringVector,
    testCreateFromFileSet,
    testCreateFromFileSets,
  });
}