Skip to content

Commit 8dd451b

Browse files
jamolnngjamolnng
committed
add values test
1 parent 99cf082 commit 8dd451b

1 file changed

Lines changed: 176 additions & 169 deletions

File tree

‎tests.cpp‎

Lines changed: 176 additions & 169 deletions
Original file line numberDiff line numberDiff line change
@@ -27,186 +27,192 @@ struct result {
2727
return {true, 0, "", "", ""}; \
2828
}
2929

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-
}, )
30+
TEST(no_args, {
31+
try {
32+
parser.parse(argc, argv);
33+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
34+
TASSERT(false, ex.what())
35+
}
36+
}, )
3837

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")
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")
5149

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-
}, )
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+
}, )
6259

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")
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")
7571

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-
}, )
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+
}, )
8782

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")
83+
TEST(long_optional_flag_exists,
84+
{
85+
parser.add_argument("--flag", "a flag", false);
86+
try {
87+
parser.parse(argc, argv);
88+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
89+
TASSERT(false, ex.what())
90+
}
91+
TASSERT(parser.exists("flag"), "flag not found")
92+
},
93+
"--flag")
10094

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")
95+
TEST(long_short_optional_flag_pair_exists,
96+
{
97+
parser.add_argument("-f", "--flag", "a flag", false);
98+
parser.add_argument("-t", "--test", "a flag", false);
99+
try {
100+
parser.parse(argc, argv);
101+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
102+
TASSERT(false, ex.what())
103+
}
104+
TASSERT(parser.exists("flag"), "flag not found")
105+
TASSERT(parser.exists("f"), "flag not found")
106+
TASSERT(parser.exists("test"), "flag not found")
107+
TASSERT(parser.exists("t"), "flag not found")
108+
},
109+
"--flag", "-t")
117110

118-
TEST(
119-
short_combined_flags,
120-
{
121-
parser.add_argument("-f", "a flag", false);
122-
parser.add_argument("-g", "a flag", false);
111+
TEST(short_combined_flags,
112+
{
113+
parser.add_argument("-f", "a flag", false);
114+
parser.add_argument("-g", "a flag", false);
123115

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")
116+
parser.add_argument("-i", "a flag", false);
117+
parser.add_argument("-j", "a flag", false);
118+
try {
119+
parser.parse(argc, argv);
120+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
121+
TASSERT(false, ex.what())
122+
}
123+
TASSERT(parser.exists("f"), "f flag not found")
124+
TASSERT(parser.exists("g"), "g flag not found")
125+
TASSERT(parser.exists("i"), "f flag not found")
126+
TASSERT(parser.exists("j"), "g flag not found")
127+
},
128+
"-fg", "-ji")
137129

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")
130+
TEST(vector_flag_empty,
131+
{
132+
parser.add_argument("-v", "a flag", false);
133+
try {
134+
parser.parse(argc, argv);
135+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
136+
TASSERT(false, ex.what())
137+
}
138+
TASSERT(parser.exists("v"), "flag not found")
139+
auto v = parser.getv<int>("v");
140+
TASSERT(v.size() == 0, "wrong vector values")
141+
},
142+
"-v")
152143

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")
144+
TEST(vector_flag,
145+
{
146+
parser.add_argument("-v", "a flag", false);
147+
try {
148+
parser.parse(argc, argv);
149+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
150+
TASSERT(false, ex.what())
151+
}
152+
TASSERT(parser.exists("v"), "flag not found")
153+
auto v = parser.getv<int>("v");
154+
TASSERT(v.size() == 5, "wrong vector values")
155+
},
156+
"-v", "1", "2", "3", "4", "5")
167157

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")
158+
TEST(short_and_vector_flag,
159+
{
160+
parser.add_argument("-v", "a flag", false);
161+
parser.add_argument("-b", "a flag", false);
162+
parser.add_argument("-f", "a flag", false);
163+
try {
164+
parser.parse(argc, argv);
165+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
166+
TASSERT(false, ex.what())
167+
}
168+
TASSERT(parser.exists("b"), "flag not found")
169+
TASSERT(parser.exists("v"), "flag not found")
170+
TASSERT(parser.exists("f"), "flag not found")
171+
auto v = parser.getv<int>("v");
172+
TASSERT(v.size() == 5, "wrong vector values")
173+
},
174+
"-b", "0", "-v", "1", "2", "3", "4", "5", "-f", "6", "7", "8")
186175

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")
176+
TEST(short_help_flag,
177+
{
178+
try {
179+
parser.parse(argc, argv);
180+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
181+
TASSERT(false, ex.what())
182+
}
183+
TASSERT(parser.is_help(), "help not found")
184+
},
185+
"-h")
198186

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")
187+
TEST(long_help_flag,
188+
{
189+
try {
190+
parser.parse(argc, argv);
191+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
192+
TASSERT(false, ex.what())
193+
}
194+
TASSERT(parser.is_help(), "help not found")
195+
},
196+
"--help")
197+
198+
TEST(flag_values,
199+
{
200+
parser.add_argument("-f", "--flag", "a flag", false);
201+
parser.add_argument("-t", "--test", "a flag", false);
202+
parser.add_argument("-g", "a flag", false);
203+
try {
204+
parser.parse(argc, argv);
205+
} catch (const ArgumentParser::ArgumentNotFound& ex) {
206+
TASSERT(false, ex.what())
207+
}
208+
TASSERT(parser.exists("flag"), "flag not found")
209+
TASSERT(parser.get<int>("flag") == 2, "wrong flag value")
210+
TASSERT(parser.exists("t"), "flag not found")
211+
TASSERT(parser.get<int>("t") == 3, "wrong flag value")
212+
TASSERT(parser.exists("g"), "flag not found")
213+
TASSERT(parser.get<double>("g") == 0.125, "wrong flag value")
214+
},
215+
"-f", "2", "--test", "3", "-g", "0.125")
210216

211217
#define TT(name) \
212218
{ #name, name }
@@ -223,7 +229,8 @@ std::map<std::string, test> tests{TT(no_args),
223229
TT(vector_flag),
224230
TT(short_and_vector_flag),
225231
TT(short_help_flag),
226-
TT(long_help_flag)};
232+
TT(long_help_flag),
233+
TT(flag_values)};
227234

228235
int main(int argc, const char* argv[]) {
229236
std::vector<result> results;
@@ -257,4 +264,4 @@ int main(int argc, const char* argv[]) {
257264
}
258265
std::cout << "Passed: " << passed << "/" << results.size() << std::endl;
259266
return static_cast<int>(results.size() - passed);
260-
}
267+
}

0 commit comments

Comments
 (0)