Debian Codegraph @

packages/stk/stk_unit_tests/stk_util/command_line/UnitTestCommandLineParser.cpp

raw
1 #include "gtest/gtest.h"
2 #include "stk_util/command_line/CommandLineParser.hpp" // for CommandLineParser, CommandLinePar...
3 #include "stk_util/command_line/CommandLineParserUtils.hpp"
4 #include <exception> // for exception
5 #include <string> // for string
6 #include <vector> // for vector
7
8 namespace {
9
10 class Args
11 {
12 public:
13 Args(const std::vector<std::string> & strArgs)
14 : m_stringArgs(strArgs),
15 m_argc(m_stringArgs.size()),
16 m_argv(strArgs.empty() ? nullptr : new char*[m_argc])
17 {
18 for (int i = 0; i < m_argc; ++i) {
19 m_argv[i] = const_cast<char*>(m_stringArgs[i].c_str());
20 }
21 }
22
23 ~Args()
24 {
25 delete [] m_argv;
26 }
27
28 int argc() { return m_argc; }
29 char** argv() { return m_argv; }
30
31 private:
32 const std::vector<std::string> m_stringArgs;
33 int m_argc;
34 char** m_argv;
35 };
36
37 TEST(UnitTestGetOption, get_command_line_option_null)
38 {
39 Args args({});
40 int defaultValue = -1;
41 int result = stk::get_command_line_option(args.argc(), args.argv(), "foo", defaultValue);
42 EXPECT_EQ(defaultValue, result);
43 }
44
45 TEST(UnitTestGetOption, get_command_line_option_bad_arg)
46 {
47 if (stk::parallel_machine_size(MPI_COMM_WORLD) != 2) { return; }
48
49 int myRank = stk::parallel_machine_rank(MPI_COMM_WORLD);
50 Args args({"exe", "--garbage-color", std::to_string(myRank)});
51 int defaultValue = 0;
52
53 testing::internal::CaptureStderr();
54 int result = stk::get_command_line_option(args.argc(), args.argv(), "app-color", defaultValue);
55 testing::internal::GetCapturedStderr();
56 EXPECT_EQ(defaultValue, result);
57 }
58
59 TEST(UnitTestGetOption, get_command_line_option_no_value)
60 {
61 if (stk::parallel_machine_size(MPI_COMM_WORLD) != 2) { return; }
62
63 Args args({"exe", "--app-color"});
64 int defaultValue = -1;
65
66 testing::internal::CaptureStderr();
67 EXPECT_THROW(stk::get_command_line_option(args.argc(), args.argv(), "app-color", defaultValue), std::runtime_error);
68 testing::internal::GetCapturedStderr();
69 }
70
71 TEST(UnitTestGetOption, get_command_line_option_non_int_value)
72 {
73 if (stk::parallel_machine_size(MPI_COMM_WORLD) != 2) { return; }
74
75 Args args({"exe", "--app-color", "foo"});
76 int defaultValue = -1;
77
78 EXPECT_THROW(stk::get_command_line_option(args.argc(), args.argv(), "app-color", defaultValue), std::logic_error);
79 }
80
81 TEST(UnitTestGetOption, get_command_line_option)
82 {
83 if (stk::parallel_machine_size(MPI_COMM_WORLD) != 2) { return; }
84
85 int myRank = stk::parallel_machine_rank(MPI_COMM_WORLD);
86 Args args({"exe", "--my-color", std::to_string(myRank)});
87 int defaultColor = -1;
88
89 int expectedResult = myRank;
90 int result = stk::get_command_line_option(args.argc(), args.argv(), "my-color", defaultColor);
91 EXPECT_EQ(expectedResult, result);
92 }
93
94
95 bool messageContains(const std::string & errorMsg, const std::string & containedString) {
96 return (errorMsg.find(containedString) != std::string::npos);
97 }
98
99 bool parse_command_line_without_error(stk::CommandLineParser & parser, Args & args)
100 {
101 return parser.parse(args.argc(), const_cast<const char**>(args.argv())) == stk::CommandLineParser::ParseComplete;
102 }
103
104 bool parse_command_line_with_help(stk::CommandLineParser & parser, Args & args)
105 {
106 testing::internal::CaptureStderr();
107
108 const bool requestedHelpDuringParse = parser.parse(args.argc(), const_cast<const char**>(args.argv())) == stk::CommandLineParser::ParseHelpOnly;
109 EXPECT_TRUE(requestedHelpDuringParse);
110
111 const std::string output = testing::internal::GetCapturedStderr();
112 const bool printedNoOutput = output.empty();
113 EXPECT_EQ(printedNoOutput, true) << "Actual output: " << output;
114
115 return requestedHelpDuringParse && printedNoOutput;
116 }
117
118 bool parse_command_line_with_version(stk::CommandLineParser & parser, Args & args)
119 {
120 testing::internal::CaptureStderr();
121
122 const bool requestedVersionDuringParse = parser.parse(args.argc(), const_cast<const char**>(args.argv())) == stk::CommandLineParser::ParseVersionOnly;
123 EXPECT_TRUE(requestedVersionDuringParse);
124
125 const std::string output = testing::internal::GetCapturedStderr();
126 const bool printedNoOutput = output.empty();
127 EXPECT_EQ(printedNoOutput, true) << "Actual output: " << output;
128
129 return requestedVersionDuringParse && printedNoOutput;
130 }
131
132 bool parse_command_line_with_error(stk::CommandLineParser & parser, Args & args, const std::string & expectedErrorText)
133 {
134 testing::internal::CaptureStderr();
135
136 const bool hadErrorDuringParse = parser.parse(args.argc(), const_cast<const char**>(args.argv())) == stk::CommandLineParser::ParseError;
137 EXPECT_TRUE(hadErrorDuringParse);
138
139 const std::string errorMessage = testing::internal::GetCapturedStderr();
140 const bool hadExpectedErrorMessage = messageContains(errorMessage, expectedErrorText);
141 EXPECT_EQ(hadExpectedErrorMessage, true) << "Actual error message: " << errorMessage;
142
143 return hadErrorDuringParse && hadExpectedErrorMessage;
144 }
145
146 //==============================================================================
147 TEST(CommandLineParser, oneFlag_notProvided_querySaysNotProvided)
148 {
149 stk::CommandLineParser parser;
150 parser.add_flag("flag,f", "One flag description");
151
152 Args args({"exe"});
153 EXPECT_TRUE(parse_command_line_without_error(parser, args));
154
155 EXPECT_TRUE(parser.is_empty());
156 EXPECT_FALSE(parser.is_option_parsed("flag"));
157 EXPECT_FALSE(parser.is_option_provided("flag"));
158 }
159
160 TEST(CommandLineParser, oneFlag_provided_querySaysProvided)
161 {
162 stk::CommandLineParser parser;
163 parser.add_flag("flag,f", "One flag description");
164
165 Args args({"exe", "--flag"});
166 EXPECT_TRUE(parse_command_line_without_error(parser, args));
167
168 EXPECT_FALSE(parser.is_empty());
169 EXPECT_TRUE(parser.is_option_parsed("flag"));
170 EXPECT_TRUE(parser.is_option_provided("flag"));
171 }
172
173 TEST(CommandLineParser, oneFlag_shortProvided_querySaysProvided)
174 {
175 stk::CommandLineParser parser;
176 parser.add_flag("flag,f", "One flag description");
177
178 Args args({"exe", "-f"});
179 EXPECT_TRUE(parse_command_line_without_error(parser, args));
180
181 EXPECT_FALSE(parser.is_empty());
182 EXPECT_TRUE(parser.is_option_parsed("flag"));
183 EXPECT_TRUE(parser.is_option_provided("flag"));
184 }
185
186
187 //==============================================================================
188 TEST(CommandLineParser, oneRequiredPositional_notProvided_printsErrorDuringParse_getValueThrows)
189 {
190 stk::CommandLineParser parser;
191 parser.add_required_positional<std::string>({"positionalOpt", "p", "One required positional description"});
192
193 Args args({"exe"});
194 EXPECT_TRUE(parse_command_line_with_error(parser, args, ""));
195
196 EXPECT_TRUE(parser.is_empty());
197 EXPECT_FALSE(parser.is_option_parsed("positionalOpt"));
198 EXPECT_FALSE(parser.is_option_provided("positionalOpt"));
199
200 EXPECT_THROW(parser.get_option_value<std::string>("positionalOpt"), std::logic_error);
201 }
202
203 TEST(CommandLineParser, oneRequiredPositional_valueProvided_getValueReturnsProvided)
204 {
205 stk::CommandLineParser parser;
206 parser.add_required_positional<std::string>({"positionalOpt", "p", "One required positional description"});
207
208 Args args({"exe", "positionalValue"});
209 EXPECT_TRUE(parse_command_line_without_error(parser, args));
210
211 EXPECT_FALSE(parser.is_empty());
212 EXPECT_FALSE(parser.is_option_parsed("positionalOpt"));
213 EXPECT_TRUE(parser.is_option_provided("positionalOpt"));
214
215 EXPECT_EQ(parser.get_option_value<std::string>("positionalOpt"), "positionalValue");
216 }
217
218 TEST(CommandLineParser, oneRequiredPositional_optionAndValueProvided_getValueReturnsProvided)
219 {
220 stk::CommandLineParser parser;
221 parser.add_required_positional<std::string>({"positionalOpt", "p", "One required positional description"});
222
223 Args args({"exe", "--positionalOpt=positionalValue"});
224 EXPECT_TRUE(parse_command_line_without_error(parser, args));
225
226 EXPECT_FALSE(parser.is_empty());
227 EXPECT_TRUE(parser.is_option_parsed("positionalOpt"));
228 EXPECT_TRUE(parser.is_option_provided("positionalOpt"));
229
230 EXPECT_EQ(parser.get_option_value<std::string>("positionalOpt"), "positionalValue");
231 }
232
233 TEST(CommandLineParser, twoPositionals_flaggedFirstValueAndPositionalSecondValue)
234 {
235 stk::CommandLineParser parser;
236 parser.add_required_positional<std::string>({"firstOption", "f", "First (required) positional description"});
237 parser.add_optional_positional<std::string>({"secondOption", "s", "Second (optional) positional description"}, "defaultValue");
238
239 Args args({"exe", "--firstOption", "valueFirst", "valueSecond"});
240 EXPECT_TRUE(parse_command_line_without_error(parser, args));
241
242 EXPECT_FALSE(parser.is_empty());
243 EXPECT_TRUE(parser.is_option_parsed("firstOption"));
244 EXPECT_TRUE(parser.is_option_provided("secondOption"));
245
246 EXPECT_EQ(parser.get_option_value<std::string>("firstOption"), "valueFirst");
247 EXPECT_EQ(parser.get_option_value<std::string>("secondOption"), "valueSecond");
248 }
249
250 TEST(CommandLineParser, twoPositionals_flaggedSecondValueThenPositionalFirstValue)
251 {
252 stk::CommandLineParser parser;
253 parser.add_required_positional<std::string>({"firstOption", "f", "First (required) positional description"});
254 parser.add_optional_positional<std::string>({"secondOption", "s", "Second (optional) positional description"}, "defaultValue");
255
256 Args args({"exe", "--secondOption", "valueSecond", "valueFirst"});
257 EXPECT_TRUE(parse_command_line_without_error(parser, args));
258
259 EXPECT_FALSE(parser.is_empty());
260 EXPECT_TRUE(parser.is_option_provided("firstOption"));
261 EXPECT_TRUE(parser.is_option_parsed("secondOption"));
262
263 EXPECT_EQ(parser.get_option_value<std::string>("firstOption"), "valueFirst");
264 EXPECT_EQ(parser.get_option_value<std::string>("secondOption"), "valueSecond");
265 }
266
267 TEST(CommandLineParser, twoPositionals_positionalFirstValueAndFlaggedSecondValue)
268 {
269 stk::CommandLineParser parser;
270 parser.add_required_positional<std::string>({"firstOption", "f", "First (required) positional description"});
271 parser.add_optional_positional<std::string>({"secondOption", "s", "Second (optional) positional description"}, "defaultValue");
272
273 Args args({"exe", "valueFirst", "--secondOption", "valueSecond"});
274 EXPECT_TRUE(parse_command_line_without_error(parser, args));
275
276 EXPECT_FALSE(parser.is_empty());
277 EXPECT_TRUE(parser.is_option_provided("firstOption"));
278 EXPECT_TRUE(parser.is_option_parsed("secondOption"));
279
280 EXPECT_EQ(parser.get_option_value<std::string>("firstOption"), "valueFirst");
281 EXPECT_EQ(parser.get_option_value<std::string>("secondOption"), "valueSecond");
282 }
283
284 TEST(CommandLineParser, twoPositionals_flaggedFirstValueAndFlaggedSecondValueAndPositionalFirstValue_throws)
285 {
286 stk::CommandLineParser parser;
287 parser.add_required_positional<std::string>({"firstOption", "f", "First (required) positional description"});
288 parser.add_optional_positional<std::string>({"secondOption", "s", "Second (optional) positional description"}, "defaultValue");
289
290 Args args({"exe", "--firstOption", "valueFirst", "--secondOption", "valueSecond", "differentValueFirst"});
291 EXPECT_TRUE(parse_command_line_with_error(parser, args, "Detected that 1 or more arguments was redundantly specified"));
292 }
293
294 //==============================================================================
295 TEST(CommandLineParser, oneOptionalPositional_notProvided_getValueReturnsDefault)
296 {
297 stk::CommandLineParser parser;
298 parser.add_optional_positional<std::string>({"positionalOpt", "p", "One required positional description"}, "defaultValue");
299
300 Args args({"exe"});
301 EXPECT_TRUE(parse_command_line_without_error(parser, args));
302
303 EXPECT_FALSE(parser.is_empty());
304 EXPECT_FALSE(parser.is_option_parsed("positionalOpt"));
305 EXPECT_TRUE(parser.is_option_provided("positionalOpt"));
306
307 EXPECT_EQ(parser.get_option_value<std::string>("positionalOpt"), "defaultValue");
308 }
309
310 TEST(CommandLineParser, oneOptionalPositional_valueProvided_getValueReturnsProvided)
311 {
312 stk::CommandLineParser parser;
313 parser.add_optional_positional<std::string>({"positionalOpt", "p", "One required positional description"}, "defaultValue");
314
315 Args args({"exe", "providedValue"});
316 EXPECT_TRUE(parse_command_line_without_error(parser, args));
317
318 EXPECT_FALSE(parser.is_empty());
319 EXPECT_FALSE(parser.is_option_parsed("positionalOpt"));
320 EXPECT_TRUE(parser.is_option_provided("positionalOpt"));
321
322 EXPECT_EQ(parser.get_option_value<std::string>("positionalOpt"), "providedValue");
323 }
324
325 TEST(CommandLineParser, oneOptionalPositional_optionAndValueProvided_getValueReturnsProvided)
326 {
327 stk::CommandLineParser parser;
328 parser.add_optional_positional<std::string>({"positionalOpt", "p", "One required positional description"}, "defaultValue");
329
330 Args args({"exe", "--positionalOpt=providedValue"});
331 EXPECT_TRUE(parse_command_line_without_error(parser, args));
332
333 EXPECT_FALSE(parser.is_empty());
334 EXPECT_TRUE(parser.is_option_parsed("positionalOpt"));
335 EXPECT_TRUE(parser.is_option_provided("positionalOpt"));
336
337 EXPECT_EQ(parser.get_option_value<std::string>("positionalOpt"), "providedValue");
338 }
339
340 TEST(CommandLineParser, oneOptionalPositional_disallowUnrecognized_unrecognizedOptionInPlaceOfPositional_errorDuringParse)
341 {
342 stk::CommandLineParser parser;
343 parser.add_optional_positional<std::string>({"positionalOpt", "p", "One positional description"}, "defaultValue");
344 parser.disallow_unrecognized();
345
346 Args args({"exe", "--unrecognizedOpt"});
347 EXPECT_TRUE(parse_command_line_with_error(parser, args, "Unrecognized option: '--unrecognizedOpt'"));
348
349 EXPECT_FALSE(parser.is_empty());
350 EXPECT_FALSE(parser.is_option_parsed("positionalOpt"));
351 EXPECT_TRUE(parser.is_option_provided("positionalOpt"));
352
353 EXPECT_EQ(parser.get_option_value<std::string>("positionalOpt"), "defaultValue");
354 }
355
356
357 //==============================================================================
358 TEST(CommandLineParser, oneRequired_notProvided_printErrorDuringParse_getValueThrows)
359 {
360 stk::CommandLineParser parser;
361 parser.add_required<std::string>({"requiredOpt", "r", "One required option description"});
362
363 Args args({"exe"});
364 EXPECT_TRUE(parse_command_line_with_error(parser, args, "Required option '--requiredOpt' not found"));
365
366 EXPECT_TRUE(parser.is_empty());
367 EXPECT_FALSE(parser.is_option_parsed("requiredOpt"));
368 EXPECT_FALSE(parser.is_option_provided("requiredOpt"));
369
370 EXPECT_THROW(parser.get_option_value<std::string>("requiredOpt"), std::exception);
371 }
372
373 TEST(CommandLineParser, oneRequired_shortOptionAndValueProvided_getValueReturnsProvided)
374 {
375 stk::CommandLineParser parser;
376 parser.add_required<std::string>({"requiredOpt", "r", "One required description"});
377
378 Args args({"exe", "-r", "providedValue"});
379 EXPECT_TRUE(parse_command_line_without_error(parser, args));
380
381 EXPECT_FALSE(parser.is_empty());
382 EXPECT_TRUE(parser.is_option_parsed("requiredOpt"));
383 EXPECT_TRUE(parser.is_option_provided("requiredOpt"));
384
385 EXPECT_EQ(parser.get_option_value<std::string>("requiredOpt"), "providedValue");
386 }
387
388 TEST(CommandLineParser, oneRequired_optionAndValueProvided_getValueReturnsProvided)
389 {
390 stk::CommandLineParser parser;
391 parser.add_required<std::string>({"requiredOpt", "r", "One required description"});
392
393 Args args({"exe", "--requiredOpt", "providedValue"});
394 EXPECT_TRUE(parse_command_line_without_error(parser, args));
395
396 EXPECT_FALSE(parser.is_empty());
397 EXPECT_TRUE(parser.is_option_parsed("requiredOpt"));
398 EXPECT_TRUE(parser.is_option_provided("requiredOpt"));
399
400 EXPECT_EQ(parser.get_option_value<std::string>("requiredOpt"), "providedValue");
401 }
402
403 TEST(CommandLineParser, oneRequired_optionAndNoValueProvided_errorDuringParse)
404 {
405 stk::CommandLineParser parser;
406 parser.add_required<std::string>({"requiredOpt", "r", "One required description"});
407
408 Args args({"exe", "--requiredOpt"});
409 EXPECT_TRUE(parse_command_line_with_error(parser, args, "Missing value for option --requiredOpt"));
410
411 EXPECT_TRUE(parser.is_empty());
412 EXPECT_FALSE(parser.is_option_parsed("requiredOpt"));
413 EXPECT_FALSE(parser.is_option_provided("requiredOpt"));
414
415 EXPECT_THROW(parser.get_option_value<std::string>("requiredOpt"), std::logic_error);
416 }
417
418
419 //==============================================================================
420 TEST(CommandLineParser, oneOptional_notProvided_getValueReturnsDefault)
421 {
422 stk::CommandLineParser parser;
423 parser.add_optional<std::string>({"optionalOpt" ,"o", "One optional option description"}, "defaultValue");
424
425 Args args({"exe"});
426 EXPECT_TRUE(parse_command_line_without_error(parser, args));
427
428 EXPECT_FALSE(parser.is_empty());
429 EXPECT_FALSE(parser.is_option_parsed("optionalOpt"));
430 EXPECT_TRUE(parser.is_option_provided("optionalOpt"));
431
432 EXPECT_EQ(parser.get_option_value<std::string>("optionalOpt"), "defaultValue");
433 }
434
435 TEST(CommandLineParser, oneOptionalWithoutAbbreviation_notProvided_getValueReturnsDefault)
436 {
437 stk::CommandLineParser parser;
438 parser.add_optional<std::string>("optionalOpt", "One optional option description", "defaultValue");
439
440 Args args({"exe"});
441 EXPECT_TRUE(parse_command_line_without_error(parser, args));
442
443 EXPECT_FALSE(parser.is_empty());
444 EXPECT_FALSE(parser.is_option_parsed("optionalOpt"));
445 EXPECT_TRUE(parser.is_option_provided("optionalOpt"));
446
447 EXPECT_EQ(parser.get_option_value<std::string>("optionalOpt"), "defaultValue");
448 }
449
450 TEST(CommandLineParser, oneOptional_notProvided_throwIfGettingWrongTypeFromDefault)
451 {
452 stk::CommandLineParser parser;
453 parser.add_optional<std::string>({"optionalOpt", "r", "One required description"}, "defaultValue");
454
455 Args args({"exe"});
456 EXPECT_TRUE(parse_command_line_without_error(parser, args));
457
458 EXPECT_FALSE(parser.is_empty());
459 EXPECT_FALSE(parser.is_option_parsed("optionalOpt"));
460 EXPECT_TRUE(parser.is_option_provided("optionalOpt"));
461
462 EXPECT_THROW(parser.get_option_value<double>("optionalOpt"), std::logic_error);
463 }
464
465 TEST(CommandLineParser, oneOptional_povided_getValueReturnsProvided)
466 {
467 stk::CommandLineParser parser;
468 parser.add_optional<std::string>({"optionalOpt", "o", "One optional option description"}, "defaultValue");
469
470 Args args({"exe", "--optionalOpt", "providedValue"});
471 EXPECT_TRUE(parse_command_line_without_error(parser, args));
472
473 EXPECT_FALSE(parser.is_empty());
474 EXPECT_TRUE(parser.is_option_parsed("optionalOpt"));
475 EXPECT_TRUE(parser.is_option_provided("optionalOpt"));
476
477 EXPECT_EQ(parser.get_option_value<std::string>("optionalOpt"), "providedValue");
478 }
479
480 TEST(CommandLineParser, oneOptional_shortPovided_getValueReturnsProvided)
481 {
482 stk::CommandLineParser parser;
483 parser.add_optional<std::string>({"optionalOpt", "o", "One optional option description"}, "defaultValue");
484
485 Args args({"exe", "-o", "providedValue"});
486 EXPECT_TRUE(parse_command_line_without_error(parser, args));
487
488 EXPECT_FALSE(parser.is_empty());
489 EXPECT_TRUE(parser.is_option_parsed("optionalOpt"));
490 EXPECT_TRUE(parser.is_option_provided("optionalOpt"));
491
492 EXPECT_EQ(parser.get_option_value<std::string>("optionalOpt"), "providedValue");
493 }
494
495 TEST(CommandLineParser, oneOptional_optionWithEqualsAndNoValueProvided_errorDuringParse)
496 {
497 stk::CommandLineParser parser;
498 parser.add_optional<std::string>({"optionalOpt", "r", "One required description"}, "defaultValue");
499
500 Args args({"exe", "--optionalOpt="});
501 EXPECT_TRUE(parse_command_line_with_error(parser, args, "Missing value for option --optionalOpt"));
502
503 EXPECT_FALSE(parser.is_empty());
504 EXPECT_FALSE(parser.is_option_parsed("optionalOpt"));
505 EXPECT_TRUE(parser.is_option_provided("optionalOpt"));
506
507 EXPECT_EQ(parser.get_option_value<std::string>("optionalOpt"), "defaultValue");
508 }
509
510 TEST(CommandLineParser, oneOptional_optionAndNoValueProvided_errorDuringParse)
511 {
512 stk::CommandLineParser parser;
513 parser.add_optional<std::string>({"optionalOpt", "r", "One required description"}, "defaultValue");
514
515 Args args({"exe", "--optionalOpt"});
516 EXPECT_TRUE(parse_command_line_with_error(parser, args, "Missing value for option --optionalOpt"));
517
518 EXPECT_FALSE(parser.is_empty());
519 EXPECT_FALSE(parser.is_option_parsed("optionalOpt"));
520 EXPECT_TRUE(parser.is_option_provided("optionalOpt"));
521
522 EXPECT_EQ(parser.get_option_value<std::string>("optionalOpt"), "defaultValue");
523 }
524
525 TEST(CommandLineParser, oneOptional_noDefault_notProvided_getValueThrows)
526 {
527 stk::CommandLineParser parser;
528 parser.add_optional<std::string>({"optionalOpt" ,"o", "One optional option description"});
529
530 Args args({"exe"});
531 EXPECT_TRUE(parse_command_line_without_error(parser, args));
532
533 EXPECT_TRUE(parser.is_empty());
534 EXPECT_FALSE(parser.is_option_parsed("optionalOpt"));
535 EXPECT_FALSE(parser.is_option_provided("optionalOpt"));
536
537 EXPECT_THROW(parser.get_option_value<std::string>("optionalOpt"), std::logic_error);
538 }
539
540 TEST(CommandLineParser, oneOptional_noDefault_optionProvided_getValueReturnsProvided)
541 {
542 stk::CommandLineParser parser;
543 parser.add_optional<std::string>({"optionalOpt" ,"o", "One optional option description"});
544
545 Args args({"exe", "--optionalOpt", "providedValue"});
546 EXPECT_TRUE(parse_command_line_without_error(parser, args));
547
548 EXPECT_FALSE(parser.is_empty());
549 EXPECT_TRUE(parser.is_option_parsed("optionalOpt"));
550 EXPECT_TRUE(parser.is_option_provided("optionalOpt"));
551
552 EXPECT_EQ(parser.get_option_value<std::string>("optionalOpt"), "providedValue");
553 }
554
555 //==============================================================================
556 TEST(CommandLineParser, oneOptionalImplicit_provided_getValueReturnsProvided)
557 {
558 stk::CommandLineParser parser;
559 parser.add_optional_implicit<std::string>({"implicitOpt", "i", "One optional implicit description"}, "defaultValue");
560
561 Args args({"exe", "--implicitOpt", "providedValue"});
562 EXPECT_TRUE(parse_command_line_without_error(parser, args));
563
564 EXPECT_FALSE(parser.is_empty());
565 EXPECT_TRUE(parser.is_option_parsed("implicitOpt"));
566 EXPECT_TRUE(parser.is_option_provided("implicitOpt"));
567
568 EXPECT_EQ(parser.get_option_value<std::string>("implicitOpt"), "providedValue");
569 }
570
571 TEST(CommandLineParser, oneOptionalImplicit_providedWithoutValue_getValueReturnsDefault)
572 {
573 stk::CommandLineParser parser;
574 parser.add_optional_implicit<std::string>({"implicitOpt", "i", "One optional implicit description"}, "defaultValue");
575
576 Args args({"exe", "--implicitOpt"});
577 EXPECT_TRUE(parse_command_line_without_error(parser, args));
578
579 EXPECT_FALSE(parser.is_empty());
580 EXPECT_TRUE(parser.is_option_parsed("implicitOpt"));
581 EXPECT_TRUE(parser.is_option_provided("implicitOpt"));
582
583 EXPECT_EQ(parser.get_option_value<std::string>("implicitOpt"), "defaultValue");
584 }
585
586 TEST(CommandLineParser, oneOptionalImplicit_notProvided_getValueThrows)
587 {
588 stk::CommandLineParser parser;
589 parser.add_optional_implicit<std::string>({"implicitOpt", "i", "One optional implicit description"}, "defaultValue");
590
591 Args args({"exe"});
592 EXPECT_TRUE(parse_command_line_without_error(parser, args));
593
594 EXPECT_TRUE(parser.is_empty());
595 EXPECT_FALSE(parser.is_option_parsed("implicitOpt"));
596 EXPECT_FALSE(parser.is_option_provided("implicitOpt"));
597
598 EXPECT_THROW(parser.get_option_value<std::string>("implicitOpt"), std::logic_error);
599 }
600
601
602 //==============================================================================
603 TEST(CommandLineParser, twoRequired_bothOptionsAndValuesProvided_getValueReturnsProvided)
604 {
605 stk::CommandLineParser parser;
606 parser.add_required<std::string>({"requiredOpt1", "r", "First required description"});
607 parser.add_required<std::string>({"requiredOpt2", "o", "Second required description"});
608
609 Args args({"exe", "-r", "firstProvidedValue", "--requiredOpt2=secondProvidedValue"});
610 EXPECT_TRUE(parse_command_line_without_error(parser, args));
611
612 EXPECT_FALSE(parser.is_empty());
613 EXPECT_TRUE(parser.is_option_parsed("requiredOpt1"));
614 EXPECT_TRUE(parser.is_option_parsed("requiredOpt2"));
615 EXPECT_TRUE(parser.is_option_provided("requiredOpt1"));
616 EXPECT_TRUE(parser.is_option_provided("requiredOpt2"));
617
618 EXPECT_EQ(parser.get_option_value<std::string>("requiredOpt1"), "firstProvidedValue");
619 EXPECT_EQ(parser.get_option_value<std::string>("requiredOpt2"), "secondProvidedValue");
620 }
621
622
623 TEST(CommandLineParser, oneRequiredPositional_disallowUnrecognized_unrecognizedOptionInPlaceOfPositional_errorDuringParse)
624 {
625 stk::CommandLineParser parser;
626 parser.add_required_positional<std::string>({"positionalOpt", "p", "One positional description"});
627 parser.disallow_unrecognized();
628
629 Args args({"exe", "--unrecognizedOpt"});
630 EXPECT_TRUE(parse_command_line_with_error(parser, args, "Required option '--positionalOpt' not found"));
631
632 EXPECT_TRUE(parser.is_empty());
633 EXPECT_FALSE(parser.is_option_parsed("positionalOpt"));
634 EXPECT_FALSE(parser.is_option_provided("positionalOpt"));
635
636 EXPECT_THROW(parser.get_option_value<std::string>("positionalOpt"), std::exception);
637 }
638
639 TEST(CommandLineParser, oneRequiredPositionalAndOneOptional_disallowUnrecognized_bothOptionsProvidedWithUnrecognized_errorDuringParse)
640 {
641 stk::CommandLineParser parser;
642 parser.add_required_positional<std::string>({"positionalOpt", "p", "One positional description"});
643 parser.add_optional<std::string>({"optionalOpt", "o", "One optional description"}, "defaultValue");
644 parser.disallow_unrecognized();
645
646 Args args({"exe", "positionalValue", "--unrecognizedOpt", "unrecognizedValue", "--optionalOpt", "optionalValue"});
647 EXPECT_TRUE(parse_command_line_with_error(parser, args, "Unrecognized option: '--unrecognizedOpt'"));
648
649 EXPECT_FALSE(parser.is_empty());
650 EXPECT_FALSE(parser.is_option_parsed("positionalOpt"));
651 EXPECT_TRUE(parser.is_option_parsed("optionalOpt"));
652 EXPECT_TRUE(parser.is_option_provided("positionalOpt"));
653 EXPECT_TRUE(parser.is_option_provided("optionalOpt"));
654
655 EXPECT_EQ(parser.get_option_value<std::string>("positionalOpt"), "positionalValue");
656 EXPECT_EQ(parser.get_option_value<std::string>("optionalOpt"), "optionalValue");
657 }
658
659 //==============================================================================
660 TEST(CommandLineParser, noDefinedArgs_getUsage_displaysDefaultArgs)
661 {
662 stk::CommandLineParser parser;
663 std::string usage = parser.get_usage();
664
665 EXPECT_TRUE(messageContains(usage, "Options"));
666 EXPECT_TRUE(messageContains(usage, "--help,-h"));
667 EXPECT_TRUE(messageContains(usage, "--version,-v"));
668 }
669
670 TEST(CommandLineParser, noDefinedArgs_specifiedPreamble_getUsage_displaysDefaultArgsWithhPreamble)
671 {
672 stk::CommandLineParser parser("myWackyProgram usage:");
673 std::string usage = parser.get_usage();
674
675 EXPECT_FALSE(messageContains(usage, "Options"));
676 EXPECT_TRUE(messageContains(usage, "myWackyProgram usage:"));
677 EXPECT_TRUE(messageContains(usage, "--help,-h"));
678 EXPECT_TRUE(messageContains(usage, "--version,-v"));
679 }
680
681 TEST(CommandLineParser, emptyCommandLine_parseNothing)
682 {
683 stk::CommandLineParser parser;
684
685 Args args({"exe"});
686 EXPECT_TRUE(parse_command_line_without_error(parser, args));
687
688 EXPECT_TRUE(parser.is_empty());
689 }
690
691 TEST(CommandLineParser, emptyCommandLine_parseNothing_getValueThrows)
692 {
693 stk::CommandLineParser parser;
694
695 Args args({"exe"});
696 EXPECT_TRUE(parse_command_line_without_error(parser, args));
697
698 EXPECT_TRUE(parser.is_empty());
699 EXPECT_THROW(parser.get_option_value<std::string>("undefinedOpt"), std::exception);
700 }
701
702 TEST(CommandLineParser, noArgsDefined_askHelp_returnsHelpStatus)
703 {
704 stk::CommandLineParser parser;
705
706 Args args({"exe", "--help"});
707 EXPECT_TRUE(parse_command_line_with_help(parser, args));
708 }
709
710 TEST(CommandLineParser, noArgsDefined_askShortHelp_returnsHelpStatus)
711 {
712 stk::CommandLineParser parser;
713
714 Args args({"exe", "-h"});
715 EXPECT_TRUE(parse_command_line_with_help(parser, args));
716 }
717
718 TEST(CommandLineParser, oneRequired_notProvided_askHelp_returnsHelpStatus)
719 {
720 stk::CommandLineParser parser;
721 parser.add_required<std::string>({"requiredOpt", "r", "One required option description"});
722
723 Args args({"exe", "--help"});
724 EXPECT_TRUE(parse_command_line_with_help(parser, args));
725 }
726
727 TEST(CommandLineParser, oneRequired_notProvided_askShortHelp_returnsHelpStatus)
728 {
729 stk::CommandLineParser parser;
730 parser.add_required<std::string>({"requiredOpt", "r", "One required option description"});
731
732 Args args({"exe", "-h"});
733 EXPECT_TRUE(parse_command_line_with_help(parser, args));
734 }
735
736 TEST(CommandLineParser, noArgsDefined_askVersion_returnsVersionStatus)
737 {
738 stk::CommandLineParser parser;
739
740 Args args({"exe", "--version"});
741 EXPECT_TRUE(parse_command_line_with_version(parser, args));
742 }
743
744 TEST(CommandLineParser, noArgsDefined_askShortVersion_returnsVersionStatus)
745 {
746 stk::CommandLineParser parser;
747
748 Args args({"exe", "-v"});
749 EXPECT_TRUE(parse_command_line_with_version(parser, args));
750 }
751
752 TEST(CommandLineParser, oneRequired_askVersion_returnsVersionStatus)
753 {
754 stk::CommandLineParser parser;
755 parser.add_required<std::string>({"requiredOpt", "r", "One required option description"});
756
757 Args args({"exe", "--version"});
758 EXPECT_TRUE(parse_command_line_with_version(parser, args));
759 }
760
761 TEST(CommandLineParser, oneRequired_askShortVersion_returnsVersionStatus)
762 {
763 stk::CommandLineParser parser;
764 parser.add_required<std::string>({"requiredOpt", "r", "One required option description"});
765
766 Args args({"exe", "-v"});
767 EXPECT_TRUE(parse_command_line_with_version(parser, args));
768 }
769
770
771 //==============================================================================
772 }