4#include "../conversion/stringbuilder.h"
5#include "../conversion/stringconversion.h"
7#include "../application/argumentparser.h"
8#include "../application/argumentparserprivate.h"
9#include "../application/commandlineutils.h"
10#include "../application/fakeqtconfigarguments.h"
12#include "../io/ansiescapecodes.h"
13#include "../io/path.h"
15#include "../misc/parseerror.h"
17#include "resources/config.h"
19#include <cppunit/TestFixture.h>
20#include <cppunit/extensions/HelperMacros.h>
26#ifdef PLATFORM_WINDOWS
34using namespace CPPUNIT_NS;
46#ifndef PLATFORM_WINDOWS
51 CPPUNIT_TEST_SUITE_END();
54 void setUp()
override;
62#ifndef PLATFORM_WINDOWS
70 [[noreturn]]
void failOnExit(
int code);
77#ifndef PLATFORM_WINDOWS
78 setenv(
"ENABLE_ESCAPE_CODES",
"0", 1);
87[[noreturn]]
void ArgumentParserTests::failOnExit(
int code)
89 CPPUNIT_FAIL(
argsToString(
"Exited unexpectedly with code ", code));
97 Argument argument(
"test",
't',
"some description");
98 CPPUNIT_ASSERT_EQUAL(
false, argument.
isRequired());
100 CPPUNIT_ASSERT_EQUAL(
true, argument.
isRequired());
101 Argument subArg(
"sub",
's',
"sub arg");
103 CPPUNIT_ASSERT_EQUAL(&argument, subArg.
parents().at(0));
107#ifndef PLATFORM_WINDOWS
108 setenv(
"FOO_ENV_VAR",
"foo", 1);
109 CPPUNIT_ASSERT_EQUAL(
"foo"s,
string(argument.
firstValue()));
112 occurrence.
values.emplace_back(
"bar");
113 argument.m_occurrences.emplace_back(std::move(occurrence));
114 CPPUNIT_ASSERT_EQUAL(
"bar"s,
string(argument.
firstValue()));
124 parser.setExitFunction(std::bind(&ArgumentParserTests::failOnExit,
this, std::placeholders::_1));
127 auto verboseArg =
Argument(
"verbose",
'v',
"be verbose");
128 verboseArg.setCombinable(
true);
129 auto fileArg =
Argument(
"file",
'f',
"specifies the path of the file to be opened");
130 fileArg.setValueNames({
"path" });
131 fileArg.setRequiredValueCount(1);
132 fileArg.setEnvironmentVariable(
"PATH");
133 auto filesArg =
Argument(
"files",
'f',
"specifies the path of the file(s) to be opened");
134 filesArg.setValueNames({
"path 1",
"path 2" });
136 auto outputFileArg =
Argument(
"output-file",
'o',
"specifies the path of the output file");
137 outputFileArg.setValueNames({
"path" });
138 outputFileArg.setRequiredValueCount(1);
139 outputFileArg.setRequired(
true);
140 outputFileArg.setCombinable(
true);
141 auto printFieldNamesArg =
Argument(
"print-field-names",
'\0',
"prints available field names");
142 auto displayFileInfoArg =
Argument(
"display-file-info",
'i',
"displays general file information");
143 auto notAlbumArg =
Argument(
"album",
'a',
"should not be confused with album value");
144 displayFileInfoArg.setDenotesOperation(
true);
145 displayFileInfoArg.setSubArguments({ &fileArg, &verboseArg, ¬AlbumArg });
146 auto fieldsArg =
Argument(
"fields",
'\0',
"specifies the fields");
148 fieldsArg.setValueNames({
"title",
"album",
"artist",
"trackpos" });
149 fieldsArg.setImplicit(
true);
150 auto displayTagInfoArg =
Argument(
"get",
'p',
"displays the values of all specified tag fields (displays all fields if none specified)");
151 displayTagInfoArg.setDenotesOperation(
true);
152 displayTagInfoArg.setSubArguments({ &fieldsArg, &filesArg, &verboseArg, ¬AlbumArg });
153 parser.setMainArguments(
154 { &qtConfigArgs.qtWidgetsGuiArg(), &printFieldNamesArg, &displayTagInfoArg, &displayFileInfoArg, &parser.noColorArg(), &parser.helpArg() });
157 parser.parseArgs(0,
nullptr, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
158 CPPUNIT_ASSERT(!parser.executable());
159 CPPUNIT_ASSERT(!parser.specifiedOperation());
160 CPPUNIT_ASSERT_EQUAL(0u, parser.actualArgumentCount());
163 const char *argv[] = {
"tageditor",
"get",
"album",
"title",
"diskpos",
"-f",
"somefile" };
166 parser.parseArgs(7, argv, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
167 CPPUNIT_FAIL(
"Exception expected.");
169 CPPUNIT_ASSERT_EQUAL(
"The argument \"files\" can not be combined with \"fields\"."s,
string(e.what()));
171 auto ss = std::stringstream();
173 CPPUNIT_ASSERT_EQUAL(
174 "Error: Unable to parse arguments: The argument \"files\" can not be combined with \"fields\".\nSee --help for available commands.\n"sv,
175 std::string_view(ss.str()));
177 CPPUNIT_ASSERT(parser.isUncombinableMainArgPresent());
180 filesArg.setCombinable(
true);
182 parser.parseArgs(7, argv, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
184 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
185 CPPUNIT_ASSERT(!displayFileInfoArg.isPresent());
186 CPPUNIT_ASSERT_EQUAL(
"tageditor"sv, std::string_view(parser.executable()));
187 CPPUNIT_ASSERT(!verboseArg.isPresent());
188 CPPUNIT_ASSERT(displayTagInfoArg.isPresent());
189 CPPUNIT_ASSERT(fieldsArg.isPresent());
190 CPPUNIT_ASSERT_EQUAL(
"album"sv, std::string_view(fieldsArg.values().at(0)));
191 CPPUNIT_ASSERT_EQUAL(
"title"sv, std::string_view(fieldsArg.values().at(1)));
192 CPPUNIT_ASSERT_EQUAL(
"diskpos"sv, std::string_view(fieldsArg.values().at(2)));
193 CPPUNIT_ASSERT_THROW(displayTagInfoArg.values().at(3), std::out_of_range);
194 CPPUNIT_ASSERT_EQUAL(&displayTagInfoArg, parser.specifiedOperation());
197 const char *argv2[] = {
"tageditor",
"",
"-p",
"album",
"title",
"diskpos",
"",
"--files",
"somefile" };
200 parser.parseArgs(9, argv2, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
202 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
203 CPPUNIT_ASSERT(!displayFileInfoArg.isPresent());
204 CPPUNIT_ASSERT(!verboseArg.isPresent());
205 CPPUNIT_ASSERT(displayTagInfoArg.isPresent());
206 CPPUNIT_ASSERT(fieldsArg.isPresent());
207 CPPUNIT_ASSERT_EQUAL(
"album"sv, std::string_view(fieldsArg.values().at(0)));
208 CPPUNIT_ASSERT_EQUAL(
"title"sv, std::string_view(fieldsArg.values().at(1)));
209 CPPUNIT_ASSERT_EQUAL(
"diskpos"sv, std::string_view(fieldsArg.values().at(2)));
210 CPPUNIT_ASSERT_EQUAL(
""sv, std::string_view(fieldsArg.values().at(3)));
211 CPPUNIT_ASSERT_THROW(fieldsArg.values().at(4), std::out_of_range);
212 CPPUNIT_ASSERT(filesArg.isPresent());
213 CPPUNIT_ASSERT_EQUAL(
"somefile"sv, std::string_view(filesArg.values().at(0)));
216 const char *argv3[] = {
"tageditor",
"album",
"title",
"diskpos",
"--files",
"somefile" };
219 parser.parseArgs(6, argv3, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
220 CPPUNIT_FAIL(
"Exception expected.");
222 CPPUNIT_ASSERT_EQUAL(
"The specified argument \"album\" is unknown.\nDid you mean get or --help?"sv, std::string_view(e.what()));
226 const char *argv18[] = {
"tageditor",
"get",
"album",
"title",
"diskpos",
"--verbose",
"--fi" };
229 parser.parseArgs(7, argv18, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
230 CPPUNIT_FAIL(
"Exception expected.");
232 CPPUNIT_ASSERT_EQUAL(
"The specified argument \"--fi\" is unknown.\nDid you mean --files or --no-color?"sv, std::string_view(e.what()));
236 parser.setUnknownArgumentBehavior(UnknownArgumentBehavior::Warn);
238#ifndef PLATFORM_WINDOWS
239 const OutputCheck outputCheck(
"Warning: The specified argument \"album\" is unknown and will be ignored.\n"s
240 "Warning: The specified argument \"title\" is unknown and will be ignored.\n"s
241 "Warning: The specified argument \"diskpos\" is unknown and will be ignored.\n"s
242 "Warning: The specified argument \"--files\" is unknown and will be ignored.\n"s
243 "Warning: The specified argument \"somefile\" is unknown and will be ignored.\n"s,
248 parser.parseArgs(6, argv3, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
251 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
252 CPPUNIT_ASSERT(!displayFileInfoArg.isPresent());
253 CPPUNIT_ASSERT(!displayTagInfoArg.isPresent());
254 CPPUNIT_ASSERT(!fieldsArg.isPresent());
255 CPPUNIT_ASSERT(!filesArg.isPresent());
259 const char *argv4[] = {
"tageditor",
"-i",
"-vf",
"test" };
260 parser.setUnknownArgumentBehavior(UnknownArgumentBehavior::Fail);
262 parser.parseArgs(4, argv4, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
263 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
264 CPPUNIT_ASSERT(displayFileInfoArg.isPresent());
265 CPPUNIT_ASSERT(verboseArg.isPresent());
266 CPPUNIT_ASSERT(!displayTagInfoArg.isPresent());
267 CPPUNIT_ASSERT(!filesArg.isPresent());
268 CPPUNIT_ASSERT(fileArg.isPresent());
269 CPPUNIT_ASSERT_EQUAL(
"test"sv, std::string_view(fileArg.values().at(0)));
270 CPPUNIT_ASSERT_THROW(fileArg.values().at(1), std::out_of_range);
273 displayFileInfoArg.reset();
276 parser.parseArgs(4, argv4, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
277 CPPUNIT_FAIL(
"Exception expected.");
279 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
280 CPPUNIT_ASSERT_EQUAL(
"The argument \"verbose\" mustn't be specified more than 1 time."sv, std::string_view(e.what()));
284 displayFileInfoArg.reset();
287 parser.parseArgs(4, argv4, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
288 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
291 verboseArg.setRequired(
true);
293 parser.parseArgs(4, argv4, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
294 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
297 const char *argv5[] = {
"tageditor",
"-i",
"-f",
"test" };
298 displayFileInfoArg.reset();
302 parser.parseArgs(4, argv5, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
303 CPPUNIT_FAIL(
"Exception expected.");
305 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
306 CPPUNIT_ASSERT_EQUAL(
"The argument \"verbose\" must be specified at least 1 time."sv, std::string_view(e.what()));
308 verboseArg.setRequired(
false);
311 const char *argv10[] = {
"tageditor",
"-pf",
"test" };
313 parser.parseArgs(3, argv10, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
314 CPPUNIT_ASSERT(displayTagInfoArg.isPresent());
315 CPPUNIT_ASSERT(!displayFileInfoArg.isPresent());
316 CPPUNIT_ASSERT(!fileArg.isPresent());
317 CPPUNIT_ASSERT(filesArg.isPresent());
318 CPPUNIT_ASSERT_EQUAL(1_st, filesArg.values(0).size());
319 CPPUNIT_ASSERT_EQUAL(
"test"sv, std::string_view(filesArg.values(0).at(0)));
320 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
323 const char *argv6[] = {
"tageditor",
"-g" };
325 parser.parseArgs(2, argv6, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
326 CPPUNIT_ASSERT(qtConfigArgs.qtWidgetsGuiArg().isPresent());
329 const char *argv7[] = {
"tageditor",
"-f",
"test" };
332 parser.parseArgs(3, argv7, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
333 CPPUNIT_FAIL(
"Exception expected.");
335 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
336 CPPUNIT_ASSERT_EQUAL(
"The specified argument \"-f\" is unknown.\nDid you mean get or --help?"sv, std::string_view(e.what()));
340 const char *argv11[] = {
"tageditor",
"-if=test-v" };
342 parser.parseArgs(2, argv11, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
343 CPPUNIT_ASSERT(!filesArg.isPresent());
344 CPPUNIT_ASSERT(fileArg.isPresent());
345 CPPUNIT_ASSERT(!verboseArg.isPresent());
346 CPPUNIT_ASSERT_EQUAL(1_st, fileArg.values(0).size());
347 CPPUNIT_ASSERT_EQUAL(
"test-v"s,
string(fileArg.values(0).front()));
348 const char *argv15[] = {
"tageditor",
"-i",
"--file=test",
"-v" };
350 parser.parseArgs(4, argv15, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
351 CPPUNIT_ASSERT(!filesArg.isPresent());
352 CPPUNIT_ASSERT(fileArg.isPresent());
353 CPPUNIT_ASSERT(verboseArg.isPresent());
354 CPPUNIT_ASSERT_EQUAL(1_st, fileArg.values(0).size());
355 CPPUNIT_ASSERT_EQUAL(
"test"sv, std::string_view(fileArg.values(0).front()));
358 const char *argv12[] = {
"tageditor",
"-iftest" };
360 parser.parseArgs(2, argv12, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
361 CPPUNIT_ASSERT(!filesArg.isPresent());
362 CPPUNIT_ASSERT(fileArg.isPresent());
363 CPPUNIT_ASSERT_EQUAL(1_st, fileArg.values(0).size());
364 CPPUNIT_ASSERT_EQUAL(
"test"sv, std::string_view(fileArg.values().at(0)));
367 const char *argv17[] = {
"tageditor",
"-if=test-v",
"--no-color" };
369 parser.parseArgs(3, argv17, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
370 CPPUNIT_ASSERT(!filesArg.isPresent());
371 CPPUNIT_ASSERT(fileArg.isPresent());
372 CPPUNIT_ASSERT(!verboseArg.isPresent());
373 CPPUNIT_ASSERT(parser.noColorArg().isPresent());
374 CPPUNIT_ASSERT_EQUAL(1_st, fileArg.values(0).size());
375 CPPUNIT_ASSERT_EQUAL(
"test-v"sv, std::string_view(fileArg.values(0).front()));
378 const char *argv8[] = {
"tageditor" };
380 parser.parseArgs(1, argv8, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
381 CPPUNIT_ASSERT(qtConfigArgs.qtWidgetsGuiArg().isPresent());
382 CPPUNIT_ASSERT(!displayFileInfoArg.isPresent());
383 CPPUNIT_ASSERT(!verboseArg.isPresent());
384 CPPUNIT_ASSERT(!displayTagInfoArg.isPresent());
385 CPPUNIT_ASSERT(!filesArg.isPresent());
386 CPPUNIT_ASSERT(!fileArg.isPresent());
387 if (
const auto path = std::getenv(
"PATH")) {
388 CPPUNIT_ASSERT(fileArg.firstValue());
389 CPPUNIT_ASSERT_EQUAL(std::string_view(path), std::string_view(fileArg.firstValue()));
391 CPPUNIT_ASSERT(!fileArg.firstValue());
395 const char *argv13[] = {
"tageditor",
"get",
"--fields",
"album=test",
"title",
"diskpos",
"--files",
"somefile" };
396 verboseArg.setRequired(
false);
398 parser.parseArgs(8, argv13, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
400 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
401 CPPUNIT_ASSERT(!displayFileInfoArg.isPresent());
402 CPPUNIT_ASSERT(!verboseArg.isPresent());
403 CPPUNIT_ASSERT(displayTagInfoArg.isPresent());
404 CPPUNIT_ASSERT(fieldsArg.isPresent());
405 CPPUNIT_ASSERT_EQUAL(
"album=test"sv, std::string_view(fieldsArg.values().at(0)));
406 CPPUNIT_ASSERT_EQUAL(
"title"sv, std::string_view(fieldsArg.values().at(1)));
407 CPPUNIT_ASSERT_EQUAL(
"diskpos"sv, std::string_view(fieldsArg.values().at(2)));
408 CPPUNIT_ASSERT_THROW(fieldsArg.values().at(3), out_of_range);
409 CPPUNIT_ASSERT(filesArg.isPresent());
410 CPPUNIT_ASSERT_EQUAL(
"somefile"sv, std::string_view(filesArg.values().at(0)));
411 CPPUNIT_ASSERT(!notAlbumArg.isPresent());
414 const char *argv9[] = {
"tageditor",
"-p",
"album",
"title",
"diskpos" };
415 fieldsArg.setRequiredValueCount(4);
418 parser.parseArgs(5, argv9, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
419 CPPUNIT_FAIL(
"Exception expected.");
421 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
422 CPPUNIT_ASSERT_EQUAL(
423 "Not all parameters for argument \"fields\" provided. You have to provide the following parameters: title album artist trackpos"sv,
424 std::string_view(e.what()));
428 const char *argv16[] = {
"tageditor",
"--hel",
"-p",
"album",
"title",
"diskpos" };
432 parser.parseArgs(6, argv16, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
433 CPPUNIT_FAIL(
"Exception expected.");
435 CPPUNIT_ASSERT(!qtConfigArgs.qtWidgetsGuiArg().isPresent());
436 CPPUNIT_ASSERT_EQUAL(
"The specified argument \"--hel\" is unknown.\nDid you mean --help or get?"sv, std::string_view(e.what()));
440 const char *argv14[] = {
"tageditor",
"get",
"fields",
"album=test",
"-f",
"somefile" };
442 fieldsArg.setDenotesOperation(
true);
443 parser.parseArgs(6, argv14, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
444 CPPUNIT_ASSERT(displayTagInfoArg.isPresent());
445 CPPUNIT_ASSERT(fieldsArg.isPresent());
446 CPPUNIT_ASSERT_EQUAL(
"album=test"sv, std::string_view(fieldsArg.values().at(0)));
450 fieldsArg.setDenotesOperation(
false);
451 parser.parseArgs(6, argv14, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
452 CPPUNIT_ASSERT(displayTagInfoArg.isPresent());
453 CPPUNIT_ASSERT(fieldsArg.isPresent());
454 CPPUNIT_ASSERT_EQUAL(
"fields"sv, std::string_view(fieldsArg.values().at(0)));
455 CPPUNIT_ASSERT_EQUAL(
"album=test"sv, std::string_view(fieldsArg.values().at(1)));
458 const char *argv19[] = {
"tageditor",
"get",
"--fields",
"foo",
"bar",
"--help" };
461 parser.parseArgs(6, argv19, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
462 CPPUNIT_FAIL(
"Exception expected.");
464 CPPUNIT_ASSERT_EQUAL_MESSAGE(
"--help assumed to be an argument without greedy-flag (leading to error)",
465 "The argument \"help\" can not be combined with \"get\"."sv, std::string_view(e.what()));
468 fieldsArg.setFlags(Argument::Flags::Greedy,
true);
469 parser.parseArgs(6, argv19, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
470 CPPUNIT_ASSERT(displayTagInfoArg.isPresent());
471 CPPUNIT_ASSERT(fieldsArg.isPresent());
472 CPPUNIT_ASSERT_MESSAGE(
"--help not considered an argument with greedy-flag", !parser.helpArg().isPresent());
473 CPPUNIT_ASSERT_EQUAL(
"foo"sv, std::string_view(fieldsArg.values().at(0)));
474 CPPUNIT_ASSERT_EQUAL(
"bar"sv, std::string_view(fieldsArg.values().at(1)));
475 CPPUNIT_ASSERT_EQUAL(
"--help"sv, std::string_view(fieldsArg.values().at(2)));
476 CPPUNIT_ASSERT_THROW(fieldsArg.values().at(3), std::out_of_range);
485 parser.
setExitFunction(std::bind(&ArgumentParserTests::failOnExit,
this, std::placeholders::_1));
486 Argument callbackArg(
"with-callback",
't',
"callback test");
489 CPPUNIT_ASSERT_EQUAL(0_st, occurrence.
index);
490 CPPUNIT_ASSERT(occurrence.
path.empty());
491 CPPUNIT_ASSERT_EQUAL(2_st, occurrence.
values.size());
492 CPPUNIT_ASSERT(!strcmp(occurrence.
values[0],
"val1"));
493 CPPUNIT_ASSERT(!strcmp(occurrence.
values[1],
"val2"));
496 Argument noCallbackArg(
"no-callback",
'l',
"callback test");
501 const char *argv[] = {
"test",
"-t",
"val1",
"val2" };
503 parser.
parseArgs(4, argv, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
505 CPPUNIT_ASSERT_EQUAL(
i, 42);
510 const char *argv2[] = {
"test",
"-l",
"val1",
"val2" };
511 parser.
parseArgs(4, argv2, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
514#ifndef PLATFORM_WINDOWS
518static bool exitCalled =
false;
529 parser.
setExitFunction(std::bind(&ArgumentParserTests::failOnExit,
this, std::placeholders::_1));
530 Argument verboseArg(
"verbose",
'v',
"be verbose");
532 Argument filesArg(
"files",
'f',
"specifies the path of the file(s) to be opened");
535 Argument nestedSubArg(
"nested-sub",
'\0',
"nested sub arg");
536 Argument subArg(
"sub",
'\0',
"sub arg");
538 Argument displayFileInfoArg(
"display-file-info",
'i',
"displays general file information");
540 displayFileInfoArg.
setSubArguments({ &filesArg, &verboseArg, &subArg });
541 Argument fieldsArg(
"fields",
'\0',
"specifies the fields");
545 Argument valuesArg(
"values",
'\0',
"specifies the fields");
549 valuesArg.
setValueCompletionBehavior(ValueCompletionBehavior::PreDefinedValues | ValueCompletionBehavior::AppendEquationSign);
550 Argument selectorsArg(
"selectors",
'\0',
"has some more pre-defined values");
557 Argument getArg(
"get",
'g',
"gets tag values");
559 Argument setArg(
"set",
's',
"sets tag values");
565 const char *
const argv1[] = {
"se" };
569 CPPUNIT_ASSERT(reader.
read());
570 parser.printBashCompletion(1, argv1, 0, reader);
579 parser.printBashCompletion(1, argv1, 0, reader);
583 const char *
const argv2[] = {
"set" };
588 parser.printBashCompletion(1, argv2, 0, reader);
594 const OutputCheck c(
"COMPREPLY=('--files' '--no-color' '--selectors' '--values' )\n");
596 parser.printBashCompletion(1, argv2, 1, reader);
603 const OutputCheck c(
"COMPREPLY=('files' '--no-color' '--selectors' '--values' )\n");
605 parser.printBashCompletion(1, argv2, 1, reader);
612 const OutputCheck c(
"COMPREPLY=('display-file-info' 'get' 'set' '--help' '--no-color' )\n");
614 parser.printBashCompletion(0,
nullptr, 0, reader);
618 const char *
const argv3[] = {
"get",
"--fields" };
621 const OutputCheck c(
"COMPREPLY=('title' 'album' 'artist' 'trackpos' '--files' '--no-color' )\n");
623 parser.printBashCompletion(2, argv3, 2, reader);
627 const char *
const argv4[] = {
"set",
"--values",
"a" };
630 const OutputCheck c(
"COMPREPLY=('album=' 'artist=' ); compopt -o nospace\n");
632 parser.printBashCompletion(3, argv4, 2, reader);
636 const char *
const argv12[] = {
"set",
"--selectors",
"tag=id3" };
639 const OutputCheck c(
"COMPREPLY=('tag=id3v1' 'tag=id3v2' )\n");
641 parser.printBashCompletion(3, argv12, 2, reader);
645 const char *
const argv13[] = {
"set",
"--selectors",
"tag",
"=",
"id3" };
648 const OutputCheck c(
"COMPREPLY=('id3v1' 'id3v2' )\n");
650 parser.printBashCompletion(5, argv13, 4, reader);
654 const OutputCheck c(
"COMPREPLY=('id3v1' 'id3v2' 'matroska' )\n");
656 parser.printBashCompletion(5, argv13, 3, reader);
663 const OutputCheck c(
"COMPREPLY=('matroska' 'mp4' 'vorbis' )\n");
665 parser.printBashCompletion(5, argv13, 3, reader);
671 const OutputCheck c(
"COMPREPLY=('title' 'album' 'artist' 'trackpos' '--fields' '--files' '--no-color' )\n");
673 parser.printBashCompletion(1, argv3, 2, reader);
678 iniFilePath.resize(iniFilePath.size() - 4);
680 mkvFilePath.resize(mkvFilePath.size() - 17);
682 const char *
const argv5[] = {
"get",
"--files", iniFilePath.c_str() };
684#ifdef CPP_UTILITIES_USE_STANDARD_FILESYSTEM
686 const OutputCheck c(
"COMPREPLY=('" % mkvFilePath %
" '\"'\"'with quote'\"'\"'.mkv' '" % iniFilePath +
".ini' ); compopt -o filenames\n",
687 "COMPREPLY=('" % iniFilePath %
".ini' '" % mkvFilePath +
" '\"'\"'with quote'\"'\"'.mkv' ); compopt -o filenames\n");
692 parser.printBashCompletion(3, argv5, 2, reader);
697 directoryPath.resize(directoryPath.size() - 4);
700 const char *
const argv14[] = {
"get",
"--files", directoryPath.c_str() };
702#ifdef CPP_UTILITIES_USE_STANDARD_FILESYSTEM
703 const OutputCheck c(
"COMPREPLY=('" % directoryPath +
"' ); compopt -o filenames\n");
708 parser.printBashCompletion(3, argv14, 2, reader);
712 const char *
const argv6[] = {
"set",
"--" };
715 const OutputCheck c(
"COMPREPLY=('--files' '--no-color' '--selectors' '--values' )\n");
717 parser.printBashCompletion(2, argv6, 1, reader);
721 const char *
const argv7[] = {
"-i",
"--sub",
"--" };
724 const OutputCheck c(
"COMPREPLY=('--files' '--nested-sub' '--no-color' '--verbose' )\n");
726 parser.printBashCompletion(3, argv7, 2, reader);
730 const char *
const argv8[] = {
"set",
"--values",
"t" };
733 const OutputCheck c(
"COMPREPLY=('title=' 'trackpos=' ); compopt -o nospace\n");
735 parser.printBashCompletion(3, argv8, 2, reader);
739 const char *
const argv9[] = {
"-gf" };
744 parser.printBashCompletion(1, argv9, 0, reader);
748 const OutputCheck c([](
const string &actualOutput) { CPPUNIT_ASSERT_EQUAL(0_st, actualOutput.find(
"COMPREPLY=('--fields' ")); });
750 parser.printBashCompletion(1, argv9, 1, reader);
757 const char *
const argv10[] = {
"/some/path/tageditor",
"--bash-completion-for",
"0" };
760 const OutputCheck c(
"COMPREPLY=('display-file-info' 'get' 'set' '--help' '--no-color' )\n");
763 CPPUNIT_ASSERT(!strcmp(
"/some/path/tageditor", parser.
executable()));
764 CPPUNIT_ASSERT(exitCalled);
767 const char *
const argv11[] = {
"/some/path/tageditor",
"--bash-completion-for",
"ge" };
776#ifndef PLATFORM_WINDOWS
786 CPPUNIT_ASSERT_EQUAL(
static_cast<unsigned char>(4 + 3), indent.
level);
790 parser.
setExitFunction(std::bind(&ArgumentParserTests::failOnExit,
this, std::placeholders::_1));
791 OperationArgument verboseArg(
"verbose",
'v',
"be verbose",
"actually not an operation");
793 ConfigValueArgument nestedSubArg(
"nested-sub",
'\0',
"nested sub arg", {
"value1",
"value2" });
795 Argument subArg(
"foo",
'f',
"dummy");
802 Argument filesArg(
"files",
'f',
"specifies the path of the file(s) to be opened");
806 Argument envArg(
"env",
'\0',
"env");
810 Argument deprecatedArg(
"deprecated");
817 const char *
const argv[] = {
"app",
"-h" };
819 const OutputCheck c(
"\033[1m" APP_NAME
", version " APP_VERSION
"\n"
821 "\033[0m" APP_DESCRIPTION
"\n"
823 "Available operations:\n"
824 "\033[1mverbose, -v\033[0m\n"
826 " example: actually not an operation\n"
828 "Available top-level options:\n"
829 "\033[1m--files, -f\033[0m\n"
830 " specifies the path of the file(s) to be opened\n"
831 " \033[1m--sub\033[0m\n"
833 " particularities: mandatory if parent argument is present\n"
834 " \033[1m--nested-sub\033[0m [value1] [value2] ...\n"
836 " example: sub arg example\n"
838 "\033[1m--env\033[0m [file] [value 2]\n"
840 " default environment variable: FILES\n"
842 "\033[1m--no-color\033[0m\n"
843 " disables formatted/colorized output\n"
844 " default environment variable: ENABLE_ESCAPE_CODES\n"
846 "Linked against: somelib, some other lib\n"
848 "Project website: " APP_URL
"\n");
850 parser.
parseArgs(2, argv, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
856 const OutputCheck c(APP_NAME
", version " APP_VERSION
"\n"
857 "\n" APP_DESCRIPTION
"\n"
859 "Available arguments:\n"
862 " example: actually not an operation\n"
865 " specifies the path of the file(s) to be opened\n"
868 " particularities: mandatory if parent argument is present\n"
869 " --nested-sub [value1] [value2] ...\n"
871 " example: sub arg example\n"
873 "--env [file] [value 2]\n"
875 " default environment variable: FILES\n"
877 "Linked against: somelib, some other lib\n"
879 "Project website: " APP_URL
"\n");
882 parser.
parseArgs(2, argv, ParseArgumentBehavior::CheckConstraints | ParseArgumentBehavior::InvokeCallbacks);
893 parser.
setExitFunction(std::bind(&ArgumentParserTests::failOnExit,
this, std::placeholders::_1));
895 Argument subArg(
"sub-arg",
's',
"mandatory sub arg");
900 CPPUNIT_ASSERT_MESSAGE(
"clear main args", parser.
mainArguments().empty());
902 CPPUNIT_ASSERT_MESSAGE(
"no default due to required sub arg", !parser.
defaultArgument());
905 CPPUNIT_ASSERT_MESSAGE(
"default if no required sub arg", &helpArg == parser.
defaultArgument());
908#ifndef PLATFORM_WINDOWS
922 unsetenv(
"ENABLE_ESCAPE_CODES");
926 noColorArg.m_occurrences.emplace_back(0);
931 setenv(
"ENABLE_ESCAPE_CODES",
" 0 ", 1);
936 setenv(
"ENABLE_ESCAPE_CODES",
" 1 ", 1);
945 CPPUNIT_ASSERT_EQUAL_MESSAGE(message,
"foo"s, get<0>(values));
946 CPPUNIT_ASSERT_EQUAL_MESSAGE(message, 42u, get<1>(values));
947 CPPUNIT_ASSERT_EQUAL_MESSAGE(message, 7.5, get<2>(values));
948 CPPUNIT_ASSERT_EQUAL_MESSAGE(message, -42, get<3>(values));
958 occurrence.
values = {
"foo",
"42",
"7.5",
"-42" };
960 static_assert(std::is_same<std::tuple<>,
decltype(occurrence.
convertValues<>())>::value,
"specifying no types yields empty tuple");
964 arg.m_occurrences = { occurrence, occurrence };
967 const auto allValues = arg.
allValuesAs<string,
unsigned int, double,
int>();
968 CPPUNIT_ASSERT_EQUAL(2_st, allValues.size());
969 for (
const auto &values : allValues) {
972 static_assert(std::is_same<std::tuple<>,
decltype(arg.
valuesAs<>())>::value,
"specifying no types yields empty tuple");
976 occurrence.
convertValues<string,
unsigned int, double, int,
int>();
977 CPPUNIT_FAIL(
"Expected exception");
979 CPPUNIT_ASSERT_EQUAL(
"Expected 5 top-level values to be present but only 4 have been specified."s,
string(failure.what()));
983 CPPUNIT_FAIL(
"Expected exception");
986 "Conversion of top-level value \"foo\" to type \".*\" failed: The character \"f\" is no valid digit."s, std::regex::extended,
987 std::string(failure.what()));
989 occurrence.
path = { &arg };
991 occurrence.
convertValues<string,
unsigned int, double, int,
int>();
992 CPPUNIT_FAIL(
"Expected exception");
994 CPPUNIT_ASSERT_EQUAL(
"Expected 5 values for argument --test to be present but only 4 have been specified."s,
string(failure.what()));
998 CPPUNIT_FAIL(
"Expected exception");
1001 "Conversion of value \"foo\" \\(for argument --test\\) to type \".*\" failed: The character \"f\" is no valid digit."s,
1002 std::regex::extended, std::string(failure.what()));
#define SET_APPLICATION_INFO
Sets application meta data (including SET_DEPENDENCY_INFO) used by ArgumentParser::printHelp().
CPPUNIT_TEST_SUITE_REGISTRATION(ArgumentParserTests)
void checkConvertedValues(const std::string &message, const ValueTuple &values)
The ArgumentParserTests class tests the ArgumentParser and Argument classes.
void testNoColorArgument()
Tests whether NocolorArgument toggles escape codes correctly.
void testCallbacks()
Tests whether callbacks are called correctly.
void testValueConversion()
Tests value conversion provided by Argument and ArgumentOccurrence.
void testArgument()
Tests the behaviour of the argument class.
void testBashCompletion()
Tests bash completion.
void testHelp()
Tests –help output.
void testSetMainArguments()
Tests some corner cases in setMainArguments() which are not already checked in the other tests.
void testParsing()
Tests parsing command line arguments.
The ArgumentParser class provides a means for handling command line arguments.
const HelpArgument & helpArg() const
Returns the --help argument.
const char * executable() const
Returns the name of the current executable.
void readArgs(int argc, const char *const *argv)
Parses the specified command line arguments.
const ArgumentVector & mainArguments() const
Returns the main arguments.
Argument * defaultArgument() const
Returns the default argument.
void setMainArguments(const ArgumentInitializerList &mainArguments)
Sets the main arguments for the parser.
void setExitFunction(std::function< void(int)> exitFunction)
Specifies a function quit the application.
void addMainArgument(Argument *argument)
Adds the specified argument to the main argument.
void parseArgs(int argc, const char *const *argv, ParseArgumentBehavior behavior=ParseArgumentBehavior::CheckConstraints|ParseArgumentBehavior::InvokeCallbacks|ParseArgumentBehavior::ExitOnFailure)
Parses the specified command line arguments.
void resetArgs()
Resets all Argument instances assigned as mainArguments() and sub arguments.
const NoColorArgument & noColorArg() const
Returns the --no-color argument.
The ArgumentReader class internally encapsulates the process of reading command line arguments.
ArgumentReader & reset(const char *const *argv, const char *const *end)
Resets the ArgumentReader to continue reading new argv.
bool read()
Reads the commands line arguments specified when constructing the object.
The Argument class is a wrapper for command line argument information.
void addSubArgument(Argument *arg)
Adds arg as a secondary argument for this argument.
static constexpr std::size_t varValueCount
Denotes a variable number of values.
const char * firstValue() const
Returns the first parameter value of the first occurrence of the argument.
void setValueCompletionBehavior(ValueCompletionBehavior valueCompletionBehaviour)
Sets the items to be considered when generating completion for the values.
ValueCompletionBehavior valueCompletionBehaviour() const
Returns the items to be considered when generating completion for the values.
void setConstraints(std::size_t minOccurrences, std::size_t maxOccurrences)
Sets the allowed number of occurrences.
void setImplicit(bool implicit)
Sets whether the argument is an implicit argument.
void setDenotesOperation(bool denotesOperation)
Sets whether the argument denotes the operation.
void markAsDeprecated(const Argument *deprecatedBy=nullptr)
Marks the argument as deprecated.
void setAbbreviation(char abbreviation)
Sets the abbreviation of the argument.
void setDescription(const char *description)
Sets the description of the argument.
void appendValueName(const char *valueName)
Appends a value name.
std::vector< std::tuple< TargetType... > > allValuesAs() const
Converts the present values for all occurrence to the specified target types.
void reset()
Resets occurrences (indices, values and paths).
void setExample(const char *example)
Sets the a usage example for the argument.
Argument * conflictsWithArgument() const
Checks if this arguments conflicts with other arguments.
const ArgumentVector & parents() const
Returns the parents of this argument.
void setSubArguments(const ArgumentInitializerList &subArguments)
Sets the secondary arguments for this argument.
void setCombinable(bool combinable)
Sets whether this argument can be combined.
void setCallback(CallbackFunction callback)
Sets a callback function which will be called by the parser if the argument could be found and no par...
bool isRequired() const
Returns an indication whether the argument is mandatory.
void setRequired(bool required)
Sets whether this argument is mandatory or not.
void setPreDefinedCompletionValues(const char *preDefinedCompletionValues)
Assigns the values to be used when generating completion for the values.
void setEnvironmentVariable(const char *environmentVariable)
Sets the environment variable queried when firstValue() is called.
std::tuple< TargetType... > valuesAs(std::size_t occurrence=0) const
Converts the present values for the specified occurrence to the specified target types.
void setRequiredValueCount(std::size_t requiredValueCount)
Sets the number of values which are required to be given for this argument.
void setName(const char *name)
Sets the name of the argument.
The ConfigValueArgument class is an Argument where setCombinable() is true by default.
The HelpArgument class prints help information for an argument parser when present (–help,...
The Indentation class allows printing indentation conveniently, eg.
The NoColorArgument class allows to specify whether use of escape codes or similar technique to provi...
void apply() const
Sets EscapeCodes::enabled according to the presence of the first instantiation of NoColorArgument.
The OperationArgument class is an Argument where denotesOperation() is true by default.
The StandardOutputCheck class asserts whether the (standard) output written in the enclosing code blo...
The ParseError class is thrown by an ArgumentParser when a parsing error occurs.
#define QT_CONFIG_ARGUMENTS
CPP_UTILITIES_EXPORT bool enabled
Controls whether the functions inside the EscapeCodes namespace actually make use of escape codes.
Contains literals to ease asserting with CPPUNIT_ASSERT_EQUAL.
Contains all utilities provides by the c++utilities library.
CPP_UTILITIES_EXPORT std::string testFilePath(const std::string &relativeTestFilePath)
Convenience function to invoke TestApplication::testFilePath().
StringType argsToString(Args &&...args)
CPP_UTILITIES_EXPORT ApplicationInfo applicationInfo
Stores global application info used by ArgumentParser::printHelp() and AboutDialog.
std::vector< const char * > dependencyVersions
The ArgumentOccurrence struct holds argument values for an occurrence of an argument.
std::size_t index
The index of the occurrence.
std::vector< const char * > values
The parameter values which have been specified after the occurrence of the argument.
std::tuple< RemainingTargetTypes... > convertValues() const
Converts the present values to the specified target types.
std::vector< Argument * > path
The "path" of the occurrence (the parent elements which have been specified before).
#define TESTUTILS_ASSERT_LIKE_FLAGS(message, expectedRegex, regexFlags, actualString)
Asserts whether the specified string matches the specified regex.