llvm-project

1
//===- unittest/Support/OptionParsingTest.cpp - OptTable 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/ADT/STLExtras.h"
10
#include "llvm/Option/Arg.h"
11
#include "llvm/Option/ArgList.h"
12
#include "llvm/Option/OptTable.h"
13
#include "llvm/Option/Option.h"
14
#include "gtest/gtest.h"
15

16
using namespace llvm;
17
using namespace llvm::opt;
18

19
#if defined(__clang__)
20
#pragma clang diagnostic ignored "-Wdeprecated-declarations"
21
#endif
22

23
enum ID {
24
  OPT_INVALID = 0, // This is not an option ID.
25
#define OPTION(...) LLVM_MAKE_OPT_ID(__VA_ARGS__),
26
#include "Opts.inc"
27
  LastOption
28
#undef OPTION
29
};
30

31
#define PREFIX(NAME, VALUE)                                                    \
32
  static constexpr StringLiteral NAME##_init[] = VALUE;                        \
33
  static constexpr ArrayRef<StringLiteral> NAME(NAME##_init,                   \
34
                                                std::size(NAME##_init) - 1);
35
#include "Opts.inc"
36
#undef PREFIX
37

38
static constexpr const StringLiteral PrefixTable_init[] =
39
#define PREFIX_UNION(VALUES) VALUES
40
#include "Opts.inc"
41
#undef PREFIX_UNION
42
    ;
43
static constexpr const ArrayRef<StringLiteral>
44
    PrefixTable(PrefixTable_init, std::size(PrefixTable_init) - 1);
45

46
enum OptionFlags {
47
  OptFlag1 = (1 << 4),
48
  OptFlag2 = (1 << 5),
49
  OptFlag3 = (1 << 6)
50
};
51

52
enum OptionVisibility {
53
  SubtoolVis = (1 << 2),
54
  MultiLineVis = (1 << 3),
55
};
56

57
static constexpr OptTable::Info InfoTable[] = {
58
#define OPTION(...) LLVM_CONSTRUCT_OPT_INFO(__VA_ARGS__),
59
#include "Opts.inc"
60
#undef OPTION
61
};
62

63
namespace {
64
class TestOptTable : public GenericOptTable {
65
public:
66
  TestOptTable(bool IgnoreCase = false)
67
      : GenericOptTable(InfoTable, IgnoreCase) {}
68
};
69

70
class TestPrecomputedOptTable : public PrecomputedOptTable {
71
public:
72
  TestPrecomputedOptTable(bool IgnoreCase = false)
73
      : PrecomputedOptTable(InfoTable, PrefixTable, IgnoreCase) {}
74
};
75
}
76

77
const char *Args[] = {
78
  "-A",
79
  "-Bhi",
80
  "--C=desu",
81
  "-C", "bye",
82
  "-D,adena",
83
  "-E", "apple", "bloom",
84
  "-Fblarg",
85
  "-F", "42",
86
  "-Gchuu", "2"
87
  };
88

89
// Test fixture
90
template <typename T> class OptTableTest : public ::testing::Test {};
91

92
template <typename T> class DISABLED_OptTableTest : public ::testing::Test {};
93

94
// Test both precomputed and computed OptTables with the same suite of tests.
95
using OptTableTestTypes =
96
    ::testing::Types<TestOptTable, TestPrecomputedOptTable>;
97

98
TYPED_TEST_SUITE(OptTableTest, OptTableTestTypes, );
99
TYPED_TEST_SUITE(DISABLED_OptTableTest, OptTableTestTypes, );
100

101
TYPED_TEST(OptTableTest, OptionParsing) {
102
  TypeParam T;
103
  unsigned MAI, MAC;
104
  InputArgList AL = T.ParseArgs(Args, MAI, MAC);
105

106
  // Check they all exist.
107
  EXPECT_TRUE(AL.hasArg(OPT_A));
108
  EXPECT_TRUE(AL.hasArg(OPT_B));
109
  EXPECT_TRUE(AL.hasArg(OPT_C));
110
  EXPECT_TRUE(AL.hasArg(OPT_D));
111
  EXPECT_TRUE(AL.hasArg(OPT_E));
112
  EXPECT_TRUE(AL.hasArg(OPT_F));
113
  EXPECT_TRUE(AL.hasArg(OPT_G));
114

115
  // Check the values.
116
  EXPECT_EQ("hi", AL.getLastArgValue(OPT_B));
117
  EXPECT_EQ("bye", AL.getLastArgValue(OPT_C));
118
  EXPECT_EQ("adena", AL.getLastArgValue(OPT_D));
119
  std::vector<std::string> Es = AL.getAllArgValues(OPT_E);
120
  EXPECT_EQ("apple", Es[0]);
121
  EXPECT_EQ("bloom", Es[1]);
122
  EXPECT_EQ("42", AL.getLastArgValue(OPT_F));
123
  std::vector<std::string> Gs = AL.getAllArgValues(OPT_G);
124
  EXPECT_EQ("chuu", Gs[0]);
125
  EXPECT_EQ("2", Gs[1]);
126

127
  // Check the help text.
128
  std::string Help;
129
  raw_string_ostream RSO(Help);
130
  T.printHelp(RSO, "test", "title!");
131
  EXPECT_NE(std::string::npos, Help.find("-A"));
132

133
  // Check usage line.
134
  T.printHelp(RSO, "name [options] file...", "title!");
135
  EXPECT_NE(std::string::npos, Help.find("USAGE: name [options] file...\n"));
136

137
  // Test aliases.
138
  auto Cs = AL.filtered(OPT_C);
139
  ASSERT_NE(Cs.begin(), Cs.end());
140
  EXPECT_EQ("desu", StringRef((*Cs.begin())->getValue()));
141
  ArgStringList ASL;
142
  (*Cs.begin())->render(AL, ASL);
143
  ASSERT_EQ(2u, ASL.size());
144
  EXPECT_EQ("-C", StringRef(ASL[0]));
145
  EXPECT_EQ("desu", StringRef(ASL[1]));
146
}
147

148
TYPED_TEST(OptTableTest, ParseWithFlagExclusions) {
149
  TypeParam T;
150
  unsigned MAI, MAC;
151

152
  // Exclude flag3 to avoid parsing as OPT_SLASH_C.
153
  InputArgList AL = T.ParseArgs(Args, MAI, MAC,
154
                                /*FlagsToInclude=*/0,
155
                                /*FlagsToExclude=*/OptFlag3);
156
  EXPECT_TRUE(AL.hasArg(OPT_A));
157
  EXPECT_TRUE(AL.hasArg(OPT_C));
158
  EXPECT_FALSE(AL.hasArg(OPT_SLASH_C));
159

160
  // Exclude flag1 to avoid parsing as OPT_C.
161
  AL = T.ParseArgs(Args, MAI, MAC,
162
                   /*FlagsToInclude=*/0,
163
                   /*FlagsToExclude=*/OptFlag1);
164
  EXPECT_TRUE(AL.hasArg(OPT_B));
165
  EXPECT_FALSE(AL.hasArg(OPT_C));
166
  EXPECT_TRUE(AL.hasArg(OPT_SLASH_C));
167

168
  const char *NewArgs[] = { "/C", "foo", "--C=bar" };
169
  AL = T.ParseArgs(NewArgs, MAI, MAC);
170
  EXPECT_TRUE(AL.hasArg(OPT_SLASH_C));
171
  EXPECT_TRUE(AL.hasArg(OPT_C));
172
  EXPECT_EQ("foo", AL.getLastArgValue(OPT_SLASH_C));
173
  EXPECT_EQ("bar", AL.getLastArgValue(OPT_C));
174
}
175

176
TYPED_TEST(OptTableTest, ParseWithVisibility) {
177
  TypeParam T;
178
  unsigned MAI, MAC;
179

180
  const char *STArgs[] = {"-A", "-Q", "-R"};
181

182
  // With no visibility specified, we find all of the arguments.
183
  InputArgList AL = T.ParseArgs(STArgs, MAI, MAC);
184
  EXPECT_TRUE(AL.hasArg(OPT_A));
185
  EXPECT_TRUE(AL.hasArg(OPT_Q));
186
  EXPECT_TRUE(AL.hasArg(OPT_R));
187

188
  // Default visibility omits SubtoolVis.
189
  AL = T.ParseArgs(STArgs, MAI, MAC, Visibility(DefaultVis));
190
  EXPECT_TRUE(AL.hasArg(OPT_A));
191
  EXPECT_FALSE(AL.hasArg(OPT_Q));
192
  EXPECT_TRUE(AL.hasArg(OPT_R));
193

194
  // ~SubtoolVis still finds arguments that are visible in Default.
195
  AL = T.ParseArgs(STArgs, MAI, MAC, Visibility(~SubtoolVis));
196
  EXPECT_TRUE(AL.hasArg(OPT_A));
197
  EXPECT_FALSE(AL.hasArg(OPT_Q));
198
  EXPECT_TRUE(AL.hasArg(OPT_R));
199

200
  // Only SubtoolVis.
201
  AL = T.ParseArgs(STArgs, MAI, MAC, Visibility(SubtoolVis));
202
  EXPECT_FALSE(AL.hasArg(OPT_A));
203
  EXPECT_TRUE(AL.hasArg(OPT_Q));
204
  EXPECT_TRUE(AL.hasArg(OPT_R));
205

206
  // Both Default and SubtoolVis are found.
207
  AL = T.ParseArgs(STArgs, MAI, MAC, Visibility(DefaultVis | SubtoolVis));
208
  EXPECT_TRUE(AL.hasArg(OPT_A));
209
  EXPECT_TRUE(AL.hasArg(OPT_Q));
210
  EXPECT_TRUE(AL.hasArg(OPT_R));
211
}
212

213
TYPED_TEST(OptTableTest, ParseAliasInGroup) {
214
  TypeParam T;
215
  unsigned MAI, MAC;
216

217
  const char *MyArgs[] = { "-I" };
218
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
219
  EXPECT_TRUE(AL.hasArg(OPT_H));
220
}
221

222
TYPED_TEST(OptTableTest, AliasArgs) {
223
  TypeParam T;
224
  unsigned MAI, MAC;
225

226
  const char *MyArgs[] = { "-J", "-Joo" };
227
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
228
  EXPECT_TRUE(AL.hasArg(OPT_B));
229
  EXPECT_EQ("foo", AL.getAllArgValues(OPT_B)[0]);
230
  EXPECT_EQ("bar", AL.getAllArgValues(OPT_B)[1]);
231
}
232

233
TYPED_TEST(OptTableTest, IgnoreCase) {
234
  TypeParam T(true);
235
  unsigned MAI, MAC;
236

237
  const char *MyArgs[] = { "-a", "-joo" };
238
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
239
  EXPECT_TRUE(AL.hasArg(OPT_A));
240
  EXPECT_TRUE(AL.hasArg(OPT_B));
241
}
242

243
#if defined(__clang__)
244
// Disable the warning that triggers on exactly what is being tested.
245
#pragma clang diagnostic push
246
#pragma clang diagnostic ignored "-Wself-move"
247
#endif
248

249
TYPED_TEST(OptTableTest, InputArgListSelfAssign) {
250
  TypeParam T;
251
  unsigned MAI, MAC;
252
  InputArgList AL = T.ParseArgs(Args, MAI, MAC,
253
                                /*FlagsToInclude=*/0,
254
                                /*FlagsToExclude=*/OptFlag3);
255
  EXPECT_TRUE(AL.hasArg(OPT_A));
256
  EXPECT_TRUE(AL.hasArg(OPT_C));
257
  EXPECT_FALSE(AL.hasArg(OPT_SLASH_C));
258

259
  AL = std::move(AL);
260

261
  EXPECT_TRUE(AL.hasArg(OPT_A));
262
  EXPECT_TRUE(AL.hasArg(OPT_C));
263
  EXPECT_FALSE(AL.hasArg(OPT_SLASH_C));
264
}
265

266
#if defined(__clang__)
267
#pragma clang diagnostic pop
268
#endif
269

270
TYPED_TEST(OptTableTest, DoNotIgnoreCase) {
271
  TypeParam T;
272
  unsigned MAI, MAC;
273

274
  const char *MyArgs[] = { "-a", "-joo" };
275
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
276
  EXPECT_FALSE(AL.hasArg(OPT_A));
277
  EXPECT_FALSE(AL.hasArg(OPT_B));
278
}
279

280
TYPED_TEST(OptTableTest, SlurpEmpty) {
281
  TypeParam T;
282
  unsigned MAI, MAC;
283

284
  const char *MyArgs[] = { "-A", "-slurp" };
285
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
286
  EXPECT_TRUE(AL.hasArg(OPT_A));
287
  EXPECT_TRUE(AL.hasArg(OPT_Slurp));
288
  EXPECT_EQ(0U, AL.getAllArgValues(OPT_Slurp).size());
289
}
290

291
TYPED_TEST(OptTableTest, Slurp) {
292
  TypeParam T;
293
  unsigned MAI, MAC;
294

295
  const char *MyArgs[] = { "-A", "-slurp", "-B", "--", "foo" };
296
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
297
  EXPECT_EQ(AL.size(), 2U);
298
  EXPECT_TRUE(AL.hasArg(OPT_A));
299
  EXPECT_FALSE(AL.hasArg(OPT_B));
300
  EXPECT_TRUE(AL.hasArg(OPT_Slurp));
301
  EXPECT_EQ(3U, AL.getAllArgValues(OPT_Slurp).size());
302
  EXPECT_EQ("-B", AL.getAllArgValues(OPT_Slurp)[0]);
303
  EXPECT_EQ("--", AL.getAllArgValues(OPT_Slurp)[1]);
304
  EXPECT_EQ("foo", AL.getAllArgValues(OPT_Slurp)[2]);
305
}
306

307
TYPED_TEST(OptTableTest, SlurpJoinedEmpty) {
308
  TypeParam T;
309
  unsigned MAI, MAC;
310

311
  const char *MyArgs[] = { "-A", "-slurpjoined" };
312
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
313
  EXPECT_TRUE(AL.hasArg(OPT_A));
314
  EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
315
  EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 0U);
316
}
317

318
TYPED_TEST(OptTableTest, SlurpJoinedOneJoined) {
319
  TypeParam T;
320
  unsigned MAI, MAC;
321

322
  const char *MyArgs[] = { "-A", "-slurpjoinedfoo" };
323
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
324
  EXPECT_TRUE(AL.hasArg(OPT_A));
325
  EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
326
  EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 1U);
327
  EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined)[0], "foo");
