Peter M. Groen / CLI11

Commit b4910df3d7df491abe33efcb03779314f92d47d3

Authored by Henry Schreiner
Committed by GitHub
1 parent 23802ea1

Move to using literals in testing (#213)

Inline Side-by-side
Showing 7 changed files with 155 additions and 155 deletions
tests/AppTest.cpp
  View file @b4910df
... ... @@ -6,8 +6,8 @@ TEST_F(TApp, OneFlagShort) {
6 6 app.add_flag("-c,--count");
7 7 args = {"-c"};
8 8 run();
9   - EXPECT_EQ((size_t)1, app.count("-c"));
10   - EXPECT_EQ((size_t)1, app.count("--count"));
  9 + EXPECT_EQ(1u, app.count("-c"));
  10 + EXPECT_EQ(1u, app.count("--count"));
11 11 }
12 12  
13 13 TEST_F(TApp, OneFlagShortWindows) {
... ... @@ -15,8 +15,8 @@ TEST_F(TApp, OneFlagShortWindows) {
15 15 args = {"/c"};
16 16 app.allow_windows_style_options();
17 17 run();
18   - EXPECT_EQ((size_t)1, app.count("-c"));
19   - EXPECT_EQ((size_t)1, app.count("--count"));
  18 + EXPECT_EQ(1u, app.count("-c"));
  19 + EXPECT_EQ(1u, app.count("--count"));
20 20 }
21 21  
22 22 TEST_F(TApp, WindowsLongShortMix1) {
... ... @@ -26,8 +26,8 @@ TEST_F(TApp, WindowsLongShortMix1) {
26 26 auto b = app.add_flag("--c");
27 27 args = {"/c"};
28 28 run();
29   - EXPECT_EQ((size_t)1, a->count());
30   - EXPECT_EQ((size_t)0, b->count());
  29 + EXPECT_EQ(1u, a->count());
  30 + EXPECT_EQ(0u, b->count());
31 31 }
32 32  
33 33 TEST_F(TApp, WindowsLongShortMix2) {
... ... @@ -37,8 +37,8 @@ TEST_F(TApp, WindowsLongShortMix2) {
37 37 auto b = app.add_flag("-c");
38 38 args = {"/c"};
39 39 run();
40   - EXPECT_EQ((size_t)1, a->count());
41   - EXPECT_EQ((size_t)0, b->count());
  40 + EXPECT_EQ(1u, a->count());
  41 + EXPECT_EQ(0u, b->count());
42 42 }
43 43  
44 44 TEST_F(TApp, CountNonExist) {
... ... @@ -52,8 +52,8 @@ TEST_F(TApp, OneFlagLong) {
52 52 app.add_flag("-c,--count");
53 53 args = {"--count"};
54 54 run();
55   - EXPECT_EQ((size_t)1, app.count("-c"));
56   - EXPECT_EQ((size_t)1, app.count("--count"));
  55 + EXPECT_EQ(1u, app.count("-c"));
  56 + EXPECT_EQ(1u, app.count("--count"));
57 57 }
58 58  
59 59 TEST_F(TApp, DashedOptions) {
... ... @@ -63,10 +63,10 @@ TEST_F(TApp, DashedOptions) {
63 63  
64 64 args = {"-c", "--q", "--this", "--that"};
65 65 run();
66   - EXPECT_EQ((size_t)1, app.count("-c"));
67   - EXPECT_EQ((size_t)1, app.count("--q"));
68   - EXPECT_EQ((size_t)2, app.count("--this"));
69   - EXPECT_EQ((size_t)2, app.count("--that"));
  66 + EXPECT_EQ(1u, app.count("-c"));
  67 + EXPECT_EQ(1u, app.count("--q"));
  68 + EXPECT_EQ(2u, app.count("--this"));
  69 + EXPECT_EQ(2u, app.count("--that"));
70 70 }
71 71  
72 72 TEST_F(TApp, DashedOptionsSingleString) {
... ... @@ -75,10 +75,10 @@ TEST_F(TApp, DashedOptionsSingleString) {
75 75 app.add_flag("--this,--that");
76 76  
77 77 app.parse("-c --q --this --that");
78   - EXPECT_EQ((size_t)1, app.count("-c"));
79   - EXPECT_EQ((size_t)1, app.count("--q"));
80   - EXPECT_EQ((size_t)2, app.count("--this"));
81   - EXPECT_EQ((size_t)2, app.count("--that"));
  78 + EXPECT_EQ(1u, app.count("-c"));
  79 + EXPECT_EQ(1u, app.count("--q"));
  80 + EXPECT_EQ(2u, app.count("--this"));
  81 + EXPECT_EQ(2u, app.count("--that"));
82 82 }
83 83  
84 84 TEST_F(TApp, OneFlagRef) {
... ... @@ -86,8 +86,8 @@ TEST_F(TApp, OneFlagRef) {
86 86 app.add_flag("-c,--count", ref);
87 87 args = {"--count"};
88 88 run();
89   - EXPECT_EQ((size_t)1, app.count("-c"));
90   - EXPECT_EQ((size_t)1, app.count("--count"));
  89 + EXPECT_EQ(1u, app.count("-c"));
  90 + EXPECT_EQ(1u, app.count("--count"));
91 91 EXPECT_EQ(1, ref);
92 92 }
93 93  
... ... @@ -96,8 +96,8 @@ TEST_F(TApp, OneString) {
96 96 app.add_option("-s,--string", str);
97 97 args = {"--string", "mystring"};
98 98 run();
99   - EXPECT_EQ((size_t)1, app.count("-s"));
100   - EXPECT_EQ((size_t)1, app.count("--string"));
  99 + EXPECT_EQ(1u, app.count("-s"));
  100 + EXPECT_EQ(1u, app.count("--string"));
101 101 EXPECT_EQ(str, "mystring");
102 102 }
103 103  
... ... @@ -107,8 +107,8 @@ TEST_F(TApp, OneStringWindowsStyle) {
107 107 args = {"/string", "mystring"};
108 108 app.allow_windows_style_options();
109 109 run();
110   - EXPECT_EQ((size_t)1, app.count("-s"));
111   - EXPECT_EQ((size_t)1, app.count("--string"));
  110 + EXPECT_EQ(1u, app.count("-s"));
  111 + EXPECT_EQ(1u, app.count("--string"));
112 112 EXPECT_EQ(str, "mystring");
113 113 }
114 114  
... ... @@ -117,8 +117,8 @@ TEST_F(TApp, OneStringSingleStringInput) {
117 117 app.add_option("-s,--string", str);
118 118  
119 119 app.parse("--string mystring");
120   - EXPECT_EQ((size_t)1, app.count("-s"));
121   - EXPECT_EQ((size_t)1, app.count("--string"));
  120 + EXPECT_EQ(1u, app.count("-s"));
  121 + EXPECT_EQ(1u, app.count("--string"));
122 122 EXPECT_EQ(str, "mystring");
123 123 }
124 124  
... ... @@ -127,8 +127,8 @@ TEST_F(TApp, OneStringEqualVersion) {
127 127 app.add_option("-s,--string", str);
128 128 args = {"--string=mystring"};
129 129 run();
130   - EXPECT_EQ((size_t)1, app.count("-s"));
131   - EXPECT_EQ((size_t)1, app.count("--string"));
  130 + EXPECT_EQ(1u, app.count("-s"));
  131 + EXPECT_EQ(1u, app.count("--string"));
132 132 EXPECT_EQ(str, "mystring");
133 133 }
134 134  
... ... @@ -138,8 +138,8 @@ TEST_F(TApp, OneStringEqualVersionWindowsStyle) {
138 138 args = {"/string:mystring"};
139 139 app.allow_windows_style_options();
140 140 run();
141   - EXPECT_EQ((size_t)1, app.count("-s"));
142   - EXPECT_EQ((size_t)1, app.count("--string"));
  141 + EXPECT_EQ(1u, app.count("-s"));
  142 + EXPECT_EQ(1u, app.count("--string"));
143 143 EXPECT_EQ(str, "mystring");
144 144 }
145 145  
... ... @@ -147,8 +147,8 @@ TEST_F(TApp, OneStringEqualVersionSingleString) {
147 147 std::string str;
148 148 app.add_option("-s,--string", str);
149 149 app.parse("--string=mystring");
150   - EXPECT_EQ((size_t)1, app.count("-s"));
151   - EXPECT_EQ((size_t)1, app.count("--string"));
  150 + EXPECT_EQ(1u, app.count("-s"));
  151 + EXPECT_EQ(1u, app.count("--string"));
152 152 EXPECT_EQ(str, "mystring");
153 153 }
154 154  
... ... @@ -156,8 +156,8 @@ TEST_F(TApp, OneStringEqualVersionSingleStringQuoted) {
156 156 std::string str;
157 157 app.add_option("-s,--string", str);
158 158 app.parse("--string=\"this is my quoted string\"");
159   - EXPECT_EQ((size_t)1, app.count("-s"));
160   - EXPECT_EQ((size_t)1, app.count("--string"));
  159 + EXPECT_EQ(1u, app.count("-s"));
  160 + EXPECT_EQ(1u, app.count("--string"));
161 161 EXPECT_EQ(str, "this is my quoted string");
162 162 }
163 163  
... ... @@ -271,8 +271,8 @@ TEST_F(TApp, TogetherInt) {
271 271 app.add_option("-i,--int", i);
272 272 args = {"-i4"};
273 273 run();
274   - EXPECT_EQ((size_t)1, app.count("--int"));
275   - EXPECT_EQ((size_t)1, app.count("-i"));
  274 + EXPECT_EQ(1u, app.count("--int"));
  275 + EXPECT_EQ(1u, app.count("-i"));
276 276 EXPECT_EQ(i, 4);
277 277 }
278 278  
... ... @@ -281,8 +281,8 @@ TEST_F(TApp, SepInt) {
281 281 app.add_option("-i,--int", i);
282 282 args = {"-i", "4"};
283 283 run();
284   - EXPECT_EQ((size_t)1, app.count("--int"));
285   - EXPECT_EQ((size_t)1, app.count("-i"));
  284 + EXPECT_EQ(1u, app.count("--int"));
  285 + EXPECT_EQ(1u, app.count("-i"));
286 286 EXPECT_EQ(i, 4);
287 287 }
288 288  
... ... @@ -291,8 +291,8 @@ TEST_F(TApp, OneStringAgain) {
291 291 app.add_option("-s,--string", str);
292 292 args = {"--string", "mystring"};
293 293 run();
294   - EXPECT_EQ((size_t)1, app.count("-s"));
295   - EXPECT_EQ((size_t)1, app.count("--string"));
  294 + EXPECT_EQ(1u, app.count("-s"));
  295 + EXPECT_EQ(1u, app.count("--string"));
296 296 EXPECT_EQ(str, "mystring");
297 297 }
298 298  
... ... @@ -304,8 +304,8 @@ TEST_F(TApp, OneStringFunction) {
304 304 });
305 305 args = {"--string", "mystring"};
306 306 run();
307   - EXPECT_EQ((size_t)1, app.count("-s"));
308   - EXPECT_EQ((size_t)1, app.count("--string"));
  307 + EXPECT_EQ(1u, app.count("-s"));
  308 + EXPECT_EQ(1u, app.count("--string"));
309 309 EXPECT_EQ(str, "mystring");
310 310 }
311 311  
... ... @@ -339,7 +339,7 @@ TEST_F(TApp, doubleVectorFunction) {
339 339 });
340 340 args = {"--val", "5", "--val", "6", "--val", "7"};
341 341 run();
342   - EXPECT_EQ(res.size(), (size_t)3);
  342 + EXPECT_EQ(res.size(), 3u);
343 343 EXPECT_EQ(res[0], 10.0);
344 344 EXPECT_EQ(res[2], 12.0);
345 345 }
... ... @@ -359,8 +359,8 @@ TEST_F(TApp, DefaultStringAgain) {
359 359 std::string str = "previous";
360 360 app.add_option("-s,--string", str);
361 361 run();
362   - EXPECT_EQ((size_t)0, app.count("-s"));
363   - EXPECT_EQ((size_t)0, app.count("--string"));
  362 + EXPECT_EQ(0u, app.count("-s"));
  363 + EXPECT_EQ(0u, app.count("--string"));
364 364 EXPECT_EQ(str, "previous");
365 365 }
366 366  
... ... @@ -368,8 +368,8 @@ TEST_F(TApp, DefaultStringAgainEmpty) {
368 368 std::string str = "previous";
369 369 app.add_option("-s,--string", str);
370 370 app.parse(" ");
371   - EXPECT_EQ((size_t)0, app.count("-s"));
372   - EXPECT_EQ((size_t)0, app.count("--string"));
  371 + EXPECT_EQ(0u, app.count("-s"));
  372 + EXPECT_EQ(0u, app.count("--string"));
373 373 EXPECT_EQ(str, "previous");
374 374 }
375 375  
... ... @@ -397,9 +397,9 @@ TEST_F(TApp, LotsOfFlags) {
397 397  
398 398 args = {"-a", "-b", "-aA"};
399 399 run();
400   - EXPECT_EQ((size_t)2, app.count("-a"));
401   - EXPECT_EQ((size_t)1, app.count("-b"));
402   - EXPECT_EQ((size_t)1, app.count("-A"));
  400 + EXPECT_EQ(2u, app.count("-a"));
  401 + EXPECT_EQ(1u, app.count("-b"));
  402 + EXPECT_EQ(1u, app.count("-A"));
403 403 }
404 404  
405 405 TEST_F(TApp, LotsOfFlagsSingleString) {
... ... @@ -409,9 +409,9 @@ TEST_F(TApp, LotsOfFlagsSingleString) {
409 409 app.add_flag("-b");
410 410  
411 411 app.parse("-a -b -aA");
412   - EXPECT_EQ((size_t)2, app.count("-a"));
413   - EXPECT_EQ((size_t)1, app.count("-b"));
414   - EXPECT_EQ((size_t)1, app.count("-A"));
  412 + EXPECT_EQ(2u, app.count("-a"));
  413 + EXPECT_EQ(1u, app.count("-b"));
  414 + EXPECT_EQ(1u, app.count("-A"));
415 415 }
416 416  
417 417 TEST_F(TApp, LotsOfFlagsSingleStringExtraSpace) {
... ... @@ -421,9 +421,9 @@ TEST_F(TApp, LotsOfFlagsSingleStringExtraSpace) {
421 421 app.add_flag("-b");
422 422  
423 423 app.parse(" -a -b -aA ");
424   - EXPECT_EQ((size_t)2, app.count("-a"));
425   - EXPECT_EQ((size_t)1, app.count("-b"));
426   - EXPECT_EQ((size_t)1, app.count("-A"));
  424 + EXPECT_EQ(2u, app.count("-a"));
  425 + EXPECT_EQ(1u, app.count("-b"));
  426 + EXPECT_EQ(1u, app.count("-A"));
427 427 }
428 428  
429 429 TEST_F(TApp, BoolAndIntFlags) {
... ... @@ -480,8 +480,8 @@ TEST_F(TApp, ShortOpts) {
480 480  
481 481 run();
482 482  
483   - EXPECT_EQ((size_t)2, app.count("-z"));
484   - EXPECT_EQ((size_t)1, app.count("-y"));
  483 + EXPECT_EQ(2u, app.count("-z"));
  484 + EXPECT_EQ(1u, app.count("-y"));
485 485 EXPECT_EQ((unsigned long long)2, funnyint);
486 486 EXPECT_EQ("zyz", someopt);
487 487 }
... ... @@ -498,8 +498,8 @@ TEST_F(TApp, DefaultOpts) {
498 498  
499 499 run();
500 500  
501   - EXPECT_EQ((size_t)1, app.count("i"));
502   - EXPECT_EQ((size_t)1, app.count("-s"));
  501 + EXPECT_EQ(1u, app.count("i"));
  502 + EXPECT_EQ(1u, app.count("-s"));
503 503 EXPECT_EQ(2, i);
504 504 EXPECT_EQ("9", s);
505 505 }
... ... @@ -750,13 +750,13 @@ TEST_F(TApp, PositionalNoSpace) {
750 750 args = {"-O", "Test", "param1", "param2"};
751 751 run();
752 752  
753   - EXPECT_EQ(options.size(), (size_t)1);
  753 + EXPECT_EQ(options.size(), 1u);
754 754 EXPECT_EQ(options.at(0), "Test");
755 755  
756 756 args = {"-OTest", "param1", "param2"};
757 757 run();
758 758  
759   - EXPECT_EQ(options.size(), (size_t)1);
  759 + EXPECT_EQ(options.size(), 1u);
760 760 EXPECT_EQ(options.at(0), "Test");
761 761 }
762 762  
... ... @@ -771,13 +771,13 @@ TEST_F(TApp, PositionalNoSpaceLong) {
771 771 args = {"--option", "Test", "param1", "param2"};
772 772 run();
773 773  
774   - EXPECT_EQ(options.size(), (size_t)1);
  774 + EXPECT_EQ(options.size(), 1u);
775 775 EXPECT_EQ(options.at(0), "Test");
776 776  
777 777 args = {"--option=Test", "param1", "param2"};
778 778 run();
779 779  
780   - EXPECT_EQ(options.size(), (size_t)1);
  780 + EXPECT_EQ(options.size(), 1u);
781 781 EXPECT_EQ(options.at(0), "Test");
782 782 }
783 783  
... ... @@ -963,15 +963,15 @@ TEST_F(TApp, CallbackFlags) {
963 963 app.add_flag_function("-v", func);
964 964  
965 965 run();
966   - EXPECT_EQ(value, (size_t)0);
  966 + EXPECT_EQ(value, 0u);
967 967  
968 968 args = {"-v"};
969 969 run();
970   - EXPECT_EQ(value, (size_t)1);
  970 + EXPECT_EQ(value, 1u);
971 971  
972 972 args = {"-vv"};
973 973 run();
974   - EXPECT_EQ(value, (size_t)2);
  974 + EXPECT_EQ(value, 2u);
975 975  
976 976 EXPECT_THROW(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
977 977 }
... ... @@ -986,15 +986,15 @@ TEST_F(TApp, CallbackFlagsAuto) {
986 986 app.add_flag("-v", func);
987 987  
988 988 run();
989   - EXPECT_EQ(value, (size_t)0);
  989 + EXPECT_EQ(value, 0u);
990 990  
991 991 args = {"-v"};
992 992 run();
993   - EXPECT_EQ(value, (size_t)1);
  993 + EXPECT_EQ(value, 1u);
994 994  
995 995 args = {"-vv"};
996 996 run();
997   - EXPECT_EQ(value, (size_t)2);
  997 + EXPECT_EQ(value, 2u);
998 998  
999 999 EXPECT_THROW(app.add_flag("hi", func), CLI::IncorrectConstruction);
1000 1000 }
... ... @@ -1011,8 +1011,8 @@ TEST_F(TApp, Positionals) {
1011 1011  
1012 1012 run();
1013 1013  
1014   - EXPECT_EQ((size_t)1, app.count("posit1"));
1015   - EXPECT_EQ((size_t)1, app.count("posit2"));
  1014 + EXPECT_EQ(1u, app.count("posit1"));
  1015 + EXPECT_EQ(1u, app.count("posit2"));
1016 1016 EXPECT_EQ("thing1", posit1);
1017 1017 EXPECT_EQ("thing2", posit2);
1018 1018 }
... ... @@ -1047,8 +1047,8 @@ TEST_F(TApp, MixedPositionals) {
1047 1047  
1048 1048 run();
1049 1049  
1050   - EXPECT_EQ((size_t)1, app.count("posit2"));
1051   - EXPECT_EQ((size_t)1, app.count("--posit1"));
  1050 + EXPECT_EQ(1u, app.count("posit2"));
  1051 + EXPECT_EQ(1u, app.count("--posit1"));
1052 1052 EXPECT_EQ(7, positional_int);
1053 1053 EXPECT_EQ("thing2", positional_string);
1054 1054 }
... ... @@ -1078,19 +1078,19 @@ TEST_F(TApp, Reset) {
1078 1078  
1079 1079 run();
1080 1080  
1081   - EXPECT_EQ((size_t)1, app.count("--simple"));
1082   - EXPECT_EQ((size_t)1, app.count("-d"));
  1081 + EXPECT_EQ(1u, app.count("--simple"));
  1082 + EXPECT_EQ(1u, app.count("-d"));
1083 1083 EXPECT_DOUBLE_EQ(1.2, doub);
1084 1084  
1085 1085 app.clear();
1086 1086  
1087   - EXPECT_EQ((size_t)0, app.count("--simple"));
1088   - EXPECT_EQ((size_t)0, app.count("-d"));
  1087 + EXPECT_EQ(0u, app.count("--simple"));
  1088 + EXPECT_EQ(0u, app.count("-d"));
1089 1089  
1090 1090 run();
1091 1091  
1092   - EXPECT_EQ((size_t)1, app.count("--simple"));
1093   - EXPECT_EQ((size_t)1, app.count("-d"));
  1092 + EXPECT_EQ(1u, app.count("--simple"));
  1093 + EXPECT_EQ(1u, app.count("-d"));
1094 1094 EXPECT_DOUBLE_EQ(1.2, doub);
1095 1095 }
1096 1096  
... ... @@ -1408,7 +1408,7 @@ TEST_F(TApp, VectorFixedString) {
1408 1408  
1409 1409 args = {"--string", "mystring", "mystring2", "mystring3"};
1410 1410 run();
1411   - EXPECT_EQ((size_t)3, app.count("--string"));
  1411 + EXPECT_EQ(3u, app.count("--string"));
1412 1412 EXPECT_EQ(answer, strvec);
1413 1413 }
1414 1414  
... ... @@ -1421,7 +1421,7 @@ TEST_F(TApp, VectorDefaultedFixedString) {
1421 1421  
1422 1422 args = {"--string", "mystring", "mystring2", "mystring3"};
1423 1423 run();
1424   - EXPECT_EQ((size_t)3, app.count("--string"));
  1424 + EXPECT_EQ(3u, app.count("--string"));
1425 1425 EXPECT_EQ(answer, strvec);
1426 1426 }
1427 1427  
... ... @@ -1434,12 +1434,12 @@ TEST_F(TApp, VectorUnlimString) {
1434 1434  
1435 1435 args = {"--string", "mystring", "mystring2", "mystring3"};
1436 1436 run();
1437   - EXPECT_EQ((size_t)3, app.count("--string"));
  1437 + EXPECT_EQ(3u, app.count("--string"));
1438 1438 EXPECT_EQ(answer, strvec);
1439 1439  
1440 1440 args = {"-s", "mystring", "mystring2", "mystring3"};
1441 1441 run();
1442   - EXPECT_EQ((size_t)3, app.count("--string"));
  1442 + EXPECT_EQ(3u, app.count("--string"));
1443 1443 EXPECT_EQ(answer, strvec);
1444 1444 }
1445 1445  
... ... @@ -1452,7 +1452,7 @@ TEST_F(TApp, VectorFancyOpts) {
1452 1452  
1453 1453 args = {"--string", "mystring", "mystring2", "mystring3"};
1454 1454 run();
1455   - EXPECT_EQ((size_t)3, app.count("--string"));
  1455 + EXPECT_EQ(3u, app.count("--string"));
1456 1456 EXPECT_EQ(answer, strvec);
1457 1457  
1458 1458 args = {"one", "two"};
... ... @@ -1626,7 +1626,7 @@ TEST_F(TApp, Env) {
1626 1626 run();
1627 1627  
1628 1628 EXPECT_EQ(2, val);
1629   - EXPECT_EQ((size_t)1, vopt->count());
  1629 + EXPECT_EQ(1u, vopt->count());
1630 1630  
1631 1631 vopt->required();
1632 1632 run();
... ...
tests/CreationTest.cpp
  View file @b4910df
... ... @@ -479,8 +479,8 @@ TEST_F(TApp, SubcommandDefaults) {
479 479 EXPECT_FALSE(app.get_fallthrough());
480 480 EXPECT_EQ(app.get_footer(), "");
481 481 EXPECT_EQ(app.get_group(), "Subcommands");
482   - EXPECT_EQ(app.get_require_subcommand_min(), (size_t)0);
483   - EXPECT_EQ(app.get_require_subcommand_max(), (size_t)0);
  482 + EXPECT_EQ(app.get_require_subcommand_min(), 0u);
  483 + EXPECT_EQ(app.get_require_subcommand_max(), 0u);
484 484  
485 485 app.allow_extras();
486 486 app.prefix_command();
... ... @@ -512,39 +512,39 @@ TEST_F(TApp, SubcommandDefaults) {
512 512 EXPECT_TRUE(app2->get_fallthrough());
513 513 EXPECT_EQ(app2->get_footer(), "footy");
514 514 EXPECT_EQ(app2->get_group(), "Stuff");
515   - EXPECT_EQ(app2->get_require_subcommand_min(), (size_t)0);
516   - EXPECT_EQ(app2->get_require_subcommand_max(), (size_t)3);
  515 + EXPECT_EQ(app2->get_require_subcommand_min(), 0u);
  516 + EXPECT_EQ(app2->get_require_subcommand_max(), 3u);
517 517 }
518 518  
519 519 TEST_F(TApp, SubcommandMinMax) {
520 520  
521   - EXPECT_EQ(app.get_require_subcommand_min(), (size_t)0);
522   - EXPECT_EQ(app.get_require_subcommand_max(), (size_t)0);
  521 + EXPECT_EQ(app.get_require_subcommand_min(), 0u);
  522 + EXPECT_EQ(app.get_require_subcommand_max(), 0u);
523 523  
524 524 app.require_subcommand();
525 525  
526   - EXPECT_EQ(app.get_require_subcommand_min(), (size_t)1);
527   - EXPECT_EQ(app.get_require_subcommand_max(), (size_t)0);
  526 + EXPECT_EQ(app.get_require_subcommand_min(), 1u);
  527 + EXPECT_EQ(app.get_require_subcommand_max(), 0u);
528 528  
529 529 app.require_subcommand(2);
530 530  
531   - EXPECT_EQ(app.get_require_subcommand_min(), (size_t)2);
532   - EXPECT_EQ(app.get_require_subcommand_max(), (size_t)2);
  531 + EXPECT_EQ(app.get_require_subcommand_min(), 2u);
  532 + EXPECT_EQ(app.get_require_subcommand_max(), 2u);
533 533  
534 534 app.require_subcommand(0);
535 535  
536   - EXPECT_EQ(app.get_require_subcommand_min(), (size_t)0);
537   - EXPECT_EQ(app.get_require_subcommand_max(), (size_t)0);
  536 + EXPECT_EQ(app.get_require_subcommand_min(), 0u);
  537 + EXPECT_EQ(app.get_require_subcommand_max(), 0u);
538 538  
539 539 app.require_subcommand(-2);
540 540  
541   - EXPECT_EQ(app.get_require_subcommand_min(), (size_t)0);
542   - EXPECT_EQ(app.get_require_subcommand_max(), (size_t)2);
  541 + EXPECT_EQ(app.get_require_subcommand_min(), 0u);
  542 + EXPECT_EQ(app.get_require_subcommand_max(), 2u);
543 543  
544 544 app.require_subcommand(3, 7);
545 545  
546   - EXPECT_EQ(app.get_require_subcommand_min(), (size_t)3);
547   - EXPECT_EQ(app.get_require_subcommand_max(), (size_t)7);
  546 + EXPECT_EQ(app.get_require_subcommand_min(), 3u);
  547 + EXPECT_EQ(app.get_require_subcommand_max(), 7u);
548 548 }
549 549  
550 550 TEST_F(TApp, GetOptionList) {
... ...
tests/HelpersTest.cpp
  View file @b4910df
... ... @@ -8,7 +8,7 @@
8 8  
9 9 TEST(Split, SimpleByToken) {
10 10 auto out = CLI::detail::split("one.two.three", '.');
11   - ASSERT_EQ((size_t)3, out.size());
  11 + ASSERT_EQ(3u, out.size());
12 12 EXPECT_EQ("one", out.at(0));
13 13 EXPECT_EQ("two", out.at(1));
14 14 EXPECT_EQ("three", out.at(2));
... ... @@ -16,13 +16,13 @@ TEST(Split, SimpleByToken) {
16 16  
17 17 TEST(Split, Single) {
18 18 auto out = CLI::detail::split("one", '.');
19   - ASSERT_EQ((size_t)1, out.size());
  19 + ASSERT_EQ(1u, out.size());
20 20 EXPECT_EQ("one", out.at(0));
21 21 }
22 22  
23 23 TEST(Split, Empty) {
24 24 auto out = CLI::detail::split("", '.');
25   - ASSERT_EQ((size_t)1, out.size());
  25 + ASSERT_EQ(1u, out.size());
26 26 EXPECT_EQ("", out.at(0));
27 27 }
28 28  
... ...
tests/IniTest.cpp
  View file @b4910df
... ... @@ -24,12 +24,12 @@ TEST(StringBased, First) {
24 24  
25 25 std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
26 26  
27   - EXPECT_EQ((size_t)2, output.size());
  27 + EXPECT_EQ(2u, output.size());
28 28 EXPECT_EQ("one", output.at(0).name);
29   - EXPECT_EQ((size_t)1, output.at(0).inputs.size());
  29 + EXPECT_EQ(1u, output.at(0).inputs.size());
30 30 EXPECT_EQ("three", output.at(0).inputs.at(0));
31 31 EXPECT_EQ("two", output.at(1).name);
32   - EXPECT_EQ((size_t)1, output.at(1).inputs.size());
  32 + EXPECT_EQ(1u, output.at(1).inputs.size());
33 33 EXPECT_EQ("four", output.at(1).inputs.at(0));
34 34 }
35 35  
... ... @@ -45,12 +45,12 @@ TEST(StringBased, FirstWithComments) {
45 45  
46 46 std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
47 47  
48   - EXPECT_EQ((size_t)2, output.size());
  48 + EXPECT_EQ(2u, output.size());
49 49 EXPECT_EQ("one", output.at(0).name);
50   - EXPECT_EQ((size_t)1, output.at(0).inputs.size());
  50 + EXPECT_EQ(1u, output.at(0).inputs.size());
51 51 EXPECT_EQ("three", output.at(0).inputs.at(0));
52 52 EXPECT_EQ("two", output.at(1).name);
53   - EXPECT_EQ((size_t)1, output.at(1).inputs.size());
  53 + EXPECT_EQ(1u, output.at(1).inputs.size());
54 54 EXPECT_EQ("four", output.at(1).inputs.at(0));
55 55 }
56 56  
... ... @@ -65,15 +65,15 @@ TEST(StringBased, Quotes) {
65 65  
66 66 std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
67 67  
68   - EXPECT_EQ((size_t)3, output.size());
  68 + EXPECT_EQ(3u, output.size());
69 69 EXPECT_EQ("one", output.at(0).name);
70   - EXPECT_EQ((size_t)1, output.at(0).inputs.size());
  70 + EXPECT_EQ(1u, output.at(0).inputs.size());
71 71 EXPECT_EQ("three", output.at(0).inputs.at(0));
72 72 EXPECT_EQ("two", output.at(1).name);
73   - EXPECT_EQ((size_t)1, output.at(1).inputs.size());
  73 + EXPECT_EQ(1u, output.at(1).inputs.size());
74 74 EXPECT_EQ("four", output.at(1).inputs.at(0));
75 75 EXPECT_EQ("five", output.at(2).name);
76   - EXPECT_EQ((size_t)1, output.at(2).inputs.size());
  76 + EXPECT_EQ(1u, output.at(2).inputs.size());
77 77 EXPECT_EQ("six and seven", output.at(2).inputs.at(0));
78 78 }
79 79  
... ... @@ -88,15 +88,15 @@ TEST(StringBased, Vector) {
88 88  
89 89 std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
90 90  
91   - EXPECT_EQ((size_t)3, output.size());
  91 + EXPECT_EQ(3u, output.size());
92 92 EXPECT_EQ("one", output.at(0).name);
93   - EXPECT_EQ((size_t)1, output.at(0).inputs.size());
  93 + EXPECT_EQ(1u, output.at(0).inputs.size());
94 94 EXPECT_EQ("three", output.at(0).inputs.at(0));
95 95 EXPECT_EQ("two", output.at(1).name);
96   - EXPECT_EQ((size_t)1, output.at(1).inputs.size());
  96 + EXPECT_EQ(1u, output.at(1).inputs.size());
97 97 EXPECT_EQ("four", output.at(1).inputs.at(0));
98 98 EXPECT_EQ("five", output.at(2).name);
99   - EXPECT_EQ((size_t)3, output.at(2).inputs.size());
  99 + EXPECT_EQ(3u, output.at(2).inputs.size());
100 100 EXPECT_EQ("six", output.at(2).inputs.at(0));
101 101 EXPECT_EQ("and", output.at(2).inputs.at(1));
102 102 EXPECT_EQ("seven", output.at(2).inputs.at(2));
... ... @@ -112,12 +112,12 @@ TEST(StringBased, Spaces) {
112 112  
113 113 std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
114 114  
115   - EXPECT_EQ((size_t)2, output.size());
  115 + EXPECT_EQ(2u, output.size());
116 116 EXPECT_EQ("one", output.at(0).name);
117   - EXPECT_EQ((size_t)1, output.at(0).inputs.size());
  117 + EXPECT_EQ(1u, output.at(0).inputs.size());
118 118 EXPECT_EQ("three", output.at(0).inputs.at(0));
119 119 EXPECT_EQ("two", output.at(1).name);
120   - EXPECT_EQ((size_t)1, output.at(1).inputs.size());
  120 + EXPECT_EQ(1u, output.at(1).inputs.size());
121 121 EXPECT_EQ("four", output.at(1).inputs.at(0));
122 122 }
123 123  
... ... @@ -132,13 +132,13 @@ TEST(StringBased, Sections) {
132 132  
133 133 std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
134 134  
135   - EXPECT_EQ((size_t)2, output.size());
  135 + EXPECT_EQ(2u, output.size());
136 136 EXPECT_EQ("one", output.at(0).name);
137   - EXPECT_EQ((size_t)1, output.at(0).inputs.size());
  137 + EXPECT_EQ(1u, output.at(0).inputs.size());
138 138 EXPECT_EQ("three", output.at(0).inputs.at(0));
139 139 EXPECT_EQ("two", output.at(1).name);
140 140 EXPECT_EQ("second", output.at(1).parents.at(0));
141   - EXPECT_EQ((size_t)1, output.at(1).inputs.size());
  141 + EXPECT_EQ(1u, output.at(1).inputs.size());
142 142 EXPECT_EQ("four", output.at(1).inputs.at(0));
143 143 EXPECT_EQ("second.two", output.at(1).fullname());
144 144 }
... ... @@ -156,14 +156,14 @@ TEST(StringBased, SpacesSections) {
156 156  
157 157 std::vector<CLI::ConfigItem> output = CLI::ConfigINI().from_config(ofile);
158 158  
159   - EXPECT_EQ((size_t)2, output.size());
  159 + EXPECT_EQ(2u, output.size());
160 160 EXPECT_EQ("one", output.at(0).name);
161   - EXPECT_EQ((size_t)1, output.at(0).inputs.size());
  161 + EXPECT_EQ(1u, output.at(0).inputs.size());
162 162 EXPECT_EQ("three", output.at(0).inputs.at(0));
163 163 EXPECT_EQ("two", output.at(1).name);
164   - EXPECT_EQ((size_t)1, output.at(1).parents.size());
  164 + EXPECT_EQ(1u, output.at(1).parents.size());
165 165 EXPECT_EQ("second", output.at(1).parents.at(0));
166   - EXPECT_EQ((size_t)1, output.at(1).inputs.size());
  166 + EXPECT_EQ(1u, output.at(1).inputs.size());
167 167 EXPECT_EQ("four", output.at(1).inputs.at(0));
168 168 }
169 169  
... ... @@ -256,7 +256,7 @@ TEST_F(TApp, IniGetNoRemaining) {
256 256 int two = 0;
257 257 app.add_option("--two", two);
258 258 ASSERT_NO_THROW(run());
259   - EXPECT_EQ(app.remaining().size(), (size_t)0);
  259 + EXPECT_EQ(app.remaining().size(), 0u);
260 260 }
261 261  
262 262 TEST_F(TApp, IniNotRequiredNotDefault) {
... ...
tests/NewParseTest.cpp
  View file @b4910df
... ... @@ -203,7 +203,7 @@ TEST_F(TApp, AddingComplexParserDetail) {
203 203 if(!rsearch) {
204 204 skip_tests = true;
205 205 } else {
206   - EXPECT_EQ(m.size(), (size_t)9);
  206 + EXPECT_EQ(m.size(), 9u);
207 207 }
208 208  
209 209 } catch(...) {
... ...
tests/SubcommandTest.cpp
  View file @b4910df
... ... @@ -19,19 +19,19 @@ TEST_F(TApp, BasicSubcommands) {
19 19 EXPECT_THROW(app.get_subcommand("sub3"), CLI::OptionNotFound);
20 20  
21 21 run();
22   - EXPECT_EQ((size_t)0, app.get_subcommands().size());
  22 + EXPECT_EQ(0u, app.get_subcommands().size());
23 23  
24 24 args = {"sub1"};
25 25 run();
26 26 EXPECT_EQ(sub1, app.get_subcommands().at(0));
27   - EXPECT_EQ((size_t)1, app.get_subcommands().size());
  27 + EXPECT_EQ(1u, app.get_subcommands().size());
28 28  
29 29 app.clear();
30   - EXPECT_EQ((size_t)0, app.get_subcommands().size());
  30 + EXPECT_EQ(0u, app.get_subcommands().size());
31 31  
32 32 args = {"sub2"};
33 33 run();
34   - EXPECT_EQ((size_t)1, app.get_subcommands().size());
  34 + EXPECT_EQ(1u, app.get_subcommands().size());
35 35 EXPECT_EQ(sub2, app.get_subcommands().at(0));
36 36  
37 37 args = {"SUb2"};
... ... @@ -64,7 +64,7 @@ TEST_F(TApp, MultiSubFallthrough) {
64 64 EXPECT_TRUE(app.got_subcommand(sub1));
65 65 EXPECT_TRUE(*sub1);
66 66 EXPECT_TRUE(sub1->parsed());
67   - EXPECT_EQ(sub1->count(), (size_t)1);
  67 + EXPECT_EQ(sub1->count(), 1u);
68 68  
69 69 EXPECT_TRUE(app.got_subcommand("sub2"));
70 70 EXPECT_TRUE(app.got_subcommand(sub2));
... ... @@ -88,7 +88,7 @@ TEST_F(TApp, MultiSubFallthrough) {
88 88 EXPECT_TRUE(*sub1);
89 89 EXPECT_FALSE(*sub2);
90 90 EXPECT_FALSE(sub2->parsed());
91   - EXPECT_EQ(sub2->count(), (size_t)0);
  91 + EXPECT_EQ(sub2->count(), 0u);
92 92  
93 93 EXPECT_THROW(app.got_subcommand("sub3"), CLI::OptionNotFound);
94 94 }
... ... @@ -415,8 +415,8 @@ TEST_F(TApp, PrefixSubcom) {
415 415 args = {"--simple", "subc", "other", "--simple", "--mine"};
416 416 run();
417 417  
418   - EXPECT_EQ(app.remaining_size(), (size_t)0);
419   - EXPECT_EQ(app.remaining_size(true), (size_t)3);
  418 + EXPECT_EQ(app.remaining_size(), 0u);
  419 + EXPECT_EQ(app.remaining_size(true), 3u);
420 420 EXPECT_EQ(subc->remaining(), std::vector<std::string>({"other", "--simple", "--mine"}));
421 421 }
422 422  
... ... @@ -424,7 +424,7 @@ TEST_F(TApp, InheritHelpAllFlag) {
424 424 app.set_help_all_flag("--help-all");
425 425 auto subc = app.add_subcommand("subc");
426 426 auto help_opt_list = subc->get_options([](const CLI::Option *opt) { return opt->get_name() == "--help-all"; });
427   - EXPECT_EQ(help_opt_list.size(), (size_t)1);
  427 + EXPECT_EQ(help_opt_list.size(), 1u);
428 428 }
429 429  
430 430 struct SubcommandProgram : public TApp {
... ... @@ -474,7 +474,7 @@ TEST_F(SubcommandProgram, Multiple) {
474 474 args = {"-d", "start", "-ffilename", "stop"};
475 475  
476 476 run();
477   - EXPECT_EQ((size_t)2, app.get_subcommands().size());
  477 + EXPECT_EQ(2u, app.get_subcommands().size());
478 478 EXPECT_EQ(1, dummy);
479 479 EXPECT_EQ("filename", file);
480 480 }
... ... @@ -490,7 +490,7 @@ TEST_F(SubcommandProgram, MultipleArgs) {
490 490  
491 491 run();
492 492  
493   - EXPECT_EQ((size_t)2, app.get_subcommands().size());
  493 + EXPECT_EQ(2u, app.get_subcommands().size());
494 494 }
495 495  
496 496 TEST_F(SubcommandProgram, CaseCheck) {
... ... @@ -513,17 +513,17 @@ TEST_F(TApp, SubcomInheritCaseCheck) {
513 513 auto sub2 = app.add_subcommand("sub2");
514 514  
515 515 run();
516   - EXPECT_EQ((size_t)0, app.get_subcommands().size());
517   - EXPECT_EQ((size_t)2, app.get_subcommands({}).size());
518   - EXPECT_EQ((size_t)1, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub1"; }).size());
  516 + EXPECT_EQ(0u, app.get_subcommands().size());
  517 + EXPECT_EQ(2u, app.get_subcommands({}).size());
  518 + EXPECT_EQ(1u, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub1"; }).size());
519 519  
520 520 args = {"SuB1"};
521 521 run();
522 522 EXPECT_EQ(sub1, app.get_subcommands().at(0));
523   - EXPECT_EQ((size_t)1, app.get_subcommands().size());
  523 + EXPECT_EQ(1u, app.get_subcommands().size());
524 524  
525 525 app.clear();
526   - EXPECT_EQ((size_t)0, app.get_subcommands().size());
  526 + EXPECT_EQ(0u, app.get_subcommands().size());
527 527  
528 528 args = {"sUb2"};
529 529 run();
... ... @@ -550,17 +550,17 @@ TEST_F(TApp, SubcomInheritUnderscoreCheck) {
550 550 auto sub2 = app.add_subcommand("sub_option2");
551 551  
552 552 run();
553   - EXPECT_EQ((size_t)0, app.get_subcommands().size());
554   - EXPECT_EQ((size_t)2, app.get_subcommands({}).size());
555   - EXPECT_EQ((size_t)1, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub_option1"; }).size());
  553 + EXPECT_EQ(0u, app.get_subcommands().size());
  554 + EXPECT_EQ(2u, app.get_subcommands({}).size());
  555 + EXPECT_EQ(1u, app.get_subcommands([](const CLI::App *s) { return s->get_name() == "sub_option1"; }).size());
556 556  
557 557 args = {"suboption1"};
558 558 run();
559 559 EXPECT_EQ(sub1, app.get_subcommands().at(0));
560   - EXPECT_EQ((size_t)1, app.get_subcommands().size());
  560 + EXPECT_EQ(1u, app.get_subcommands().size());
561 561  
562 562 app.clear();
563   - EXPECT_EQ((size_t)0, app.get_subcommands().size());
  563 + EXPECT_EQ(0u, app.get_subcommands().size());
564 564  
565 565 args = {"_suboption2"};
566 566 run();
... ... @@ -798,7 +798,7 @@ TEST_F(ManySubcommands, MaxCommands) {
798 798 // The extra subcommand counts as an extra
799 799 args = {"sub1", "sub2", "sub3"};
800 800 EXPECT_NO_THROW(run());
801   - EXPECT_EQ(sub2->remaining().size(), (size_t)1);
  801 + EXPECT_EQ(sub2->remaining().size(), 1u);
802 802  
803 803 // Currently, setting sub2 to throw causes an extras error
804 804 // In the future, would passing on up to app's extras be better?
... ...
tests/WindowsTest.cpp
  View file @b4910df
... ... @@ -8,6 +8,6 @@ TEST_F(TApp, WindowsTestSimple) {
8 8 app.add_flag("-c,--count");
9 9 args = {"-c"};
10 10 run();
11   - EXPECT_EQ((size_t)1, app.count("-c"));
12   - EXPECT_EQ((size_t)1, app.count("--count"));
  11 + EXPECT_EQ(1u, app.count("-c"));
  12 + EXPECT_EQ(1u, app.count("--count"));
13 13 }
... ...