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 2075