328
}
329

330
TYPED_TEST(OptTableTest, SlurpJoinedAndSeparate) {
331
  TypeParam T;
332
  unsigned MAI, MAC;
333

334
  const char *MyArgs[] = { "-A", "-slurpjoinedfoo", "bar", "baz" };
335
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
336
  EXPECT_TRUE(AL.hasArg(OPT_A));
337
  EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
338
  EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
339
  EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
340
  EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
341
  EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
342
}
343

344
TYPED_TEST(OptTableTest, SlurpJoinedButSeparate) {
345
  TypeParam T;
346
  unsigned MAI, MAC;
347

348
  const char *MyArgs[] = { "-A", "-slurpjoined", "foo", "bar", "baz" };
349
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
350
  EXPECT_TRUE(AL.hasArg(OPT_A));
351
  EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
352
  EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
353
  EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
354
  EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
355
  EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
356
}
357

358
TYPED_TEST(OptTableTest, FlagAliasToJoined) {
359
  TypeParam T;
360
  unsigned MAI, MAC;
361

362
  // Check that a flag alias provides an empty argument to a joined option.
363
  const char *MyArgs[] = { "-K" };
364
  InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
365
  EXPECT_EQ(AL.size(), 1U);
366
  EXPECT_TRUE(AL.hasArg(OPT_B));
367
  EXPECT_EQ(1U, AL.getAllArgValues(OPT_B).size());
368
  EXPECT_EQ("", AL.getAllArgValues(OPT_B)[0]);
369
}
370

