Skip to content

Commit 96e4dcd

Browse files
author
Jesse
committed
Update tests.cpp
1 parent c1d1e74 commit 96e4dcd

1 file changed

Lines changed: 191 additions & 54 deletions

File tree

‎tests.cpp‎

Lines changed: 191 additions & 54 deletions
Original file line numberDiff line numberDiff line change
@@ -27,66 +27,203 @@ struct result {
2727
return {true, 0, "", "", ""}; \
2828
}
2929

30-
TEST(no_args, {
31-
try {
32-
parser.parse(argc, argv);
33-
} catch (const ArgumentParser::ArgumentNotFound& ex) {
34-
TASSERT(false, ex.what())
35-
}
36-
}, )
37-
38-
TEST(short_optional_flag_exists,
39-
{
40-
parser.add_argument("-f", "a flag", false);
41-
try {
42-
parser.parse(argc, argv);
43-
} catch (const ArgumentParser::ArgumentNotFound& ex) {
44-
TASSERT(false, ex.what())
45-
}
46-
TASSERT(parser.exists("f"), "flag not found")
47-
},
48-
"-f")
49-
50-
TEST(short_optional_flag_does_not_exist, {
51-
parser.add_argument("-f", "a flag", false);
52-
try {
53-
parser.parse(argc, argv);
54-
} catch (const ArgumentParser::ArgumentNotFound& ex) {
55-
TASSERT(false, ex.what())
56-
}
57-
TASSERT(!parser.exists("f"), "flag found")
58-
}, )
59-
60-
TEST(short_required_flag_exists,
61-
{
62-
parser.add_argument("-f", "a flag", true);
63-
try {
64-
parser.parse(argc, argv);
65-
} catch (const ArgumentParser::ArgumentNotFound& ex) {
66-
TASSERT(false, ex.what())
67-
}
68-
TASSERT(parser.exists("f"), "required flag not found")
69-
},
70-
"-f")
71-
72-
TEST(short_required_flag_does_not_exist, {
73-
parser.add_argument("-f", "a flag", true);
74-
bool failed = false;
75-
try {
76-
parser.parse(argc, argv);
77-
} catch (const ArgumentParser::ArgumentNotFound&) {
78-
failed = true;
79-
}
80-
TASSERT(failed, "required flag found")
81-
}, )
30+
TEST(
31+
no_args, {
32+
try {
33+
parser.parse(argc, argv);
34+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
35+
TASSERT(false, ex.what())
36+
}
37+
}, )
38+
39+
TEST(
40+
short_optional_flag_exists,
41+
{
42+
parser.add_argument("-f", "a flag", false);
43+
try {
44+
parser.parse(argc, argv);
45+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
46+
TASSERT(false, ex.what())
47+
}
48+
TASSERT(parser.exists("f"), "flag not found")
49+
},
50+
"-f")
51+
52+
TEST(
53+
short_optional_flag_does_not_exist, {
54+
parser.add_argument("-f", "a flag", false);
55+
try {
56+
parser.parse(argc, argv);
57+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
58+
TASSERT(false, ex.what())
59+
}
60+
TASSERT(!parser.exists("f"), "flag found")
61+
}, )
62+
63+
TEST(
64+
short_required_flag_exists,
65+
{
66+
parser.add_argument("-f", "a flag", true);
67+
try {
68+
parser.parse(argc, argv);
69+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
70+
TASSERT(false, ex.what())
71+
}
72+
TASSERT(parser.exists("f"), "required flag not found")
73+
},
74+
"-f")
75+
76+
TEST(
77+
short_required_flag_does_not_exist, {
78+
parser.add_argument("-f", "a flag", true);
79+
bool failed = false;
80+
try {
81+
parser.parse(argc, argv);
82+
} catch (const ArgumentParser::ArgumentNotFound&) {
83+
failed = true;
84+
}
85+
TASSERT(failed, "required flag found")
86+
}, )
87+
88+
TEST(
89+
long_optional_flag_exists,
90+
{
91+
parser.add_argument("--flag", "a flag", false);
92+
try {
93+
parser.parse(argc, argv);
94+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
95+
TASSERT(false, ex.what())
96+
}
97+
TASSERT(parser.exists("flag"), "flag not found")
98+
},
99+
"--flag")
100+
101+
TEST(
102+
long_short_optional_flag_pair_exists,
103+
{
104+
parser.add_argument("-f", "--flag", "a flag", false);
105+
parser.add_argument("-t", "--test", "a flag", false);
106+
try {
107+
parser.parse(argc, argv);
108+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
109+
TASSERT(false, ex.what())
110+
}
111+
TASSERT(parser.exists("flag"), "flag not found")
112+
TASSERT(parser.exists("f"), "flag not found")
113+
TASSERT(parser.exists("test"), "flag not found")
114+
TASSERT(parser.exists("t"), "flag not found")
115+
},
116+
"--flag", "-t")
117+
118+
TEST(
119+
short_combined_flags,
120+
{
121+
parser.add_argument("-f", "a flag", false);
122+
parser.add_argument("-g", "a flag", false);
123+
124+
parser.add_argument("-i", "a flag", false);
125+
parser.add_argument("-j", "a flag", false);
126+
try {
127+
parser.parse(argc, argv);
128+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
129+
TASSERT(false, ex.what())
130+
}
131+
TASSERT(parser.exists("f"), "f flag not found")
132+
TASSERT(parser.exists("g"), "g flag not found")
133+
TASSERT(parser.exists("i"), "f flag not found")
134+
TASSERT(parser.exists("j"), "g flag not found")
135+
},
136+
"-fg", "-ji")
137+
138+
TEST(
139+
vector_flag_empty,
140+
{
141+
parser.add_argument("-v", "a flag", false);
142+
try {
143+
parser.parse(argc, argv);
144+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
145+
TASSERT(false, ex.what())
146+
}
147+
TASSERT(parser.exists("v"), "flag not found")
148+
auto v = parser.getv<int>("v");
149+
TASSERT(v.size() == 0, "wrong vector values")
150+
},
151+
"-v")
152+
153+
TEST(
154+
vector_flag,
155+
{
156+
parser.add_argument("-v", "a flag", false);
157+
try {
158+
parser.parse(argc, argv);
159+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
160+
TASSERT(false, ex.what())
161+
}
162+
TASSERT(parser.exists("v"), "flag not found")
163+
auto v = parser.getv<int>("v");
164+
TASSERT(v.size() == 5, "wrong vector values")
165+
},
166+
"-v", "1", "2", "3", "4", "5")
167+
168+
TEST(
169+
short_and_vector_flag,
170+
{
171+
parser.add_argument("-v", "a flag", false);
172+
parser.add_argument("-b", "a flag", false);
173+
parser.add_argument("-f", "a flag", false);
174+
try {
175+
parser.parse(argc, argv);
176+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
177+
TASSERT(false, ex.what())
178+
}
179+
TASSERT(parser.exists("b"), "flag not found")
180+
TASSERT(parser.exists("v"), "flag not found")
181+
TASSERT(parser.exists("f"), "flag not found")
182+
auto v = parser.getv<int>("v");
183+
TASSERT(v.size() == 5, "wrong vector values")
184+
},
185+
"-b", "0", "-v", "1", "2", "3", "4", "5", "-f", "6", "7", "8")
186+
187+
TEST(
188+
short_help_flag,
189+
{
190+
try {
191+
parser.parse(argc, argv);
192+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
193+
TASSERT(false, ex.what())
194+
}
195+
TASSERT(parser.is_help(), "help not found")
196+
},
197+
"-h")
198+
199+
TEST(
200+
long_help_flag,
201+
{
202+
try {
203+
parser.parse(argc, argv);
204+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
205+
TASSERT(false, ex.what())
206+
}
207+
TASSERT(parser.is_help(), "help not found")
208+
},
209+
"--help")
82210

83211
#define TT(name) \
84212
{ #name, name }
85213
using test = std::function<result()>;
86-
std::map<std::string, test> tests{TT(no_args), TT(short_optional_flag_exists),
214+
std::map<std::string, test> tests{TT(no_args),
215+
TT(short_optional_flag_exists),
87216
TT(short_optional_flag_does_not_exist),
88217
TT(short_required_flag_exists),
89-
TT(short_required_flag_does_not_exist)};
218+
TT(short_required_flag_does_not_exist),
219+
TT(long_optional_flag_exists),
220+
TT(long_short_optional_flag_pair_exists),
221+
TT(short_combined_flags),
222+
TT(vector_flag_empty),
223+
TT(vector_flag),
224+
TT(short_and_vector_flag),
225+
TT(short_help_flag),
226+
TT(long_help_flag)};
90227

91228
int main(int argc, const char* argv[]) {
92229
std::vector<result> results;

0 commit comments

Comments
 (0)