mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Refactor command line errors to mirror diagnostic style (#4568)
This changes to an `Error` return to let the driver do the "error: " prefix, except for one case with `help` that needs more work to change (I'm not planning on picking up that TODO). It also changes capitalization, backtick use, and a few minor punctuation things to try to better match the diagnostic style. This also adds `Error` matchers so that the changes to command line testing are clearer.
This commit is contained in:
Jon Ross-Perkins
+145
-154
@@ -7,17 +7,18 @@
|
||||
#include <gmock/gmock.h>
|
||||
#include <gtest/gtest.h>
|
||||
|
||||
#include "common/error_test_helpers.h"
|
||||
#include "llvm/Support/FormatVariadic.h"
|
||||
#include "testing/base/test_raw_ostream.h"
|
||||
|
||||
namespace Carbon::CommandLine {
|
||||
namespace {
|
||||
|
||||
using ::Carbon::Testing::IsError;
|
||||
using ::Carbon::Testing::IsSuccess;
|
||||
using ::Carbon::Testing::TestRawOstream;
|
||||
using ::testing::ElementsAre;
|
||||
using ::testing::Eq;
|
||||
using ::testing::HasSubstr;
|
||||
using ::testing::Not;
|
||||
using ::testing::StrEq;
|
||||
|
||||
constexpr CommandInfo TestCommandInfo = {
|
||||
@@ -41,19 +42,18 @@ TEST(ArgParserTest, BasicCommand) {
|
||||
int integer_option = -1;
|
||||
llvm::StringRef string_option = "";
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args) {
|
||||
return Parse(
|
||||
args, llvm::errs(), llvm::errs(), TestCommandInfo, [&](auto& b) {
|
||||
b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
|
||||
b.AddIntegerOption({.name = "option1"},
|
||||
[&](auto& arg_b) { arg_b.Set(&integer_option); });
|
||||
b.AddStringOption({.name = "option2"},
|
||||
[&](auto& arg_b) { arg_b.Set(&string_option); });
|
||||
b.Do([] {});
|
||||
});
|
||||
return Parse(args, llvm::errs(), TestCommandInfo, [&](auto& b) {
|
||||
b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
|
||||
b.AddIntegerOption({.name = "option1"},
|
||||
[&](auto& arg_b) { arg_b.Set(&integer_option); });
|
||||
b.AddStringOption({.name = "option2"},
|
||||
[&](auto& arg_b) { arg_b.Set(&string_option); });
|
||||
b.Do([] {});
|
||||
});
|
||||
};
|
||||
|
||||
EXPECT_THAT(parse({"--flag", "--option2=value", "--option1=42"}),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
EXPECT_THAT(integer_option, Eq(42));
|
||||
EXPECT_THAT(string_option, StrEq("value"));
|
||||
@@ -62,47 +62,46 @@ TEST(ArgParserTest, BasicCommand) {
|
||||
TEST(ArgParserTest, BooleanFlags) {
|
||||
bool flag = false;
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
|
||||
b.Do([] {});
|
||||
});
|
||||
};
|
||||
|
||||
EXPECT_THAT(parse({"--no-flag"}, llvm::errs()), Eq(ParseResult::Success));
|
||||
EXPECT_THAT(parse({"--no-flag"}, llvm::errs()),
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_FALSE(flag);
|
||||
|
||||
EXPECT_THAT(parse({"--flag", "--no-flag"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_FALSE(flag);
|
||||
|
||||
EXPECT_THAT(parse({"--no-flag", "--flag"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
|
||||
EXPECT_THAT(parse({"--no-flag", "--flag", "--flag=false"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_FALSE(flag);
|
||||
|
||||
EXPECT_THAT(parse({"--no-flag", "--flag=true"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
|
||||
EXPECT_THAT(parse({"--no-flag", "--flag=true", "--no-flag"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_FALSE(flag);
|
||||
|
||||
TestRawOstream os;
|
||||
EXPECT_THAT(parse({"--no-flag=true"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(
|
||||
os.TakeStr(),
|
||||
StrEq("ERROR: Cannot specify a value when using a flag name prefixed "
|
||||
"with 'no-' -- that prefix implies a value of 'false'.\n"));
|
||||
parse({"--no-flag=true"}, os),
|
||||
IsError(StrEq("cannot specify a value when using a flag name prefixed "
|
||||
"with `no-` -- that prefix implies a value of `false`")));
|
||||
|
||||
EXPECT_THAT(parse({"--no-flag=false"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(
|
||||
os.TakeStr(),
|
||||
StrEq("ERROR: Cannot specify a value when using a flag name prefixed "
|
||||
"with 'no-' -- that prefix implies a value of 'false'.\n"));
|
||||
parse({"--no-flag=false"}, os),
|
||||
IsError(StrEq("cannot specify a value when using a flag name prefixed "
|
||||
"with `no-` -- that prefix implies a value of `false`")));
|
||||
}
|
||||
|
||||
TEST(ArgParserTest, ArgDefaults) {
|
||||
@@ -110,7 +109,7 @@ TEST(ArgParserTest, ArgDefaults) {
|
||||
int integer_option = -1;
|
||||
llvm::StringRef string_option = "";
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddFlag({.name = "flag"}, [&](auto& arg_b) {
|
||||
arg_b.Default(true);
|
||||
arg_b.Set(&flag);
|
||||
@@ -127,19 +126,19 @@ TEST(ArgParserTest, ArgDefaults) {
|
||||
});
|
||||
};
|
||||
|
||||
EXPECT_THAT(parse({}, llvm::errs()), Eq(ParseResult::Success));
|
||||
EXPECT_THAT(parse({}, llvm::errs()), IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
EXPECT_THAT(integer_option, Eq(7));
|
||||
EXPECT_THAT(string_option, StrEq("default"));
|
||||
|
||||
EXPECT_THAT(parse({"--option1", "--option2"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
EXPECT_THAT(integer_option, Eq(7));
|
||||
EXPECT_THAT(string_option, StrEq("default"));
|
||||
|
||||
EXPECT_THAT(parse({"--option1=42", "--option2=explicit"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
EXPECT_THAT(integer_option, Eq(42));
|
||||
EXPECT_THAT(string_option, StrEq("explicit"));
|
||||
@@ -147,7 +146,7 @@ TEST(ArgParserTest, ArgDefaults) {
|
||||
EXPECT_THAT(
|
||||
parse({"--option1=42", "--option2=explicit", "--option1", "--option2"},
|
||||
llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
EXPECT_THAT(integer_option, Eq(7));
|
||||
EXPECT_THAT(string_option, StrEq("default"));
|
||||
@@ -158,7 +157,7 @@ TEST(ArgParserTest, ShortArgs) {
|
||||
bool example = false;
|
||||
int integer_option = -1;
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddFlag({.name = "flag", .short_name = "f"},
|
||||
[&](auto& arg_b) { arg_b.Set(&flag); });
|
||||
b.AddFlag({.name = "example", .short_name = "x"},
|
||||
@@ -175,7 +174,7 @@ TEST(ArgParserTest, ShortArgs) {
|
||||
};
|
||||
|
||||
EXPECT_THAT(parse({"-f", "-o=42", "-x"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
EXPECT_TRUE(example);
|
||||
EXPECT_THAT(integer_option, Eq(42));
|
||||
@@ -183,27 +182,27 @@ TEST(ArgParserTest, ShortArgs) {
|
||||
flag = false;
|
||||
example = false;
|
||||
EXPECT_THAT(parse({"--option1=13", "-xfo"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
EXPECT_TRUE(example);
|
||||
EXPECT_THAT(integer_option, Eq(123));
|
||||
|
||||
TestRawOstream os;
|
||||
EXPECT_THAT(parse({"-xzf"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(),
|
||||
StrEq("ERROR: Option '-z' (short for '--option2') requires a "
|
||||
"value to be provided and none was.\n"));
|
||||
|
||||
EXPECT_THAT(parse({"--option2"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Option '--option2' requires a value "
|
||||
"to be provided and none was.\n"));
|
||||
|
||||
EXPECT_THAT(parse({"-xz=123"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(
|
||||
os.TakeStr(),
|
||||
StrEq("ERROR: Cannot provide a value to the group of multiple short "
|
||||
"options '-xz=...'; values must be provided to a single option, "
|
||||
"using either the short or long spelling.\n"));
|
||||
parse({"-xzf"}, os),
|
||||
IsError(StrEq("option `-z` (short for `--option2`) requires a value to "
|
||||
"be provided and none was")));
|
||||
|
||||
EXPECT_THAT(
|
||||
parse({"--option2"}, os),
|
||||
IsError(StrEq(
|
||||
"option `--option2` requires a value to be provided and none was")));
|
||||
|
||||
EXPECT_THAT(
|
||||
parse({"-xz=123"}, os),
|
||||
IsError(StrEq("cannot provide a value to the group of multiple short "
|
||||
"options `-xz=...`; values must be provided to a single "
|
||||
"option, using either the short or long spelling")));
|
||||
}
|
||||
|
||||
TEST(ArgParserTest, PositionalArgs) {
|
||||
@@ -212,7 +211,7 @@ TEST(ArgParserTest, PositionalArgs) {
|
||||
llvm::StringRef source_string;
|
||||
llvm::StringRef dest_string;
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
|
||||
b.AddStringOption({.name = "option"},
|
||||
[&](auto& arg_b) { arg_b.Set(&string_option); });
|
||||
@@ -229,25 +228,25 @@ TEST(ArgParserTest, PositionalArgs) {
|
||||
};
|
||||
|
||||
TestRawOstream os;
|
||||
EXPECT_THAT(parse({"--flag", "--option=x"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(
|
||||
os.TakeStr(),
|
||||
StrEq("ERROR: Not all required positional arguments were provided. First "
|
||||
"missing and required positional argument: 'source'\n"));
|
||||
EXPECT_THAT(parse({"--flag", "--option=x"}, os),
|
||||
IsError(StrEq(
|
||||
"not all required positional arguments were provided; first "
|
||||
"missing and required positional argument: `source`")));
|
||||
|
||||
EXPECT_THAT(parse({"src", "--flag", "--option=value", "dst"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
EXPECT_THAT(string_option, StrEq("value"));
|
||||
EXPECT_THAT(source_string, StrEq("src"));
|
||||
EXPECT_THAT(dest_string, StrEq("dst"));
|
||||
|
||||
EXPECT_THAT(parse({"src2", "--", "dst2"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(source_string, StrEq("src2"));
|
||||
EXPECT_THAT(dest_string, StrEq("dst2"));
|
||||
|
||||
EXPECT_THAT(parse({"-", "--", "-"}, llvm::errs()), Eq(ParseResult::Success));
|
||||
EXPECT_THAT(parse({"-", "--", "-"}, llvm::errs()),
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(source_string, StrEq("-"));
|
||||
EXPECT_THAT(dest_string, StrEq("-"));
|
||||
}
|
||||
@@ -258,7 +257,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
|
||||
llvm::SmallVector<llvm::StringRef> source_strings;
|
||||
llvm::SmallVector<llvm::StringRef> dest_strings;
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
|
||||
b.AddStringOption({.name = "option"},
|
||||
[&](auto& arg_b) { arg_b.Set(&string_option); });
|
||||
@@ -275,16 +274,15 @@ TEST(ArgParserTest, PositionalAppendArgs) {
|
||||
};
|
||||
|
||||
TestRawOstream os;
|
||||
EXPECT_THAT(parse({"--flag", "--option=x"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(
|
||||
os.TakeStr(),
|
||||
StrEq("ERROR: Not all required positional arguments were provided. First "
|
||||
"missing and required positional argument: 'sources'\n"));
|
||||
EXPECT_THAT(parse({"--flag", "--option=x"}, os),
|
||||
IsError(StrEq(
|
||||
"not all required positional arguments were provided; first "
|
||||
"missing and required positional argument: `sources`")));
|
||||
|
||||
EXPECT_THAT(
|
||||
parse({"src1", "--flag", "src2", "--option=value", "--", "--dst--"},
|
||||
llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(flag);
|
||||
EXPECT_THAT(string_option, StrEq("value"));
|
||||
EXPECT_THAT(source_strings, ElementsAre(StrEq("src1"), StrEq("src2")));
|
||||
@@ -294,7 +292,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
|
||||
dest_strings.clear();
|
||||
EXPECT_THAT(
|
||||
parse({"--", "--src1--", "--src2--", "--", "dst1", "dst2"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(source_strings,
|
||||
ElementsAre(StrEq("--src1--"), StrEq("--src2--")));
|
||||
EXPECT_THAT(dest_strings, ElementsAre(StrEq("dst1"), StrEq("dst2")));
|
||||
@@ -302,7 +300,7 @@ TEST(ArgParserTest, PositionalAppendArgs) {
|
||||
source_strings.clear();
|
||||
dest_strings.clear();
|
||||
EXPECT_THAT(parse({"--", "--", "dst1", "dst2"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(source_strings, ElementsAre());
|
||||
EXPECT_THAT(dest_strings, ElementsAre(StrEq("dst1"), StrEq("dst2")));
|
||||
}
|
||||
@@ -316,7 +314,7 @@ TEST(ArgParserTest, BasicSubcommands) {
|
||||
bool subsub_command = false;
|
||||
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddSubcommand({.name = "sub1"}, [&](auto& sub_b) {
|
||||
sub_b.AddFlag({.name = "flag"}, [&](auto& arg_b) { arg_b.Set(&flag); });
|
||||
sub_b.AddStringOption({.name = "option"},
|
||||
@@ -338,39 +336,36 @@ TEST(ArgParserTest, BasicSubcommands) {
|
||||
};
|
||||
|
||||
TestRawOstream os;
|
||||
EXPECT_THAT(parse({}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq("ERROR: No subcommand specified. Available "
|
||||
"subcommands: 'sub1', 'sub2', or 'help'\n"));
|
||||
EXPECT_THAT(parse({}, os),
|
||||
IsError(StrEq("no subcommand specified; available subcommands: "
|
||||
"`sub1`, `sub2`, or `help`")));
|
||||
|
||||
EXPECT_THAT(parse({"--flag"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Unknown option '--flag'\n"));
|
||||
EXPECT_THAT(parse({"--flag"}, os), IsError(StrEq("unknown option `--flag`")));
|
||||
|
||||
EXPECT_THAT(parse({"sub3"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Invalid subcommand 'sub3'. Available "
|
||||
"subcommands: 'sub1', 'sub2', or 'help'\n"));
|
||||
EXPECT_THAT(parse({"sub3"}, os),
|
||||
IsError(StrEq("invalid subcommand `sub3`; available subcommands: "
|
||||
"`sub1`, `sub2`, or `help`")));
|
||||
|
||||
EXPECT_THAT(parse({"--flag", "sub1"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Unknown option '--flag'\n"));
|
||||
EXPECT_THAT(parse({"--flag", "sub1"}, os),
|
||||
IsError(StrEq("unknown option `--flag`")));
|
||||
|
||||
EXPECT_THAT(parse({"sub1", "--flag"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(subcommand, Eq(TestSubcommand::Sub1));
|
||||
EXPECT_TRUE(flag);
|
||||
|
||||
EXPECT_THAT(parse({"sub2", "--option=value"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(subcommand, Eq(TestSubcommand::Sub2));
|
||||
EXPECT_THAT(option1, StrEq("value"));
|
||||
|
||||
EXPECT_THAT(parse({"sub2", "--option=abc", "subsub42", "--option=xyz"}, os),
|
||||
Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(),
|
||||
StrEq("ERROR: Invalid subcommand 'subsub42'. Available "
|
||||
"subcommands: 'subsub', or 'help'\n"));
|
||||
IsError(StrEq("invalid subcommand `subsub42`; available "
|
||||
"subcommands: `subsub`, or `help`")));
|
||||
|
||||
EXPECT_THAT(
|
||||
parse({"sub2", "--option=abc", "subsub", "--option=xyz"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_TRUE(subsub_command);
|
||||
EXPECT_THAT(option1, StrEq("abc"));
|
||||
EXPECT_THAT(option2, StrEq("xyz"));
|
||||
@@ -380,7 +375,7 @@ TEST(ArgParserTest, Appending) {
|
||||
llvm::SmallVector<int> integers;
|
||||
llvm::SmallVector<llvm::StringRef> strings;
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddIntegerOption({.name = "int"},
|
||||
[&](auto& arg_b) { arg_b.Append(&integers); });
|
||||
b.AddStringOption({.name = "str"},
|
||||
@@ -389,22 +384,22 @@ TEST(ArgParserTest, Appending) {
|
||||
});
|
||||
};
|
||||
|
||||
EXPECT_THAT(parse({}, llvm::errs()), Eq(ParseResult::Success));
|
||||
EXPECT_THAT(parse({}, llvm::errs()), IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(integers, ElementsAre());
|
||||
EXPECT_THAT(strings, ElementsAre());
|
||||
|
||||
EXPECT_THAT(parse({"--int=1", "--int=2", "--int=3"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(integers, ElementsAre(Eq(1), Eq(2), Eq(3)));
|
||||
EXPECT_THAT(strings, ElementsAre());
|
||||
|
||||
EXPECT_THAT(parse({"--str=a", "--str=b", "--str=c"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(integers, ElementsAre(Eq(1), Eq(2), Eq(3)));
|
||||
EXPECT_THAT(strings, ElementsAre(StrEq("a"), StrEq("b"), StrEq("c")));
|
||||
|
||||
EXPECT_THAT(parse({"--str=d", "--int=4", "--str=e"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(integers, ElementsAre(Eq(1), Eq(2), Eq(3), Eq(4)));
|
||||
EXPECT_THAT(strings, ElementsAre(StrEq("a"), StrEq("b"), StrEq("c"),
|
||||
StrEq("d"), StrEq("e")));
|
||||
@@ -416,7 +411,7 @@ TEST(ArgParserTest, PositionalAppending) {
|
||||
llvm::SmallVector<llvm::StringRef> strings2;
|
||||
llvm::SmallVector<llvm::StringRef> strings3;
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddStringOption({.name = "opt"},
|
||||
[&](auto& arg_b) { arg_b.Append(&option_strings); });
|
||||
b.AddStringPositionalArg({.name = "s1"},
|
||||
@@ -432,7 +427,7 @@ TEST(ArgParserTest, PositionalAppending) {
|
||||
EXPECT_THAT(parse({"a", "--opt=x", "b", "--opt=y", "--", "c", "--opt=z", "d",
|
||||
"--", "e", "f"},
|
||||
llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(option_strings, ElementsAre(StrEq("x"), StrEq("y")));
|
||||
EXPECT_THAT(strings1, ElementsAre(StrEq("a"), StrEq("b")));
|
||||
EXPECT_THAT(strings2, ElementsAre(StrEq("c"), StrEq("--opt=z"), StrEq("d")));
|
||||
@@ -442,7 +437,7 @@ TEST(ArgParserTest, PositionalAppending) {
|
||||
TEST(ArgParserTest, OneOfOption) {
|
||||
int value = 0;
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddOneOfOption({.name = "option"}, [&](auto& arg_b) {
|
||||
arg_b.SetOneOf(
|
||||
{
|
||||
@@ -456,45 +451,48 @@ TEST(ArgParserTest, OneOfOption) {
|
||||
});
|
||||
};
|
||||
|
||||
EXPECT_THAT(parse({"--option=x"}, llvm::errs()), Eq(ParseResult::Success));
|
||||
EXPECT_THAT(parse({"--option=x"}, llvm::errs()),
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(value, Eq(1));
|
||||
|
||||
EXPECT_THAT(parse({"--option=y"}, llvm::errs()), Eq(ParseResult::Success));
|
||||
EXPECT_THAT(parse({"--option=y"}, llvm::errs()),
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(value, Eq(2));
|
||||
|
||||
EXPECT_THAT(parse({"--option=z"}, llvm::errs()), Eq(ParseResult::Success));
|
||||
EXPECT_THAT(parse({"--option=z"}, llvm::errs()),
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(value, Eq(3));
|
||||
|
||||
TestRawOstream os;
|
||||
|
||||
EXPECT_THAT(parse({"--option"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq("ERROR: Option '--option' requires a value "
|
||||
"to be provided and none was.\n"));
|
||||
EXPECT_THAT(
|
||||
parse({"--option"}, os),
|
||||
IsError(StrEq(
|
||||
"option `--option` requires a value to be provided and none was")));
|
||||
|
||||
constexpr const char* ErrorStr =
|
||||
"ERROR: Option '--option={0}' has an invalid value '{0}'; valid values "
|
||||
"are: 'x', 'y', or 'z'\n";
|
||||
EXPECT_THAT(parse({"--option=a"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "a")));
|
||||
"option `--option={0}` has an invalid value `{0}`; valid values are: "
|
||||
"`x`, `y`, or `z`";
|
||||
EXPECT_THAT(parse({"--option=a"}, os),
|
||||
IsError(StrEq(llvm::formatv(ErrorStr, "a"))));
|
||||
|
||||
EXPECT_THAT(parse({"--option="}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "")));
|
||||
EXPECT_THAT(parse({"--option="}, os),
|
||||
IsError(StrEq(llvm::formatv(ErrorStr, ""))));
|
||||
|
||||
EXPECT_THAT(parse({"--option=xx"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "xx")));
|
||||
EXPECT_THAT(parse({"--option=xx"}, os),
|
||||
IsError(StrEq(llvm::formatv(ErrorStr, "xx"))));
|
||||
|
||||
EXPECT_THAT(parse({"--option=\xFF"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "\\FF")));
|
||||
EXPECT_THAT(parse({"--option=\xFF"}, os),
|
||||
IsError(StrEq(llvm::formatv(ErrorStr, "\\FF"))));
|
||||
|
||||
EXPECT_THAT(parse({llvm::StringRef("--option=\0", 10)}, os),
|
||||
Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "\\00")));
|
||||
IsError(StrEq(llvm::formatv(ErrorStr, "\\00"))));
|
||||
}
|
||||
|
||||
TEST(ArgParserTest, OneOfOptionAppending) {
|
||||
llvm::SmallVector<int> values;
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddOneOfOption({.name = "option"}, [&](auto& arg_b) {
|
||||
arg_b.AppendOneOf(
|
||||
{
|
||||
@@ -508,15 +506,15 @@ TEST(ArgParserTest, OneOfOptionAppending) {
|
||||
});
|
||||
};
|
||||
|
||||
EXPECT_THAT(parse({}, llvm::errs()), Eq(ParseResult::Success));
|
||||
EXPECT_THAT(parse({}, llvm::errs()), IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(values, ElementsAre());
|
||||
|
||||
EXPECT_THAT(parse({"--option=x", "--option=y", "--option=z"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(values, ElementsAre(Eq(1), Eq(2), Eq(3)));
|
||||
|
||||
EXPECT_THAT(parse({"--option=y", "--option=y", "--option=x"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(values, ElementsAre(Eq(1), Eq(2), Eq(3), Eq(2), Eq(2), Eq(1)));
|
||||
}
|
||||
|
||||
@@ -530,7 +528,7 @@ TEST(ArgParserTest, RequiredArgs) {
|
||||
TestEnum enum_sub_option;
|
||||
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse(args, s, s, TestCommandInfo, [&](auto& b) {
|
||||
return Parse(args, s, TestCommandInfo, [&](auto& b) {
|
||||
b.AddIntegerOption({.name = "opt1"}, [&](auto& arg_b) {
|
||||
arg_b.Required(true);
|
||||
arg_b.Set(&integer_option);
|
||||
@@ -574,46 +572,35 @@ TEST(ArgParserTest, RequiredArgs) {
|
||||
});
|
||||
};
|
||||
|
||||
constexpr const char* ErrorStr =
|
||||
"ERROR: Required option '{0}' not provided.\n";
|
||||
TestRawOstream os;
|
||||
EXPECT_THAT(parse({}, os), Eq(ParseResult::Error));
|
||||
auto errors = os.TakeStr();
|
||||
EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--opt1")));
|
||||
EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--opt2")));
|
||||
EXPECT_THAT(parse({}, os),
|
||||
IsError(StrEq("required options not provided: --opt1, --opt2")));
|
||||
|
||||
EXPECT_THAT(parse({"--opt2=xyz"}, os), Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "--opt1")));
|
||||
EXPECT_THAT(parse({"--opt2=xyz"}, os),
|
||||
IsError(StrEq("required options not provided: --opt1")));
|
||||
|
||||
EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42"}, llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(integer_option, Eq(42));
|
||||
EXPECT_THAT(string_option, StrEq("xyz"));
|
||||
|
||||
EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2"}, os),
|
||||
Eq(ParseResult::Error));
|
||||
errors = os.TakeStr();
|
||||
EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt1")));
|
||||
EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt2")));
|
||||
EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt3")));
|
||||
IsError(StrEq("required options not provided: --sub-opt1, "
|
||||
"--sub-opt2, --sub-opt3")));
|
||||
|
||||
EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b"}, os),
|
||||
Eq(ParseResult::Error));
|
||||
errors = os.TakeStr();
|
||||
EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt1")));
|
||||
EXPECT_THAT(errors, HasSubstr(llvm::formatv(ErrorStr, "--sub-opt2")));
|
||||
EXPECT_THAT(errors, Not(HasSubstr(llvm::formatv(ErrorStr, "--sub-opt3"))));
|
||||
EXPECT_THAT(
|
||||
parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b"}, os),
|
||||
IsError(StrEq("required options not provided: --sub-opt1, --sub-opt2")));
|
||||
|
||||
EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b",
|
||||
"--sub-opt1=13"},
|
||||
os),
|
||||
Eq(ParseResult::Error));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(llvm::formatv(ErrorStr, "--sub-opt2")));
|
||||
IsError(StrEq("required options not provided: --sub-opt2")));
|
||||
|
||||
EXPECT_THAT(parse({"--opt2=xyz", "--opt1=42", "sub2", "--sub-opt3=b",
|
||||
"--sub-opt1=13", "--sub-opt2=abc"},
|
||||
llvm::errs()),
|
||||
Eq(ParseResult::Success));
|
||||
IsSuccess(Eq(ParseResult::Success)));
|
||||
EXPECT_THAT(integer_option, Eq(42));
|
||||
EXPECT_THAT(string_option, StrEq("xyz"));
|
||||
EXPECT_THAT(subcommand, Eq(TestSubcommand::Sub2));
|
||||
@@ -628,7 +615,7 @@ TEST(ArgParserTest, HelpAndVersion) {
|
||||
llvm::StringRef string = "";
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse( // Force line break.
|
||||
args, s, s,
|
||||
args, s,
|
||||
{
|
||||
.name = "test",
|
||||
.version = "Test Command -- version 1.2.3",
|
||||
@@ -747,7 +734,8 @@ A hidden subcommand.
|
||||
|
||||
TestRawOstream os;
|
||||
|
||||
EXPECT_THAT(parse({"--flag", "--help"}, os), Eq(ParseResult::MetaSuccess));
|
||||
EXPECT_THAT(parse({"--flag", "--help"}, os),
|
||||
IsSuccess(Eq(ParseResult::MetaSuccess)));
|
||||
std::string help_flag_output = os.TakeStr();
|
||||
EXPECT_THAT(help_flag_output, StrEq(llvm::StringRef(R"""(
|
||||
Test Command -- version 1.2.3
|
||||
@@ -789,10 +777,11 @@ Closing remarks.
|
||||
|
||||
)""")
|
||||
.ltrim('\n')));
|
||||
EXPECT_THAT(parse({"help"}, os), Eq(ParseResult::MetaSuccess));
|
||||
EXPECT_THAT(parse({"help"}, os), IsSuccess(Eq(ParseResult::MetaSuccess)));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(help_flag_output));
|
||||
|
||||
EXPECT_THAT(parse({"--version"}, os), Eq(ParseResult::MetaSuccess));
|
||||
EXPECT_THAT(parse({"--version"}, os),
|
||||
IsSuccess(Eq(ParseResult::MetaSuccess)));
|
||||
std::string version_flag_output = os.TakeStr();
|
||||
EXPECT_THAT(version_flag_output, StrEq(llvm::StringRef(R"""(
|
||||
Test Command -- version 1.2.3
|
||||
@@ -801,21 +790,21 @@ Build timestamp: )""" __TIMESTAMP__ R"""(
|
||||
Build config: test-config-info
|
||||
)""")
|
||||
.ltrim('\n')));
|
||||
EXPECT_THAT(parse({"version"}, os), Eq(ParseResult::MetaSuccess));
|
||||
EXPECT_THAT(parse({"version"}, os), IsSuccess(Eq(ParseResult::MetaSuccess)));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(version_flag_output));
|
||||
|
||||
EXPECT_THAT(parse({"--flag", "edit", "--option=42", "--help"}, os),
|
||||
Eq(ParseResult::MetaSuccess));
|
||||
IsSuccess(Eq(ParseResult::MetaSuccess)));
|
||||
std::string edit_help_output = os.TakeStr();
|
||||
EXPECT_THAT(edit_help_output, StrEq(llvm::StringRef(R"""(
|
||||
Edit the widget.
|
||||
|
||||
This will take the provided widgets and edit them.
|
||||
|
||||
Subcommand 'edit' usage:
|
||||
Subcommand `edit` usage:
|
||||
test [-f] edit [--option=...]
|
||||
|
||||
Subcommand 'edit' options:
|
||||
Subcommand `edit` options:
|
||||
-o, --option=...
|
||||
An integer option.
|
||||
|
||||
@@ -831,21 +820,22 @@ That's all.
|
||||
)""")
|
||||
.ltrim('\n')));
|
||||
|
||||
EXPECT_THAT(parse({"help", "edit"}, os), Eq(ParseResult::MetaSuccess));
|
||||
EXPECT_THAT(parse({"help", "edit"}, os),
|
||||
IsSuccess(Eq(ParseResult::MetaSuccess)));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(edit_help_output));
|
||||
|
||||
EXPECT_THAT(parse({"--flag", "run", "--option=abc", "--help"}, os),
|
||||
Eq(ParseResult::MetaSuccess));
|
||||
IsSuccess(Eq(ParseResult::MetaSuccess)));
|
||||
std::string run_help_output = os.TakeStr();
|
||||
EXPECT_THAT(run_help_output, StrEq(llvm::StringRef(R"""(
|
||||
Run wombats across the screen.
|
||||
|
||||
This will cause several wombats to run across your screen.
|
||||
|
||||
Subcommand 'run' usage:
|
||||
Subcommand `run` usage:
|
||||
test [-f] run [OPTIONS]
|
||||
|
||||
Subcommand 'run' options:
|
||||
Subcommand `run` options:
|
||||
-o, --option=...
|
||||
A string option.
|
||||
|
||||
@@ -869,7 +859,8 @@ Or it won't, who knows.
|
||||
)""")
|
||||
.ltrim('\n')));
|
||||
|
||||
EXPECT_THAT(parse({"help", "run"}, os), Eq(ParseResult::MetaSuccess));
|
||||
EXPECT_THAT(parse({"help", "run"}, os),
|
||||
IsSuccess(Eq(ParseResult::MetaSuccess)));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(run_help_output));
|
||||
}
|
||||
|
||||
@@ -877,7 +868,7 @@ TEST(ArgParserTest, HelpMarkdownLike) {
|
||||
bool flag = false;
|
||||
auto parse = [&](llvm::ArrayRef<llvm::StringRef> args, llvm::raw_ostream& s) {
|
||||
return Parse( // Force line break.
|
||||
args, s, s, {.name = "test"}, [&](auto& b) {
|
||||
args, s, {.name = "test"}, [&](auto& b) {
|
||||
b.AddFlag(
|
||||
{
|
||||
.name = "flag",
|
||||
@@ -907,7 +898,7 @@ x
|
||||
};
|
||||
|
||||
TestRawOstream os;
|
||||
EXPECT_THAT(parse({"--help"}, os), Eq(ParseResult::MetaSuccess));
|
||||
EXPECT_THAT(parse({"--help"}, os), IsSuccess(Eq(ParseResult::MetaSuccess)));
|
||||
EXPECT_THAT(os.TakeStr(), StrEq(llvm::StringRef(R"""(
|
||||
Usage:
|
||||
test [--flag]
|
||||
|
||||
Reference in New Issue
Block a user