371
TYPED_TEST(OptTableTest, FindNearest) {
372
  TypeParam T;
373
  std::string Nearest;
374

375
  // Options that are too short should not be considered
376
  // "near" other short options.
377
  EXPECT_GT(T.findNearest("-A", Nearest), 4U);
378
  EXPECT_GT(T.findNearest("/C", Nearest), 4U);
379
  EXPECT_GT(T.findNearest("--C=foo", Nearest), 4U);
380

381
  // The nearest candidate should mirror the amount of prefix
382
  // characters used in the original string.
383
  EXPECT_EQ(1U, T.findNearest("-blorb", Nearest));
384
  EXPECT_EQ(Nearest, "-blorp");
385
  EXPECT_EQ(1U, T.findNearest("--blorm", Nearest));
386
  EXPECT_EQ(Nearest, "--blorp");
387
  EXPECT_EQ(1U, T.findNearest("-blarg", Nearest));
388
  EXPECT_EQ(Nearest, "-blarn");
389
  EXPECT_EQ(1U, T.findNearest("--blarm", Nearest));
390
  EXPECT_EQ(Nearest, "--blarn");
391
  EXPECT_EQ(1U, T.findNearest("-fjormp", Nearest));
392
  EXPECT_EQ(Nearest, "--fjormp");
393

394
  // The nearest candidate respects the prefix and value delimiter
395
  // of the original string.
396
  EXPECT_EQ(1U, T.findNearest("/framb:foo", Nearest));
397
  EXPECT_EQ(Nearest, "/cramb:foo");
398

399
  // `--glormp` should have an editing distance > 0 from `--glormp=`.
400
  EXPECT_GT(T.findNearest("--glorrmp", Nearest), 0U);
401
  EXPECT_EQ(Nearest, "--glorrmp=");
402
  EXPECT_EQ(0U, T.findNearest("--glorrmp=foo", Nearest));
403

404
  // `--blurmps` should correct to `--blurmp`, not `--blurmp=`, even though
405
  // both naively have an editing distance of 1.
406
  EXPECT_EQ(1U, T.findNearest("--blurmps", Nearest));
407
  EXPECT_EQ(Nearest, "--blurmp");
408

409
  // ...but `--blurmps=foo` should correct to `--blurmp=foo`.
410
  EXPECT_EQ(1U, T.findNearest("--blurmps=foo", Nearest));
411
  EXPECT_EQ(Nearest, "--blurmp=foo");
412

413
  // Flags should be included and excluded as specified.
414
  EXPECT_EQ(1U, T.findNearest("-doopf", Nearest,
415
                              /*FlagsToInclude=*/OptFlag2,
416
                              /*FlagsToExclude=*/0));
417
  EXPECT_EQ(Nearest, "-doopf2");
418
  EXPECT_EQ(1U, T.findNearest("-doopf", Nearest,
419
                              /*FlagsToInclude=*/0,
420
                              /*FlagsToExclude=*/OptFlag2));
421
  EXPECT_EQ(Nearest, "-doopf1");
422

423
  // Spelling should respect visibility.
424
  EXPECT_EQ(1U, T.findNearest("-xyzzy", Nearest, Visibility(DefaultVis)));
425
  EXPECT_EQ(Nearest, "-xyzzy2");
426
  EXPECT_EQ(1U, T.findNearest("-xyzzy", Nearest, Visibility(SubtoolVis)));
427
  EXPECT_EQ(Nearest, "-xyzzy1");
428
}
429

