llvm/unittests/Support/CommandLineTest.cpp

   1 //===- llvm/unittest/Support/CommandLineTest.cpp - CommandLine tests ------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "llvm/Support/CommandLine.h"
  10 #include "llvm/ADT/STLExtras.h"
  11 #include "llvm/ADT/SmallString.h"
  12 #include "llvm/ADT/StringRef.h"
  13 #include "llvm/Config/config.h"
  14 #include "llvm/Support/Allocator.h"
  15 #include "llvm/Support/FileSystem.h"
  16 #include "llvm/Support/InitLLVM.h"
  17 #include "llvm/Support/MemoryBuffer.h"
  18 #include "llvm/Support/Path.h"
  19 #include "llvm/Support/Program.h"
  20 #include "llvm/Support/StringSaver.h"
  21 #include "llvm/Support/VirtualFileSystem.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 #include "llvm/TargetParser/Host.h"
  24 #include "llvm/TargetParser/Triple.h"
  25 #include "llvm/Testing/Support/SupportHelpers.h"
  26 #include "gmock/gmock.h"
  27 #include "gtest/gtest.h"
  28 #include <fstream>
  29 #include <stdlib.h>
  30 #include <string>
  31
  32 using namespace llvm;
  33 using llvm::unittest::TempDir;
  34 using llvm::unittest::TempFile;
  35
  36 namespace {
  37
  38 MATCHER(StringEquality, "Checks if two char* are equal as strings") {
  39   return std::string(std::get<0>(arg)) == std::string(std::get<1>(arg));
  40 }
  41
  42 class TempEnvVar {
  43  public:
  44   TempEnvVar(const char *name, const char *value)
  45       : name(name) {
  46     const char *old_value = getenv(name);
  47     EXPECT_EQ(nullptr, old_value) << old_value;
  48 #if HAVE_SETENV
  49     setenv(name, value, true);
  50 #endif
  51   }
  52
  53   ~TempEnvVar() {
  54 #if HAVE_SETENV
  55     // Assume setenv and unsetenv come together.
  56     unsetenv(name);
  57 #else
  58     (void)name; // Suppress -Wunused-private-field.
  59 #endif
  60   }
  61
  62  private:
  63   const char *const name;
  64 };
  65
  66 template <typename T, typename Base = cl::opt<T>>
  67 class StackOption : public Base {
  68 public:
  69   template <class... Ts>
  70   explicit StackOption(Ts &&... Ms) : Base(std::forward<Ts>(Ms)...) {}
  71
  72   ~StackOption() override { this->removeArgument(); }
  73
  74   template <class DT> StackOption<T> &operator=(const DT &V) {
  75     Base::operator=(V);
  76     return *this;
  77   }
  78 };
  79
  80 class StackSubCommand : public cl::SubCommand {
  81 public:
  82   StackSubCommand(StringRef Name,
  83                   StringRef Description = StringRef())
  84       : SubCommand(Name, Description) {}
  85
  86   StackSubCommand() : SubCommand() {}
  87
  88   ~StackSubCommand() { unregisterSubCommand(); }
  89 };
  90
  91
  92 cl::OptionCategory TestCategory("Test Options", "Description");
  93 TEST(CommandLineTest, ModifyExisitingOption) {
  94   StackOption<int> TestOption("test-option", cl::desc("old description"));
  95
  96   static const char Description[] = "New description";
  97   static const char ArgString[] = "new-test-option";
  98   static const char ValueString[] = "Integer";
  99
 100   StringMap<cl::Option *> &Map =
 101       cl::getRegisteredOptions(cl::SubCommand::getTopLevel());
 102
 103   ASSERT_EQ(Map.count("test-option"), 1u) << "Could not find option in map.";
 104
 105   cl::Option *Retrieved = Map["test-option"];
 106   ASSERT_EQ(&TestOption, Retrieved) << "Retrieved wrong option.";
 107
 108   ASSERT_NE(Retrieved->Categories.end(),
 109             find_if(Retrieved->Categories,
 110                     [&](const llvm::cl::OptionCategory *Cat) {
 111                       return Cat == &cl::getGeneralCategory();
 112                     }))
 113       << "Incorrect default option category.";
 114
 115   Retrieved->addCategory(TestCategory);
 116   ASSERT_NE(Retrieved->Categories.end(),
 117             find_if(Retrieved->Categories,
 118                     [&](const llvm::cl::OptionCategory *Cat) {
 119                       return Cat == &TestCategory;
 120                     }))
 121       << "Failed to modify option's option category.";
 122
 123   Retrieved->setDescription(Description);
 124   ASSERT_STREQ(Retrieved->HelpStr.data(), Description)
 125       << "Changing option description failed.";
 126
 127   Retrieved->setArgStr(ArgString);
 128   ASSERT_STREQ(ArgString, Retrieved->ArgStr.data())
 129       << "Failed to modify option's Argument string.";
 130
 131   Retrieved->setValueStr(ValueString);
 132   ASSERT_STREQ(Retrieved->ValueStr.data(), ValueString)
 133       << "Failed to modify option's Value string.";
 134
 135   Retrieved->setHiddenFlag(cl::Hidden);
 136   ASSERT_EQ(cl::Hidden, TestOption.getOptionHiddenFlag()) <<
 137     "Failed to modify option's hidden flag.";
 138 }
 139
 140 TEST(CommandLineTest, UseOptionCategory) {
 141   StackOption<int> TestOption2("test-option", cl::cat(TestCategory));
 142
 143   ASSERT_NE(TestOption2.Categories.end(),
 144             find_if(TestOption2.Categories,
 145                          [&](const llvm::cl::OptionCategory *Cat) {
 146                            return Cat == &TestCategory;
 147                          }))
 148       << "Failed to assign Option Category.";
 149 }
 150
 151 TEST(CommandLineTest, UseMultipleCategories) {
 152   StackOption<int> TestOption2("test-option2", cl::cat(TestCategory),
 153                                cl::cat(cl::getGeneralCategory()),
 154                                cl::cat(cl::getGeneralCategory()));
 155
 156   // Make sure cl::getGeneralCategory() wasn't added twice.
 157   ASSERT_EQ(TestOption2.Categories.size(), 2U);
 158
 159   ASSERT_NE(TestOption2.Categories.end(),
 160             find_if(TestOption2.Categories,
 161                          [&](const llvm::cl::OptionCategory *Cat) {
 162                            return Cat == &TestCategory;
 163                          }))
 164       << "Failed to assign Option Category.";
 165   ASSERT_NE(TestOption2.Categories.end(),
 166             find_if(TestOption2.Categories,
 167                     [&](const llvm::cl::OptionCategory *Cat) {
 168                       return Cat == &cl::getGeneralCategory();
 169                     }))
 170       << "Failed to assign General Category.";
 171
 172   cl::OptionCategory AnotherCategory("Additional test Options", "Description");
 173   StackOption<int> TestOption("test-option", cl::cat(TestCategory),
 174                               cl::cat(AnotherCategory));
 175   ASSERT_EQ(TestOption.Categories.end(),
 176             find_if(TestOption.Categories,
 177                     [&](const llvm::cl::OptionCategory *Cat) {
 178                       return Cat == &cl::getGeneralCategory();
 179                     }))
 180       << "Failed to remove General Category.";
 181   ASSERT_NE(TestOption.Categories.end(),
 182             find_if(TestOption.Categories,
 183                          [&](const llvm::cl::OptionCategory *Cat) {
 184                            return Cat == &TestCategory;
 185                          }))
 186       << "Failed to assign Option Category.";
 187   ASSERT_NE(TestOption.Categories.end(),
 188             find_if(TestOption.Categories,
 189                          [&](const llvm::cl::OptionCategory *Cat) {
 190                            return Cat == &AnotherCategory;
 191                          }))
 192       << "Failed to assign Another Category.";
 193 }
 194
 195 typedef void ParserFunction(StringRef Source, StringSaver &Saver,
 196                             SmallVectorImpl<const char *> &NewArgv,
 197                             bool MarkEOLs);
 198
 199 void testCommandLineTokenizer(ParserFunction *parse, StringRef Input,
 200                               ArrayRef<const char *> Output,
 201                               bool MarkEOLs = false) {
 202   SmallVector<const char *, 0> Actual;
 203   BumpPtrAllocator A;
 204   StringSaver Saver(A);
 205   parse(Input, Saver, Actual, MarkEOLs);
 206   EXPECT_EQ(Output.size(), Actual.size());
 207   for (unsigned I = 0, E = Actual.size(); I != E; ++I) {
 208     if (I < Output.size()) {
 209       EXPECT_STREQ(Output[I], Actual[I]);
 210     }
 211   }
 212 }
 213
 214 TEST(CommandLineTest, TokenizeGNUCommandLine) {
 215   const char Input[] =
 216       "foo\\ bar \"foo bar\" \'foo bar\' 'foo\\\\bar' -DFOO=bar\\(\\) "
 217       "foo\"bar\"baz C:\\\\src\\\\foo.cpp \"C:\\src\\foo.cpp\"";
 218   const char *const Output[] = {
 219       "foo bar",     "foo bar",   "foo bar",          "foo\\bar",
 220       "-DFOO=bar()", "foobarbaz", "C:\\src\\foo.cpp", "C:srcfoo.cpp"};
 221   testCommandLineTokenizer(cl::TokenizeGNUCommandLine, Input, Output);
 222 }
 223
 224 TEST(CommandLineTest, TokenizeWindowsCommandLine1) {
 225   const char Input[] =
 226       R"(a\b c\\d e\\"f g" h\"i j\\\"k "lmn" o pqr "st \"u" \v)";
 227   const char *const Output[] = { "a\\b", "c\\\\d", "e\\f g", "h\"i", "j\\\"k",
 228                                  "lmn", "o", "pqr", "st \"u", "\\v" };
 229   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input, Output);
 230 }
 231
 232 TEST(CommandLineTest, TokenizeWindowsCommandLine2) {
 233   const char Input[] = "clang -c -DFOO=\"\"\"ABC\"\"\" x.cpp";
 234   const char *const Output[] = { "clang", "-c", "-DFOO=\"ABC\"", "x.cpp"};
 235   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input, Output);
 236 }
 237
 238 TEST(CommandLineTest, TokenizeWindowsCommandLineQuotedLastArgument) {
 239   // Whitespace at the end of the command line doesn't cause an empty last word
 240   const char Input0[] = R"(a b c d )";
 241   const char *const Output0[] = {"a", "b", "c", "d"};
 242   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input0, Output0);
 243
 244   // But an explicit "" does
 245   const char Input1[] = R"(a b c d "")";
 246   const char *const Output1[] = {"a", "b", "c", "d", ""};
 247   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input1, Output1);
 248
 249   // An unterminated quoted string is also emitted as an argument word, empty
 250   // or not
 251   const char Input2[] = R"(a b c d ")";
 252   const char *const Output2[] = {"a", "b", "c", "d", ""};
 253   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input2, Output2);
 254   const char Input3[] = R"(a b c d "text)";
 255   const char *const Output3[] = {"a", "b", "c", "d", "text"};
 256   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input3, Output3);
 257 }
 258
 259 TEST(CommandLineTest, TokenizeWindowsCommandLineExeName) {
 260   const char Input1[] =
 261       R"("C:\Program Files\Whatever\"clang.exe z.c -DY=\"x\")";
 262   const char *const Output1[] = {"C:\\Program Files\\Whatever\\clang.exe",
 263                                  "z.c", "-DY=\"x\""};
 264   testCommandLineTokenizer(cl::TokenizeWindowsCommandLineFull, Input1, Output1);
 265
 266   const char Input2[] = "\"a\\\"b c\\\"d\n\"e\\\"f g\\\"h\n";
 267   const char *const Output2[] = {"a\\b", "c\"d", nullptr,
 268                                  "e\\f", "g\"h", nullptr};
 269   testCommandLineTokenizer(cl::TokenizeWindowsCommandLineFull, Input2, Output2,
 270                            /*MarkEOLs=*/true);
 271
 272   const char Input3[] = R"(\\server\share\subdir\clang.exe)";
 273   const char *const Output3[] = {"\\\\server\\share\\subdir\\clang.exe"};
 274   testCommandLineTokenizer(cl::TokenizeWindowsCommandLineFull, Input3, Output3);
 275 }
 276
 277 TEST(CommandLineTest, TokenizeAndMarkEOLs) {
 278   // Clang uses EOL marking in response files to support options that consume
 279   // the rest of the arguments on the current line, but do not consume arguments
 280   // from subsequent lines. For example, given these rsp files contents:
 281   // /c /Zi /O2
 282   // /Oy- /link /debug /opt:ref
 283   // /Zc:ThreadsafeStatics-
 284   //
 285   // clang-cl needs to treat "/debug /opt:ref" as linker flags, and everything
 286   // else as compiler flags. The tokenizer inserts nullptr sentinels into the
 287   // output so that clang-cl can find the end of the current line.
 288   const char Input[] = "clang -Xclang foo\n\nfoo\"bar\"baz\n x.cpp\n";
 289   const char *const Output[] = {"clang", "-Xclang", "foo",
 290                                 nullptr, nullptr,   "foobarbaz",
 291                                 nullptr, "x.cpp",   nullptr};
 292   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input, Output,
 293                            /*MarkEOLs=*/true);
 294   testCommandLineTokenizer(cl::TokenizeGNUCommandLine, Input, Output,
 295                            /*MarkEOLs=*/true);
 296 }
 297
 298 TEST(CommandLineTest, TokenizeConfigFile1) {
 299   const char *Input = "\\";
 300   const char *const Output[] = { "\\" };
 301   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output);
 302 }
 303
 304 TEST(CommandLineTest, TokenizeConfigFile2) {
 305   const char *Input = "\\abc";
 306   const char *const Output[] = { "abc" };
 307   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output);
 308 }
 309
 310 TEST(CommandLineTest, TokenizeConfigFile3) {
 311   const char *Input = "abc\\";
 312   const char *const Output[] = { "abc\\" };
 313   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output);
 314 }
 315
 316 TEST(CommandLineTest, TokenizeConfigFile4) {
 317   const char *Input = "abc\\\n123";
 318   const char *const Output[] = { "abc123" };
 319   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output);
 320 }
 321
 322 TEST(CommandLineTest, TokenizeConfigFile5) {
 323   const char *Input = "abc\\\r\n123";
 324   const char *const Output[] = { "abc123" };
 325   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output);
 326 }
 327
 328 TEST(CommandLineTest, TokenizeConfigFile6) {
 329   const char *Input = "abc\\\n";
 330   const char *const Output[] = { "abc" };
 331   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output);
 332 }
 333
 334 TEST(CommandLineTest, TokenizeConfigFile7) {
 335   const char *Input = "abc\\\r\n";
 336   const char *const Output[] = { "abc" };
 337   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output);
 338 }
 339
 340 TEST(CommandLineTest, TokenizeConfigFile8) {
 341   SmallVector<const char *, 0> Actual;
 342   BumpPtrAllocator A;
 343   StringSaver Saver(A);
 344   cl::tokenizeConfigFile("\\\n", Saver, Actual, /*MarkEOLs=*/false);
 345   EXPECT_TRUE(Actual.empty());
 346 }
 347
 348 TEST(CommandLineTest, TokenizeConfigFile9) {
 349   SmallVector<const char *, 0> Actual;
 350   BumpPtrAllocator A;
 351   StringSaver Saver(A);
 352   cl::tokenizeConfigFile("\\\r\n", Saver, Actual, /*MarkEOLs=*/false);
 353   EXPECT_TRUE(Actual.empty());
 354 }
 355
 356 TEST(CommandLineTest, TokenizeConfigFile10) {
 357   const char *Input = "\\\nabc";
 358   const char *const Output[] = { "abc" };
 359   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output);
 360 }
 361
 362 TEST(CommandLineTest, TokenizeConfigFile11) {
 363   const char *Input = "\\\r\nabc";
 364   const char *const Output[] = { "abc" };
 365   testCommandLineTokenizer(cl::tokenizeConfigFile, Input, Output);
 366 }
 367
 368 TEST(CommandLineTest, AliasesWithArguments) {
 369   static const size_t ARGC = 3;
 370   const char *const Inputs[][ARGC] = {
 371     { "-tool", "-actual=x", "-extra" },
 372     { "-tool", "-actual", "x" },
 373     { "-tool", "-alias=x", "-extra" },
 374     { "-tool", "-alias", "x" }
 375   };
 376
 377   for (size_t i = 0, e = std::size(Inputs); i < e; ++i) {
 378     StackOption<std::string> Actual("actual");
 379     StackOption<bool> Extra("extra");
 380     StackOption<std::string> Input(cl::Positional);
 381
 382     cl::alias Alias("alias", llvm::cl::aliasopt(Actual));
 383
 384     cl::ParseCommandLineOptions(ARGC, Inputs[i]);
 385     EXPECT_EQ("x", Actual);
 386     EXPECT_EQ(0, Input.getNumOccurrences());
 387
 388     Alias.removeArgument();
 389   }
 390 }
 391
 392 void testAliasRequired(int argc, const char *const *argv) {
 393   StackOption<std::string> Option("option", cl::Required);
 394   cl::alias Alias("o", llvm::cl::aliasopt(Option));
 395
 396   cl::ParseCommandLineOptions(argc, argv);
 397   EXPECT_EQ("x", Option);
 398   EXPECT_EQ(1, Option.getNumOccurrences());
 399
 400   Alias.removeArgument();
 401 }
 402
 403 TEST(CommandLineTest, AliasRequired) {
 404   const char *opts1[] = { "-tool", "-option=x" };
 405   const char *opts2[] = { "-tool", "-o", "x" };
 406   testAliasRequired(std::size(opts1), opts1);
 407   testAliasRequired(std::size(opts2), opts2);
 408 }
 409
 410 TEST(CommandLineTest, HideUnrelatedOptions) {
 411   StackOption<int> TestOption1("hide-option-1");
 412   StackOption<int> TestOption2("hide-option-2", cl::cat(TestCategory));
 413
 414   cl::HideUnrelatedOptions(TestCategory);
 415
 416   ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
 417       << "Failed to hide extra option.";
 418   ASSERT_EQ(cl::NotHidden, TestOption2.getOptionHiddenFlag())
 419       << "Hid extra option that should be visable.";
 420
 421   StringMap<cl::Option *> &Map =
 422       cl::getRegisteredOptions(cl::SubCommand::getTopLevel());
 423   ASSERT_TRUE(Map.count("help") == (size_t)0 ||
 424               cl::NotHidden == Map["help"]->getOptionHiddenFlag())
 425       << "Hid default option that should be visable.";
 426 }
 427
 428 cl::OptionCategory TestCategory2("Test Options set 2", "Description");
 429
 430 TEST(CommandLineTest, HideUnrelatedOptionsMulti) {
 431   StackOption<int> TestOption1("multi-hide-option-1");
 432   StackOption<int> TestOption2("multi-hide-option-2", cl::cat(TestCategory));
 433   StackOption<int> TestOption3("multi-hide-option-3", cl::cat(TestCategory2));
 434
 435   const cl::OptionCategory *VisibleCategories[] = {&TestCategory,
 436                                                    &TestCategory2};
 437
 438   cl::HideUnrelatedOptions(ArrayRef(VisibleCategories));
 439
 440   ASSERT_EQ(cl::ReallyHidden, TestOption1.getOptionHiddenFlag())
 441       << "Failed to hide extra option.";
 442   ASSERT_EQ(cl::NotHidden, TestOption2.getOptionHiddenFlag())
 443       << "Hid extra option that should be visable.";
 444   ASSERT_EQ(cl::NotHidden, TestOption3.getOptionHiddenFlag())
 445       << "Hid extra option that should be visable.";
 446
 447   StringMap<cl::Option *> &Map =
 448       cl::getRegisteredOptions(cl::SubCommand::getTopLevel());
 449   ASSERT_TRUE(Map.count("help") == (size_t)0 ||
 450               cl::NotHidden == Map["help"]->getOptionHiddenFlag())
 451       << "Hid default option that should be visable.";
 452 }
 453
 454 TEST(CommandLineTest, SetMultiValues) {
 455   StackOption<int> Option("option");
 456   const char *args[] = {"prog", "-option=1", "-option=2"};
 457   EXPECT_TRUE(cl::ParseCommandLineOptions(std::size(args), args, StringRef(),
 458                                           &llvm::nulls()));
 459   EXPECT_EQ(Option, 2);
 460 }
 461
 462 TEST(CommandLineTest, SetValueInSubcategories) {
 463   cl::ResetCommandLineParser();
 464
 465   StackSubCommand SC1("sc1", "First subcommand");
 466   StackSubCommand SC2("sc2", "Second subcommand");
 467
 468   StackOption<bool> TopLevelOpt("top-level", cl::init(false));
 469   StackOption<bool> SC1Opt("sc1", cl::sub(SC1), cl::init(false));
 470   StackOption<bool> SC2Opt("sc2", cl::sub(SC2), cl::init(false));
 471
 472   EXPECT_FALSE(TopLevelOpt);
 473   EXPECT_FALSE(SC1Opt);
 474   EXPECT_FALSE(SC2Opt);
 475   const char *args[] = {"prog", "-top-level"};
 476   EXPECT_TRUE(
 477       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 478   EXPECT_TRUE(TopLevelOpt);
 479   EXPECT_FALSE(SC1Opt);
 480   EXPECT_FALSE(SC2Opt);
 481
 482   TopLevelOpt = false;
 483
 484   cl::ResetAllOptionOccurrences();
 485   EXPECT_FALSE(TopLevelOpt);
 486   EXPECT_FALSE(SC1Opt);
 487   EXPECT_FALSE(SC2Opt);
 488   const char *args2[] = {"prog", "sc1", "-sc1"};
 489   EXPECT_TRUE(
 490       cl::ParseCommandLineOptions(3, args2, StringRef(), &llvm::nulls()));
 491   EXPECT_FALSE(TopLevelOpt);
 492   EXPECT_TRUE(SC1Opt);
 493   EXPECT_FALSE(SC2Opt);
 494
 495   SC1Opt = false;
 496
 497   cl::ResetAllOptionOccurrences();
 498   EXPECT_FALSE(TopLevelOpt);
 499   EXPECT_FALSE(SC1Opt);
 500   EXPECT_FALSE(SC2Opt);
 501   const char *args3[] = {"prog", "sc2", "-sc2"};
 502   EXPECT_TRUE(
 503       cl::ParseCommandLineOptions(3, args3, StringRef(), &llvm::nulls()));
 504   EXPECT_FALSE(TopLevelOpt);
 505   EXPECT_FALSE(SC1Opt);
 506   EXPECT_TRUE(SC2Opt);
 507 }
 508
 509 TEST(CommandLineTest, LookupFailsInWrongSubCommand) {
 510   cl::ResetCommandLineParser();
 511
 512   StackSubCommand SC1("sc1", "First subcommand");
 513   StackSubCommand SC2("sc2", "Second subcommand");
 514
 515   StackOption<bool> SC1Opt("sc1", cl::sub(SC1), cl::init(false));
 516   StackOption<bool> SC2Opt("sc2", cl::sub(SC2), cl::init(false));
 517
 518   std::string Errs;
 519   raw_string_ostream OS(Errs);
 520
 521   const char *args[] = {"prog", "sc1", "-sc2"};
 522   EXPECT_FALSE(cl::ParseCommandLineOptions(3, args, StringRef(), &OS));
 523   OS.flush();
 524   EXPECT_FALSE(Errs.empty());
 525 }
 526
 527 TEST(CommandLineTest, TopLevelOptInSubcommand) {
 528   enum LiteralOptionEnum {
 529     foo,
 530     bar,
 531     baz,
 532   };
 533
 534   cl::ResetCommandLineParser();
 535
 536   // This is a top-level option and not associated with a subcommand.
 537   // A command line using subcommand should parse both subcommand options and
 538   // top-level options.  A valid use case is that users of llvm command line
 539   // tools should be able to specify top-level options defined in any library.
 540   StackOption<std::string> TopLevelOpt("str", cl::init("txt"),
 541                                        cl::desc("A top-level option."));
 542
 543   StackSubCommand SC("sc", "Subcommand");
 544   StackOption<std::string> PositionalOpt(
 545       cl::Positional, cl::desc("positional argument test coverage"),
 546       cl::sub(SC));
 547   StackOption<LiteralOptionEnum> LiteralOpt(
 548       cl::desc("literal argument test coverage"), cl::sub(SC), cl::init(bar),
 549       cl::values(clEnumVal(foo, "foo"), clEnumVal(bar, "bar"),
 550                  clEnumVal(baz, "baz")));
 551   StackOption<bool> EnableOpt("enable", cl::sub(SC), cl::init(false));
 552   StackOption<int> ThresholdOpt("threshold", cl::sub(SC), cl::init(1));
 553
 554   const char *PositionalOptVal = "input-file";
 555   const char *args[] = {"prog",    "sc",        PositionalOptVal,
 556                         "-enable", "--str=csv", "--threshold=2"};
 557
 558   // cl::ParseCommandLineOptions returns true on success. Otherwise, it will
 559   // print the error message to stderr and exit in this setting (`Errs` ostream
 560   // is not set).
 561   ASSERT_TRUE(cl::ParseCommandLineOptions(sizeof(args) / sizeof(args[0]), args,
 562                                           StringRef()));
 563   EXPECT_STREQ(PositionalOpt.getValue().c_str(), PositionalOptVal);
 564   EXPECT_TRUE(EnableOpt);
 565   // Tests that the value of `str` option is `csv` as specified.
 566   EXPECT_STREQ(TopLevelOpt.getValue().c_str(), "csv");
 567   EXPECT_EQ(ThresholdOpt, 2);
 568
 569   for (auto &[LiteralOptVal, WantLiteralOpt] :
 570        {std::pair{"--bar", bar}, {"--foo", foo}, {"--baz", baz}}) {
 571     const char *args[] = {"prog", "sc", LiteralOptVal};
 572     ASSERT_TRUE(cl::ParseCommandLineOptions(sizeof(args) / sizeof(args[0]),
 573                                             args, StringRef()));
 574
 575     // Tests that literal options are parsed correctly.
 576     EXPECT_EQ(LiteralOpt, WantLiteralOpt);
 577   }
 578 }
 579
 580 TEST(CommandLineTest, AddToAllSubCommands) {
 581   cl::ResetCommandLineParser();
 582
 583   StackSubCommand SC1("sc1", "First subcommand");
 584   StackOption<bool> AllOpt("everywhere", cl::sub(cl::SubCommand::getAll()),
 585                            cl::init(false));
 586   StackSubCommand SC2("sc2", "Second subcommand");
 587
 588   EXPECT_TRUE(cl::SubCommand::getTopLevel().OptionsMap.contains("everywhere"));
 589   EXPECT_TRUE(cl::SubCommand::getAll().OptionsMap.contains("everywhere"));
 590   EXPECT_TRUE(SC1.OptionsMap.contains("everywhere"));
 591   EXPECT_TRUE(SC2.OptionsMap.contains("everywhere"));
 592
 593   const char *args[] = {"prog", "-everywhere"};
 594   const char *args2[] = {"prog", "sc1", "-everywhere"};
 595   const char *args3[] = {"prog", "sc2", "-everywhere"};
 596
 597   std::string Errs;
 598   raw_string_ostream OS(Errs);
 599
 600   EXPECT_FALSE(AllOpt);
 601   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args, StringRef(), &OS));
 602   EXPECT_TRUE(AllOpt);
 603
 604   AllOpt = false;
 605
 606   cl::ResetAllOptionOccurrences();
 607   EXPECT_FALSE(AllOpt);
 608   EXPECT_TRUE(cl::ParseCommandLineOptions(3, args2, StringRef(), &OS));
 609   EXPECT_TRUE(AllOpt);
 610
 611   AllOpt = false;
 612
 613   cl::ResetAllOptionOccurrences();
 614   EXPECT_FALSE(AllOpt);
 615   EXPECT_TRUE(cl::ParseCommandLineOptions(3, args3, StringRef(), &OS));
 616   EXPECT_TRUE(AllOpt);
 617
 618   // Since all parsing succeeded, the error message should be empty.
 619   OS.flush();
 620   EXPECT_TRUE(Errs.empty());
 621 }
 622
 623 TEST(CommandLineTest, ReparseCommandLineOptions) {
 624   cl::ResetCommandLineParser();
 625
 626   StackOption<bool> TopLevelOpt(
 627       "top-level", cl::sub(cl::SubCommand::getTopLevel()), cl::init(false));
 628
 629   const char *args[] = {"prog", "-top-level"};
 630
 631   EXPECT_FALSE(TopLevelOpt);
 632   EXPECT_TRUE(
 633       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 634   EXPECT_TRUE(TopLevelOpt);
 635
 636   TopLevelOpt = false;
 637
 638   cl::ResetAllOptionOccurrences();
 639   EXPECT_FALSE(TopLevelOpt);
 640   EXPECT_TRUE(
 641       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 642   EXPECT_TRUE(TopLevelOpt);
 643 }
 644
 645 TEST(CommandLineTest, RemoveFromRegularSubCommand) {
 646   cl::ResetCommandLineParser();
 647
 648   StackSubCommand SC("sc", "Subcommand");
 649   StackOption<bool> RemoveOption("remove-option", cl::sub(SC), cl::init(false));
 650   StackOption<bool> KeepOption("keep-option", cl::sub(SC), cl::init(false));
 651
 652   const char *args[] = {"prog", "sc", "-remove-option"};
 653
 654   std::string Errs;
 655   raw_string_ostream OS(Errs);
 656
 657   EXPECT_FALSE(RemoveOption);
 658   EXPECT_TRUE(cl::ParseCommandLineOptions(3, args, StringRef(), &OS));
 659   EXPECT_TRUE(RemoveOption);
 660   OS.flush();
 661   EXPECT_TRUE(Errs.empty());
 662
 663   RemoveOption.removeArgument();
 664
 665   cl::ResetAllOptionOccurrences();
 666   EXPECT_FALSE(cl::ParseCommandLineOptions(3, args, StringRef(), &OS));
 667   OS.flush();
 668   EXPECT_FALSE(Errs.empty());
 669 }
 670
 671 TEST(CommandLineTest, RemoveFromTopLevelSubCommand) {
 672   cl::ResetCommandLineParser();
 673
 674   StackOption<bool> TopLevelRemove("top-level-remove",
 675                                    cl::sub(cl::SubCommand::getTopLevel()),
 676                                    cl::init(false));
 677   StackOption<bool> TopLevelKeep("top-level-keep",
 678                                  cl::sub(cl::SubCommand::getTopLevel()),
 679                                  cl::init(false));
 680
 681   const char *args[] = {"prog", "-top-level-remove"};
 682
 683   EXPECT_FALSE(TopLevelRemove);
 684   EXPECT_TRUE(
 685       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 686   EXPECT_TRUE(TopLevelRemove);
 687
 688   TopLevelRemove.removeArgument();
 689
 690   cl::ResetAllOptionOccurrences();
 691   EXPECT_FALSE(
 692       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 693 }
 694
 695 TEST(CommandLineTest, RemoveFromAllSubCommands) {
 696   cl::ResetCommandLineParser();
 697
 698   StackSubCommand SC1("sc1", "First Subcommand");
 699   StackSubCommand SC2("sc2", "Second Subcommand");
 700   StackOption<bool> RemoveOption(
 701       "remove-option", cl::sub(cl::SubCommand::getAll()), cl::init(false));
 702   StackOption<bool> KeepOption("keep-option", cl::sub(cl::SubCommand::getAll()),
 703                                cl::init(false));
 704
 705   const char *args0[] = {"prog", "-remove-option"};
 706   const char *args1[] = {"prog", "sc1", "-remove-option"};
 707   const char *args2[] = {"prog", "sc2", "-remove-option"};
 708
 709   // It should work for all subcommands including the top-level.
 710   EXPECT_FALSE(RemoveOption);
 711   EXPECT_TRUE(
 712       cl::ParseCommandLineOptions(2, args0, StringRef(), &llvm::nulls()));
 713   EXPECT_TRUE(RemoveOption);
 714
 715   RemoveOption = false;
 716
 717   cl::ResetAllOptionOccurrences();
 718   EXPECT_FALSE(RemoveOption);
 719   EXPECT_TRUE(
 720       cl::ParseCommandLineOptions(3, args1, StringRef(), &llvm::nulls()));
 721   EXPECT_TRUE(RemoveOption);
 722
 723   RemoveOption = false;
 724
 725   cl::ResetAllOptionOccurrences();
 726   EXPECT_FALSE(RemoveOption);
 727   EXPECT_TRUE(
 728       cl::ParseCommandLineOptions(3, args2, StringRef(), &llvm::nulls()));
 729   EXPECT_TRUE(RemoveOption);
 730
 731   RemoveOption.removeArgument();
 732
 733   // It should not work for any subcommands including the top-level.
 734   cl::ResetAllOptionOccurrences();
 735   EXPECT_FALSE(
 736       cl::ParseCommandLineOptions(2, args0, StringRef(), &llvm::nulls()));
 737   cl::ResetAllOptionOccurrences();
 738   EXPECT_FALSE(
 739       cl::ParseCommandLineOptions(3, args1, StringRef(), &llvm::nulls()));
 740   cl::ResetAllOptionOccurrences();
 741   EXPECT_FALSE(
 742       cl::ParseCommandLineOptions(3, args2, StringRef(), &llvm::nulls()));
 743 }
 744
 745 TEST(CommandLineTest, GetRegisteredSubcommands) {
 746   cl::ResetCommandLineParser();
 747
 748   StackSubCommand SC1("sc1", "First Subcommand");
 749   StackOption<bool> Opt1("opt1", cl::sub(SC1), cl::init(false));
 750   StackSubCommand SC2("sc2", "Second subcommand");
 751   StackOption<bool> Opt2("opt2", cl::sub(SC2), cl::init(false));
 752
 753   const char *args0[] = {"prog", "sc1"};
 754   const char *args1[] = {"prog", "sc2"};
 755
 756   EXPECT_TRUE(
 757       cl::ParseCommandLineOptions(2, args0, StringRef(), &llvm::nulls()));
 758   EXPECT_FALSE(Opt1);
 759   EXPECT_FALSE(Opt2);
 760   for (auto *S : cl::getRegisteredSubcommands()) {
 761     if (*S) {
 762       EXPECT_EQ("sc1", S->getName());
 763     }
 764   }
 765
 766   cl::ResetAllOptionOccurrences();
 767   EXPECT_TRUE(
 768       cl::ParseCommandLineOptions(2, args1, StringRef(), &llvm::nulls()));
 769   EXPECT_FALSE(Opt1);
 770   EXPECT_FALSE(Opt2);
 771   for (auto *S : cl::getRegisteredSubcommands()) {
 772     if (*S) {
 773       EXPECT_EQ("sc2", S->getName());
 774     }
 775   }
 776 }
 777
 778 TEST(CommandLineTest, DefaultOptions) {
 779   cl::ResetCommandLineParser();
 780
 781   StackOption<std::string> Bar("bar", cl::sub(cl::SubCommand::getAll()),
 782                                cl::DefaultOption);
 783   StackOption<std::string, cl::alias> Bar_Alias(
 784       "b", cl::desc("Alias for -bar"), cl::aliasopt(Bar), cl::DefaultOption);
 785
 786   StackOption<bool> Foo("foo", cl::init(false),
 787                         cl::sub(cl::SubCommand::getAll()), cl::DefaultOption);
 788   StackOption<bool, cl::alias> Foo_Alias("f", cl::desc("Alias for -foo"),
 789                                          cl::aliasopt(Foo), cl::DefaultOption);
 790
 791   StackSubCommand SC1("sc1", "First Subcommand");
 792   // Override "-b" and change type in sc1 SubCommand.
 793   StackOption<bool> SC1_B("b", cl::sub(SC1), cl::init(false));
 794   StackSubCommand SC2("sc2", "Second subcommand");
 795   // Override "-foo" and change type in sc2 SubCommand.  Note that this does not
 796   // affect "-f" alias, which continues to work correctly.
 797   StackOption<std::string> SC2_Foo("foo", cl::sub(SC2));
 798
 799   const char *args0[] = {"prog", "-b", "args0 bar string", "-f"};
 800   EXPECT_TRUE(cl::ParseCommandLineOptions(std::size(args0), args0,
 801                                           StringRef(), &llvm::nulls()));
 802   EXPECT_EQ(Bar, "args0 bar string");
 803   EXPECT_TRUE(Foo);
 804   EXPECT_FALSE(SC1_B);
 805   EXPECT_TRUE(SC2_Foo.empty());
 806
 807   cl::ResetAllOptionOccurrences();
 808
 809   const char *args1[] = {"prog", "sc1", "-b", "-bar", "args1 bar string", "-f"};
 810   EXPECT_TRUE(cl::ParseCommandLineOptions(std::size(args1), args1,
 811                                           StringRef(), &llvm::nulls()));
 812   EXPECT_EQ(Bar, "args1 bar string");
 813   EXPECT_TRUE(Foo);
 814   EXPECT_TRUE(SC1_B);
 815   EXPECT_TRUE(SC2_Foo.empty());
 816   for (auto *S : cl::getRegisteredSubcommands()) {
 817     if (*S) {
 818       EXPECT_EQ("sc1", S->getName());
 819     }
 820   }
 821
 822   cl::ResetAllOptionOccurrences();
 823
 824   const char *args2[] = {"prog", "sc2", "-b", "args2 bar string",
 825                          "-f", "-foo", "foo string"};
 826   EXPECT_TRUE(cl::ParseCommandLineOptions(std::size(args2), args2,
 827                                           StringRef(), &llvm::nulls()));
 828   EXPECT_EQ(Bar, "args2 bar string");
 829   EXPECT_TRUE(Foo);
 830   EXPECT_FALSE(SC1_B);
 831   EXPECT_EQ(SC2_Foo, "foo string");
 832   for (auto *S : cl::getRegisteredSubcommands()) {
 833     if (*S) {
 834       EXPECT_EQ("sc2", S->getName());
 835     }
 836   }
 837   cl::ResetCommandLineParser();
 838 }
 839
 840 TEST(CommandLineTest, ArgumentLimit) {
 841   std::string args(32 * 4096, 'a');
 842   EXPECT_FALSE(llvm::sys::commandLineFitsWithinSystemLimits("cl", args.data()));
 843   std::string args2(256, 'a');
 844   EXPECT_TRUE(llvm::sys::commandLineFitsWithinSystemLimits("cl", args2.data()));
 845 }
 846
 847 TEST(CommandLineTest, ArgumentLimitWindows) {
 848   if (!Triple(sys::getProcessTriple()).isOSWindows())
 849     GTEST_SKIP();
 850   // We use 32000 as a limit for command line length. Program name ('cl'),
 851   // separating spaces and termination null character occupy 5 symbols.
 852   std::string long_arg(32000 - 5, 'b');
 853   EXPECT_TRUE(
 854       llvm::sys::commandLineFitsWithinSystemLimits("cl", long_arg.data()));
 855   long_arg += 'b';
 856   EXPECT_FALSE(
 857       llvm::sys::commandLineFitsWithinSystemLimits("cl", long_arg.data()));
 858 }
 859
 860 TEST(CommandLineTest, ResponseFileWindows) {
 861   if (!Triple(sys::getProcessTriple()).isOSWindows())
 862     GTEST_SKIP();
 863
 864   StackOption<std::string, cl::list<std::string>> InputFilenames(
 865       cl::Positional, cl::desc("<input files>"));
 866   StackOption<bool> TopLevelOpt("top-level", cl::init(false));
 867
 868   // Create response file.
 869   TempFile ResponseFile("resp-", ".txt",
 870                         "-top-level\npath\\dir\\file1\npath/dir/file2",
 871                         /*Unique*/ true);
 872
 873   llvm::SmallString<128> RspOpt;
 874   RspOpt.append(1, '@');
 875   RspOpt.append(ResponseFile.path());
 876   const char *args[] = {"prog", RspOpt.c_str()};
 877   EXPECT_FALSE(TopLevelOpt);
 878   EXPECT_TRUE(
 879       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
 880   EXPECT_TRUE(TopLevelOpt);
 881   EXPECT_EQ(InputFilenames[0], "path\\dir\\file1");
 882   EXPECT_EQ(InputFilenames[1], "path/dir/file2");
 883 }
 884
 885 TEST(CommandLineTest, ResponseFiles) {
 886   vfs::InMemoryFileSystem FS;
 887 #ifdef _WIN32
 888   const char *TestRoot = "C:\\";
 889 #else
 890   const char *TestRoot = "/";
 891 #endif
 892   FS.setCurrentWorkingDirectory(TestRoot);
 893
 894   // Create included response file of first level.
 895   llvm::StringRef IncludedFileName = "resp1";
 896   FS.addFile(IncludedFileName, 0,
 897              llvm::MemoryBuffer::getMemBuffer("-option_1 -option_2\n"
 898                                               "@incdir/resp2\n"
 899                                               "-option_3=abcd\n"
 900                                               "@incdir/resp3\n"
 901                                               "-option_4=efjk\n"));
 902
 903   // Directory for included file.
 904   llvm::StringRef IncDir = "incdir";
 905
 906   // Create included response file of second level.
 907   llvm::SmallString<128> IncludedFileName2;
 908   llvm::sys::path::append(IncludedFileName2, IncDir, "resp2");
 909   FS.addFile(IncludedFileName2, 0,
 910              MemoryBuffer::getMemBuffer("-option_21 -option_22\n"
 911                                         "-option_23=abcd\n"));
 912
 913   // Create second included response file of second level.
 914   llvm::SmallString<128> IncludedFileName3;
 915   llvm::sys::path::append(IncludedFileName3, IncDir, "resp3");
 916   FS.addFile(IncludedFileName3, 0,
 917              MemoryBuffer::getMemBuffer("-option_31 -option_32\n"
 918                                         "-option_33=abcd\n"));
 919
 920   // Prepare 'file' with reference to response file.
 921   SmallString<128> IncRef;
 922   IncRef.append(1, '@');
 923   IncRef.append(IncludedFileName);
 924   llvm::SmallVector<const char *, 4> Argv = {"test/test", "-flag_1",
 925                                              IncRef.c_str(), "-flag_2"};
 926
 927   // Expand response files.
 928   llvm::BumpPtrAllocator A;
 929   llvm::cl::ExpansionContext ECtx(A, llvm::cl::TokenizeGNUCommandLine);
 930   ECtx.setVFS(&FS).setCurrentDir(TestRoot).setRelativeNames(true);
 931   ASSERT_FALSE((bool)ECtx.expandResponseFiles(Argv));
 932   EXPECT_THAT(Argv, testing::Pointwise(
 933                         StringEquality(),
 934                         {"test/test", "-flag_1", "-option_1", "-option_2",
 935                          "-option_21", "-option_22", "-option_23=abcd",
 936                          "-option_3=abcd", "-option_31", "-option_32",
 937                          "-option_33=abcd", "-option_4=efjk", "-flag_2"}));
 938 }
 939
 940 TEST(CommandLineTest, RecursiveResponseFiles) {
 941   vfs::InMemoryFileSystem FS;
 942 #ifdef _WIN32
 943   const char *TestRoot = "C:\\";
 944 #else
 945   const char *TestRoot = "/";
 946 #endif
 947   FS.setCurrentWorkingDirectory(TestRoot);
 948
 949   StringRef SelfFilePath = "self.rsp";
 950   std::string SelfFileRef = ("@" + SelfFilePath).str();
 951
 952   StringRef NestedFilePath = "nested.rsp";
 953   std::string NestedFileRef = ("@" + NestedFilePath).str();
 954
 955   StringRef FlagFilePath = "flag.rsp";
 956   std::string FlagFileRef = ("@" + FlagFilePath).str();
 957
 958   std::string SelfFileContents;
 959   raw_string_ostream SelfFile(SelfFileContents);
 960   SelfFile << "-option_1\n";
 961   SelfFile << FlagFileRef << "\n";
 962   SelfFile << NestedFileRef << "\n";
 963   SelfFile << SelfFileRef << "\n";
 964   FS.addFile(SelfFilePath, 0, MemoryBuffer::getMemBuffer(SelfFile.str()));
 965
 966   std::string NestedFileContents;
 967   raw_string_ostream NestedFile(NestedFileContents);
 968   NestedFile << "-option_2\n";
 969   NestedFile << FlagFileRef << "\n";
 970   NestedFile << SelfFileRef << "\n";
 971   NestedFile << NestedFileRef << "\n";
 972   FS.addFile(NestedFilePath, 0, MemoryBuffer::getMemBuffer(NestedFile.str()));
 973
 974   std::string FlagFileContents;
 975   raw_string_ostream FlagFile(FlagFileContents);
 976   FlagFile << "-option_x\n";
 977   FS.addFile(FlagFilePath, 0, MemoryBuffer::getMemBuffer(FlagFile.str()));
 978
 979   // Ensure:
 980   // Recursive expansion terminates
 981   // Recursive files never expand
 982   // Non-recursive repeats are allowed
 983   SmallVector<const char *, 4> Argv = {"test/test", SelfFileRef.c_str(),
 984                                        "-option_3"};
 985   BumpPtrAllocator A;
 986 #ifdef _WIN32
 987   cl::TokenizerCallback Tokenizer = cl::TokenizeWindowsCommandLine;
 988 #else
 989   cl::TokenizerCallback Tokenizer = cl::TokenizeGNUCommandLine;
 990 #endif
 991   llvm::cl::ExpansionContext ECtx(A, Tokenizer);
 992   ECtx.setVFS(&FS).setCurrentDir(TestRoot);
 993   llvm::Error Err = ECtx.expandResponseFiles(Argv);
 994   ASSERT_TRUE((bool)Err);
 995   SmallString<128> FilePath = SelfFilePath;
 996   std::error_code EC = FS.makeAbsolute(FilePath);
 997   ASSERT_FALSE((bool)EC);
 998   std::string ExpectedMessage =
 999       std::string("recursive expansion of: '") + std::string(FilePath) + "'";
1000   ASSERT_TRUE(toString(std::move(Err)) == ExpectedMessage);
1001
1002   EXPECT_THAT(Argv,
1003               testing::Pointwise(StringEquality(),
1004                                  {"test/test", "-option_1", "-option_x",
1005                                   "-option_2", "-option_x", SelfFileRef.c_str(),
1006                                   NestedFileRef.c_str(), SelfFileRef.c_str(),
1007                                   "-option_3"}));
1008 }
1009
1010 TEST(CommandLineTest, ResponseFilesAtArguments) {
1011   vfs::InMemoryFileSystem FS;
1012 #ifdef _WIN32
1013   const char *TestRoot = "C:\\";
1014 #else
1015   const char *TestRoot = "/";
1016 #endif
1017   FS.setCurrentWorkingDirectory(TestRoot);
1018
1019   StringRef ResponseFilePath = "test.rsp";
1020
1021   std::string ResponseFileContents;
1022   raw_string_ostream ResponseFile(ResponseFileContents);
1023   ResponseFile << "-foo" << "\n";
1024   ResponseFile << "-bar" << "\n";
1025   FS.addFile(ResponseFilePath, 0,
1026              MemoryBuffer::getMemBuffer(ResponseFile.str()));
1027
1028   // Ensure we expand rsp files after lots of non-rsp arguments starting with @.
1029   constexpr size_t NON_RSP_AT_ARGS = 64;
1030   SmallVector<const char *, 4> Argv = {"test/test"};
1031   Argv.append(NON_RSP_AT_ARGS, "@non_rsp_at_arg");
1032   std::string ResponseFileRef = ("@" + ResponseFilePath).str();
1033   Argv.push_back(ResponseFileRef.c_str());
1034
1035   BumpPtrAllocator A;
1036   llvm::cl::ExpansionContext ECtx(A, cl::TokenizeGNUCommandLine);
1037   ECtx.setVFS(&FS).setCurrentDir(TestRoot);
1038   ASSERT_FALSE((bool)ECtx.expandResponseFiles(Argv));
1039
1040   // ASSERT instead of EXPECT to prevent potential out-of-bounds access.
1041   ASSERT_EQ(Argv.size(), 1 + NON_RSP_AT_ARGS + 2);
1042   size_t i = 0;
1043   EXPECT_STREQ(Argv[i++], "test/test");
1044   for (; i < 1 + NON_RSP_AT_ARGS; ++i)
1045     EXPECT_STREQ(Argv[i], "@non_rsp_at_arg");
1046   EXPECT_STREQ(Argv[i++], "-foo");
1047   EXPECT_STREQ(Argv[i++], "-bar");
1048 }
1049
1050 TEST(CommandLineTest, ResponseFileRelativePath) {
1051   vfs::InMemoryFileSystem FS;
1052 #ifdef _WIN32
1053   const char *TestRoot = "C:\\";
1054 #else
1055   const char *TestRoot = "//net";
1056 #endif
1057   FS.setCurrentWorkingDirectory(TestRoot);
1058
1059   StringRef OuterFile = "dir/outer.rsp";
1060   StringRef OuterFileContents = "@inner.rsp";
1061   FS.addFile(OuterFile, 0, MemoryBuffer::getMemBuffer(OuterFileContents));
1062
1063   StringRef InnerFile = "dir/inner.rsp";
1064   StringRef InnerFileContents = "-flag";
1065   FS.addFile(InnerFile, 0, MemoryBuffer::getMemBuffer(InnerFileContents));
1066
1067   SmallVector<const char *, 2> Argv = {"test/test", "@dir/outer.rsp"};
1068
1069   BumpPtrAllocator A;
1070   llvm::cl::ExpansionContext ECtx(A, cl::TokenizeGNUCommandLine);
1071   ECtx.setVFS(&FS).setCurrentDir(TestRoot).setRelativeNames(true);
1072   ASSERT_FALSE((bool)ECtx.expandResponseFiles(Argv));
1073   EXPECT_THAT(Argv,
1074               testing::Pointwise(StringEquality(), {"test/test", "-flag"}));
1075 }
1076
1077 TEST(CommandLineTest, ResponseFileEOLs) {
1078   vfs::InMemoryFileSystem FS;
1079 #ifdef _WIN32
1080   const char *TestRoot = "C:\\";
1081 #else
1082   const char *TestRoot = "//net";
1083 #endif
1084   FS.setCurrentWorkingDirectory(TestRoot);
1085   FS.addFile("eols.rsp", 0,
1086              MemoryBuffer::getMemBuffer("-Xclang -Wno-whatever\n input.cpp"));
1087   SmallVector<const char *, 2> Argv = {"clang", "@eols.rsp"};
1088   BumpPtrAllocator A;
1089   llvm::cl::ExpansionContext ECtx(A, cl::TokenizeWindowsCommandLine);
1090   ECtx.setVFS(&FS).setCurrentDir(TestRoot).setMarkEOLs(true).setRelativeNames(
1091       true);
1092   ASSERT_FALSE((bool)ECtx.expandResponseFiles(Argv));
1093   const char *Expected[] = {"clang", "-Xclang", "-Wno-whatever", nullptr,
1094                             "input.cpp"};
1095   ASSERT_EQ(std::size(Expected), Argv.size());
1096   for (size_t I = 0, E = std::size(Expected); I < E; ++I) {
1097     if (Expected[I] == nullptr) {
1098       ASSERT_EQ(Argv[I], nullptr);
1099     } else {
1100       ASSERT_STREQ(Expected[I], Argv[I]);
1101     }
1102   }
1103 }
1104
1105 TEST(CommandLineTest, BadResponseFile) {
1106   BumpPtrAllocator A;
1107   StringSaver Saver(A);
1108   TempDir ADir("dir", /*Unique*/ true);
1109   SmallString<128> AFilePath = ADir.path();
1110   llvm::sys::path::append(AFilePath, "file.rsp");
1111   std::string AFileExp = std::string("@") + std::string(AFilePath.str());
1112   SmallVector<const char *, 2> Argv = {"clang", AFileExp.c_str()};
1113
1114   bool Res = cl::ExpandResponseFiles(Saver, cl::TokenizeGNUCommandLine, Argv);
1115   ASSERT_TRUE(Res);
1116   ASSERT_EQ(2U, Argv.size());
1117   ASSERT_STREQ(Argv[0], "clang");
1118   ASSERT_STREQ(Argv[1], AFileExp.c_str());
1119
1120   std::string ADirExp = std::string("@") + std::string(ADir.path());
1121   Argv = {"clang", ADirExp.c_str()};
1122   Res = cl::ExpandResponseFiles(Saver, cl::TokenizeGNUCommandLine, Argv);
1123   ASSERT_FALSE(Res);
1124   ASSERT_EQ(2U, Argv.size());
1125   ASSERT_STREQ(Argv[0], "clang");
1126   ASSERT_STREQ(Argv[1], ADirExp.c_str());
1127 }
1128
1129 TEST(CommandLineTest, SetDefaultValue) {
1130   cl::ResetCommandLineParser();
1131
1132   StackOption<std::string> Opt1("opt1", cl::init("true"));
1133   StackOption<bool> Opt2("opt2", cl::init(true));
1134   cl::alias Alias("alias", llvm::cl::aliasopt(Opt2));
1135   StackOption<int> Opt3("opt3", cl::init(3));
1136
1137   llvm::SmallVector<int, 3> IntVals = {1, 2, 3};
1138   llvm::SmallVector<std::string, 3> StrVals = {"foo", "bar", "baz"};
1139
1140   StackOption<int, cl::list<int>> List1(
1141       "list1", cl::list_init<int>(llvm::ArrayRef<int>(IntVals)),
1142       cl::CommaSeparated);
1143   StackOption<std::string, cl::list<std::string>> List2(
1144       "list2", cl::list_init<std::string>(llvm::ArrayRef<std::string>(StrVals)),
1145       cl::CommaSeparated);
1146   cl::alias ListAlias("list-alias", llvm::cl::aliasopt(List2));
1147
1148   const char *args[] = {"prog",   "-opt1=false", "-list1", "4",
1149                         "-list1", "5,6",         "-opt2",  "-opt3"};
1150
1151   EXPECT_TRUE(
1152       cl::ParseCommandLineOptions(7, args, StringRef(), &llvm::nulls()));
1153
1154   EXPECT_EQ(Opt1, "false");
1155   EXPECT_TRUE(Opt2);
1156   EXPECT_EQ(Opt3, 3);
1157
1158   for (size_t I = 0, E = IntVals.size(); I < E; ++I) {
1159     EXPECT_EQ(IntVals[I] + 3, List1[I]);
1160     EXPECT_EQ(StrVals[I], List2[I]);
1161   }
1162
1163   Opt2 = false;
1164   Opt3 = 1;
1165
1166   cl::ResetAllOptionOccurrences();
1167
1168   for (auto &OM : cl::getRegisteredOptions(cl::SubCommand::getTopLevel())) {
1169     cl::Option *O = OM.second;
1170     if (O->ArgStr == "opt2") {
1171       continue;
1172     }
1173     O->setDefault();
1174   }
1175
1176   EXPECT_EQ(Opt1, "true");
1177   EXPECT_TRUE(Opt2);
1178   EXPECT_EQ(Opt3, 3);
1179   for (size_t I = 0, E = IntVals.size(); I < E; ++I) {
1180     EXPECT_EQ(IntVals[I], List1[I]);
1181     EXPECT_EQ(StrVals[I], List2[I]);
1182   }
1183
1184   Alias.removeArgument();
1185   ListAlias.removeArgument();
1186 }
1187
1188 TEST(CommandLineTest, ReadConfigFile) {
1189   llvm::SmallVector<const char *, 1> Argv;
1190
1191   TempDir TestDir("unittest", /*Unique*/ true);
1192   TempDir TestSubDir(TestDir.path("subdir"), /*Unique*/ false);
1193
1194   llvm::SmallString<128> TestCfg = TestDir.path("foo");
1195   TempFile ConfigFile(TestCfg, "",
1196                       "# Comment\n"
1197                       "-option_1\n"
1198                       "-option_2=<CFGDIR>/dir1\n"
1199                       "-option_3=<CFGDIR>\n"
1200                       "-option_4 <CFGDIR>\n"
1201                       "-option_5=<CFG\\\n"
1202                       "DIR>\n"
1203                       "-option_6=<CFGDIR>/dir1,<CFGDIR>/dir2\n"
1204                       "@subconfig\n"
1205                       "-option_11=abcd\n"
1206                       "-option_12=\\\n"
1207                       "cdef\n");
1208
1209   llvm::SmallString<128> TestCfg2 = TestDir.path("subconfig");
1210   TempFile ConfigFile2(TestCfg2, "",
1211                        "-option_7\n"
1212                        "-option_8=<CFGDIR>/dir2\n"
1213                        "@subdir/subfoo\n"
1214                        "\n"
1215                        "   # comment\n");
1216
1217   llvm::SmallString<128> TestCfg3 = TestSubDir.path("subfoo");
1218   TempFile ConfigFile3(TestCfg3, "",
1219                        "-option_9=<CFGDIR>/dir3\n"
1220                        "@<CFGDIR>/subfoo2\n");
1221
1222   llvm::SmallString<128> TestCfg4 = TestSubDir.path("subfoo2");
1223   TempFile ConfigFile4(TestCfg4, "", "-option_10\n");
1224
1225   // Make sure the current directory is not the directory where config files
1226   // resides. In this case the code that expands response files will not find
1227   // 'subconfig' unless it resolves nested inclusions relative to the including
1228   // file.
1229   llvm::SmallString<128> CurrDir;
1230   std::error_code EC = llvm::sys::fs::current_path(CurrDir);
1231   EXPECT_TRUE(!EC);
1232   EXPECT_NE(CurrDir.str(), TestDir.path());
1233
1234   llvm::BumpPtrAllocator A;
1235   llvm::cl::ExpansionContext ECtx(A, cl::tokenizeConfigFile);
1236   llvm::Error Result = ECtx.readConfigFile(ConfigFile.path(), Argv);
1237
1238   EXPECT_FALSE((bool)Result);
1239   EXPECT_EQ(Argv.size(), 13U);
1240   EXPECT_STREQ(Argv[0], "-option_1");
1241   EXPECT_STREQ(Argv[1],
1242                ("-option_2=" + TestDir.path() + "/dir1").str().c_str());
1243   EXPECT_STREQ(Argv[2], ("-option_3=" + TestDir.path()).str().c_str());
1244   EXPECT_STREQ(Argv[3], "-option_4");
1245   EXPECT_STREQ(Argv[4], TestDir.path().str().c_str());
1246   EXPECT_STREQ(Argv[5], ("-option_5=" + TestDir.path()).str().c_str());
1247   EXPECT_STREQ(Argv[6], ("-option_6=" + TestDir.path() + "/dir1," +
1248                          TestDir.path() + "/dir2")
1249                             .str()
1250                             .c_str());
1251   EXPECT_STREQ(Argv[7], "-option_7");
1252   EXPECT_STREQ(Argv[8],
1253                ("-option_8=" + TestDir.path() + "/dir2").str().c_str());
1254   EXPECT_STREQ(Argv[9],
1255                ("-option_9=" + TestSubDir.path() + "/dir3").str().c_str());
1256   EXPECT_STREQ(Argv[10], "-option_10");
1257   EXPECT_STREQ(Argv[11], "-option_11=abcd");
1258   EXPECT_STREQ(Argv[12], "-option_12=cdef");
1259 }
1260
1261 TEST(CommandLineTest, PositionalEatArgsError) {
1262   cl::ResetCommandLineParser();
1263
1264   StackOption<std::string, cl::list<std::string>> PosEatArgs(
1265       "positional-eat-args", cl::Positional, cl::desc("<arguments>..."),
1266       cl::PositionalEatsArgs);
1267   StackOption<std::string, cl::list<std::string>> PosEatArgs2(
1268       "positional-eat-args2", cl::Positional, cl::desc("Some strings"),
1269       cl::PositionalEatsArgs);
1270
1271   const char *args[] = {"prog", "-positional-eat-args=XXXX"};
1272   const char *args2[] = {"prog", "-positional-eat-args=XXXX", "-foo"};
1273   const char *args3[] = {"prog", "-positional-eat-args", "-foo"};
1274   const char *args4[] = {"prog", "-positional-eat-args",
1275                          "-foo", "-positional-eat-args2",
1276                          "-bar", "foo"};
1277
1278   std::string Errs;
1279   raw_string_ostream OS(Errs);
1280   EXPECT_FALSE(cl::ParseCommandLineOptions(2, args, StringRef(), &OS)); OS.flush();
1281   EXPECT_FALSE(Errs.empty()); Errs.clear();
1282   EXPECT_FALSE(cl::ParseCommandLineOptions(3, args2, StringRef(), &OS)); OS.flush();
1283   EXPECT_FALSE(Errs.empty()); Errs.clear();
1284   EXPECT_TRUE(cl::ParseCommandLineOptions(3, args3, StringRef(), &OS)); OS.flush();
1285   EXPECT_TRUE(Errs.empty()); Errs.clear();
1286
1287   cl::ResetAllOptionOccurrences();
1288   EXPECT_TRUE(cl::ParseCommandLineOptions(6, args4, StringRef(), &OS)); OS.flush();
1289   EXPECT_EQ(PosEatArgs.size(), 1u);
1290   EXPECT_EQ(PosEatArgs2.size(), 2u);
1291   EXPECT_TRUE(Errs.empty());
1292 }
1293
1294 #ifdef _WIN32
1295 void checkSeparators(StringRef Path) {
1296   char UndesiredSeparator = sys::path::get_separator()[0] == '/' ? '\\' : '/';
1297   ASSERT_EQ(Path.find(UndesiredSeparator), StringRef::npos);
1298 }
1299
1300 TEST(CommandLineTest, GetCommandLineArguments) {
1301   int argc = __argc;
1302   char **argv = __argv;
1303
1304   // GetCommandLineArguments is called in InitLLVM.
1305   llvm::InitLLVM X(argc, argv);
1306
1307   EXPECT_EQ(llvm::sys::path::is_absolute(argv[0]),
1308             llvm::sys::path::is_absolute(__argv[0]));
1309   checkSeparators(argv[0]);
1310
1311   EXPECT_TRUE(
1312       llvm::sys::path::filename(argv[0]).equals_insensitive("supporttests.exe"))
1313       << "Filename of test executable is "
1314       << llvm::sys::path::filename(argv[0]);
1315 }
1316 #endif
1317
1318 class OutputRedirector {
1319 public:
1320   OutputRedirector(int RedirectFD)
1321       : RedirectFD(RedirectFD), OldFD(dup(RedirectFD)) {
1322     if (OldFD == -1 ||
1323         sys::fs::createTemporaryFile("unittest-redirect", "", NewFD,
1324                                      FilePath) ||
1325         dup2(NewFD, RedirectFD) == -1)
1326       Valid = false;
1327   }
1328
1329   ~OutputRedirector() {
1330     dup2(OldFD, RedirectFD);
1331     close(OldFD);
1332     close(NewFD);
1333   }
1334
1335   SmallVector<char, 128> FilePath;
1336   bool Valid = true;
1337
1338 private:
1339   int RedirectFD;
1340   int OldFD;
1341   int NewFD;
1342 };
1343
1344 struct AutoDeleteFile {
1345   SmallVector<char, 128> FilePath;
1346   ~AutoDeleteFile() {
1347     if (!FilePath.empty())
1348       sys::fs::remove(std::string(FilePath.data(), FilePath.size()));
1349   }
1350 };
1351
1352 static std::string interceptStdout(std::function<void()> F) {
1353   outs().flush(); // flush any output from previous tests
1354   AutoDeleteFile File;
1355   {
1356     OutputRedirector Stdout(fileno(stdout));
1357     if (!Stdout.Valid)
1358       return "";
1359     File.FilePath = Stdout.FilePath;
1360     F();
1361     outs().flush();
1362   }
1363   auto Buffer = MemoryBuffer::getFile(File.FilePath);
1364   if (!Buffer)
1365     return "";
1366   return Buffer->get()->getBuffer().str();
1367 }
1368
1369 template <void (*Func)(const cl::Option &)>
1370 class PrintOptionTestBase : public ::testing::Test {
1371 public:
1372   // Return std::string because the output of a failing EXPECT check is
1373   // unreadable for StringRef. It also avoids any lifetime issues.
1374   template <typename... Ts> std::string runTest(Ts... OptionAttributes) {
1375     StackOption<OptionValue> TestOption(Opt, cl::desc(HelpText),
1376                                         OptionAttributes...);
1377     return interceptStdout([&]() { Func(TestOption); });
1378   }
1379
1380   enum class OptionValue { Val };
1381   const StringRef Opt = "some-option";
1382   const StringRef HelpText = "some help";
1383 };
1384
1385   // This is a workaround for cl::Option sub-classes having their
1386   // printOptionInfo functions private.
1387 void printOptionInfo(const cl::Option &O) {
1388   O.printOptionInfo(/*GlobalWidth=*/26);
1389 }
1390
1391 using PrintOptionInfoTest = PrintOptionTestBase<printOptionInfo>;
1392
1393 TEST_F(PrintOptionInfoTest, PrintOptionInfoValueOptionalWithoutSentinel) {
1394   std::string Output =
1395       runTest(cl::ValueOptional,
1396               cl::values(clEnumValN(OptionValue::Val, "v1", "desc1")));
1397
1398   // clang-format off
1399   EXPECT_EQ(Output, ("  --" + Opt + "=<value> - " + HelpText + "\n"
1400                      "    =v1                 -   desc1\n")
1401                         .str());
1402   // clang-format on
1403 }
1404
1405 TEST_F(PrintOptionInfoTest, PrintOptionInfoValueOptionalWithSentinel) {
1406   std::string Output = runTest(
1407       cl::ValueOptional, cl::values(clEnumValN(OptionValue::Val, "v1", "desc1"),
1408                                     clEnumValN(OptionValue::Val, "", "")));
1409
1410   // clang-format off
1411   EXPECT_EQ(Output,
1412             ("  --" + Opt + "         - " + HelpText + "\n"
1413              "  --" + Opt + "=<value> - " + HelpText + "\n"
1414              "    =v1                 -   desc1\n")
1415                 .str());
1416   // clang-format on
1417 }
1418
1419 TEST_F(PrintOptionInfoTest, PrintOptionInfoValueOptionalWithSentinelWithHelp) {
1420   std::string Output = runTest(
1421       cl::ValueOptional, cl::values(clEnumValN(OptionValue::Val, "v1", "desc1"),
1422                                     clEnumValN(OptionValue::Val, "", "desc2")));
1423
1424   // clang-format off
1425   EXPECT_EQ(Output, ("  --" + Opt + "         - " + HelpText + "\n"
1426                      "  --" + Opt + "=<value> - " + HelpText + "\n"
1427                      "    =v1                 -   desc1\n"
1428                      "    =<empty>            -   desc2\n")
1429                         .str());
1430   // clang-format on
1431 }
1432
1433 TEST_F(PrintOptionInfoTest, PrintOptionInfoValueRequiredWithEmptyValueName) {
1434   std::string Output = runTest(
1435       cl::ValueRequired, cl::values(clEnumValN(OptionValue::Val, "v1", "desc1"),
1436                                     clEnumValN(OptionValue::Val, "", "")));
1437
1438   // clang-format off
1439   EXPECT_EQ(Output, ("  --" + Opt + "=<value> - " + HelpText + "\n"
1440                      "    =v1                 -   desc1\n"
1441                      "    =<empty>\n")
1442                         .str());
1443   // clang-format on
1444 }
1445
1446 TEST_F(PrintOptionInfoTest, PrintOptionInfoEmptyValueDescription) {
1447   std::string Output = runTest(
1448       cl::ValueRequired, cl::values(clEnumValN(OptionValue::Val, "v1", "")));
1449
1450   // clang-format off
1451   EXPECT_EQ(Output,
1452             ("  --" + Opt + "=<value> - " + HelpText + "\n"
1453              "    =v1\n").str());
1454   // clang-format on
1455 }
1456
1457 TEST_F(PrintOptionInfoTest, PrintOptionInfoMultilineValueDescription) {
1458   std::string Output =
1459       runTest(cl::ValueRequired,
1460               cl::values(clEnumValN(OptionValue::Val, "v1",
1461                                     "This is the first enum value\n"
1462                                     "which has a really long description\n"
1463                                     "thus it is multi-line."),
1464                          clEnumValN(OptionValue::Val, "",
1465                                     "This is an unnamed enum value\n"
1466                                     "Should be indented as well")));
1467
1468   // clang-format off
1469   EXPECT_EQ(Output,
1470             ("  --" + Opt + "=<value> - " + HelpText + "\n"
1471              "    =v1                 -   This is the first enum value\n"
1472              "                            which has a really long description\n"
1473              "                            thus it is multi-line.\n"
1474              "    =<empty>            -   This is an unnamed enum value\n"
1475              "                            Should be indented as well\n").str());
1476   // clang-format on
1477 }
1478
1479 void printOptionValue(const cl::Option &O) {
1480   O.printOptionValue(/*GlobalWidth=*/12, /*Force=*/true);
1481 }
1482
1483 using PrintOptionValueTest = PrintOptionTestBase<printOptionValue>;
1484
1485 TEST_F(PrintOptionValueTest, PrintOptionDefaultValue) {
1486   std::string Output =
1487       runTest(cl::init(OptionValue::Val),
1488               cl::values(clEnumValN(OptionValue::Val, "v1", "desc1")));
1489
1490   EXPECT_EQ(Output, ("    --" + Opt + " = v1       (default: v1)\n").str());
1491 }
1492
1493 TEST_F(PrintOptionValueTest, PrintOptionNoDefaultValue) {
1494   std::string Output =
1495       runTest(cl::values(clEnumValN(OptionValue::Val, "v1", "desc1")));
1496
1497   // Note: the option still has a (zero-initialized) value, but the default
1498   // is invalid and doesn't match any value.
1499   EXPECT_EQ(Output, ("    --" + Opt + " = v1       (default: )\n").str());
1500 }
1501
1502 TEST_F(PrintOptionValueTest, PrintOptionUnknownValue) {
1503   std::string Output = runTest(cl::init(OptionValue::Val));
1504
1505   EXPECT_EQ(Output, ("    --" + Opt + " = *unknown option value*\n").str());
1506 }
1507
1508 class GetOptionWidthTest : public ::testing::Test {
1509 public:
1510   enum class OptionValue { Val };
1511
1512   template <typename... Ts>
1513   size_t runTest(StringRef ArgName, Ts... OptionAttributes) {
1514     StackOption<OptionValue> TestOption(ArgName, cl::desc("some help"),
1515                                         OptionAttributes...);
1516     return getOptionWidth(TestOption);
1517   }
1518
1519 private:
1520   // This is a workaround for cl::Option sub-classes having their
1521   // printOptionInfo
1522   // functions private.
1523   size_t getOptionWidth(const cl::Option &O) { return O.getOptionWidth(); }
1524 };
1525
1526 TEST_F(GetOptionWidthTest, GetOptionWidthArgNameLonger) {
1527   StringRef ArgName("a-long-argument-name");
1528   size_t ExpectedStrSize = ("  --" + ArgName + "=<value> - ").str().size();
1529   EXPECT_EQ(
1530       runTest(ArgName, cl::values(clEnumValN(OptionValue::Val, "v", "help"))),
1531       ExpectedStrSize);
1532 }
1533
1534 TEST_F(GetOptionWidthTest, GetOptionWidthFirstOptionNameLonger) {
1535   StringRef OptName("a-long-option-name");
1536   size_t ExpectedStrSize = ("    =" + OptName + " - ").str().size();
1537   EXPECT_EQ(
1538       runTest("a", cl::values(clEnumValN(OptionValue::Val, OptName, "help"),
1539                               clEnumValN(OptionValue::Val, "b", "help"))),
1540       ExpectedStrSize);
1541 }
1542
1543 TEST_F(GetOptionWidthTest, GetOptionWidthSecondOptionNameLonger) {
1544   StringRef OptName("a-long-option-name");
1545   size_t ExpectedStrSize = ("    =" + OptName + " - ").str().size();
1546   EXPECT_EQ(
1547       runTest("a", cl::values(clEnumValN(OptionValue::Val, "b", "help"),
1548                               clEnumValN(OptionValue::Val, OptName, "help"))),
1549       ExpectedStrSize);
1550 }
1551
1552 TEST_F(GetOptionWidthTest, GetOptionWidthEmptyOptionNameLonger) {
1553   size_t ExpectedStrSize = StringRef("    =<empty> - ").size();
1554   // The length of a=<value> (including indentation) is actually the same as the
1555   // =<empty> string, so it is impossible to distinguish via testing the case
1556   // where the empty string is picked from where the option name is picked.
1557   EXPECT_EQ(runTest("a", cl::values(clEnumValN(OptionValue::Val, "b", "help"),
1558                                     clEnumValN(OptionValue::Val, "", "help"))),
1559             ExpectedStrSize);
1560 }
1561
1562 TEST_F(GetOptionWidthTest,
1563        GetOptionWidthValueOptionalEmptyOptionWithNoDescription) {
1564   StringRef ArgName("a");
1565   // The length of a=<value> (including indentation) is actually the same as the
1566   // =<empty> string, so it is impossible to distinguish via testing the case
1567   // where the empty string is ignored from where it is not ignored.
1568   // The dash will not actually be printed, but the space it would take up is
1569   // included to ensure a consistent column width.
1570   size_t ExpectedStrSize = ("  -" + ArgName + "=<value> - ").str().size();
1571   EXPECT_EQ(runTest(ArgName, cl::ValueOptional,
1572                     cl::values(clEnumValN(OptionValue::Val, "value", "help"),
1573                                clEnumValN(OptionValue::Val, "", ""))),
1574             ExpectedStrSize);
1575 }
1576
1577 TEST_F(GetOptionWidthTest,
1578        GetOptionWidthValueRequiredEmptyOptionWithNoDescription) {
1579   // The length of a=<value> (including indentation) is actually the same as the
1580   // =<empty> string, so it is impossible to distinguish via testing the case
1581   // where the empty string is picked from where the option name is picked
1582   size_t ExpectedStrSize = StringRef("    =<empty> - ").size();
1583   EXPECT_EQ(runTest("a", cl::ValueRequired,
1584                     cl::values(clEnumValN(OptionValue::Val, "value", "help"),
1585                                clEnumValN(OptionValue::Val, "", ""))),
1586             ExpectedStrSize);
1587 }
1588
1589 TEST(CommandLineTest, PrefixOptions) {
1590   cl::ResetCommandLineParser();
1591
1592   StackOption<std::string, cl::list<std::string>> IncludeDirs(
1593       "I", cl::Prefix, cl::desc("Declare an include directory"));
1594
1595   // Test non-prefixed variant works with cl::Prefix options.
1596   EXPECT_TRUE(IncludeDirs.empty());
1597   const char *args[] = {"prog", "-I=/usr/include"};
1598   EXPECT_TRUE(
1599       cl::ParseCommandLineOptions(2, args, StringRef(), &llvm::nulls()));
1600   EXPECT_EQ(IncludeDirs.size(), 1u);
1601   EXPECT_EQ(IncludeDirs.front().compare("/usr/include"), 0);
1602
1603   IncludeDirs.erase(IncludeDirs.begin());
1604   cl::ResetAllOptionOccurrences();
1605
1606   // Test non-prefixed variant works with cl::Prefix options when value is
1607   // passed in following argument.
1608   EXPECT_TRUE(IncludeDirs.empty());
1609   const char *args2[] = {"prog", "-I", "/usr/include"};
1610   EXPECT_TRUE(
1611       cl::ParseCommandLineOptions(3, args2, StringRef(), &llvm::nulls()));
1612   EXPECT_EQ(IncludeDirs.size(), 1u);
1613   EXPECT_EQ(IncludeDirs.front().compare("/usr/include"), 0);
1614
1615   IncludeDirs.erase(IncludeDirs.begin());
1616   cl::ResetAllOptionOccurrences();
1617
1618   // Test prefixed variant works with cl::Prefix options.
1619   EXPECT_TRUE(IncludeDirs.empty());
1620   const char *args3[] = {"prog", "-I/usr/include"};
1621   EXPECT_TRUE(
1622       cl::ParseCommandLineOptions(2, args3, StringRef(), &llvm::nulls()));
1623   EXPECT_EQ(IncludeDirs.size(), 1u);
1624   EXPECT_EQ(IncludeDirs.front().compare("/usr/include"), 0);
1625
1626   StackOption<std::string, cl::list<std::string>> MacroDefs(
1627       "D", cl::AlwaysPrefix, cl::desc("Define a macro"),
1628       cl::value_desc("MACRO[=VALUE]"));
1629
1630   cl::ResetAllOptionOccurrences();
1631
1632   // Test non-prefixed variant does not work with cl::AlwaysPrefix options:
1633   // equal sign is part of the value.
1634   EXPECT_TRUE(MacroDefs.empty());
1635   const char *args4[] = {"prog", "-D=HAVE_FOO"};
1636   EXPECT_TRUE(
1637       cl::ParseCommandLineOptions(2, args4, StringRef(), &llvm::nulls()));
1638   EXPECT_EQ(MacroDefs.size(), 1u);
1639   EXPECT_EQ(MacroDefs.front().compare("=HAVE_FOO"), 0);
1640
1641   MacroDefs.erase(MacroDefs.begin());
1642   cl::ResetAllOptionOccurrences();
1643
1644   // Test non-prefixed variant does not allow value to be passed in following
1645   // argument with cl::AlwaysPrefix options.
1646   EXPECT_TRUE(MacroDefs.empty());
1647   const char *args5[] = {"prog", "-D", "HAVE_FOO"};
1648   EXPECT_FALSE(
1649       cl::ParseCommandLineOptions(3, args5, StringRef(), &llvm::nulls()));
1650   EXPECT_TRUE(MacroDefs.empty());
1651
1652   cl::ResetAllOptionOccurrences();
1653
1654   // Test prefixed variant works with cl::AlwaysPrefix options.
1655   EXPECT_TRUE(MacroDefs.empty());
1656   const char *args6[] = {"prog", "-DHAVE_FOO"};
1657   EXPECT_TRUE(
1658       cl::ParseCommandLineOptions(2, args6, StringRef(), &llvm::nulls()));
1659   EXPECT_EQ(MacroDefs.size(), 1u);
1660   EXPECT_EQ(MacroDefs.front().compare("HAVE_FOO"), 0);
1661 }
1662
1663 TEST(CommandLineTest, GroupingWithValue) {
1664   cl::ResetCommandLineParser();
1665
1666   StackOption<bool> OptF("f", cl::Grouping, cl::desc("Some flag"));
1667   StackOption<bool> OptB("b", cl::Grouping, cl::desc("Another flag"));
1668   StackOption<bool> OptD("d", cl::Grouping, cl::ValueDisallowed,
1669                          cl::desc("ValueDisallowed option"));
1670   StackOption<std::string> OptV("v", cl::Grouping,
1671                                 cl::desc("ValueRequired option"));
1672   StackOption<std::string> OptO("o", cl::Grouping, cl::ValueOptional,
1673                                 cl::desc("ValueOptional option"));
1674
1675   // Should be possible to use an option which requires a value
1676   // at the end of a group.
1677   const char *args1[] = {"prog", "-fv", "val1"};
1678   EXPECT_TRUE(
1679       cl::ParseCommandLineOptions(3, args1, StringRef(), &llvm::nulls()));
1680   EXPECT_TRUE(OptF);
1681   EXPECT_STREQ("val1", OptV.c_str());
1682   OptV.clear();
1683   cl::ResetAllOptionOccurrences();
1684
1685   // Should not crash if it is accidentally used elsewhere in the group.
1686   const char *args2[] = {"prog", "-vf", "val2"};
1687   EXPECT_FALSE(
1688       cl::ParseCommandLineOptions(3, args2, StringRef(), &llvm::nulls()));
1689   OptV.clear();
1690   cl::ResetAllOptionOccurrences();
1691
1692   // Should allow the "opt=value" form at the end of the group
1693   const char *args3[] = {"prog", "-fv=val3"};
1694   EXPECT_TRUE(
1695       cl::ParseCommandLineOptions(2, args3, StringRef(), &llvm::nulls()));
1696   EXPECT_TRUE(OptF);
1697   EXPECT_STREQ("val3", OptV.c_str());
1698   OptV.clear();
1699   cl::ResetAllOptionOccurrences();
1700
1701   // Should allow assigning a value for a ValueOptional option
1702   // at the end of the group
1703   const char *args4[] = {"prog", "-fo=val4"};
1704   EXPECT_TRUE(
1705       cl::ParseCommandLineOptions(2, args4, StringRef(), &llvm::nulls()));
1706   EXPECT_TRUE(OptF);
1707   EXPECT_STREQ("val4", OptO.c_str());
1708   OptO.clear();
1709   cl::ResetAllOptionOccurrences();
1710
1711   // Should assign an empty value if a ValueOptional option is used elsewhere
1712   // in the group.
1713   const char *args5[] = {"prog", "-fob"};
1714   EXPECT_TRUE(
1715       cl::ParseCommandLineOptions(2, args5, StringRef(), &llvm::nulls()));
1716   EXPECT_TRUE(OptF);
1717   EXPECT_EQ(1, OptO.getNumOccurrences());
1718   EXPECT_EQ(1, OptB.getNumOccurrences());
1719   EXPECT_TRUE(OptO.empty());
1720   cl::ResetAllOptionOccurrences();
1721
1722   // Should not allow an assignment for a ValueDisallowed option.
1723   const char *args6[] = {"prog", "-fd=false"};
1724   EXPECT_FALSE(
1725       cl::ParseCommandLineOptions(2, args6, StringRef(), &llvm::nulls()));
1726 }
1727
1728 TEST(CommandLineTest, GroupingAndPrefix) {
1729   cl::ResetCommandLineParser();
1730
1731   StackOption<bool> OptF("f", cl::Grouping, cl::desc("Some flag"));
1732   StackOption<bool> OptB("b", cl::Grouping, cl::desc("Another flag"));
1733   StackOption<std::string> OptP("p", cl::Prefix, cl::Grouping,
1734                                 cl::desc("Prefix and Grouping"));
1735   StackOption<std::string> OptA("a", cl::AlwaysPrefix, cl::Grouping,
1736                                 cl::desc("AlwaysPrefix and Grouping"));
1737
1738   // Should be possible to use a cl::Prefix option without grouping.
1739   const char *args1[] = {"prog", "-pval1"};
1740   EXPECT_TRUE(
1741       cl::ParseCommandLineOptions(2, args1, StringRef(), &llvm::nulls()));
1742   EXPECT_STREQ("val1", OptP.c_str());
1743   OptP.clear();
1744   cl::ResetAllOptionOccurrences();
1745
1746   // Should be possible to pass a value in a separate argument.
1747   const char *args2[] = {"prog", "-p", "val2"};
1748   EXPECT_TRUE(
1749       cl::ParseCommandLineOptions(3, args2, StringRef(), &llvm::nulls()));
1750   EXPECT_STREQ("val2", OptP.c_str());
1751   OptP.clear();
1752   cl::ResetAllOptionOccurrences();
1753
1754   // The "-opt=value" form should work, too.
1755   const char *args3[] = {"prog", "-p=val3"};
1756   EXPECT_TRUE(
1757       cl::ParseCommandLineOptions(2, args3, StringRef(), &llvm::nulls()));
1758   EXPECT_STREQ("val3", OptP.c_str());
1759   OptP.clear();
1760   cl::ResetAllOptionOccurrences();
1761
1762   // All three previous cases should work the same way if an option with both
1763   // cl::Prefix and cl::Grouping modifiers is used at the end of a group.
1764   const char *args4[] = {"prog", "-fpval4"};
1765   EXPECT_TRUE(
1766       cl::ParseCommandLineOptions(2, args4, StringRef(), &llvm::nulls()));
1767   EXPECT_TRUE(OptF);
1768   EXPECT_STREQ("val4", OptP.c_str());
1769   OptP.clear();
1770   cl::ResetAllOptionOccurrences();
1771
1772   const char *args5[] = {"prog", "-fp", "val5"};
1773   EXPECT_TRUE(
1774       cl::ParseCommandLineOptions(3, args5, StringRef(), &llvm::nulls()));
1775   EXPECT_TRUE(OptF);
1776   EXPECT_STREQ("val5", OptP.c_str());
1777   OptP.clear();
1778   cl::ResetAllOptionOccurrences();
1779
1780   const char *args6[] = {"prog", "-fp=val6"};
1781   EXPECT_TRUE(
1782       cl::ParseCommandLineOptions(2, args6, StringRef(), &llvm::nulls()));
1783   EXPECT_TRUE(OptF);
1784   EXPECT_STREQ("val6", OptP.c_str());
1785   OptP.clear();
1786   cl::ResetAllOptionOccurrences();
1787
1788   // Should assign a value even if the part after a cl::Prefix option is equal
1789   // to the name of another option.
1790   const char *args7[] = {"prog", "-fpb"};
1791   EXPECT_TRUE(
1792       cl::ParseCommandLineOptions(2, args7, StringRef(), &llvm::nulls()));
1793   EXPECT_TRUE(OptF);
1794   EXPECT_STREQ("b", OptP.c_str());
1795   EXPECT_FALSE(OptB);
1796   OptP.clear();
1797   cl::ResetAllOptionOccurrences();
1798
1799   // Should be possible to use a cl::AlwaysPrefix option without grouping.
1800   const char *args8[] = {"prog", "-aval8"};
1801   EXPECT_TRUE(
1802       cl::ParseCommandLineOptions(2, args8, StringRef(), &llvm::nulls()));
1803   EXPECT_STREQ("val8", OptA.c_str());
1804   OptA.clear();
1805   cl::ResetAllOptionOccurrences();
1806
1807   // Should not be possible to pass a value in a separate argument.
1808   const char *args9[] = {"prog", "-a", "val9"};
1809   EXPECT_FALSE(
1810       cl::ParseCommandLineOptions(3, args9, StringRef(), &llvm::nulls()));
1811   cl::ResetAllOptionOccurrences();
1812
1813   // With the "-opt=value" form, the "=" symbol should be preserved.
1814   const char *args10[] = {"prog", "-a=val10"};
1815   EXPECT_TRUE(
1816       cl::ParseCommandLineOptions(2, args10, StringRef(), &llvm::nulls()));
1817   EXPECT_STREQ("=val10", OptA.c_str());
1818   OptA.clear();
1819   cl::ResetAllOptionOccurrences();
1820
1821   // All three previous cases should work the same way if an option with both
1822   // cl::AlwaysPrefix and cl::Grouping modifiers is used at the end of a group.
1823   const char *args11[] = {"prog", "-faval11"};
1824   EXPECT_TRUE(
1825       cl::ParseCommandLineOptions(2, args11, StringRef(), &llvm::nulls()));
1826   EXPECT_TRUE(OptF);
1827   EXPECT_STREQ("val11", OptA.c_str());
1828   OptA.clear();
1829   cl::ResetAllOptionOccurrences();
1830
1831   const char *args12[] = {"prog", "-fa", "val12"};
1832   EXPECT_FALSE(
1833       cl::ParseCommandLineOptions(3, args12, StringRef(), &llvm::nulls()));
1834   cl::ResetAllOptionOccurrences();
1835
1836   const char *args13[] = {"prog", "-fa=val13"};
1837   EXPECT_TRUE(
1838       cl::ParseCommandLineOptions(2, args13, StringRef(), &llvm::nulls()));
1839   EXPECT_TRUE(OptF);
1840   EXPECT_STREQ("=val13", OptA.c_str());
1841   OptA.clear();
1842   cl::ResetAllOptionOccurrences();
1843
1844   // Should assign a value even if the part after a cl::AlwaysPrefix option
1845   // is equal to the name of another option.
1846   const char *args14[] = {"prog", "-fab"};
1847   EXPECT_TRUE(
1848       cl::ParseCommandLineOptions(2, args14, StringRef(), &llvm::nulls()));
1849   EXPECT_TRUE(OptF);
1850   EXPECT_STREQ("b", OptA.c_str());
1851   EXPECT_FALSE(OptB);
1852   OptA.clear();
1853   cl::ResetAllOptionOccurrences();
1854 }
1855
1856 TEST(CommandLineTest, LongOptions) {
1857   cl::ResetCommandLineParser();
1858
1859   StackOption<bool> OptA("a", cl::desc("Some flag"));
1860   StackOption<bool> OptBLong("long-flag", cl::desc("Some long flag"));
1861   StackOption<bool, cl::alias> OptB("b", cl::desc("Alias to --long-flag"),
1862                                     cl::aliasopt(OptBLong));
1863   StackOption<std::string> OptAB("ab", cl::desc("Another long option"));
1864
1865   std::string Errs;
1866   raw_string_ostream OS(Errs);
1867
1868   const char *args1[] = {"prog", "-a", "-ab", "val1"};
1869   const char *args2[] = {"prog", "-a", "--ab", "val1"};
1870   const char *args3[] = {"prog", "-ab", "--ab", "val1"};
1871
1872   //
1873   // The following tests treat `-` and `--` the same, and always match the
1874   // longest string.
1875   //
1876
1877   EXPECT_TRUE(
1878       cl::ParseCommandLineOptions(4, args1, StringRef(), &OS)); OS.flush();
1879   EXPECT_TRUE(OptA);
1880   EXPECT_FALSE(OptBLong);
1881   EXPECT_STREQ("val1", OptAB.c_str());
1882   EXPECT_TRUE(Errs.empty()); Errs.clear();
1883   cl::ResetAllOptionOccurrences();
1884
1885   EXPECT_TRUE(
1886       cl::ParseCommandLineOptions(4, args2, StringRef(), &OS)); OS.flush();
1887   EXPECT_TRUE(OptA);
1888   EXPECT_FALSE(OptBLong);
1889   EXPECT_STREQ("val1", OptAB.c_str());
1890   EXPECT_TRUE(Errs.empty()); Errs.clear();
1891   cl::ResetAllOptionOccurrences();
1892
1893   // Fails because `-ab` and `--ab` are treated the same and appear more than
1894   // once.  Also, `val1` is unexpected.
1895   EXPECT_FALSE(
1896       cl::ParseCommandLineOptions(4, args3, StringRef(), &OS)); OS.flush();
1897   outs()<< Errs << "\n";
1898   EXPECT_FALSE(Errs.empty()); Errs.clear();
1899   cl::ResetAllOptionOccurrences();
1900
1901   //
1902   // The following tests treat `-` and `--` differently, with `-` for short, and
1903   // `--` for long options.
1904   //
1905
1906   // Fails because `-ab` is treated as `-a -b`, so `-a` is seen twice, and
1907   // `val1` is unexpected.
1908   EXPECT_FALSE(cl::ParseCommandLineOptions(4, args1, StringRef(),
1909                                            &OS, nullptr, true)); OS.flush();
1910   EXPECT_FALSE(Errs.empty()); Errs.clear();
1911   cl::ResetAllOptionOccurrences();
1912
1913   // Works because `-a` is treated differently than `--ab`.
1914   EXPECT_TRUE(cl::ParseCommandLineOptions(4, args2, StringRef(),
1915                                            &OS, nullptr, true)); OS.flush();
1916   EXPECT_TRUE(Errs.empty()); Errs.clear();
1917   cl::ResetAllOptionOccurrences();
1918
1919   // Works because `-ab` is treated as `-a -b`, and `--ab` is a long option.
1920   EXPECT_TRUE(cl::ParseCommandLineOptions(4, args3, StringRef(),
1921                                            &OS, nullptr, true));
1922   EXPECT_TRUE(OptA);
1923   EXPECT_TRUE(OptBLong);
1924   EXPECT_STREQ("val1", OptAB.c_str());
1925   OS.flush();
1926   EXPECT_TRUE(Errs.empty()); Errs.clear();
1927   cl::ResetAllOptionOccurrences();
1928 }
1929
1930 TEST(CommandLineTest, OptionErrorMessage) {
1931   // When there is an error, we expect some error message like:
1932   //   prog: for the -a option: [...]
1933   //
1934   // Test whether the "for the -a option"-part is correctly formatted.
1935   cl::ResetCommandLineParser();
1936
1937   StackOption<bool> OptA("a", cl::desc("Some option"));
1938   StackOption<bool> OptLong("long", cl::desc("Some long option"));
1939
1940   std::string Errs;
1941   raw_string_ostream OS(Errs);
1942
1943   OptA.error("custom error", OS);
1944   OS.flush();
1945   EXPECT_NE(Errs.find("for the -a option:"), std::string::npos);
1946   Errs.clear();
1947
1948   OptLong.error("custom error", OS);
1949   OS.flush();
1950   EXPECT_NE(Errs.find("for the --long option:"), std::string::npos);
1951   Errs.clear();
1952
1953   cl::ResetAllOptionOccurrences();
1954 }
1955
1956 TEST(CommandLineTest, OptionErrorMessageSuggest) {
1957   // When there is an error, and the edit-distance is not very large,
1958   // we expect some error message like:
1959   //   prog: did you mean '--option'?
1960   //
1961   // Test whether this message is well-formatted.
1962   cl::ResetCommandLineParser();
1963
1964   StackOption<bool> OptLong("aluminium", cl::desc("Some long option"));
1965
1966   const char *args[] = {"prog", "--aluminum"};
1967
1968   std::string Errs;
1969   raw_string_ostream OS(Errs);
1970
1971   EXPECT_FALSE(cl::ParseCommandLineOptions(2, args, StringRef(), &OS));
1972   OS.flush();
1973   EXPECT_NE(Errs.find("prog: Did you mean '--aluminium'?\n"),
1974             std::string::npos);
1975   Errs.clear();
1976
1977   cl::ResetAllOptionOccurrences();
1978 }
1979
1980 TEST(CommandLineTest, OptionErrorMessageSuggestNoHidden) {
1981   // We expect that 'really hidden' option do not show up in option
1982   // suggestions.
1983   cl::ResetCommandLineParser();
1984
1985   StackOption<bool> OptLong("aluminium", cl::desc("Some long option"));
1986   StackOption<bool> OptLong2("aluminum", cl::desc("Bad option"),
1987                              cl::ReallyHidden);
1988
1989   const char *args[] = {"prog", "--alumnum"};
1990
1991   std::string Errs;
1992   raw_string_ostream OS(Errs);
1993
1994   EXPECT_FALSE(cl::ParseCommandLineOptions(2, args, StringRef(), &OS));
1995   OS.flush();
1996   EXPECT_NE(Errs.find("prog: Did you mean '--aluminium'?\n"),
1997             std::string::npos);
1998   Errs.clear();
1999
2000   cl::ResetAllOptionOccurrences();
2001 }
2002
2003 TEST(CommandLineTest, Callback) {
2004   cl::ResetCommandLineParser();
2005
2006   StackOption<bool> OptA("a", cl::desc("option a"));
2007   StackOption<bool> OptB(
2008       "b", cl::desc("option b -- This option turns on option a"),
2009       cl::callback([&](const bool &) { OptA = true; }));
2010   StackOption<bool> OptC(
2011       "c", cl::desc("option c -- This option turns on options a and b"),
2012       cl::callback([&](const bool &) { OptB = true; }));
2013   StackOption<std::string, cl::list<std::string>> List(
2014       "list",
2015       cl::desc("option list -- This option turns on options a, b, and c when "
2016                "'foo' is included in list"),
2017       cl::CommaSeparated,
2018       cl::callback([&](const std::string &Str) {
2019         if (Str == "foo")
2020           OptC = true;
2021       }));
2022
2023   const char *args1[] = {"prog", "-a"};
2024   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args1));
2025   EXPECT_TRUE(OptA);
2026   EXPECT_FALSE(OptB);
2027   EXPECT_FALSE(OptC);
2028   EXPECT_EQ(List.size(), 0u);
2029   cl::ResetAllOptionOccurrences();
2030
2031   const char *args2[] = {"prog", "-b"};
2032   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args2));
2033   EXPECT_TRUE(OptA);
2034   EXPECT_TRUE(OptB);
2035   EXPECT_FALSE(OptC);
2036   EXPECT_EQ(List.size(), 0u);
2037   cl::ResetAllOptionOccurrences();
2038
2039   const char *args3[] = {"prog", "-c"};
2040   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args3));
2041   EXPECT_TRUE(OptA);
2042   EXPECT_TRUE(OptB);
2043   EXPECT_TRUE(OptC);
2044   EXPECT_EQ(List.size(), 0u);
2045   cl::ResetAllOptionOccurrences();
2046
2047   const char *args4[] = {"prog", "--list=foo,bar"};
2048   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args4));
2049   EXPECT_TRUE(OptA);
2050   EXPECT_TRUE(OptB);
2051   EXPECT_TRUE(OptC);
2052   EXPECT_EQ(List.size(), 2u);
2053   cl::ResetAllOptionOccurrences();
2054
2055   const char *args5[] = {"prog", "--list=bar"};
2056   EXPECT_TRUE(cl::ParseCommandLineOptions(2, args5));
2057   EXPECT_FALSE(OptA);
2058   EXPECT_FALSE(OptB);
2059   EXPECT_FALSE(OptC);
2060   EXPECT_EQ(List.size(), 1u);
2061
2062   cl::ResetAllOptionOccurrences();
2063 }
2064
2065 enum Enum { Val1, Val2 };
2066 static cl::bits<Enum> ExampleBits(
2067     cl::desc("An example cl::bits to ensure it compiles"),
2068     cl::values(
2069       clEnumValN(Val1, "bits-val1", "The Val1 value"),
2070       clEnumValN(Val1, "bits-val2", "The Val2 value")));
2071
2072 TEST(CommandLineTest, ConsumeAfterOnePositional) {
2073   cl::ResetCommandLineParser();
2074
2075   // input [args]
2076   StackOption<std::string, cl::opt<std::string>> Input(cl::Positional,
2077                                                        cl::Required);
2078   StackOption<std::string, cl::list<std::string>> ExtraArgs(cl::ConsumeAfter);
2079
2080   const char *Args[] = {"prog", "input", "arg1", "arg2"};
2081
2082   std::string Errs;
2083   raw_string_ostream OS(Errs);
2084   EXPECT_TRUE(cl::ParseCommandLineOptions(4, Args, StringRef(), &OS));
2085   OS.flush();
2086   EXPECT_EQ("input", Input);
2087   EXPECT_EQ(ExtraArgs.size(), 2u);
2088   EXPECT_EQ(ExtraArgs[0], "arg1");
2089   EXPECT_EQ(ExtraArgs[1], "arg2");
2090   EXPECT_TRUE(Errs.empty());
2091 }
2092
2093 TEST(CommandLineTest, ConsumeAfterTwoPositionals) {
2094   cl::ResetCommandLineParser();
2095
2096   // input1 input2 [args]
2097   StackOption<std::string, cl::opt<std::string>> Input1(cl::Positional,
2098                                                         cl::Required);
2099   StackOption<std::string, cl::opt<std::string>> Input2(cl::Positional,
2100                                                         cl::Required);
2101   StackOption<std::string, cl::list<std::string>> ExtraArgs(cl::ConsumeAfter);
2102
2103   const char *Args[] = {"prog", "input1", "input2", "arg1", "arg2"};
2104
2105   std::string Errs;
2106   raw_string_ostream OS(Errs);
2107   EXPECT_TRUE(cl::ParseCommandLineOptions(5, Args, StringRef(), &OS));
2108   OS.flush();
2109   EXPECT_EQ("input1", Input1);
2110   EXPECT_EQ("input2", Input2);
2111   EXPECT_EQ(ExtraArgs.size(), 2u);
2112   EXPECT_EQ(ExtraArgs[0], "arg1");
2113   EXPECT_EQ(ExtraArgs[1], "arg2");
2114   EXPECT_TRUE(Errs.empty());
2115 }
2116
2117 TEST(CommandLineTest, ResetAllOptionOccurrences) {
2118   cl::ResetCommandLineParser();
2119
2120   // -option -str -enableA -enableC [sink] input [args]
2121   StackOption<bool> Option("option");
2122   StackOption<std::string> Str("str");
2123   enum Vals { ValA, ValB, ValC };
2124   StackOption<Vals, cl::bits<Vals>> Bits(
2125       cl::values(clEnumValN(ValA, "enableA", "Enable A"),
2126                  clEnumValN(ValB, "enableB", "Enable B"),
2127                  clEnumValN(ValC, "enableC", "Enable C")));
2128   StackOption<std::string, cl::list<std::string>> Sink(cl::Sink);
2129   StackOption<std::string> Input(cl::Positional);
2130   StackOption<std::string, cl::list<std::string>> ExtraArgs(cl::ConsumeAfter);
2131
2132   const char *Args[] = {"prog",     "-option",  "-str=STR", "-enableA",
2133                         "-enableC", "-unknown", "input",    "-arg"};
2134
2135   std::string Errs;
2136   raw_string_ostream OS(Errs);
2137   EXPECT_TRUE(cl::ParseCommandLineOptions(8, Args, StringRef(), &OS));
2138   EXPECT_TRUE(OS.str().empty());
2139
2140   EXPECT_TRUE(Option);
2141   EXPECT_EQ("STR", Str);
2142   EXPECT_EQ((1u << ValA) | (1u << ValC), Bits.getBits());
2143   EXPECT_EQ(1u, Sink.size());
2144   EXPECT_EQ("-unknown", Sink[0]);
2145   EXPECT_EQ("input", Input);
2146   EXPECT_EQ(1u, ExtraArgs.size());
2147   EXPECT_EQ("-arg", ExtraArgs[0]);
2148
2149   cl::ResetAllOptionOccurrences();
2150   EXPECT_FALSE(Option);
2151   EXPECT_EQ("", Str);
2152   EXPECT_EQ(0u, Bits.getBits());
2153   EXPECT_EQ(0u, Sink.size());
2154   EXPECT_EQ(0, Input.getNumOccurrences());
2155   EXPECT_EQ(0u, ExtraArgs.size());
2156 }
2157
2158 TEST(CommandLineTest, DefaultValue) {
2159   cl::ResetCommandLineParser();
2160
2161   StackOption<bool> BoolOption("bool-option");
2162   StackOption<std::string> StrOption("str-option");
2163   StackOption<bool> BoolInitOption("bool-init-option", cl::init(true));
2164   StackOption<std::string> StrInitOption("str-init-option",
2165                                          cl::init("str-default-value"));
2166
2167   const char *Args[] = {"prog"}; // no options
2168
2169   std::string Errs;
2170   raw_string_ostream OS(Errs);
2171   EXPECT_TRUE(cl::ParseCommandLineOptions(1, Args, StringRef(), &OS));
2172   EXPECT_TRUE(OS.str().empty());
2173
2174   EXPECT_TRUE(!BoolOption);
2175   EXPECT_FALSE(BoolOption.Default.hasValue());
2176   EXPECT_EQ(0, BoolOption.getNumOccurrences());
2177
2178   EXPECT_EQ("", StrOption);
2179   EXPECT_FALSE(StrOption.Default.hasValue());
2180   EXPECT_EQ(0, StrOption.getNumOccurrences());
2181
2182   EXPECT_TRUE(BoolInitOption);
2183   EXPECT_TRUE(BoolInitOption.Default.hasValue());
2184   EXPECT_EQ(0, BoolInitOption.getNumOccurrences());
2185
2186   EXPECT_EQ("str-default-value", StrInitOption);
2187   EXPECT_TRUE(StrInitOption.Default.hasValue());
2188   EXPECT_EQ(0, StrInitOption.getNumOccurrences());
2189
2190   const char *Args2[] = {"prog", "-bool-option", "-str-option=str-value",
2191                          "-bool-init-option=0",
2192                          "-str-init-option=str-init-value"};
2193
2194   EXPECT_TRUE(cl::ParseCommandLineOptions(5, Args2, StringRef(), &OS));
2195   EXPECT_TRUE(OS.str().empty());
2196
2197   EXPECT_TRUE(BoolOption);
2198   EXPECT_FALSE(BoolOption.Default.hasValue());
2199   EXPECT_EQ(1, BoolOption.getNumOccurrences());
2200
2201   EXPECT_EQ("str-value", StrOption);
2202   EXPECT_FALSE(StrOption.Default.hasValue());
2203   EXPECT_EQ(1, StrOption.getNumOccurrences());
2204
2205   EXPECT_FALSE(BoolInitOption);
2206   EXPECT_TRUE(BoolInitOption.Default.hasValue());
2207   EXPECT_EQ(1, BoolInitOption.getNumOccurrences());
2208
2209   EXPECT_EQ("str-init-value", StrInitOption);
2210   EXPECT_TRUE(StrInitOption.Default.hasValue());
2211   EXPECT_EQ(1, StrInitOption.getNumOccurrences());
2212 }
2213
2214 TEST(CommandLineTest, HelpWithoutSubcommands) {
2215   // Check that the help message does not contain the "[subcommand]" placeholder
2216   // and the "SUBCOMMANDS" section if there are no subcommands.
2217   cl::ResetCommandLineParser();
2218   StackOption<bool> Opt("opt", cl::init(false));
2219   const char *args[] = {"prog"};
2220   EXPECT_TRUE(cl::ParseCommandLineOptions(std::size(args), args, StringRef(),
2221                                           &llvm::nulls()));
2222   auto Output = interceptStdout([]() { cl::PrintHelpMessage(); });
2223   EXPECT_NE(std::string::npos, Output.find("USAGE: prog [options]")) << Output;
2224   EXPECT_EQ(std::string::npos, Output.find("SUBCOMMANDS:")) << Output;
2225   cl::ResetCommandLineParser();
2226 }
2227
2228 TEST(CommandLineTest, HelpWithSubcommands) {
2229   // Check that the help message contains the "[subcommand]" placeholder in the
2230   // "USAGE" line and describes subcommands.
2231   cl::ResetCommandLineParser();
2232   StackSubCommand SC1("sc1", "First Subcommand");
2233   StackSubCommand SC2("sc2", "Second Subcommand");
2234   StackOption<bool> SC1Opt("sc1", cl::sub(SC1), cl::init(false));
2235   StackOption<bool> SC2Opt("sc2", cl::sub(SC2), cl::init(false));
2236   const char *args[] = {"prog"};
2237   EXPECT_TRUE(cl::ParseCommandLineOptions(std::size(args), args, StringRef(),
2238                                           &llvm::nulls()));
2239   auto Output = interceptStdout([]() { cl::PrintHelpMessage(); });
2240   EXPECT_NE(std::string::npos,
2241             Output.find("USAGE: prog [subcommand] [options]"))
2242       << Output;
2243   EXPECT_NE(std::string::npos, Output.find("SUBCOMMANDS:")) << Output;
2244   EXPECT_NE(std::string::npos, Output.find("sc1 - First Subcommand")) << Output;
2245   EXPECT_NE(std::string::npos, Output.find("sc2 - Second Subcommand"))
2246       << Output;
2247   cl::ResetCommandLineParser();
2248 }
2249
2250 TEST(CommandLineTest, UnknownCommands) {
2251   cl::ResetCommandLineParser();
2252
2253   StackSubCommand SC1("foo", "Foo subcommand");
2254   StackSubCommand SC2("bar", "Bar subcommand");
2255   StackOption<bool> SC1Opt("put", cl::sub(SC1));
2256   StackOption<bool> SC2Opt("get", cl::sub(SC2));
2257   StackOption<bool> TopOpt1("peek");
2258   StackOption<bool> TopOpt2("set");
2259
2260   std::string Errs;
2261   raw_string_ostream OS(Errs);
2262
2263   const char *Args1[] = {"prog", "baz", "--get"};
2264   EXPECT_FALSE(
2265       cl::ParseCommandLineOptions(std::size(Args1), Args1, StringRef(), &OS));
2266   EXPECT_EQ(Errs,
2267             "prog: Unknown subcommand 'baz'.  Try: 'prog --help'\n"
2268             "prog: Did you mean 'bar'?\n"
2269             "prog: Unknown command line argument '--get'.  Try: 'prog --help'\n"
2270             "prog: Did you mean '--set'?\n");
2271
2272   // Do not show a suggestion if the subcommand is not similar to any known.
2273   Errs.clear();
2274   const char *Args2[] = {"prog", "faz"};
2275   EXPECT_FALSE(
2276       cl::ParseCommandLineOptions(std::size(Args2), Args2, StringRef(), &OS));
2277   EXPECT_EQ(Errs, "prog: Unknown subcommand 'faz'.  Try: 'prog --help'\n");
2278 }
2279
2280 TEST(CommandLineTest, SubCommandGroups) {
2281   // Check that options in subcommand groups are associated with expected
2282   // subcommands.
2283
2284   cl::ResetCommandLineParser();
2285
2286   StackSubCommand SC1("sc1", "SC1 subcommand");
2287   StackSubCommand SC2("sc2", "SC2 subcommand");
2288   StackSubCommand SC3("sc3", "SC3 subcommand");
2289   cl::SubCommandGroup Group12 = {&SC1, &SC2};
2290
2291   StackOption<bool> Opt12("opt12", cl::sub(Group12), cl::init(false));
2292   StackOption<bool> Opt3("opt3", cl::sub(SC3), cl::init(false));
2293
2294   // The "--opt12" option is expected to be added to both subcommands in the
2295   // group, but not to the top-level "no subcommand" pseudo-subcommand or the
2296   // "sc3" subcommand.
2297   EXPECT_EQ(1U, SC1.OptionsMap.size());
2298   EXPECT_TRUE(SC1.OptionsMap.contains("opt12"));
2299
2300   EXPECT_EQ(1U, SC2.OptionsMap.size());
2301   EXPECT_TRUE(SC2.OptionsMap.contains("opt12"));
2302
2303   EXPECT_FALSE(cl::SubCommand::getTopLevel().OptionsMap.contains("opt12"));
2304   EXPECT_FALSE(SC3.OptionsMap.contains("opt12"));
2305 }
2306
2307 TEST(CommandLineTest, HelpWithEmptyCategory) {
2308   cl::ResetCommandLineParser();
2309
2310   cl::OptionCategory Category1("First Category");
2311   cl::OptionCategory Category2("Second Category");
2312   StackOption<int> Opt1("opt1", cl::cat(Category1));
2313   StackOption<int> Opt2("opt2", cl::cat(Category2));
2314   cl::HideUnrelatedOptions(Category2);
2315
2316   const char *args[] = {"prog"};
2317   EXPECT_TRUE(cl::ParseCommandLineOptions(std::size(args), args, StringRef(),
2318                                           &llvm::nulls()));
2319   auto Output = interceptStdout(
2320       []() { cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true); });
2321   EXPECT_EQ(std::string::npos, Output.find("First Category"))
2322       << "An empty category should not be printed";
2323
2324   Output = interceptStdout(
2325       []() { cl::PrintHelpMessage(/*Hidden=*/true, /*Categorized=*/true); });
2326   EXPECT_EQ(std::string::npos, Output.find("First Category"))
2327       << "An empty category should not be printed";
2328
2329   cl::ResetCommandLineParser();
2330 }
2331
2332 } // anonymous namespace