mirrors/CLI11
1
0
Fork 0
mirror of https://github.com/CLIUtils/CLI11.git synced 2025-04-29 12:13:52 +00:00
Code Issues Releases Wiki Activity

Move to using literals in testing (#213)

Browse Source
This commit is contained in:
Henry Schreiner 2019-02-01 11:32:47 +01:00 committed by GitHub
parent 23802ea123
commit b4910df3d7
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 155 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

172
tests/AppTest.cpp
View File

@ -6,8 +6,8 @@ TEST_F(TApp, OneFlagShort) {
app.add_flag("-c,--count");
args = {"-c"};
run();
EXPECT_EQ((size_t)1, app.count("-c"));
EXPECT_EQ((size_t)1, app.count("--count"));
EXPECT_EQ(1u, app.count("-c"));
EXPECT_EQ(1u, app.count("--count"));
}
TEST_F(TApp, OneFlagShortWindows) {
@ -15,8 +15,8 @@ TEST_F(TApp, OneFlagShortWindows) {
args = {"/c"};
app.allow_windows_style_options();
run();
EXPECT_EQ((size_t)1, app.count("-c"));
EXPECT_EQ((size_t)1, app.count("--count"));
EXPECT_EQ(1u, app.count("-c"));
EXPECT_EQ(1u, app.count("--count"));
}
TEST_F(TApp, WindowsLongShortMix1) {
@ -26,8 +26,8 @@ TEST_F(TApp, WindowsLongShortMix1) {
auto b = app.add_flag("--c");
args = {"/c"};
run();
EXPECT_EQ((size_t)1, a->count());
EXPECT_EQ((size_t)0, b->count());
EXPECT_EQ(1u, a->count());
EXPECT_EQ(0u, b->count());
}
TEST_F(TApp, WindowsLongShortMix2) {
@ -37,8 +37,8 @@ TEST_F(TApp, WindowsLongShortMix2) {
auto b = app.add_flag("-c");
args = {"/c"};
run();
EXPECT_EQ((size_t)1, a->count());
EXPECT_EQ((size_t)0, b->count());
EXPECT_EQ(1u, a->count());
EXPECT_EQ(0u, b->count());
}
TEST_F(TApp, CountNonExist) {
@ -52,8 +52,8 @@ TEST_F(TApp, OneFlagLong) {
app.add_flag("-c,--count");
args = {"--count"};
run();
EXPECT_EQ((size_t)1, app.count("-c"));
EXPECT_EQ((size_t)1, app.count("--count"));
EXPECT_EQ(1u, app.count("-c"));
EXPECT_EQ(1u, app.count("--count"));
}
TEST_F(TApp, DashedOptions) {
@ -63,10 +63,10 @@ TEST_F(TApp, DashedOptions) {
args = {"-c", "--q", "--this", "--that"};
run();
EXPECT_EQ((size_t)1, app.count("-c"));
EXPECT_EQ((size_t)1, app.count("--q"));
EXPECT_EQ((size_t)2, app.count("--this"));
EXPECT_EQ((size_t)2, app.count("--that"));
EXPECT_EQ(1u, app.count("-c"));
EXPECT_EQ(1u, app.count("--q"));
EXPECT_EQ(2u, app.count("--this"));
EXPECT_EQ(2u, app.count("--that"));
}
TEST_F(TApp, DashedOptionsSingleString) {
@ -75,10 +75,10 @@ TEST_F(TApp, DashedOptionsSingleString) {
app.add_flag("--this,--that");
app.parse("-c --q --this --that");
EXPECT_EQ((size_t)1, app.count("-c"));
EXPECT_EQ((size_t)1, app.count("--q"));
EXPECT_EQ((size_t)2, app.count("--this"));
EXPECT_EQ((size_t)2, app.count("--that"));
EXPECT_EQ(1u, app.count("-c"));
EXPECT_EQ(1u, app.count("--q"));
EXPECT_EQ(2u, app.count("--this"));
EXPECT_EQ(2u, app.count("--that"));
}
TEST_F(TApp, OneFlagRef) {
@ -86,8 +86,8 @@ TEST_F(TApp, OneFlagRef) {
app.add_flag("-c,--count", ref);
args = {"--count"};
run();
EXPECT_EQ((size_t)1, app.count("-c"));
EXPECT_EQ((size_t)1, app.count("--count"));
EXPECT_EQ(1u, app.count("-c"));
EXPECT_EQ(1u, app.count("--count"));
EXPECT_EQ(1, ref);
}
@ -96,8 +96,8 @@ TEST_F(TApp, OneString) {
app.add_option("-s,--string", str);
args = {"--string", "mystring"};
run();
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ((size_t)1, app.count("--string"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(1u, app.count("--string"));
EXPECT_EQ(str, "mystring");
}
@ -107,8 +107,8 @@ TEST_F(TApp, OneStringWindowsStyle) {
args = {"/string", "mystring"};
app.allow_windows_style_options();
run();
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ((size_t)1, app.count("--string"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(1u, app.count("--string"));
EXPECT_EQ(str, "mystring");
}
@ -117,8 +117,8 @@ TEST_F(TApp, OneStringSingleStringInput) {
app.add_option("-s,--string", str);
app.parse("--string mystring");
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ((size_t)1, app.count("--string"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(1u, app.count("--string"));
EXPECT_EQ(str, "mystring");
}
@ -127,8 +127,8 @@ TEST_F(TApp, OneStringEqualVersion) {
app.add_option("-s,--string", str);
args = {"--string=mystring"};
run();
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ((size_t)1, app.count("--string"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(1u, app.count("--string"));
EXPECT_EQ(str, "mystring");
}
@ -138,8 +138,8 @@ TEST_F(TApp, OneStringEqualVersionWindowsStyle) {
args = {"/string:mystring"};
app.allow_windows_style_options();
run();
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ((size_t)1, app.count("--string"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(1u, app.count("--string"));
EXPECT_EQ(str, "mystring");
}
@ -147,8 +147,8 @@ TEST_F(TApp, OneStringEqualVersionSingleString) {
std::string str;
app.add_option("-s,--string", str);
app.parse("--string=mystring");
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ((size_t)1, app.count("--string"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(1u, app.count("--string"));
EXPECT_EQ(str, "mystring");
}
@ -156,8 +156,8 @@ TEST_F(TApp, OneStringEqualVersionSingleStringQuoted) {
std::string str;
app.add_option("-s,--string", str);
app.parse("--string=\"this is my quoted string\"");
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ((size_t)1, app.count("--string"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(1u, app.count("--string"));
EXPECT_EQ(str, "this is my quoted string");
}
@ -271,8 +271,8 @@ TEST_F(TApp, TogetherInt) {
app.add_option("-i,--int", i);
args = {"-i4"};
run();
EXPECT_EQ((size_t)1, app.count("--int"));
EXPECT_EQ((size_t)1, app.count("-i"));
EXPECT_EQ(1u, app.count("--int"));
EXPECT_EQ(1u, app.count("-i"));
EXPECT_EQ(i, 4);
}
@ -281,8 +281,8 @@ TEST_F(TApp, SepInt) {
app.add_option("-i,--int", i);
args = {"-i", "4"};
run();
EXPECT_EQ((size_t)1, app.count("--int"));
EXPECT_EQ((size_t)1, app.count("-i"));
EXPECT_EQ(1u, app.count("--int"));
EXPECT_EQ(1u, app.count("-i"));
EXPECT_EQ(i, 4);
}
@ -291,8 +291,8 @@ TEST_F(TApp, OneStringAgain) {
app.add_option("-s,--string", str);
args = {"--string", "mystring"};
run();
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ((size_t)1, app.count("--string"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(1u, app.count("--string"));
EXPECT_EQ(str, "mystring");
}
@ -304,8 +304,8 @@ TEST_F(TApp, OneStringFunction) {
});
args = {"--string", "mystring"};
run();
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ((size_t)1, app.count("--string"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(1u, app.count("--string"));
EXPECT_EQ(str, "mystring");
}
@ -339,7 +339,7 @@ TEST_F(TApp, doubleVectorFunction) {
});
args = {"--val", "5", "--val", "6", "--val", "7"};
run();
EXPECT_EQ(res.size(), (size_t)3);
EXPECT_EQ(res.size(), 3u);
EXPECT_EQ(res[0], 10.0);
EXPECT_EQ(res[2], 12.0);
}
@ -359,8 +359,8 @@ TEST_F(TApp, DefaultStringAgain) {
std::string str = "previous";
app.add_option("-s,--string", str);
run();
EXPECT_EQ((size_t)0, app.count("-s"));
EXPECT_EQ((size_t)0, app.count("--string"));
EXPECT_EQ(0u, app.count("-s"));
EXPECT_EQ(0u, app.count("--string"));
EXPECT_EQ(str, "previous");
}
@ -368,8 +368,8 @@ TEST_F(TApp, DefaultStringAgainEmpty) {
std::string str = "previous";
app.add_option("-s,--string", str);
app.parse(" ");
EXPECT_EQ((size_t)0, app.count("-s"));
EXPECT_EQ((size_t)0, app.count("--string"));
EXPECT_EQ(0u, app.count("-s"));
EXPECT_EQ(0u, app.count("--string"));
EXPECT_EQ(str, "previous");
}
@ -397,9 +397,9 @@ TEST_F(TApp, LotsOfFlags) {
args = {"-a", "-b", "-aA"};
run();
EXPECT_EQ((size_t)2, app.count("-a"));
EXPECT_EQ((size_t)1, app.count("-b"));
EXPECT_EQ((size_t)1, app.count("-A"));
EXPECT_EQ(2u, app.count("-a"));
EXPECT_EQ(1u, app.count("-b"));
EXPECT_EQ(1u, app.count("-A"));
}
TEST_F(TApp, LotsOfFlagsSingleString) {
@ -409,9 +409,9 @@ TEST_F(TApp, LotsOfFlagsSingleString) {
app.add_flag("-b");
app.parse("-a -b -aA");
EXPECT_EQ((size_t)2, app.count("-a"));
EXPECT_EQ((size_t)1, app.count("-b"));
EXPECT_EQ((size_t)1, app.count("-A"));
EXPECT_EQ(2u, app.count("-a"));
EXPECT_EQ(1u, app.count("-b"));
EXPECT_EQ(1u, app.count("-A"));
}
TEST_F(TApp, LotsOfFlagsSingleStringExtraSpace) {
@ -421,9 +421,9 @@ TEST_F(TApp, LotsOfFlagsSingleStringExtraSpace) {
app.add_flag("-b");
app.parse(" -a -b -aA ");
EXPECT_EQ((size_t)2, app.count("-a"));
EXPECT_EQ((size_t)1, app.count("-b"));
EXPECT_EQ((size_t)1, app.count("-A"));
EXPECT_EQ(2u, app.count("-a"));
EXPECT_EQ(1u, app.count("-b"));
EXPECT_EQ(1u, app.count("-A"));
}
TEST_F(TApp, BoolAndIntFlags) {
@ -480,8 +480,8 @@ TEST_F(TApp, ShortOpts) {
run();
EXPECT_EQ((size_t)2, app.count("-z"));
EXPECT_EQ((size_t)1, app.count("-y"));
EXPECT_EQ(2u, app.count("-z"));
EXPECT_EQ(1u, app.count("-y"));
EXPECT_EQ((unsigned long long)2, funnyint);
EXPECT_EQ("zyz", someopt);
}
@ -498,8 +498,8 @@ TEST_F(TApp, DefaultOpts) {
run();
EXPECT_EQ((size_t)1, app.count("i"));
EXPECT_EQ((size_t)1, app.count("-s"));
EXPECT_EQ(1u, app.count("i"));
EXPECT_EQ(1u, app.count("-s"));
EXPECT_EQ(2, i);
EXPECT_EQ("9", s);
}
@ -750,13 +750,13 @@ TEST_F(TApp, PositionalNoSpace) {
args = {"-O", "Test", "param1", "param2"};
run();
EXPECT_EQ(options.size(), (size_t)1);
EXPECT_EQ(options.size(), 1u);
EXPECT_EQ(options.at(0), "Test");
args = {"-OTest", "param1", "param2"};
run();
EXPECT_EQ(options.size(), (size_t)1);
EXPECT_EQ(options.size(), 1u);
EXPECT_EQ(options.at(0), "Test");
}
@ -771,13 +771,13 @@ TEST_F(TApp, PositionalNoSpaceLong) {
args = {"--option", "Test", "param1", "param2"};
run();
EXPECT_EQ(options.size(), (size_t)1);
EXPECT_EQ(options.size(), 1u);
EXPECT_EQ(options.at(0), "Test");
args = {"--option=Test", "param1", "param2"};
run();
EXPECT_EQ(options.size(), (size_t)1);
EXPECT_EQ(options.size(), 1u);
EXPECT_EQ(options.at(0), "Test");
}
@ -963,15 +963,15 @@ TEST_F(TApp, CallbackFlags) {
app.add_flag_function("-v", func);
run();
EXPECT_EQ(value, (size_t)0);
EXPECT_EQ(value, 0u);
args = {"-v"};
run();
EXPECT_EQ(value, (size_t)1);
EXPECT_EQ(value, 1u);
args = {"-vv"};
run();
EXPECT_EQ(value, (size_t)2);
EXPECT_EQ(value, 2u);
EXPECT_THROW(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
}
@ -986,15 +986,15 @@ TEST_F(TApp, CallbackFlagsAuto) {
app.add_flag("-v", func);
run();
EXPECT_EQ(value, (size_t)0);
EXPECT_EQ(value, 0u);
args = {"-v"};
run();
EXPECT_EQ(value, (size_t)1);
EXPECT_EQ(value, 1u);
args = {"-vv"};
run();
EXPECT_EQ(value, (size_t)2);
EXPECT_EQ(value, 2u);
EXPECT_THROW(app.add_flag("hi", func), CLI::IncorrectConstruction);
}
@ -1011,8 +1011,8 @@ TEST_F(TApp, Positionals) {
run();
EXPECT_EQ((size_t)1, app.count("posit1"));
EXPECT_EQ((size_t)1, app.count("posit2"));
EXPECT_EQ(1u, app.count("posit1"));
EXPECT_EQ(1u, app.count("posit2"));
EXPECT_EQ("thing1", posit1);
EXPECT_EQ("thing2", posit2);
}
@ -1047,8 +1047,8 @@ TEST_F(TApp, MixedPositionals) {
run();
EXPECT_EQ((size_t)1, app.count("posit2"));
EXPECT_EQ((size_t)1, app.count("--posit1"));
EXPECT_EQ(1u, app.count("posit2"));
EXPECT_EQ(1u, app.count("--posit1"));
EXPECT_EQ(7, positional_int);
EXPECT_EQ("thing2", positional_string);
}
@ -1078,19 +1078,19 @@ TEST_F(TApp, Reset) {
run();
EXPECT_EQ((size_t)1, app.count("--simple"));
EXPECT_EQ((size_t)1, app.count("-d"));
EXPECT_EQ(1u, app.count("--simple"));
EXPECT_EQ(1u, app.count("-d"));
EXPECT_DOUBLE_EQ(1.2, doub);
app.clear();
EXPECT_EQ((size_t)0, app.count("--simple"));
EXPECT_EQ((size_t)0, app.count("-d"));
EXPECT_EQ(0u, app.count("--simple"));
EXPECT_EQ(0u, app.count("-d"));
run();
EXPECT_EQ((size_t)1, app.count("--simple"));
EXPECT_EQ((size_t)1, app.count("-d"));
EXPECT_EQ(1u, app.count("--simple"));
EXPECT_EQ(1u, app.count("-d"));
EXPECT_DOUBLE_EQ(1.2, doub);
}
@ -1408,7 +1408,7 @@ TEST_F(TApp, VectorFixedString) {
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
EXPECT_EQ((size_t)3, app.count("--string"));
EXPECT_EQ(3u, app.count("--string"));
EXPECT_EQ(answer, strvec);
}
@ -1421,7 +1421,7 @@ TEST_F(TApp, VectorDefaultedFixedString) {
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
EXPECT_EQ((size_t)3, app.count("--string"));
EXPECT_EQ(3u, app.count("--string"));
EXPECT_EQ(answer, strvec);
}
@ -1434,12 +1434,12 @@ TEST_F(TApp, VectorUnlimString) {
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
EXPECT_EQ((size_t)3, app.count("--string"));
EXPECT_EQ(3u, app.count("--string"));
EXPECT_EQ(answer, strvec);
args = {"-s", "mystring", "mystring2", "mystring3"};
run();
EXPECT_EQ((size_t)3, app.count("--string"));
EXPECT_EQ(3u, app.count("--string"));
EXPECT_EQ(answer, strvec);
}
@ -1452,7 +1452,7 @@ TEST_F(TApp, VectorFancyOpts) {
args = {"--string", "mystring", "mystring2", "mystring3"};
run();
EXPECT_EQ((size_t)3, app.count("--string"));
EXPECT_EQ(3u, app.count("--string"));
EXPECT_EQ(answer, strvec);
args = {"one", "two"};
@ -1626,7 +1626,7 @@ TEST_F(TApp, Env) {
run();
EXPECT_EQ(2, val);
EXPECT_EQ((size_t)1, vopt->count());
EXPECT_EQ(1u, vopt->count());
vopt->required();
run();

32
tests/CreationTest.cpp
View File

@ -479,8 +479,8 @@ TEST_F(TApp, SubcommandDefaults) {
EXPECT_FALSE(app.get_fallthrough());
EXPECT_EQ(app.get_footer(), "");
EXPECT_EQ(app.get_group(), "Subcommands");
EXPECT_EQ(app.get_require_subcommand_min(), (size_t)0);
EXPECT_EQ(app.get_require_subcommand_max(), (size_t)0);
EXPECT_EQ(app.get_require_subcommand_min(), 0u);
EXPECT_EQ(app.get_require_subcommand_max(), 0u);
app.allow_extras();
app.prefix_command();
@ -512,39 +512,39 @@ TEST_F(TApp, SubcommandDefaults) {
EXPECT_TRUE(app2->get_fallthrough());
EXPECT_EQ(app2->get_footer(), "footy");
EXPECT_EQ(app2->get_group(), "Stuff");
EXPECT_EQ(app2->get_require_subcommand_min(), (size_t)0);
EXPECT_EQ(app2->get_require_subcommand_max(), (size_t)3);
EXPECT_EQ(app2->get_require_subcommand_min(), 0u);
EXPECT_EQ(app2->get_require_subcommand_max(), 3u);
}
TEST_F(TApp, SubcommandMinMax) {
EXPECT_EQ(app.get_require_subcommand_min(), (size_t)0);
EXPECT_EQ(app.get_require_subcommand_max(), (size_t)0);
EXPECT_EQ(app.get_require_subcommand_min(), 0u);
EXPECT_EQ(app.get_require_subcommand_max(), 0u);
app.require_subcommand();
EXPECT_EQ(app.get_require_subcommand_min(), (size_t)1);
EXPECT_EQ(app.get_require_subcommand_max(), (size_t)0);
EXPECT_EQ(app.get_require_subcommand_min(), 1u);
EXPECT_EQ(app.get_require_subcommand_max(), 0u);
app.require_subcommand(2);
EXPECT_EQ(app.get_require_subcommand_min(), (size_t)2);
EXPECT_EQ(app.get_require_subcommand_max(), (size_t)2);
EXPECT_EQ(app.get_require_subcommand_min(), 2u);
EXPECT_EQ(app.get_require_subcommand_max(), 2u);
app.require_subcommand(0);
EXPECT_EQ(app.get_require_subcommand_min(), (size_t)0);
EXPECT_EQ(app.get_require_subcommand_max(), (size_t)0);
EXPECT_EQ(app.get_require_subcommand_min(), 0u);
EXPECT_EQ(app.get_require_subcommand_max(), 0u);
app.require_subcommand(-2);
EXPECT_EQ(app.get_require_subcommand_min(), (size_t)0);
EXPECT_EQ(app.get_require_subcommand_max(), (size_t)2);
EXPECT_EQ(app.get_require_subcommand_min(), 0u);
EXPECT_EQ(app.get_require_subcommand_max(), 2u);
app.require_subcommand(3, 7);
EXPECT_EQ(app.get_require_subcommand_min(), (size_t)3);
EXPECT_EQ(app.get_require_subcommand_max(), (size_t)7);
EXPECT_EQ(app.get_require_subcommand_min(), 3u);
EXPECT_EQ(app.get_require_subcommand_max(), 7u);
}
TEST_F(TApp, GetOptionList) {

6
tests/HelpersTest.cpp
View File

@ -8,7 +8,7 @@
TEST(Split, SimpleByToken) {
auto out = CLI::detail::split("one.two.three", '.');
ASSERT_EQ((size_t)3, out.size());
ASSERT_EQ(3u, out.size());
EXPECT_EQ("one", out.at(0));
EXPECT_EQ("two", out.at(1));
EXPECT_EQ("three", out.at(2));
@ -16,13 +16,13 @@ TEST(Split, SimpleByToken) {
TEST(Split, Single) {
auto out = CLI::detail::split("one", '.');
ASSERT_EQ((size_t)1, out.size());
ASSERT_EQ(1u, out.size());
EXPECT_EQ("one", out.at(0));
}
TEST(Split, Empty) {
auto out = CLI::detail::split("", '.');
ASSERT_EQ((size_t)1, out.size());
ASSERT_EQ(1u, out.size());
EXPECT_EQ("", out.at(0));
}

50
tests/IniTest.cpp
View File

@ -24,12 +24,12 @@ TEST(StringBased, First) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
EXPECT_EQ((size_t)2, output.size());
EXPECT_EQ(2u, output.size());
EXPECT_EQ("one", output.at(0).name);
EXPECT_EQ((size_t)1, output.at(0).inputs.size());
EXPECT_EQ(1u, output.at(0).inputs.size());
EXPECT_EQ("three", output.at(0).inputs.at(0));
EXPECT_EQ("two", output.at(1).name);
EXPECT_EQ((size_t)1, output.at(1).inputs.size());
EXPECT_EQ(1u, output.at(1).inputs.size());
EXPECT_EQ("four", output.at(1).inputs.at(0));
}
@ -45,12 +45,12 @@ TEST(StringBased, FirstWithComments) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
EXPECT_EQ((size_t)2, output.size());
EXPECT_EQ(2u, output.size());
EXPECT_EQ("one", output.at(0).name);
EXPECT_EQ((size_t)1, output.at(0).inputs.size());
EXPECT_EQ(1u, output.at(0).inputs.size());
EXPECT_EQ("three", output.at(0).inputs.at(0));
EXPECT_EQ("two", output.at(1).name);
EXPECT_EQ((size_t)1, output.at(1).inputs.size());
EXPECT_EQ(1u, output.at(1).inputs.size());
EXPECT_EQ("four", output.at(1).inputs.at(0));
}
@ -65,15 +65,15 @@ TEST(StringBased, Quotes) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
EXPECT_EQ((size_t)3, output.size());
EXPECT_EQ(3u, output.size());
EXPECT_EQ("one", output.at(0).name);
EXPECT_EQ((size_t)1, output.at(0).inputs.size());
EXPECT_EQ(1u, output.at(0).inputs.size());
EXPECT_EQ("three", output.at(0).inputs.at(0));
EXPECT_EQ("two", output.at(1).name);
EXPECT_EQ((size_t)1, output.at(1).inputs.size());
EXPECT_EQ(1u, output.at(1).inputs.size());
EXPECT_EQ("four", output.at(1).inputs.at(0));
EXPECT_EQ("five", output.at(2).name);
EXPECT_EQ((size_t)1, output.at(2).inputs.size());
EXPECT_EQ(1u, output.at(2).inputs.size());
EXPECT_EQ("six and seven", output.at(2).inputs.at(0));
}
@ -88,15 +88,15 @@ TEST(StringBased, Vector) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
EXPECT_EQ((size_t)3, output.size());
EXPECT_EQ(3u, output.size());
EXPECT_EQ("one", output.at(0).name);
EXPECT_EQ((size_t)1, output.at(0).inputs.size());
EXPECT_EQ(1u, output.at(0).inputs.size());
EXPECT_EQ("three", output.at(0).inputs.at(0));
EXPECT_EQ("two", output.at(1).name);
EXPECT_EQ((size_t)1, output.at(1).inputs.size());
EXPECT_EQ(1u, output.at(1).inputs.size());
EXPECT_EQ("four", output.at(1).inputs.at(0));
EXPECT_EQ("five", output.at(2).name);
EXPECT_EQ((size_t)3, output.at(2).inputs.size());
EXPECT_EQ(3u, output.at(2).inputs.size());
EXPECT_EQ("six", output.at(2).inputs.at(0));
EXPECT_EQ("and", output.at(2).inputs.at(1));
EXPECT_EQ("seven", output.at(2).inputs.at(2));
@ -112,12 +112,12 @@ TEST(StringBased, Spaces) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
EXPECT_EQ((size_t)2, output.size());
EXPECT_EQ(2u, output.size());
EXPECT_EQ("one", output.at(0).name);
EXPECT_EQ((size_t)1, output.at(0).inputs.size());
EXPECT_EQ(1u, output.at(0).inputs.size());
EXPECT_EQ("three", output.at(0).inputs.at(0));
EXPECT_EQ("two", output.at(1).name);
EXPECT_EQ((size_t)1, output.at(1).inputs.size());
EXPECT_EQ(1u, output.at(1).inputs.size());
EXPECT_EQ("four", output.at(1).inputs.at(0));
}
@ -132,13 +132,13 @@ TEST(StringBased, Sections) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
EXPECT_EQ((size_t)2, output.size());
EXPECT_EQ(2u, output.size());
EXPECT_EQ("one", output.at(0).name);
EXPECT_EQ((size_t)1, output.at(0).inputs.size());
EXPECT_EQ(1u, output.at(0).inputs.size());
EXPECT_EQ("three", output.at(0).inputs.at(0));
EXPECT_EQ("two", output.at(1).name);
EXPECT_EQ("second", output.at(1).parents.at(0));
EXPECT_EQ((size_t)1, output.at(1).inputs.size());
EXPECT_EQ(1u, output.at(1).inputs.size());
EXPECT_EQ("four", output.at(1).inputs.at(0));
EXPECT_EQ("second.two", output.at(1).fullname());
}
@ -156,14 +156,14 @@ TEST(StringBased, SpacesSections) {
std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
EXPECT_EQ((size_t)2, output.size());
EXPECT_EQ(2u, output.size());
EXPECT_EQ("one", output.at(0).name);
EXPECT_EQ((size_t)1, output.at(0).inputs.size());
EXPECT_EQ(1u, output.at(0).inputs.size());
EXPECT_EQ("three", output.at(0).inputs.at(0));
EXPECT_EQ("two", output.at(1).name);
EXPECT_EQ((size_t)1, output.at(1).parents.size());
EXPECT_EQ(1u, output.at(1).parents.size());
EXPECT_EQ("second", output.at(1).parents.at(0));
EXPECT_EQ((size_t)1, output.at(1).inputs.size());
EXPECT_EQ(1u, output.at(1).inputs.size());
EXPECT_EQ("four", output.at(1).inputs.at(0));
}
@ -256,7 +256,7 @@ TEST_F(TApp, IniGetNoRemaining) {
int two = 0;
app.add_option("--two", two);
ASSERT_NO_THROW(run());
EXPECT_EQ(app.remaining().size(), (size_t)0);
EXPECT_EQ(app.remaining().size(), 0u);
}
TEST_F(TApp, IniNotRequiredNotDefault) {

2
tests/NewParseTest.cpp
View File

@ -203,7 +203,7 @@ TEST_F(TApp, AddingComplexParserDetail) {
if(!rsearch) {
skip_tests = true;
} else {
EXPECT_EQ(m.size(), (size_t)9);
EXPECT_EQ(m.size(), 9u);
}
} catch(...) {

44
tests/SubcommandTest.cpp
View File

@ -19,19 +19,19 @@ TEST_F(TApp, BasicSubcommands) {
EXPECT_THROW(app.get_subcommand("sub3"), CLI::OptionNotFound);
run();
EXPECT_EQ((size_t)0, app.get_subcommands().size());
EXPECT_EQ(0u, app.get_subcommands().size());
args = {"sub1"};
run();
EXPECT_EQ(sub1, app.get_subcommands().at(0));
EXPECT_EQ((size_t)1, app.get_subcommands().size());
EXPECT_EQ(1u, app.get_subcommands().size());
app.clear();
EXPECT_EQ((size_t)0, app.get_subcommands().size());
EXPECT_EQ(0u, app.get_subcommands().size());
args = {"sub2"};
run();
EXPECT_EQ((size_t)1, app.get_subcommands().size());
EXPECT_EQ(1u, app.get_subcommands().size());
EXPECT_EQ(sub2, app.get_subcommands().at(0));
args = {"SUb2"};
@ -64,7 +64,7 @@ TEST_F(TApp, MultiSubFallthrough) {
EXPECT_TRUE(app.got_subcommand(sub1));
EXPECT_TRUE(*sub1);
EXPECT_TRUE(sub1->parsed());
EXPECT_EQ(sub1->count(), (size_t)1);
EXPECT_EQ(sub1->count(), 1u);
EXPECT_TRUE(app.got_subcommand("sub2"));
EXPECT_TRUE(app.got_subcommand(sub2));
@ -88,7 +88,7 @@ TEST_F(TApp, MultiSubFallthrough) {
EXPECT_TRUE(*sub1);
EXPECT_FALSE(*sub2);
EXPECT_FALSE(sub2->parsed());
EXPECT_EQ(sub2->count(), (size_t)0);
EXPECT_EQ(sub2->count(), 0u);
EXPECT_THROW(app.got_subcommand("sub3"), CLI::OptionNotFound);
}
@ -415,8 +415,8 @@ TEST_F(TApp, PrefixSubcom) {
args = {"--simple", "subc", "other", "--simple", "--mine"};
run();
EXPECT_EQ(app.remaining_size(), (size_t)0);
EXPECT_EQ(app.remaining_size(true), (size_t)3);
EXPECT_EQ(app.remaining_size(), 0u);
EXPECT_EQ(app.remaining_size(true), 3u);
EXPECT_EQ(subc->remaining(), std::vector<std::string>({"other", "--simple", "--mine"}));
}
@ -424,7 +424,7 @@ TEST_F(TApp, InheritHelpAllFlag) {
app.set_help_all_flag("--help-all");
auto subc = app.add_subcommand("subc");
auto help_opt_list = subc->get_options([](const CLI::Option *opt) { return opt->get_name() == "--help-all"; });
EXPECT_EQ(help_opt_list.size(), (size_t)1);
EXPECT_EQ(help_opt_list.size(), 1u);
}
struct SubcommandProgram : public TApp {
@ -474,7 +474,7 @@ TEST_F(SubcommandProgram, Multiple) {
args = {"-d", "start", "-ffilename", "stop"};
run();
EXPECT_EQ((size_t)2, app.get_subcommands().size());
EXPECT_EQ(2u, app.get_subcommands().size());
EXPECT_EQ(1, dummy);
EXPECT_EQ("filename", file);
}
@ -490,7 +490,7 @@ TEST_F(SubcommandProgram, MultipleArgs) {
run();
EXPECT_EQ((size_t)2, app.get_subcommands().size());
EXPECT_EQ(2u, app.get_subcommands().size());
}
TEST_F(SubcommandProgram, CaseCheck) {
@ -513,17 +513,17 @@ TEST_F(TApp, SubcomInheritCaseCheck) {
auto sub2 = app.add_subcommand("sub2");
run();
EXPECT_EQ((size_t)0, app.get_subcommands().size());
EXPECT_EQ((size_t)2, app.get_subcommands({}).size());
EXPECT_EQ((size_t)1, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub1"; }).size());
EXPECT_EQ(0u, app.get_subcommands().size());
EXPECT_EQ(2u, app.get_subcommands({}).size());
EXPECT_EQ(1u, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub1"; }).size());
args = {"SuB1"};
run();
EXPECT_EQ(sub1, app.get_subcommands().at(0));
EXPECT_EQ((size_t)1, app.get_subcommands().size());
EXPECT_EQ(1u, app.get_subcommands().size());
app.clear();
EXPECT_EQ((size_t)0, app.get_subcommands().size());
EXPECT_EQ(0u, app.get_subcommands().size());
args = {"sUb2"};
run();
@ -550,17 +550,17 @@ TEST_F(TApp, SubcomInheritUnderscoreCheck) {
auto sub2 = app.add_subcommand("sub_option2");
run();
EXPECT_EQ((size_t)0, app.get_subcommands().size());
EXPECT_EQ((size_t)2, app.get_subcommands({}).size());
EXPECT_EQ((size_t)1, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub_option1"; }).size());
EXPECT_EQ(0u, app.get_subcommands().size());
EXPECT_EQ(2u, app.get_subcommands({}).size());
EXPECT_EQ(1u, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub_option1"; }).size());
args = {"suboption1"};
run();
EXPECT_EQ(sub1, app.get_subcommands().at(0));
EXPECT_EQ((size_t)1, app.get_subcommands().size());
EXPECT_EQ(1u, app.get_subcommands().size());
app.clear();
EXPECT_EQ((size_t)0, app.get_subcommands().size());
EXPECT_EQ(0u, app.get_subcommands().size());
args = {"_suboption2"};
run();
@ -798,7 +798,7 @@ TEST_F(ManySubcommands, MaxCommands) {
// The extra subcommand counts as an extra
args = {"sub1", "sub2", "sub3"};
EXPECT_NO_THROW(run());
EXPECT_EQ(sub2->remaining().size(), (size_t)1);
EXPECT_EQ(sub2->remaining().size(), 1u);
// Currently, setting sub2 to throw causes an extras error
// In the future, would passing on up to app's extras be better?

4
tests/WindowsTest.cpp
View File

@ -8,6 +8,6 @@ TEST_F(TApp, WindowsTestSimple) {
app.add_flag("-c,--count");
args = {"-c"};
run();
EXPECT_EQ((size_t)1, app.count("-c"));
EXPECT_EQ((size_t)1, app.count("--count"));
EXPECT_EQ(1u, app.count("-c"));
EXPECT_EQ(1u, app.count("--count"));
}