unittests/Interpreter/TestArgs.cpp

   1 //===-- ArgsTest.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "gtest/gtest.h"
  11
  12 #include "lldb/Interpreter/Args.h"
  13
  14 #include <limits>
  15 #include <sstream>
  16
  17 using namespace lldb_private;
  18
  19 TEST(ArgsTest, TestSingleArg) {
  20   Args args;
  21   args.SetCommandString("arg");
  22   EXPECT_EQ(1u, args.GetArgumentCount());
  23   EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
  24 }
  25
  26 TEST(ArgsTest, TestSingleQuotedArgWithSpace) {
  27   Args args;
  28   args.SetCommandString("\"arg with space\"");
  29   EXPECT_EQ(1u, args.GetArgumentCount());
  30   EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
  31 }
  32
  33 TEST(ArgsTest, TestSingleArgWithQuotedSpace) {
  34   Args args;
  35   args.SetCommandString("arg\\ with\\ space");
  36   EXPECT_EQ(1u, args.GetArgumentCount());
  37   EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg with space");
  38 }
  39
  40 TEST(ArgsTest, TestMultipleArgs) {
  41   Args args;
  42   args.SetCommandString("this has multiple args");
  43   EXPECT_EQ(4u, args.GetArgumentCount());
  44   EXPECT_STREQ(args.GetArgumentAtIndex(0), "this");
  45   EXPECT_STREQ(args.GetArgumentAtIndex(1), "has");
  46   EXPECT_STREQ(args.GetArgumentAtIndex(2), "multiple");
  47   EXPECT_STREQ(args.GetArgumentAtIndex(3), "args");
  48 }
  49
  50 TEST(ArgsTest, TestOverwriteArgs) {
  51   Args args;
  52   args.SetCommandString("this has multiple args");
  53   EXPECT_EQ(4u, args.GetArgumentCount());
  54   args.SetCommandString("arg");
  55   EXPECT_EQ(1u, args.GetArgumentCount());
  56   EXPECT_STREQ(args.GetArgumentAtIndex(0), "arg");
  57 }
  58
  59 TEST(ArgsTest, TestAppendArg) {
  60   Args args;
  61   args.SetCommandString("first_arg");
  62   EXPECT_EQ(1u, args.GetArgumentCount());
  63   args.AppendArgument(llvm::StringRef("second_arg"));
  64   EXPECT_EQ(2u, args.GetArgumentCount());
  65   EXPECT_STREQ(args.GetArgumentAtIndex(0), "first_arg");
  66   EXPECT_STREQ(args.GetArgumentAtIndex(1), "second_arg");
  67 }
  68
  69 TEST(ArgsTest, TestInsertArg) {
  70   Args args;
  71   args.AppendArgument("1");
  72   args.AppendArgument("2");
  73   args.AppendArgument("3");
  74   args.InsertArgumentAtIndex(1, "1.5");
  75   args.InsertArgumentAtIndex(4, "3.5");
  76
  77   ASSERT_EQ(5u, args.GetArgumentCount());
  78   EXPECT_STREQ("1", args.GetArgumentAtIndex(0));
  79   EXPECT_STREQ("1.5", args.GetArgumentAtIndex(1));
  80   EXPECT_STREQ("2", args.GetArgumentAtIndex(2));
  81   EXPECT_STREQ("3", args.GetArgumentAtIndex(3));
  82   EXPECT_STREQ("3.5", args.GetArgumentAtIndex(4));
  83 }
  84
  85 TEST(ArgsTest, TestArgv) {
  86   Args args;
  87   EXPECT_EQ(nullptr, args.GetArgumentVector());
  88
  89   args.AppendArgument("1");
  90   EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
  91   EXPECT_EQ(nullptr, args.GetArgumentVector()[1]);
  92
  93   args.AppendArgument("2");
  94   EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
  95   EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
  96   EXPECT_EQ(nullptr, args.GetArgumentVector()[2]);
  97
  98   args.AppendArgument("3");
  99   EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
 100   EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
 101   EXPECT_NE(nullptr, args.GetArgumentVector()[2]);
 102   EXPECT_EQ(nullptr, args.GetArgumentVector()[3]);
 103
 104   args.InsertArgumentAtIndex(1, "1.5");
 105   EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
 106   EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
 107   EXPECT_NE(nullptr, args.GetArgumentVector()[2]);
 108   EXPECT_NE(nullptr, args.GetArgumentVector()[3]);
 109   EXPECT_EQ(nullptr, args.GetArgumentVector()[4]);
 110
 111   args.InsertArgumentAtIndex(4, "3.5");
 112   EXPECT_NE(nullptr, args.GetArgumentVector()[0]);
 113   EXPECT_NE(nullptr, args.GetArgumentVector()[1]);
 114   EXPECT_NE(nullptr, args.GetArgumentVector()[2]);
 115   EXPECT_NE(nullptr, args.GetArgumentVector()[3]);
 116   EXPECT_NE(nullptr, args.GetArgumentVector()[4]);
 117   EXPECT_EQ(nullptr, args.GetArgumentVector()[5]);
 118 }
 119
 120 TEST(ArgsTest, GetQuotedCommandString) {
 121   Args args;
 122   const char *str = "process launch -o stdout.txt -- \"a b c\"";
 123   args.SetCommandString(str);
 124
 125   std::string stdstr;
 126   ASSERT_TRUE(args.GetQuotedCommandString(stdstr));
 127   EXPECT_EQ(str, stdstr);
 128 }
 129
 130 TEST(ArgsTest, BareSingleQuote) {
 131   Args args;
 132   args.SetCommandString("a\\'b");
 133   EXPECT_EQ(1u, args.GetArgumentCount());
 134
 135   EXPECT_STREQ("a'b", args.GetArgumentAtIndex(0));
 136 }
 137
 138 TEST(ArgsTest, DoubleQuotedItem) {
 139   Args args;
 140   args.SetCommandString("\"a b c\"");
 141   EXPECT_EQ(1u, args.GetArgumentCount());
 142
 143   EXPECT_STREQ("a b c", args.GetArgumentAtIndex(0));
 144 }
 145
 146 TEST(ArgsTest, AppendArguments) {
 147   Args args;
 148   const char *argv[] = {"1", "2", nullptr};
 149   const char *argv2[] = {"3", "4", nullptr};
 150
 151   args.AppendArguments(argv);
 152   ASSERT_EQ(2u, args.GetArgumentCount());
 153   EXPECT_STREQ("1", args.GetArgumentVector()[0]);
 154   EXPECT_STREQ("2", args.GetArgumentVector()[1]);
 155   EXPECT_EQ(nullptr, args.GetArgumentVector()[2]);
 156   EXPECT_STREQ("1", args.GetArgumentAtIndex(0));
 157   EXPECT_STREQ("2", args.GetArgumentAtIndex(1));
 158
 159   args.AppendArguments(argv2);
 160   ASSERT_EQ(4u, args.GetArgumentCount());
 161   EXPECT_STREQ("1", args.GetArgumentVector()[0]);
 162   EXPECT_STREQ("2", args.GetArgumentVector()[1]);
 163   EXPECT_STREQ("3", args.GetArgumentVector()[2]);
 164   EXPECT_STREQ("4", args.GetArgumentVector()[3]);
 165   EXPECT_EQ(nullptr, args.GetArgumentVector()[4]);
 166   EXPECT_STREQ("1", args.GetArgumentAtIndex(0));
 167   EXPECT_STREQ("2", args.GetArgumentAtIndex(1));
 168   EXPECT_STREQ("3", args.GetArgumentAtIndex(2));
 169   EXPECT_STREQ("4", args.GetArgumentAtIndex(3));
 170 }
 171
 172 TEST(ArgsTest, StringToBoolean) {
 173   bool success = false;
 174   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, nullptr));
 175   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("on"), false, nullptr));
 176   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("yes"), false, nullptr));
 177   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("1"), false, nullptr));
 178
 179   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("true"), false, &success));
 180   EXPECT_TRUE(success);
 181   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("on"), false, &success));
 182   EXPECT_TRUE(success);
 183   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("yes"), false, &success));
 184   EXPECT_TRUE(success);
 185   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("1"), false, &success));
 186   EXPECT_TRUE(success);
 187
 188   EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("false"), true, nullptr));
 189   EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("off"), true, nullptr));
 190   EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("no"), true, nullptr));
 191   EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("0"), true, nullptr));
 192
 193   EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("false"), true, &success));
 194   EXPECT_TRUE(success);
 195   EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("off"), true, &success));
 196   EXPECT_TRUE(success);
 197   EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("no"), true, &success));
 198   EXPECT_TRUE(success);
 199   EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("0"), true, &success));
 200   EXPECT_TRUE(success);
 201
 202   EXPECT_FALSE(Args::StringToBoolean(llvm::StringRef("10"), false, &success));
 203   EXPECT_FALSE(success);
 204   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef("10"), true, &success));
 205   EXPECT_FALSE(success);
 206   EXPECT_TRUE(Args::StringToBoolean(llvm::StringRef(""), true, &success));
 207   EXPECT_FALSE(success);
 208 }
 209
 210 TEST(ArgsTest, StringToChar) {
 211   bool success = false;
 212
 213   EXPECT_EQ('A', Args::StringToChar("A", 'B', nullptr));
 214   EXPECT_EQ('B', Args::StringToChar("B", 'A', nullptr));
 215
 216   EXPECT_EQ('A', Args::StringToChar("A", 'B', &success));
 217   EXPECT_TRUE(success);
 218   EXPECT_EQ('B', Args::StringToChar("B", 'A', &success));
 219   EXPECT_TRUE(success);
 220
 221   EXPECT_EQ('A', Args::StringToChar("", 'A', &success));
 222   EXPECT_FALSE(success);
 223   EXPECT_EQ('A', Args::StringToChar("ABC", 'A', &success));
 224   EXPECT_FALSE(success);
 225 }
 226
 227 TEST(ArgsTest, StringToScriptLanguage) {
 228   bool success = false;
 229
 230   EXPECT_EQ(lldb::eScriptLanguageDefault,
 231             Args::StringToScriptLanguage(llvm::StringRef("default"),
 232                                          lldb::eScriptLanguageNone, nullptr));
 233   EXPECT_EQ(lldb::eScriptLanguagePython,
 234             Args::StringToScriptLanguage(llvm::StringRef("python"),
 235                                          lldb::eScriptLanguageNone, nullptr));
 236   EXPECT_EQ(lldb::eScriptLanguageNone,
 237             Args::StringToScriptLanguage(llvm::StringRef("none"),
 238                                          lldb::eScriptLanguagePython, nullptr));
 239
 240   EXPECT_EQ(lldb::eScriptLanguageDefault,
 241             Args::StringToScriptLanguage(llvm::StringRef("default"),
 242                                          lldb::eScriptLanguageNone, &success));
 243   EXPECT_TRUE(success);
 244   EXPECT_EQ(lldb::eScriptLanguagePython,
 245             Args::StringToScriptLanguage(llvm::StringRef("python"),
 246                                          lldb::eScriptLanguageNone, &success));
 247   EXPECT_TRUE(success);
 248   EXPECT_EQ(lldb::eScriptLanguageNone,
 249             Args::StringToScriptLanguage(llvm::StringRef("none"),
 250                                          lldb::eScriptLanguagePython,
 251                                          &success));
 252   EXPECT_TRUE(success);
 253
 254   EXPECT_EQ(lldb::eScriptLanguagePython,
 255             Args::StringToScriptLanguage(llvm::StringRef("invalid"),
 256                                          lldb::eScriptLanguagePython,
 257                                          &success));
 258   EXPECT_FALSE(success);
 259 }
 260
 261 TEST(ArgsTest, StringToVersion) {}
 262
 263 // Environment Variable Tests
 264
 265 class EnvVarFixture: public ::testing::Test {
 266 protected:
 267
 268     void SetUp() {
 269         args.AppendArgument(llvm::StringRef("Arg1=foo"));
 270         args.AppendArgument(llvm::StringRef("Arg2"));
 271         args.AppendArgument(llvm::StringRef("Arg3=bar"));
 272     }
 273
 274     size_t GetIndexForEnvVar(llvm::StringRef envvar_name) {
 275         size_t argument_index = std::numeric_limits<size_t>::max();
 276         EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name,
 277                                                      &argument_index));
 278         EXPECT_LT(argument_index, args.GetArgumentCount());
 279         return argument_index;
 280     }
 281
 282     Args  args;
 283 };
 284
 285
 286 TEST_F(EnvVarFixture, TestContainsEnvironmentVariableNoValue) {
 287     EXPECT_TRUE(args.ContainsEnvironmentVariable(llvm::StringRef("Arg2")));
 288 }
 289
 290 TEST_F(EnvVarFixture, TestContainsEnvironmentVariableWithValue) {
 291     EXPECT_TRUE(args.ContainsEnvironmentVariable(llvm::StringRef("Arg3")));
 292 }
 293
 294 TEST_F(EnvVarFixture, TestContainsEnvironmentVariableNonExistentVariable) {
 295     auto nonexistent_envvar = llvm::StringRef("ThisEnvVarShouldNotExist");
 296     EXPECT_FALSE(args.ContainsEnvironmentVariable(nonexistent_envvar));
 297 }
 298
 299 TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialNoValueWithNoValue) {
 300     auto envvar_name = llvm::StringRef("Arg2");
 301     auto argument_index = GetIndexForEnvVar(envvar_name);
 302
 303     args.AddOrReplaceEnvironmentVariable(envvar_name, llvm::StringRef(""));
 304     EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
 305     EXPECT_EQ(envvar_name, args.GetArgumentAtIndex(argument_index));
 306 }
 307
 308 TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialNoValueWithValue) {
 309     auto envvar_name = llvm::StringRef("Arg2");
 310     auto argument_index = GetIndexForEnvVar(envvar_name);
 311
 312     auto new_value = llvm::StringRef("NewValue");
 313     args.AddOrReplaceEnvironmentVariable(envvar_name, new_value);
 314     EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
 315
 316     std::stringstream stream;
 317     stream << envvar_name.str() << '=' << new_value.str();
 318     EXPECT_EQ(llvm::StringRef(stream.str()),
 319               args.GetArgumentAtIndex(argument_index));
 320 }
 321
 322 TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialValueWithNoValue) {
 323     auto envvar_name = llvm::StringRef("Arg1");
 324     auto argument_index = GetIndexForEnvVar(envvar_name);
 325
 326     args.AddOrReplaceEnvironmentVariable(envvar_name, llvm::StringRef(""));
 327     EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
 328     EXPECT_EQ(envvar_name, args.GetArgumentAtIndex(argument_index));
 329 }
 330
 331 TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialValueWithValue) {
 332     auto envvar_name = llvm::StringRef("Arg1");
 333     auto argument_index = GetIndexForEnvVar(envvar_name);
 334
 335     auto new_value = llvm::StringRef("NewValue");
 336     args.AddOrReplaceEnvironmentVariable(envvar_name, new_value);
 337     EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
 338
 339     std::stringstream stream;
 340     stream << envvar_name.str() << '=' << new_value.str();
 341     EXPECT_EQ(llvm::StringRef(stream.str()),
 342               args.GetArgumentAtIndex(argument_index));
 343 }