430
TYPED_TEST(DISABLED_OptTableTest, FindNearestFIXME) {
431
  TypeParam T;
432
  std::string Nearest;
433

434
  // FIXME: Options with joined values should not have those values considered
435
  // when calculating distance. The test below would fail if run, but it should
436
  // succeed.
437
  EXPECT_EQ(1U, T.findNearest("--erbghFoo", Nearest));
438
  EXPECT_EQ(Nearest, "--ermghFoo");
439
}
440

441
TYPED_TEST(OptTableTest, ParseGroupedShortOptions) {
442
  TypeParam T;
443
  T.setGroupedShortOptions(true);
444
  unsigned MAI, MAC;
445

446
  // Grouped short options can be followed by a long Flag (-Joo), or a non-Flag
447
  // option (-C=1).
448
  const char *Args1[] = {"-AIJ", "-AIJoo", "-AC=1"};
449
  InputArgList AL = T.ParseArgs(Args1, MAI, MAC);
450
  EXPECT_TRUE(AL.hasArg(OPT_A));
451
  EXPECT_TRUE(AL.hasArg(OPT_H));
452
  ASSERT_EQ((size_t)2, AL.getAllArgValues(OPT_B).size());
453
  EXPECT_EQ("foo", AL.getAllArgValues(OPT_B)[0]);
454
  EXPECT_EQ("bar", AL.getAllArgValues(OPT_B)[1]);
455
  ASSERT_TRUE(AL.hasArg(OPT_C));
456
  EXPECT_EQ("1", AL.getAllArgValues(OPT_C)[0]);
457

458
  // Prefer a long option to a short option.
459
  const char *Args2[] = {"-AB"};
460
  InputArgList AL2 = T.ParseArgs(Args2, MAI, MAC);
461
  EXPECT_TRUE(!AL2.hasArg(OPT_A));
462
  EXPECT_TRUE(AL2.hasArg(OPT_AB));
463

464
  // Short options followed by a long option. We probably should disallow this.
465
  const char *Args3[] = {"-AIblorp"};
466
  InputArgList AL3 = T.ParseArgs(Args3, MAI, MAC);
467
  EXPECT_TRUE(AL3.hasArg(OPT_A));
468
  EXPECT_TRUE(AL3.hasArg(OPT_Blorp));
469
}
470

