1 files changed, 587 insertions, 0 deletions
diff --git a/Tests/CMakeLib/testDebuggerVariablesHelper.cxx b/Tests/CMakeLib/testDebuggerVariablesHelper.cxx
new file mode 100644
index 0000000..e0bbdf0
--- /dev/null
+++ b/Tests/CMakeLib/testDebuggerVariablesHelper.cxx
@@ -0,0 +1,587 @@
+/* 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,
+  });
+}