forked from OSchip/llvm-project
352 lines
12 KiB
C++
352 lines
12 KiB
C++
//===-- ArgsTest.cpp --------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "gtest/gtest.h"
|
|
|
|
#include "lldb/Interpreter/Args.h"
|
|
|
|
#include <limits>
|
|
#include <sstream>
|
|
|
|
using namespace lldb_private;
|
|
|
|
TEST(ArgsTest, TestSingleArg) {
|
|
Args args;
|
|
args.SetCommandString("arg");
|
|
EXPECT_EQ(1u, args.GetArgumentCount());
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
|
|
}
|
|
|
|
TEST(ArgsTest, TestSingleQuotedArgWithSpace) {
|
|
Args args;
|
|
args.SetCommandString("\"arg with space\"");
|
|
EXPECT_EQ(1u, args.GetArgumentCount());
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
|
|
}
|
|
|
|
TEST(ArgsTest, TestSingleArgWithQuotedSpace) {
|
|
Args args;
|
|
args.SetCommandString("arg\\ with\\ space");
|
|
EXPECT_EQ(1u, args.GetArgumentCount());
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
|
|
}
|
|
|
|
TEST(ArgsTest, TestMultipleArgs) {
|
|
Args args;
|
|
args.SetCommandString("this has multiple args");
|
|
EXPECT_EQ(4u, args.GetArgumentCount());
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(0), "this");
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(1), "has");
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(2), "multiple");
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(3), "args");
|
|
}
|
|
|
|
TEST(ArgsTest, TestOverwriteArgs) {
|
|
Args args;
|
|
args.SetCommandString("this has multiple args");
|
|
EXPECT_EQ(4u, args.GetArgumentCount());
|
|
args.SetCommandString("arg");
|
|
EXPECT_EQ(1u, args.GetArgumentCount());
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
|
|
}
|
|
|
|
TEST(ArgsTest, TestAppendArg) {
|
|
Args args;
|
|
args.SetCommandString("first_arg");
|
|
EXPECT_EQ(1u, args.GetArgumentCount());
|
|
args.AppendArgument(llvm::StringRef("second_arg"));
|
|
EXPECT_EQ(2u, args.GetArgumentCount());
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(0), "first_arg");
|
|
EXPECT_STREQ(args.GetArgumentAtIndex(1), "second_arg");
|
|
}
|
|
|
|
TEST(ArgsTest, TestInsertArg) {
|
|
Args args;
|
|
args.AppendArgument("1");
|
|
args.AppendArgument("2");
|
|
args.AppendArgument("3");
|
|
args.InsertArgumentAtIndex(1, "1.5");
|
|
args.InsertArgumentAtIndex(4, "3.5");
|
|
|
|
ASSERT_EQ(5u, args.GetArgumentCount());
|
|
EXPECT_STREQ("1", args.GetArgumentAtIndex(0));
|
|
EXPECT_STREQ("1.5", args.GetArgumentAtIndex(1));
|
|
EXPECT_STREQ("2", args.GetArgumentAtIndex(2));
|
|
EXPECT_STREQ("3", args.GetArgumentAtIndex(3));
|
|
EXPECT_STREQ("3.5", args.GetArgumentAtIndex(4));
|
|
}
|
|
|
|
TEST(ArgsTest, TestArgv) {
|
|
Args args;
|
|
EXPECT_EQ(nullptr, args.GetArgumentVector());
|
|
|
|
args.AppendArgument("1");
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
|
|
EXPECT_EQ(nullptr, args.GetArgumentVector()[1]);
|
|
|
|
args.AppendArgument("2");
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
|
|
EXPECT_EQ(nullptr, args.GetArgumentVector()[2]);
|
|
|
|
args.AppendArgument("3");
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[2]);
|
|
EXPECT_EQ(nullptr, args.GetArgumentVector()[3]);
|
|
|
|
args.InsertArgumentAtIndex(1, "1.5");
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[2]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[3]);
|
|
EXPECT_EQ(nullptr, args.GetArgumentVector()[4]);
|
|
|
|
args.InsertArgumentAtIndex(4, "3.5");
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[2]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[3]);
|
|
EXPECT_NE(nullptr, args.GetArgumentVector()[4]);
|
|
EXPECT_EQ(nullptr, args.GetArgumentVector()[5]);
|
|
}
|
|
|
|
TEST(ArgsTest, GetQuotedCommandString) {
|
|
Args args;
|
|
const char *str = "process launch -o stdout.txt -- \"a b c\"";
|
|
args.SetCommandString(str);
|
|
|
|
std::string stdstr;
|
|
ASSERT_TRUE(args.GetQuotedCommandString(stdstr));
|
|
EXPECT_EQ(str, stdstr);
|
|
}
|
|
|
|
TEST(ArgsTest, BareSingleQuote) {
|
|
Args args;
|
|
args.SetCommandString("a\\'b");
|
|
EXPECT_EQ(1u, args.GetArgumentCount());
|
|
|
|
EXPECT_STREQ("a'b", args.GetArgumentAtIndex(0));
|
|
}
|
|
|
|
TEST(ArgsTest, DoubleQuotedItem) {
|
|
Args args;
|
|
args.SetCommandString("\"a b c\"");
|
|
EXPECT_EQ(1u, args.GetArgumentCount());
|
|
|
|
EXPECT_STREQ("a b c", args.GetArgumentAtIndex(0));
|
|
}
|
|
|
|
TEST(ArgsTest, AppendArguments) {
|
|
Args args;
|
|
const char *argv[] = {"1", "2", nullptr};
|
|
const char *argv2[] = {"3", "4", nullptr};
|
|
|
|
args.AppendArguments(argv);
|
|
ASSERT_EQ(2u, args.GetArgumentCount());
|
|
EXPECT_STREQ("1", args.GetArgumentVector()[0]);
|
|
EXPECT_STREQ("2", args.GetArgumentVector()[1]);
|
|
EXPECT_EQ(nullptr, args.GetArgumentVector()[2]);
|
|
EXPECT_STREQ("1", args.GetArgumentAtIndex(0));
|
|
EXPECT_STREQ("2", args.GetArgumentAtIndex(1));
|
|
|
|
args.AppendArguments(argv2);
|
|
ASSERT_EQ(4u, args.GetArgumentCount());
|
|
EXPECT_STREQ("1", args.GetArgumentVector()[0]);
|
|
EXPECT_STREQ("2", args.GetArgumentVector()[1]);
|
|
EXPECT_STREQ("3", args.GetArgumentVector()[2]);
|
|
EXPECT_STREQ("4", args.GetArgumentVector()[3]);
|
|
EXPECT_EQ(nullptr, args.GetArgumentVector()[4]);
|
|
EXPECT_STREQ("1", args.GetArgumentAtIndex(0));
|
|
EXPECT_STREQ("2", args.GetArgumentAtIndex(1));
|
|
EXPECT_STREQ("3", args.GetArgumentAtIndex(2));
|
|
EXPECT_STREQ("4", args.GetArgumentAtIndex(3));
|
|
}
|
|
|
|
TEST(ArgsTest, GetArgumentArrayRef) {
|
|
Args args("foo bar");
|
|
auto ref = args.GetArgumentArrayRef();
|
|
ASSERT_EQ(2u, ref.size());
|
|
EXPECT_STREQ("foo", ref[0]);
|
|
EXPECT_STREQ("bar", ref[1]);
|
|
}
|
|
|
|
TEST(ArgsTest, StringToBoolean) {
|
|
bool success = false;
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, nullptr));
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("on"), false, nullptr));
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("yes"), false, nullptr));
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("1"), false, nullptr));
|
|
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, &success));
|
|
EXPECT_TRUE(success);
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("on"), false, &success));
|
|
EXPECT_TRUE(success);
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("yes"), false, &success));
|
|
EXPECT_TRUE(success);
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("1"), false, &success));
|
|
EXPECT_TRUE(success);
|
|
|
|
EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("false"), true, nullptr));
|
|
EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("off"), true, nullptr));
|
|
EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("no"), true, nullptr));
|
|
EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("0"), true, nullptr));
|
|
|
|
EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("false"), true, &success));
|
|
EXPECT_TRUE(success);
|
|
EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("off"), true, &success));
|
|
EXPECT_TRUE(success);
|
|
EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("no"), true, &success));
|
|
EXPECT_TRUE(success);
|
|
EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("0"), true, &success));
|
|
EXPECT_TRUE(success);
|
|
|
|
EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("10"), false, &success));
|
|
EXPECT_FALSE(success);
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("10"), true, &success));
|
|
EXPECT_FALSE(success);
|
|
EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef(""), true, &success));
|
|
EXPECT_FALSE(success);
|
|
}
|
|
|
|
TEST(ArgsTest, StringToChar) {
|
|
bool success = false;
|
|
|
|
EXPECT_EQ('A', Args::StringToChar("A", 'B', nullptr));
|
|
EXPECT_EQ('B', Args::StringToChar("B", 'A', nullptr));
|
|
|
|
EXPECT_EQ('A', Args::StringToChar("A", 'B', &success));
|
|
EXPECT_TRUE(success);
|
|
EXPECT_EQ('B', Args::StringToChar("B", 'A', &success));
|
|
EXPECT_TRUE(success);
|
|
|
|
EXPECT_EQ('A', Args::StringToChar("", 'A', &success));
|
|
EXPECT_FALSE(success);
|
|
EXPECT_EQ('A', Args::StringToChar("ABC", 'A', &success));
|
|
EXPECT_FALSE(success);
|
|
}
|
|
|
|
TEST(ArgsTest, StringToScriptLanguage) {
|
|
bool success = false;
|
|
|
|
EXPECT_EQ(lldb::eScriptLanguageDefault,
|
|
Args::StringToScriptLanguage(llvm::StringRef("default"),
|
|
lldb::eScriptLanguageNone, nullptr));
|
|
EXPECT_EQ(lldb::eScriptLanguagePython,
|
|
Args::StringToScriptLanguage(llvm::StringRef("python"),
|
|
lldb::eScriptLanguageNone, nullptr));
|
|
EXPECT_EQ(lldb::eScriptLanguageNone,
|
|
Args::StringToScriptLanguage(llvm::StringRef("none"),
|
|
lldb::eScriptLanguagePython, nullptr));
|
|
|
|
EXPECT_EQ(lldb::eScriptLanguageDefault,
|
|
Args::StringToScriptLanguage(llvm::StringRef("default"),
|
|
lldb::eScriptLanguageNone, &success));
|
|
EXPECT_TRUE(success);
|
|
EXPECT_EQ(lldb::eScriptLanguagePython,
|
|
Args::StringToScriptLanguage(llvm::StringRef("python"),
|
|
lldb::eScriptLanguageNone, &success));
|
|
EXPECT_TRUE(success);
|
|
EXPECT_EQ(lldb::eScriptLanguageNone,
|
|
Args::StringToScriptLanguage(llvm::StringRef("none"),
|
|
lldb::eScriptLanguagePython,
|
|
&success));
|
|
EXPECT_TRUE(success);
|
|
|
|
EXPECT_EQ(lldb::eScriptLanguagePython,
|
|
Args::StringToScriptLanguage(llvm::StringRef("invalid"),
|
|
lldb::eScriptLanguagePython,
|
|
&success));
|
|
EXPECT_FALSE(success);
|
|
}
|
|
|
|
TEST(ArgsTest, StringToVersion) {}
|
|
|
|
// Environment Variable Tests
|
|
|
|
class EnvVarFixture: public ::testing::Test {
|
|
protected:
|
|
|
|
void SetUp() {
|
|
args.AppendArgument(llvm::StringRef("Arg1=foo"));
|
|
args.AppendArgument(llvm::StringRef("Arg2"));
|
|
args.AppendArgument(llvm::StringRef("Arg3=bar"));
|
|
}
|
|
|
|
size_t GetIndexForEnvVar(llvm::StringRef envvar_name) {
|
|
size_t argument_index = std::numeric_limits<size_t>::max();
|
|
EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name,
|
|
&argument_index));
|
|
EXPECT_LT(argument_index, args.GetArgumentCount());
|
|
return argument_index;
|
|
}
|
|
|
|
Args args;
|
|
};
|
|
|
|
|
|
TEST_F(EnvVarFixture, TestContainsEnvironmentVariableNoValue) {
|
|
EXPECT_TRUE(args.ContainsEnvironmentVariable(llvm::StringRef("Arg2")));
|
|
}
|
|
|
|
TEST_F(EnvVarFixture, TestContainsEnvironmentVariableWithValue) {
|
|
EXPECT_TRUE(args.ContainsEnvironmentVariable(llvm::StringRef("Arg3")));
|
|
}
|
|
|
|
TEST_F(EnvVarFixture, TestContainsEnvironmentVariableNonExistentVariable) {
|
|
auto nonexistent_envvar = llvm::StringRef("ThisEnvVarShouldNotExist");
|
|
EXPECT_FALSE(args.ContainsEnvironmentVariable(nonexistent_envvar));
|
|
}
|
|
|
|
TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialNoValueWithNoValue) {
|
|
auto envvar_name = llvm::StringRef("Arg2");
|
|
auto argument_index = GetIndexForEnvVar(envvar_name);
|
|
|
|
args.AddOrReplaceEnvironmentVariable(envvar_name, llvm::StringRef(""));
|
|
EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
|
|
EXPECT_EQ(envvar_name, args.GetArgumentAtIndex(argument_index));
|
|
}
|
|
|
|
TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialNoValueWithValue) {
|
|
auto envvar_name = llvm::StringRef("Arg2");
|
|
auto argument_index = GetIndexForEnvVar(envvar_name);
|
|
|
|
auto new_value = llvm::StringRef("NewValue");
|
|
args.AddOrReplaceEnvironmentVariable(envvar_name, new_value);
|
|
EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
|
|
|
|
std::stringstream stream;
|
|
stream << envvar_name.str() << '=' << new_value.str();
|
|
EXPECT_EQ(llvm::StringRef(stream.str()),
|
|
args.GetArgumentAtIndex(argument_index));
|
|
}
|
|
|
|
TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialValueWithNoValue) {
|
|
auto envvar_name = llvm::StringRef("Arg1");
|
|
auto argument_index = GetIndexForEnvVar(envvar_name);
|
|
|
|
args.AddOrReplaceEnvironmentVariable(envvar_name, llvm::StringRef(""));
|
|
EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
|
|
EXPECT_EQ(envvar_name, args.GetArgumentAtIndex(argument_index));
|
|
}
|
|
|
|
TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialValueWithValue) {
|
|
auto envvar_name = llvm::StringRef("Arg1");
|
|
auto argument_index = GetIndexForEnvVar(envvar_name);
|
|
|
|
auto new_value = llvm::StringRef("NewValue");
|
|
args.AddOrReplaceEnvironmentVariable(envvar_name, new_value);
|
|
EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
|
|
|
|
std::stringstream stream;
|
|
stream << envvar_name.str() << '=' << new_value.str();
|
|
EXPECT_EQ(llvm::StringRef(stream.str()),
|
|
args.GetArgumentAtIndex(argument_index));
|
|
}
|