Lubuntu
/
cmake
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c0e0ccb431'
${ noResults }
cmake/Tests/CMakeLib/testDebuggerVariablesHelper...

588 lines
21 KiB
Raw Blame History

/* 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,
});
}
Reference in new issue View Git Blame Copy Permalink