471
TYPED_TEST(OptTableTest, ParseDashDash) {
472
  TypeParam T;
473
  T.setDashDashParsing(true);
474
  unsigned MAI, MAC;
475

476
  const char *Args1[] = {"-A", "--"};
477
  InputArgList AL = T.ParseArgs(Args1, MAI, MAC);
478
  EXPECT_TRUE(AL.hasArg(OPT_A));
479
  EXPECT_EQ(size_t(0), AL.getAllArgValues(OPT_INPUT).size());
480
  EXPECT_EQ(size_t(0), AL.getAllArgValues(OPT_UNKNOWN).size());
481

482
  const char *Args2[] = {"-A", "--", "-A", "--", "-B"};
483
  AL = T.ParseArgs(Args2, MAI, MAC);
484
  EXPECT_TRUE(AL.hasArg(OPT_A));
485
  EXPECT_FALSE(AL.hasArg(OPT_B));
486
  const std::vector<std::string> Input = AL.getAllArgValues(OPT_INPUT);
487
  ASSERT_EQ(size_t(3), Input.size());
488
  EXPECT_EQ("-A", Input[0]);
489
  EXPECT_EQ("--", Input[1]);
490
  EXPECT_EQ("-B", Input[2]);
491
  EXPECT_EQ(size_t(0), AL.getAllArgValues(OPT_UNKNOWN).size());
492

493
  T.setDashDashParsing(false);
494
  AL = T.ParseArgs(Args2, MAI, MAC);
495
  EXPECT_TRUE(AL.hasArg(OPT_A));
496
  EXPECT_TRUE(AL.hasArg(OPT_B));
497
  EXPECT_EQ(size_t(0), AL.getAllArgValues(OPT_INPUT).size());
498
  const std::vector<std::string> Unknown = AL.getAllArgValues(OPT_UNKNOWN);
499
  ASSERT_EQ(size_t(2), Unknown.size());
500
  EXPECT_EQ("--", Unknown[0]);
501
  EXPECT_EQ("--", Unknown[1]);
502
}
503

