unittests/Option/OptionParsingTest.cpp

   1 //===- unittest/Support/OptionParsingTest.cpp - OptTable tests ------------===//
   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 "llvm/ADT/STLExtras.h"
  11 #include "llvm/Option/Arg.h"
  12 #include "llvm/Option/ArgList.h"
  13 #include "llvm/Option/Option.h"
  14 #include "gtest/gtest.h"
  15
  16 using namespace llvm;
  17 using namespace llvm::opt;
  18
  19 enum ID {
  20   OPT_INVALID = 0, // This is not an option ID.
  21 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
  22                HELPTEXT, METAVAR, VALUES)                                      \
  23   OPT_##ID,
  24 #include "Opts.inc"
  25   LastOption
  26 #undef OPTION
  27 };
  28
  29 #define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
  30 #include "Opts.inc"
  31 #undef PREFIX
  32
  33 enum OptionFlags {
  34   OptFlag1 = (1 << 4),
  35   OptFlag2 = (1 << 5),
  36   OptFlag3 = (1 << 6)
  37 };
  38
  39 static const OptTable::Info InfoTable[] = {
  40 #define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
  41                HELPTEXT, METAVAR, VALUES)                                      \
  42   {PREFIX, NAME,  HELPTEXT,    METAVAR,     OPT_##ID,  Option::KIND##Class,    \
  43    PARAM,  FLAGS, OPT_##GROUP, OPT_##ALIAS, ALIASARGS, VALUES},
  44 #include "Opts.inc"
  45 #undef OPTION
  46 };
  47
  48 namespace {
  49 class TestOptTable : public OptTable {
  50 public:
  51   TestOptTable(bool IgnoreCase = false)
  52     : OptTable(InfoTable, IgnoreCase) {}
  53 };
  54 }
  55
  56 const char *Args[] = {
  57   "-A",
  58   "-Bhi",
  59   "--C=desu",
  60   "-C", "bye",
  61   "-D,adena",
  62   "-E", "apple", "bloom",
  63   "-Fblarg",
  64   "-F", "42",
  65   "-Gchuu", "2"
  66   };
  67
  68 TEST(Option, OptionParsing) {
  69   TestOptTable T;
  70   unsigned MAI, MAC;
  71   InputArgList AL = T.ParseArgs(Args, MAI, MAC);
  72
  73   // Check they all exist.
  74   EXPECT_TRUE(AL.hasArg(OPT_A));
  75   EXPECT_TRUE(AL.hasArg(OPT_B));
  76   EXPECT_TRUE(AL.hasArg(OPT_C));
  77   EXPECT_TRUE(AL.hasArg(OPT_D));
  78   EXPECT_TRUE(AL.hasArg(OPT_E));
  79   EXPECT_TRUE(AL.hasArg(OPT_F));
  80   EXPECT_TRUE(AL.hasArg(OPT_G));
  81
  82   // Check the values.
  83   EXPECT_EQ("hi", AL.getLastArgValue(OPT_B));
  84   EXPECT_EQ("bye", AL.getLastArgValue(OPT_C));
  85   EXPECT_EQ("adena", AL.getLastArgValue(OPT_D));
  86   std::vector<std::string> Es = AL.getAllArgValues(OPT_E);
  87   EXPECT_EQ("apple", Es[0]);
  88   EXPECT_EQ("bloom", Es[1]);
  89   EXPECT_EQ("42", AL.getLastArgValue(OPT_F));
  90   std::vector<std::string> Gs = AL.getAllArgValues(OPT_G);
  91   EXPECT_EQ("chuu", Gs[0]);
  92   EXPECT_EQ("2", Gs[1]);
  93
  94   // Check the help text.
  95   std::string Help;
  96   raw_string_ostream RSO(Help);
  97   T.PrintHelp(RSO, "test", "title!");
  98   EXPECT_NE(std::string::npos, Help.find("-A"));
  99
 100   // Test aliases.
 101   auto Cs = AL.filtered(OPT_C);
 102   ASSERT_NE(Cs.begin(), Cs.end());
 103   EXPECT_EQ("desu", StringRef((*Cs.begin())->getValue()));
 104   ArgStringList ASL;
 105   (*Cs.begin())->render(AL, ASL);
 106   ASSERT_EQ(2u, ASL.size());
 107   EXPECT_EQ("-C", StringRef(ASL[0]));
 108   EXPECT_EQ("desu", StringRef(ASL[1]));
 109 }
 110
 111 TEST(Option, ParseWithFlagExclusions) {
 112   TestOptTable T;
 113   unsigned MAI, MAC;
 114
 115   // Exclude flag3 to avoid parsing as OPT_SLASH_C.
 116   InputArgList AL = T.ParseArgs(Args, MAI, MAC,
 117                                 /*FlagsToInclude=*/0,
 118                                 /*FlagsToExclude=*/OptFlag3);
 119   EXPECT_TRUE(AL.hasArg(OPT_A));
 120   EXPECT_TRUE(AL.hasArg(OPT_C));
 121   EXPECT_FALSE(AL.hasArg(OPT_SLASH_C));
 122
 123   // Exclude flag1 to avoid parsing as OPT_C.
 124   AL = T.ParseArgs(Args, MAI, MAC,
 125                    /*FlagsToInclude=*/0,
 126                    /*FlagsToExclude=*/OptFlag1);
 127   EXPECT_TRUE(AL.hasArg(OPT_B));
 128   EXPECT_FALSE(AL.hasArg(OPT_C));
 129   EXPECT_TRUE(AL.hasArg(OPT_SLASH_C));
 130
 131   const char *NewArgs[] = { "/C", "foo", "--C=bar" };
 132   AL = T.ParseArgs(NewArgs, MAI, MAC);
 133   EXPECT_TRUE(AL.hasArg(OPT_SLASH_C));
 134   EXPECT_TRUE(AL.hasArg(OPT_C));
 135   EXPECT_EQ("foo", AL.getLastArgValue(OPT_SLASH_C));
 136   EXPECT_EQ("bar", AL.getLastArgValue(OPT_C));
 137 }
 138
 139 TEST(Option, ParseAliasInGroup) {
 140   TestOptTable T;
 141   unsigned MAI, MAC;
 142
 143   const char *MyArgs[] = { "-I" };
 144   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 145   EXPECT_TRUE(AL.hasArg(OPT_H));
 146 }
 147
 148 TEST(Option, AliasArgs) {
 149   TestOptTable T;
 150   unsigned MAI, MAC;
 151
 152   const char *MyArgs[] = { "-J", "-Joo" };
 153   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 154   EXPECT_TRUE(AL.hasArg(OPT_B));
 155   EXPECT_EQ("foo", AL.getAllArgValues(OPT_B)[0]);
 156   EXPECT_EQ("bar", AL.getAllArgValues(OPT_B)[1]);
 157 }
 158
 159 TEST(Option, IgnoreCase) {
 160   TestOptTable T(true);
 161   unsigned MAI, MAC;
 162
 163   const char *MyArgs[] = { "-a", "-joo" };
 164   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 165   EXPECT_TRUE(AL.hasArg(OPT_A));
 166   EXPECT_TRUE(AL.hasArg(OPT_B));
 167 }
 168
 169 TEST(Option, DoNotIgnoreCase) {
 170   TestOptTable T;
 171   unsigned MAI, MAC;
 172
 173   const char *MyArgs[] = { "-a", "-joo" };
 174   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 175   EXPECT_FALSE(AL.hasArg(OPT_A));
 176   EXPECT_FALSE(AL.hasArg(OPT_B));
 177 }
 178
 179 TEST(Option, SlurpEmpty) {
 180   TestOptTable T;
 181   unsigned MAI, MAC;
 182
 183   const char *MyArgs[] = { "-A", "-slurp" };
 184   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 185   EXPECT_TRUE(AL.hasArg(OPT_A));
 186   EXPECT_TRUE(AL.hasArg(OPT_Slurp));
 187   EXPECT_EQ(0U, AL.getAllArgValues(OPT_Slurp).size());
 188 }
 189
 190 TEST(Option, Slurp) {
 191   TestOptTable T;
 192   unsigned MAI, MAC;
 193
 194   const char *MyArgs[] = { "-A", "-slurp", "-B", "--", "foo" };
 195   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 196   EXPECT_EQ(AL.size(), 2U);
 197   EXPECT_TRUE(AL.hasArg(OPT_A));
 198   EXPECT_FALSE(AL.hasArg(OPT_B));
 199   EXPECT_TRUE(AL.hasArg(OPT_Slurp));
 200   EXPECT_EQ(3U, AL.getAllArgValues(OPT_Slurp).size());
 201   EXPECT_EQ("-B", AL.getAllArgValues(OPT_Slurp)[0]);
 202   EXPECT_EQ("--", AL.getAllArgValues(OPT_Slurp)[1]);
 203   EXPECT_EQ("foo", AL.getAllArgValues(OPT_Slurp)[2]);
 204 }
 205
 206 TEST(Option, SlurpJoinedEmpty) {
 207   TestOptTable T;
 208   unsigned MAI, MAC;
 209
 210   const char *MyArgs[] = { "-A", "-slurpjoined" };
 211   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 212   EXPECT_TRUE(AL.hasArg(OPT_A));
 213   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
 214   EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 0U);
 215 }
 216
 217 TEST(Option, SlurpJoinedOneJoined) {
 218   TestOptTable T;
 219   unsigned MAI, MAC;
 220
 221   const char *MyArgs[] = { "-A", "-slurpjoinedfoo" };
 222   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 223   EXPECT_TRUE(AL.hasArg(OPT_A));
 224   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
 225   EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 1U);
 226   EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined)[0], "foo");
 227 }
 228
 229 TEST(Option, SlurpJoinedAndSeparate) {
 230   TestOptTable T;
 231   unsigned MAI, MAC;
 232
 233   const char *MyArgs[] = { "-A", "-slurpjoinedfoo", "bar", "baz" };
 234   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 235   EXPECT_TRUE(AL.hasArg(OPT_A));
 236   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
 237   EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
 238   EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
 239   EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
 240   EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
 241 }
 242
 243 TEST(Option, SlurpJoinedButSeparate) {
 244   TestOptTable T;
 245   unsigned MAI, MAC;
 246
 247   const char *MyArgs[] = { "-A", "-slurpjoined", "foo", "bar", "baz" };
 248   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 249   EXPECT_TRUE(AL.hasArg(OPT_A));
 250   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
 251   EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
 252   EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
 253   EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
 254   EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
 255 }
 256
 257 TEST(Option, FlagAliasToJoined) {
 258   TestOptTable T;
 259   unsigned MAI, MAC;
 260
 261   // Check that a flag alias provides an empty argument to a joined option.
 262   const char *MyArgs[] = { "-K" };
 263   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
 264   EXPECT_EQ(AL.size(), 1U);
 265   EXPECT_TRUE(AL.hasArg(OPT_B));
 266   EXPECT_EQ(1U, AL.getAllArgValues(OPT_B).size());
 267   EXPECT_EQ("", AL.getAllArgValues(OPT_B)[0]);
 268 }
 269
 270 TEST(Option, FindNearest) {
 271   TestOptTable T;
 272   std::string Nearest;
 273
 274   // Options that are too short should not be considered
 275   // "near" other short options.
 276   EXPECT_GT(T.findNearest("-A", Nearest), 4U);
 277   EXPECT_GT(T.findNearest("/C", Nearest), 4U);
 278   EXPECT_GT(T.findNearest("--C=foo", Nearest), 4U);
 279
 280   // The nearest candidate should mirror the amount of prefix
 281   // characters used in the original string.
 282   EXPECT_EQ(1U, T.findNearest("-blorb", Nearest));
 283   EXPECT_EQ(Nearest, "-blorp");
 284   EXPECT_EQ(1U, T.findNearest("--blorm", Nearest));
 285   EXPECT_EQ(Nearest, "--blorp");
 286   EXPECT_EQ(1U, T.findNearest("-fjormp", Nearest));
 287   EXPECT_EQ(Nearest, "--fjormp");
 288
 289   // The nearest candidate respects the prefix and value delimiter
 290   // of the original string.
 291   EXPECT_EQ(1U, T.findNearest("/framb:foo", Nearest));
 292   EXPECT_EQ(Nearest, "/cramb:foo");
 293
 294   // Flags should be included and excluded as specified.
 295   EXPECT_EQ(1U, T.findNearest("-doopf", Nearest, /*FlagsToInclude=*/OptFlag2));
 296   EXPECT_EQ(Nearest, "-doopf2");
 297   EXPECT_EQ(1U, T.findNearest("-doopf", Nearest,
 298                               /*FlagsToInclude=*/0,
 299                               /*FlagsToExclude=*/OptFlag2));
 300   EXPECT_EQ(Nearest, "-doopf1");
 301 }
 302
 303 TEST(DISABLED_Option, FindNearestFIXME) {
 304   TestOptTable T;
 305   std::string Nearest;
 306
 307   // FIXME: Options with joined values should not have those values considered
 308   // when calculating distance. The test below would fail if run, but it should
 309   // succeed.
 310   EXPECT_EQ(1U, T.findNearest("--erbghFoo", Nearest));
 311   EXPECT_EQ(Nearest, "--ermghFoo");
 312
 313 }