Tests/CMakeLib/testDebuggerVariablesHelper.cxx - third_party/cmake - Git at Google

 /* 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,
   });
 }
	/* 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,
	});
	}