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