504
TYPED_TEST(OptTableTest, UnknownOptions) {
505
  TypeParam T;
506
  unsigned MAI, MAC;
507
  const char *Args[] = {"-u", "--long", "0"};
508
  for (int I = 0; I < 2; ++I) {
509
    T.setGroupedShortOptions(I != 0);
510
    InputArgList AL = T.ParseArgs(Args, MAI, MAC);
511
    const std::vector<std::string> Unknown = AL.getAllArgValues(OPT_UNKNOWN);
512
    ASSERT_EQ((size_t)2, Unknown.size());
513
    EXPECT_EQ("-u", Unknown[0]);
514
    EXPECT_EQ("--long", Unknown[1]);
515
  }
516
}
517

518
TYPED_TEST(OptTableTest, FlagsWithoutValues) {
519
  TypeParam T;
520
  T.setGroupedShortOptions(true);
521
  unsigned MAI, MAC;
522
  const char *Args[] = {"-A=1", "-A="};
523
  InputArgList AL = T.ParseArgs(Args, MAI, MAC);
524
  const std::vector<std::string> Unknown = AL.getAllArgValues(OPT_UNKNOWN);
525
  ASSERT_EQ((size_t)2, Unknown.size());
526
  EXPECT_EQ("-A=1", Unknown[0]);
527
  EXPECT_EQ("-A=", Unknown[1]);
528
}
529

