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