]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- |
2 | // vim: ts=8 sw=2 smarttab | |
3 | /* | |
4 | * Ceph - scalable distributed file system | |
5 | * | |
6 | * Copyright (C) 2011 New Dream Network | |
7 | * | |
8 | * This is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU Lesser General Public | |
10 | * License version 2.1, as published by the Free Software | |
11 | * Foundation. See file COPYING. | |
12 | * | |
13 | */ | |
14 | ||
15 | #include "common/ceph_argparse.h" | |
16 | ||
17 | #include "gtest/gtest.h" | |
18 | #include <vector> | |
19 | ||
20 | /* Holds a std::vector with C-strings. | |
21 | * Will free() them properly in the destructor. | |
22 | * | |
23 | * Note: the ceph_argparse functions modify the vector, removing elements as | |
24 | * they find them. So we keep a parallel vector, orig, to make sure that we | |
25 | * never forget to delete a string. | |
26 | */ | |
27 | class VectorContainer | |
28 | { | |
29 | public: | |
30 | explicit VectorContainer(const char** arr_) { | |
31 | for (const char **a = arr_; *a; ++a) { | |
32 | const char *str = (const char*)strdup(*a); | |
33 | arr.push_back(str); | |
34 | orig.push_back(str); | |
35 | } | |
36 | } | |
37 | ~VectorContainer() { | |
38 | for (std::vector<const char*>::iterator i = orig.begin(); | |
39 | i != orig.end(); ++i) | |
40 | { | |
41 | free((void*)*i); | |
42 | } | |
43 | } | |
44 | void refresh() { | |
45 | arr.assign(orig.begin(), orig.end()); | |
46 | } | |
47 | std::vector < const char* > arr; | |
48 | ||
49 | private: | |
50 | std::vector < const char* > orig; | |
51 | }; | |
52 | ||
53 | TEST(CephArgParse, SimpleArgParse) { | |
54 | const char *BAR5[] = { "./myprog", "--bar", "5", NULL }; | |
55 | const char *FOO[] = { "./myprog", "--foo", "--baz", NULL }; | |
56 | const char *NONE[] = { "./myprog", NULL }; | |
57 | ||
58 | bool found_foo = false; | |
59 | std::string found_bar; | |
60 | VectorContainer bar5(BAR5); | |
61 | for (std::vector<const char*>::iterator i = bar5.arr.begin(); | |
62 | i != bar5.arr.end(); ) | |
63 | { | |
64 | if (ceph_argparse_flag(bar5.arr, i, "--foo", (char*)NULL)) { | |
65 | found_foo = true; | |
66 | } | |
67 | else if (ceph_argparse_witharg(bar5.arr, i, &found_bar, "--bar", (char*)NULL)) { | |
68 | } | |
69 | else | |
70 | ++i; | |
71 | } | |
72 | ASSERT_EQ(found_foo, false); | |
73 | ASSERT_EQ(found_bar, "5"); | |
74 | ||
75 | found_foo = false; | |
76 | found_bar = ""; | |
77 | bool baz_found = false; | |
78 | std::string found_baz = ""; | |
79 | VectorContainer foo(FOO); | |
80 | ostringstream err; | |
81 | for (std::vector<const char*>::iterator i = foo.arr.begin(); | |
82 | i != foo.arr.end(); ) | |
83 | { | |
84 | if (ceph_argparse_flag(foo.arr, i, "--foo", (char*)NULL)) { | |
85 | found_foo = true; | |
86 | } | |
87 | else if (ceph_argparse_witharg(foo.arr, i, &found_bar, "--bar", (char*)NULL)) { | |
88 | } | |
89 | else if (ceph_argparse_witharg(foo.arr, i, &found_baz, err, "--baz", (char*)NULL)) { | |
90 | ASSERT_NE(string(""), err.str()); | |
91 | baz_found = true; | |
92 | } | |
93 | else | |
94 | ++i; | |
95 | } | |
96 | ASSERT_EQ(found_foo, true); | |
97 | ASSERT_EQ(found_bar, ""); | |
98 | ASSERT_EQ(baz_found, true); | |
99 | ASSERT_EQ(found_baz, ""); | |
100 | ||
101 | found_foo = false; | |
102 | found_bar = ""; | |
103 | VectorContainer none(NONE); | |
104 | for (std::vector<const char*>::iterator i = none.arr.begin(); | |
105 | i != none.arr.end(); ) | |
106 | { | |
107 | if (ceph_argparse_flag(none.arr, i, "--foo", (char*)NULL)) { | |
108 | found_foo = true; | |
109 | } | |
110 | else if (ceph_argparse_witharg(none.arr, i, &found_bar, "--bar", (char*)NULL)) { | |
111 | } | |
112 | else | |
113 | ++i; | |
114 | } | |
115 | ASSERT_EQ(found_foo, false); | |
116 | ASSERT_EQ(found_bar, ""); | |
117 | } | |
118 | ||
119 | TEST(CephArgParse, DoubleDash) { | |
120 | const char *ARGS[] = { "./myprog", "--foo", "5", "--", "--bar", "6", NULL }; | |
121 | ||
122 | int foo = -1, bar = -1; | |
123 | VectorContainer args(ARGS); | |
124 | for (std::vector<const char*>::iterator i = args.arr.begin(); | |
125 | i != args.arr.end(); ) | |
126 | { | |
127 | std::string myarg; | |
128 | if (ceph_argparse_double_dash(args.arr, i)) { | |
129 | break; | |
130 | } | |
131 | else if (ceph_argparse_witharg(args.arr, i, &myarg, "--foo", (char*)NULL)) { | |
132 | foo = atoi(myarg.c_str()); | |
133 | } | |
134 | else if (ceph_argparse_witharg(args.arr, i, &myarg, "--bar", (char*)NULL)) { | |
135 | bar = atoi(myarg.c_str()); | |
136 | } | |
137 | else | |
138 | ++i; | |
139 | } | |
140 | ASSERT_EQ(foo, 5); | |
141 | ASSERT_EQ(bar, -1); | |
142 | } | |
143 | ||
144 | ||
145 | TEST(CephArgParse, WithDashesAndUnderscores) { | |
146 | const char *BAZSTUFF1[] = { "./myprog", "--goo", "--baz-stuff", "50", "--end", NULL }; | |
147 | const char *BAZSTUFF2[] = { "./myprog", "--goo2", "--baz_stuff", "50", NULL }; | |
148 | const char *BAZSTUFF3[] = { "./myprog", "--goo2", "--baz-stuff=50", "50", NULL }; | |
149 | const char *BAZSTUFF4[] = { "./myprog", "--goo2", "--baz_stuff=50", "50", NULL }; | |
150 | const char *NONE1[] = { "./myprog", NULL }; | |
151 | const char *NONE2[] = { "./myprog", "--goo2", "--baz_stuff2", "50", NULL }; | |
152 | const char *NONE3[] = { "./myprog", "--goo2", "__baz_stuff", "50", NULL }; | |
153 | ||
154 | // as flag | |
155 | std::string found_baz; | |
156 | VectorContainer bazstuff1(BAZSTUFF1); | |
157 | for (std::vector<const char*>::iterator i = bazstuff1.arr.begin(); | |
158 | i != bazstuff1.arr.end(); ) | |
159 | { | |
160 | if (ceph_argparse_flag(bazstuff1.arr, i, "--baz-stuff", (char*)NULL)) { | |
161 | found_baz = "true"; | |
162 | } | |
163 | else | |
164 | ++i; | |
165 | } | |
166 | ASSERT_EQ(found_baz, "true"); | |
167 | ||
168 | // as flag | |
169 | found_baz = ""; | |
170 | VectorContainer bazstuff2(BAZSTUFF2); | |
171 | for (std::vector<const char*>::iterator i = bazstuff2.arr.begin(); | |
172 | i != bazstuff2.arr.end(); ) | |
173 | { | |
174 | if (ceph_argparse_flag(bazstuff2.arr, i, "--baz-stuff", (char*)NULL)) { | |
175 | found_baz = "true"; | |
176 | } | |
177 | else | |
178 | ++i; | |
179 | } | |
180 | ASSERT_EQ(found_baz, "true"); | |
181 | ||
182 | // with argument | |
183 | found_baz = ""; | |
184 | bazstuff1.refresh(); | |
185 | for (std::vector<const char*>::iterator i = bazstuff1.arr.begin(); | |
186 | i != bazstuff1.arr.end(); ) | |
187 | { | |
188 | if (ceph_argparse_witharg(bazstuff1.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) { | |
189 | } | |
190 | else | |
191 | ++i; | |
192 | } | |
193 | ASSERT_EQ(found_baz, "50"); | |
194 | ||
195 | // with argument | |
196 | found_baz = ""; | |
197 | bazstuff2.refresh(); | |
198 | for (std::vector<const char*>::iterator i = bazstuff2.arr.begin(); | |
199 | i != bazstuff2.arr.end(); ) | |
200 | { | |
201 | if (ceph_argparse_witharg(bazstuff2.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) { | |
202 | } | |
203 | else | |
204 | ++i; | |
205 | } | |
206 | ASSERT_EQ(found_baz, "50"); | |
207 | ||
208 | // with argument | |
209 | found_baz = ""; | |
210 | VectorContainer bazstuff3(BAZSTUFF3); | |
211 | for (std::vector<const char*>::iterator i = bazstuff3.arr.begin(); | |
212 | i != bazstuff3.arr.end(); ) | |
213 | { | |
214 | if (ceph_argparse_witharg(bazstuff3.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) { | |
215 | } | |
216 | else | |
217 | ++i; | |
218 | } | |
219 | ASSERT_EQ(found_baz, "50"); | |
220 | ||
221 | // with argument | |
222 | found_baz = ""; | |
223 | VectorContainer bazstuff4(BAZSTUFF4); | |
224 | for (std::vector<const char*>::iterator i = bazstuff4.arr.begin(); | |
225 | i != bazstuff4.arr.end(); ) | |
226 | { | |
227 | if (ceph_argparse_witharg(bazstuff4.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) { | |
228 | } | |
229 | else | |
230 | ++i; | |
231 | } | |
232 | ASSERT_EQ(found_baz, "50"); | |
233 | ||
234 | // not found | |
235 | found_baz = ""; | |
236 | VectorContainer none1(NONE1); | |
237 | for (std::vector<const char*>::iterator i = none1.arr.begin(); | |
238 | i != none1.arr.end(); ) | |
239 | { | |
240 | if (ceph_argparse_flag(none1.arr, i, "--baz-stuff", (char*)NULL)) { | |
241 | found_baz = "true"; | |
242 | } | |
243 | else if (ceph_argparse_witharg(none1.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) { | |
244 | } | |
245 | else | |
246 | ++i; | |
247 | } | |
248 | ASSERT_EQ(found_baz, ""); | |
249 | ||
250 | // not found | |
251 | found_baz = ""; | |
252 | VectorContainer none2(NONE2); | |
253 | for (std::vector<const char*>::iterator i = none2.arr.begin(); | |
254 | i != none2.arr.end(); ) | |
255 | { | |
256 | if (ceph_argparse_flag(none2.arr, i, "--baz-stuff", (char*)NULL)) { | |
257 | found_baz = "true"; | |
258 | } | |
259 | else if (ceph_argparse_witharg(none2.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) { | |
260 | } | |
261 | else | |
262 | ++i; | |
263 | } | |
264 | ASSERT_EQ(found_baz, ""); | |
265 | ||
266 | // not found | |
267 | found_baz = ""; | |
268 | VectorContainer none3(NONE3); | |
269 | for (std::vector<const char*>::iterator i = none3.arr.begin(); | |
270 | i != none3.arr.end(); ) | |
271 | { | |
272 | if (ceph_argparse_flag(none3.arr, i, "--baz-stuff", (char*)NULL)) { | |
273 | found_baz = "true"; | |
274 | } | |
275 | else if (ceph_argparse_witharg(none3.arr, i, &found_baz, "--baz-stuff", (char*)NULL)) { | |
276 | } | |
277 | else | |
278 | ++i; | |
279 | } | |
280 | ASSERT_EQ(found_baz, ""); | |
281 | } | |
282 | ||
283 | TEST(CephArgParse, WithFloat) { | |
284 | const char *BAZSTUFF1[] = { "./myprog", "--foo", "50.5", "--bar", "52", NULL }; | |
285 | ||
286 | VectorContainer bazstuff1(BAZSTUFF1); | |
287 | ostringstream err; | |
288 | float foo; | |
289 | int bar = -1; | |
290 | for (std::vector<const char*>::iterator i = bazstuff1.arr.begin(); | |
291 | i != bazstuff1.arr.end(); ) | |
292 | { | |
293 | if (ceph_argparse_double_dash(bazstuff1.arr, i)) { | |
294 | break; | |
295 | } else if (ceph_argparse_witharg(bazstuff1.arr, i, &foo, err, "--foo", (char*)NULL)) { | |
296 | ASSERT_EQ(string(""), err.str()); | |
297 | } else if (ceph_argparse_witharg(bazstuff1.arr, i, &bar, err, "--bar", (char*)NULL)) { | |
298 | ASSERT_EQ(string(""), err.str()); | |
299 | } | |
300 | else { | |
301 | ++i; | |
302 | } | |
303 | } | |
304 | ASSERT_EQ(foo, 50.5); | |
305 | ASSERT_EQ(bar, 52); | |
306 | } | |
307 | ||
308 | TEST(CephArgParse, WithInt) { | |
309 | const char *BAZSTUFF1[] = { "./myprog", "--foo", "50", "--bar", "52", NULL }; | |
310 | const char *BAZSTUFF2[] = { "./myprog", "--foo", "--bar", "52", NULL }; | |
311 | const char *BAZSTUFF3[] = { "./myprog", "--foo", "40", "--", "--bar", "42", NULL }; | |
312 | ||
313 | // normal test | |
314 | VectorContainer bazstuff1(BAZSTUFF1); | |
315 | ostringstream err; | |
316 | int foo = -1, bar = -1; | |
317 | for (std::vector<const char*>::iterator i = bazstuff1.arr.begin(); | |
318 | i != bazstuff1.arr.end(); ) | |
319 | { | |
320 | if (ceph_argparse_double_dash(bazstuff1.arr, i)) { | |
321 | break; | |
322 | } else if (ceph_argparse_witharg(bazstuff1.arr, i, &foo, err, "--foo", (char*)NULL)) { | |
323 | ASSERT_EQ(string(""), err.str()); | |
324 | } else if (ceph_argparse_witharg(bazstuff1.arr, i, &bar, err, "--bar", (char*)NULL)) { | |
325 | ASSERT_EQ(string(""), err.str()); | |
326 | } | |
327 | else { | |
328 | ++i; | |
329 | } | |
330 | } | |
331 | ASSERT_EQ(foo, 50); | |
332 | ASSERT_EQ(bar, 52); | |
333 | ||
334 | // parse error test | |
335 | VectorContainer bazstuff2(BAZSTUFF2); | |
336 | ostringstream err2; | |
337 | for (std::vector<const char*>::iterator i = bazstuff2.arr.begin(); | |
338 | i != bazstuff2.arr.end(); ) | |
339 | { | |
340 | if (ceph_argparse_double_dash(bazstuff2.arr, i)) { | |
341 | break; | |
342 | } else if (ceph_argparse_witharg(bazstuff2.arr, i, &foo, err2, "--foo", (char*)NULL)) { | |
343 | ASSERT_NE(string(""), err2.str()); | |
344 | } | |
345 | else { | |
346 | ++i; | |
347 | } | |
348 | } | |
349 | ||
350 | // double dash test | |
351 | VectorContainer bazstuff3(BAZSTUFF3); | |
352 | foo = -1, bar = -1; | |
353 | for (std::vector<const char*>::iterator i = bazstuff3.arr.begin(); | |
354 | i != bazstuff3.arr.end(); ) | |
355 | { | |
356 | if (ceph_argparse_double_dash(bazstuff3.arr, i)) { | |
357 | break; | |
358 | } else if (ceph_argparse_witharg(bazstuff3.arr, i, &foo, err, "--foo", (char*)NULL)) { | |
359 | ASSERT_EQ(string(""), err.str()); | |
360 | } else if (ceph_argparse_witharg(bazstuff3.arr, i, &bar, err, "--bar", (char*)NULL)) { | |
361 | ASSERT_EQ(string(""), err.str()); | |
362 | } | |
363 | else { | |
364 | ++i; | |
365 | } | |
366 | } | |
367 | ASSERT_EQ(foo, 40); | |
368 | ASSERT_EQ(bar, -1); | |
369 | } | |
370 | ||
371 | TEST(CephArgParse, env_to_vec) { | |
372 | { | |
373 | std::vector<const char*> args; | |
374 | unsetenv("CEPH_ARGS"); | |
375 | unsetenv("WHATEVER"); | |
b32b8144 | 376 | clear_g_str_vec(); |
7c673cae FG |
377 | env_to_vec(args); |
378 | EXPECT_EQ(0u, args.size()); | |
b32b8144 | 379 | clear_g_str_vec(); |
7c673cae FG |
380 | env_to_vec(args, "WHATEVER"); |
381 | EXPECT_EQ(0u, args.size()); | |
382 | args.push_back("a"); | |
383 | setenv("CEPH_ARGS", "b c", 0); | |
b32b8144 | 384 | clear_g_str_vec(); |
7c673cae FG |
385 | env_to_vec(args); |
386 | EXPECT_EQ(3u, args.size()); | |
387 | EXPECT_EQ(string("b"), args[1]); | |
388 | EXPECT_EQ(string("c"), args[2]); | |
389 | setenv("WHATEVER", "d e", 0); | |
b32b8144 | 390 | clear_g_str_vec(); |
7c673cae FG |
391 | env_to_vec(args, "WHATEVER"); |
392 | EXPECT_EQ(5u, args.size()); | |
393 | EXPECT_EQ(string("d"), args[3]); | |
394 | EXPECT_EQ(string("e"), args[4]); | |
395 | } | |
396 | { | |
397 | std::vector<const char*> args; | |
398 | unsetenv("CEPH_ARGS"); | |
399 | args.push_back("a"); | |
400 | args.push_back("--"); | |
401 | args.push_back("c"); | |
402 | setenv("CEPH_ARGS", "b -- d", 0); | |
b32b8144 | 403 | clear_g_str_vec(); |
7c673cae FG |
404 | env_to_vec(args); |
405 | EXPECT_EQ(5u, args.size()); | |
406 | EXPECT_EQ(string("a"), args[0]); | |
407 | EXPECT_EQ(string("b"), args[1]); | |
408 | EXPECT_EQ(string("--"), args[2]); | |
409 | EXPECT_EQ(string("c"), args[3]); | |
410 | EXPECT_EQ(string("d"), args[4]); | |
411 | } | |
412 | { | |
413 | std::vector<const char*> args; | |
414 | unsetenv("CEPH_ARGS"); | |
415 | args.push_back("a"); | |
416 | args.push_back("--"); | |
417 | setenv("CEPH_ARGS", "b -- c", 0); | |
b32b8144 | 418 | clear_g_str_vec(); |
7c673cae FG |
419 | env_to_vec(args); |
420 | EXPECT_EQ(4u, args.size()); | |
421 | EXPECT_EQ(string("a"), args[0]); | |
422 | EXPECT_EQ(string("b"), args[1]); | |
423 | EXPECT_EQ(string("--"), args[2]); | |
424 | EXPECT_EQ(string("c"), args[3]); | |
425 | } | |
426 | { | |
427 | std::vector<const char*> args; | |
428 | unsetenv("CEPH_ARGS"); | |
429 | args.push_back("--"); | |
430 | args.push_back("c"); | |
431 | setenv("CEPH_ARGS", "b -- d", 0); | |
b32b8144 | 432 | clear_g_str_vec(); |
7c673cae FG |
433 | env_to_vec(args); |
434 | EXPECT_EQ(4u, args.size()); | |
435 | EXPECT_EQ(string("b"), args[0]); | |
436 | EXPECT_EQ(string("--"), args[1]); | |
437 | EXPECT_EQ(string("c"), args[2]); | |
438 | EXPECT_EQ(string("d"), args[3]); | |
439 | } | |
440 | { | |
441 | std::vector<const char*> args; | |
442 | unsetenv("CEPH_ARGS"); | |
443 | args.push_back("b"); | |
444 | setenv("CEPH_ARGS", "c -- d", 0); | |
b32b8144 | 445 | clear_g_str_vec(); |
7c673cae FG |
446 | env_to_vec(args); |
447 | EXPECT_EQ(4u, args.size()); | |
448 | EXPECT_EQ(string("b"), args[0]); | |
449 | EXPECT_EQ(string("c"), args[1]); | |
450 | EXPECT_EQ(string("--"), args[2]); | |
451 | EXPECT_EQ(string("d"), args[3]); | |
452 | } | |
453 | { | |
454 | std::vector<const char*> args; | |
455 | unsetenv("CEPH_ARGS"); | |
456 | args.push_back("a"); | |
457 | args.push_back("--"); | |
458 | args.push_back("c"); | |
459 | setenv("CEPH_ARGS", "-- d", 0); | |
b32b8144 | 460 | clear_g_str_vec(); |
7c673cae FG |
461 | env_to_vec(args); |
462 | EXPECT_EQ(4u, args.size()); | |
463 | EXPECT_EQ(string("a"), args[0]); | |
464 | EXPECT_EQ(string("--"), args[1]); | |
465 | EXPECT_EQ(string("c"), args[2]); | |
466 | EXPECT_EQ(string("d"), args[3]); | |
467 | } | |
468 | { | |
469 | std::vector<const char*> args; | |
470 | unsetenv("CEPH_ARGS"); | |
471 | args.push_back("a"); | |
472 | args.push_back("--"); | |
473 | args.push_back("c"); | |
474 | setenv("CEPH_ARGS", "d", 0); | |
b32b8144 | 475 | clear_g_str_vec(); |
7c673cae FG |
476 | env_to_vec(args); |
477 | EXPECT_EQ(4u, args.size()); | |
478 | EXPECT_EQ(string("a"), args[0]); | |
479 | EXPECT_EQ(string("d"), args[1]); | |
480 | EXPECT_EQ(string("--"), args[2]); | |
481 | EXPECT_EQ(string("c"), args[3]); | |
482 | } | |
483 | } | |
484 | /* | |
485 | * Local Variables: | |
486 | * compile-command: "cd .. ; make unittest_ceph_argparse && ./unittest_ceph_argparse" | |
487 | * End: | |
488 | */ |