530
TYPED_TEST(OptTableTest, UnknownGroupedShortOptions) {
531
  TypeParam T;
532
  T.setGroupedShortOptions(true);
533
  unsigned MAI, MAC;
534
  const char *Args[] = {"-AuzK", "-AuzK"};
535
  InputArgList AL = T.ParseArgs(Args, MAI, MAC);
536
  const std::vector<std::string> Unknown = AL.getAllArgValues(OPT_UNKNOWN);
537
  ASSERT_EQ((size_t)4, Unknown.size());
538
  EXPECT_EQ("-u", Unknown[0]);
539
  EXPECT_EQ("-z", Unknown[1]);
540
  EXPECT_EQ("-u", Unknown[2]);
541
  EXPECT_EQ("-z", Unknown[3]);
542
}
543

544
TYPED_TEST(OptTableTest, PrintMultilineHelpText) {
545
  TypeParam T;
546
  std::string Help;
547
  raw_string_ostream RSO(Help);
548
  T.printHelp(RSO, "usage", "title", /*ShowHidden=*/false,
549
              /*ShowAllAliases=*/false, Visibility(MultiLineVis));
550
  EXPECT_STREQ(Help.c_str(), R"(OVERVIEW: title
551

552
USAGE: usage
553

554
OPTIONS:
555
  -multiline-help-with-long-name
556
                  This a help text that has
557
                  multiple lines in it
558
                  and a long name
559
  -multiline-help This a help text that has
560
                  multiple lines in it
561
)");
562
}
563