Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2024 HiSilicon Limited
3 : : */
4 : :
5 : : #include <stdio.h>
6 : : #include <string.h>
7 : :
8 : : #include <rte_argparse.h>
9 : :
10 : : #include "test.h"
11 : :
12 : : static int default_argc;
13 : : static char *default_argv[1];
14 : :
15 : : #define MAX_STRDUP_STORE_NUM 512
16 : : static char *strdup_store_array[MAX_STRDUP_STORE_NUM];
17 : : static uint32_t strdup_store_index;
18 : :
19 : : /*
20 : : * Define strdup wrapper.
21 : : * 1. Mainly to fix compile error "warning: assignment discards 'const'
22 : : * qualifier from pointer target type [-Wdiscarded-qualifiers]" for
23 : : * following code:
24 : : * argv[x] = "100";
25 : : * 2. The strdup result will store in the strdup_store_array, and then
26 : : * freed in the teardown function, prevent ASAN errors from being
27 : : * triggered.
28 : : */
29 : : static char *
30 : 62 : test_strdup(const char *str)
31 : : {
32 : 62 : char *s = strdup(str);
33 [ - + ]: 62 : if (s == NULL) {
34 : : printf("strdup failed! exiting...\n");
35 : 0 : exit(-ENOMEM);
36 : : }
37 [ - + ]: 62 : if (strdup_store_index >= MAX_STRDUP_STORE_NUM) {
38 : : printf("too much strdup calls! exiting...\n");
39 : 0 : exit(-ERANGE);
40 : : }
41 : 62 : strdup_store_array[strdup_store_index++] = s;
42 : 62 : return s;
43 : : }
44 : :
45 : : static int
46 : 1 : test_argparse_setup(void)
47 : : {
48 : 1 : strdup_store_index = 0;
49 : 1 : default_argc = 1;
50 : 1 : default_argv[0] = test_strdup("test_argparse");
51 : 1 : return 0;
52 : : }
53 : :
54 : : static void
55 : 1 : test_argparse_teardown(void)
56 : : {
57 : : uint32_t i;
58 : 1 : printf("total used strdup_store_index = %u\n", strdup_store_index);
59 [ + + ]: 63 : for (i = 0; i < strdup_store_index; i++)
60 : 62 : free(strdup_store_array[i]);
61 : 1 : strdup_store_index = 0;
62 : 1 : }
63 : :
64 : : static int
65 : 3 : test_argparse_callback(uint32_t index, const char *value, void *opaque)
66 : : {
67 : : RTE_SET_USED(index);
68 : : RTE_SET_USED(value);
69 : : RTE_SET_USED(opaque);
70 : 3 : return 0;
71 : : }
72 : :
73 : : /* valid templater, must contain at least two args. */
74 : : #define argparse_templater() { \
75 : : .prog_name = "test_argparse", \
76 : : .usage = "-a xx -b yy", \
77 : : .descriptor = NULL, \
78 : : .epilog = NULL, \
79 : : .exit_on_error = false, \
80 : : .callback = test_argparse_callback, \
81 : : .args = { \
82 : : { "--abc", "-a", "abc argument", (void *)1, (void *)1, \
83 : : RTE_ARGPARSE_VALUE_NONE, RTE_ARGPARSE_VALUE_TYPE_NONE }, \
84 : : { "--xyz", "-x", "xyz argument", (void *)1, (void *)2, \
85 : : RTE_ARGPARSE_VALUE_NONE, RTE_ARGPARSE_VALUE_TYPE_NONE }, \
86 : : ARGPARSE_ARG_END(), \
87 : : }, \
88 : : }
89 : :
90 : : static void
91 : 33 : test_argparse_copy(struct rte_argparse *dst, struct rte_argparse *src)
92 : : {
93 : : uint32_t i;
94 : : memcpy(dst, src, sizeof(*src));
95 : 66 : for (i = 0; /* NULL */; i++) {
96 [ + + ]: 99 : memcpy(&dst->args[i], &src->args[i], sizeof(src->args[i]));
97 [ + + ]: 99 : if (src->args[i].name_long == NULL)
98 : : break;
99 : : }
100 : 33 : }
101 : :
102 : : static struct rte_argparse *
103 : : test_argparse_init_obj(void)
104 : : {
105 : : static struct rte_argparse backup = argparse_templater();
106 : : static struct rte_argparse obj = argparse_templater();
107 : : /* Because obj may be overwritten, do a deep copy. */
108 : 17 : test_argparse_copy(&obj, &backup);
109 : : return &obj;
110 : : }
111 : :
112 : : static int
113 : 1 : test_argparse_invalid_basic_param(void)
114 : : {
115 : : struct rte_argparse *obj;
116 : : int ret;
117 : :
118 : : obj = test_argparse_init_obj();
119 : 1 : obj->prog_name = NULL;
120 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
121 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
122 : :
123 : : obj = test_argparse_init_obj();
124 : 1 : obj->usage = NULL;
125 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
126 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
127 : :
128 : : return TEST_SUCCESS;
129 : : }
130 : :
131 : : static int
132 : 1 : test_argparse_invalid_arg_name(void)
133 : : {
134 : : struct rte_argparse *obj;
135 : : int ret;
136 : :
137 : : obj = test_argparse_init_obj();
138 : 1 : obj->args[0].name_long = "-ab";
139 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
140 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
141 : :
142 : : obj = test_argparse_init_obj();
143 : 1 : obj->args[0].name_long = "-abc";
144 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
145 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
146 : :
147 : : obj = test_argparse_init_obj();
148 : 1 : obj->args[0].name_long = "---c";
149 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
150 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
151 : :
152 : : obj = test_argparse_init_obj();
153 : 1 : obj->args[0].name_long = "abc";
154 : 1 : obj->args[0].name_short = "-a";
155 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
156 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
157 : :
158 : : obj = test_argparse_init_obj();
159 : 1 : obj->args[0].name_short = "a";
160 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
161 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
162 : :
163 : : obj = test_argparse_init_obj();
164 : 1 : obj->args[0].name_short = "abc";
165 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
166 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
167 : :
168 : : obj = test_argparse_init_obj();
169 : 1 : obj->args[0].name_short = "ab";
170 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
171 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
172 : :
173 : : return 0;
174 : : }
175 : :
176 : : static int
177 : 1 : test_argparse_invalid_arg_help(void)
178 : : {
179 : : struct rte_argparse *obj;
180 : : int ret;
181 : :
182 : : obj = test_argparse_init_obj();
183 : 1 : obj->args[0].help = NULL;
184 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
185 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
186 : :
187 : : return 0;
188 : : }
189 : :
190 : : static int
191 : 1 : test_argparse_invalid_has_val(void)
192 : : {
193 : 1 : uint64_t invalid_values[] = {
194 : : RTE_ARGPARSE_VALUE_NONE,
195 : : RTE_ARGPARSE_VALUE_OPTIONAL,
196 : : };
197 : : struct rte_argparse *obj;
198 : : uint32_t index;
199 : : int ret;
200 : :
201 : : /* test positional arg don't config required-value. */
202 [ + + ]: 3 : for (index = 0; index < RTE_DIM(invalid_values); index++) {
203 : : obj = test_argparse_init_obj();
204 : 2 : obj->args[0].name_long = "abc";
205 : 2 : obj->args[0].name_short = NULL;
206 : 2 : obj->args[0].value_required = invalid_values[index];
207 : 2 : ret = rte_argparse_parse(obj, default_argc, default_argv);
208 [ - + ]: 2 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
209 : : }
210 : :
211 : : return 0;
212 : : }
213 : :
214 : : static int
215 : 1 : test_argparse_invalid_arg_saver(void)
216 : : {
217 : : struct rte_argparse *obj;
218 : : int ret;
219 : :
220 : : /* test saver == NULL with val-type != 0. */
221 : : obj = test_argparse_init_obj();
222 : 1 : obj->args[0].val_saver = NULL;
223 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_NONE;
224 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
225 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
226 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
227 : :
228 : : /* test saver == NULL with callback is NULL. */
229 : : obj = test_argparse_init_obj();
230 : 1 : obj->args[0].val_saver = NULL;
231 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_NONE;
232 : 1 : obj->callback = NULL;
233 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
234 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
235 : :
236 : : /* test saver != NULL with val-type is zero! */
237 : : obj = test_argparse_init_obj();
238 : 1 : obj->args[0].val_saver = (void *)1;
239 : 1 : obj->args[0].val_set = (void *)1;
240 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_NONE;
241 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
242 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
243 : :
244 : : /* test saver != NULL with required value, but val-set is not NULL. */
245 : : obj = test_argparse_init_obj();
246 : 1 : obj->args[0].val_saver = (void *)1;
247 : 1 : obj->args[0].val_set = (void *)1;
248 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
249 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
250 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
251 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
252 : :
253 : : return 0;
254 : : }
255 : :
256 : : static int
257 : 1 : test_argparse_invalid_arg_flags(void)
258 : : {
259 : : struct rte_argparse *obj;
260 : : int ret;
261 : :
262 : : /* test set unused bits. */
263 : : obj = test_argparse_init_obj();
264 : 1 : obj->args[0].flags |= ~(RTE_ARGPARSE_FLAG_SUPPORT_MULTI);
265 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
266 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
267 : :
268 : : /* test positional arg should not config multiple. */
269 : : obj = test_argparse_init_obj();
270 : 1 : obj->args[0].name_long = "positional";
271 : 1 : obj->args[0].name_short = NULL;
272 : 1 : obj->args[0].val_saver = (void *)1;
273 : 1 : obj->args[0].val_set = NULL;
274 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
275 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
276 : 1 : obj->args[0].flags |= RTE_ARGPARSE_FLAG_SUPPORT_MULTI;
277 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
278 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
279 : :
280 : : /* test optional arg enabled multiple but prased by autosave. */
281 : : obj = test_argparse_init_obj();
282 : 1 : obj->args[0].flags |= RTE_ARGPARSE_FLAG_SUPPORT_MULTI;
283 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
284 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
285 : :
286 : : return 0;
287 : : }
288 : :
289 : : static int
290 : 1 : test_argparse_invalid_arg_repeat(void)
291 : : {
292 : : struct rte_argparse *obj;
293 : : int ret;
294 : :
295 : : /* test for long name repeat! */
296 : : obj = test_argparse_init_obj();
297 : 1 : obj->args[1].name_long = obj->args[0].name_long;
298 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
299 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
300 : :
301 : : /* test for short name repeat! */
302 : : obj = test_argparse_init_obj();
303 : 1 : obj->args[1].name_short = obj->args[0].name_short;
304 : 1 : ret = rte_argparse_parse(obj, default_argc, default_argv);
305 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
306 : :
307 : : return 0;
308 : : }
309 : :
310 : : static int
311 : 1 : test_argparse_invalid_option(void)
312 : : {
313 : : struct rte_argparse *obj;
314 : : char *argv[2];
315 : : int ret;
316 : :
317 : : obj = test_argparse_init_obj();
318 : 1 : argv[0] = test_strdup(obj->prog_name);
319 : 1 : argv[1] = test_strdup("--invalid");
320 : 1 : ret = rte_argparse_parse(obj, 2, argv);
321 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
322 : :
323 : : obj = test_argparse_init_obj();
324 : 1 : argv[0] = test_strdup(obj->prog_name);
325 : 1 : argv[1] = test_strdup("invalid");
326 : 1 : ret = rte_argparse_parse(obj, 2, argv);
327 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
328 : :
329 : : return 0;
330 : : }
331 : :
332 : : static int
333 : 1 : test_argparse_invalid_repeated_option(void)
334 : : {
335 : : /* test that we allow repeated args only with the MULTI flag */
336 : : struct rte_argparse *obj;
337 : : char *argv[3];
338 : : int ret;
339 : :
340 : : /* check that we error out with two "-a" flags */
341 : : obj = test_argparse_init_obj();
342 : 1 : obj->args[0].val_saver = NULL;
343 : 1 : obj->args[1].val_saver = NULL;
344 : 1 : argv[0] = test_strdup(obj->prog_name);
345 : 1 : argv[1] = test_strdup("-a");
346 : 1 : argv[2] = test_strdup("-a");
347 : 1 : ret = rte_argparse_parse(obj, 3, argv);
348 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse did not error out with two '-a' flags!");
349 : :
350 : : obj = test_argparse_init_obj();
351 : 1 : obj->args[0].val_saver = NULL;
352 : 1 : obj->args[1].val_saver = NULL;
353 : 1 : obj->args[0].flags |= RTE_ARGPARSE_FLAG_SUPPORT_MULTI;
354 : : /* check that we allow two "-a" flags with MULTI flag set */
355 : 1 : argv[0] = test_strdup(obj->prog_name);
356 : 1 : argv[1] = test_strdup("-a");
357 : 1 : argv[2] = test_strdup("-a");
358 : 1 : ret = rte_argparse_parse(obj, 3, argv);
359 [ - + ]: 1 : TEST_ASSERT(ret == 3, "Argparse failed to handle duplicate '-a' flags!");
360 : :
361 : : return 0;
362 : : }
363 : :
364 : : static int
365 : 1 : test_argparse_opt_autosave_parse_int_of_no_val(void)
366 : : {
367 : : struct rte_argparse *obj;
368 : 1 : int val_saver = 0;
369 : : char *argv[2];
370 : : int ret;
371 : :
372 : : obj = test_argparse_init_obj();
373 : 1 : obj->args[0].name_long = "--test-long";
374 : 1 : obj->args[0].name_short = "-t";
375 : 1 : obj->args[0].val_saver = (void *)&val_saver;
376 : 1 : obj->args[0].val_set = (void *)100;
377 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_NONE;
378 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
379 : 1 : obj->args[1].name_long = NULL;
380 : 1 : argv[0] = test_strdup(obj->prog_name);
381 : 1 : argv[1] = test_strdup("--test-long");
382 : 1 : ret = rte_argparse_parse(obj, 2, argv);
383 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
384 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
385 : :
386 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_NONE;
387 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
388 : 1 : val_saver = 0;
389 : 1 : argv[1] = test_strdup("-t");
390 : 1 : ret = rte_argparse_parse(obj, 2, argv);
391 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
392 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
393 : :
394 : : return 0;
395 : : }
396 : :
397 : : static int
398 : 1 : test_argparse_opt_autosave_parse_int_of_required_val(void)
399 : : {
400 : : struct rte_argparse *obj;
401 : 1 : int val_saver = 0;
402 : : char *argv[3];
403 : : int ret;
404 : :
405 : : obj = test_argparse_init_obj();
406 : 1 : obj->args[0].name_long = "--test-long";
407 : 1 : obj->args[0].name_short = "-t";
408 : 1 : obj->args[0].val_saver = (void *)&val_saver;
409 : 1 : obj->args[0].val_set = NULL;
410 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
411 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
412 : 1 : obj->args[1].name_long = NULL;
413 : 1 : argv[0] = test_strdup(obj->prog_name);
414 : 1 : argv[1] = test_strdup("--test-long");
415 : 1 : argv[2] = test_strdup("100");
416 : 1 : ret = rte_argparse_parse(obj, 3, argv);
417 [ - + ]: 1 : TEST_ASSERT(ret == 3, "Argparse parse expect success!");
418 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
419 : :
420 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
421 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
422 : 1 : val_saver = 0;
423 : 1 : argv[1] = test_strdup("-t");
424 : 1 : ret = rte_argparse_parse(obj, 3, argv);
425 [ - + ]: 1 : TEST_ASSERT(ret == 3, "Argparse parse expect success!");
426 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
427 : :
428 : : /* test invalid value. */
429 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
430 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
431 : 1 : val_saver = 0;
432 : 1 : argv[1] = test_strdup("-t");
433 : 1 : argv[2] = test_strdup("100a");
434 : 1 : ret = rte_argparse_parse(obj, 3, argv);
435 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
436 : :
437 : : return 0;
438 : : }
439 : :
440 : : static int
441 : 1 : test_argparse_opt_autosave_parse_int_of_optional_val(void)
442 : : {
443 : : struct rte_argparse *obj;
444 : 1 : int val_saver = 0;
445 : : char *argv[2];
446 : : int ret;
447 : :
448 : : /* test without value. */
449 : : obj = test_argparse_init_obj();
450 : 1 : obj->args[0].name_long = "--test-long";
451 : 1 : obj->args[0].name_short = "-t";
452 : 1 : obj->args[0].val_saver = (void *)&val_saver;
453 : 1 : obj->args[0].val_set = (void *)100;
454 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
455 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
456 : 1 : obj->args[1].name_long = NULL;
457 : 1 : argv[0] = test_strdup(obj->prog_name);
458 : 1 : argv[1] = test_strdup("--test-long");
459 : 1 : ret = rte_argparse_parse(obj, 2, argv);
460 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
461 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
462 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
463 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
464 : 1 : val_saver = 0;
465 : 1 : argv[1] = test_strdup("-t");
466 : 1 : ret = rte_argparse_parse(obj, 2, argv);
467 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
468 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
469 : :
470 : : /* test with value. */
471 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
472 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
473 : 1 : val_saver = 0;
474 : 1 : argv[1] = test_strdup("--test-long=200");
475 : 1 : ret = rte_argparse_parse(obj, 2, argv);
476 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
477 [ - + ]: 1 : TEST_ASSERT(val_saver == 200, "Argparse parse expect success!");
478 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
479 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
480 : 1 : val_saver = 0;
481 : 1 : argv[1] = test_strdup("-t=200");
482 : 1 : ret = rte_argparse_parse(obj, 2, argv);
483 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
484 [ - + ]: 1 : TEST_ASSERT(val_saver == 200, "Argparse parse expect success!");
485 : :
486 : : /* test with option value, but with wrong value. */
487 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
488 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
489 : 1 : val_saver = 0;
490 : 1 : argv[1] = test_strdup("--test-long=200a");
491 : 1 : ret = rte_argparse_parse(obj, 2, argv);
492 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
493 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
494 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
495 : 1 : val_saver = 0;
496 : 1 : argv[1] = test_strdup("-t=200a");
497 : 1 : ret = rte_argparse_parse(obj, 2, argv);
498 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
499 : :
500 : : return 0;
501 : : }
502 : :
503 : : static int
504 : 2 : opt_callback_parse_int_of_no_val(uint32_t index, const char *value, void *opaque)
505 : : {
506 [ + - ]: 2 : if (index != 1)
507 : : return -EINVAL;
508 [ + - ]: 2 : if (value != NULL)
509 : : return -EINVAL;
510 : 2 : *(int *)opaque = 100;
511 : 2 : return 0;
512 : : }
513 : :
514 : : static int
515 : 1 : test_argparse_opt_callback_parse_int_of_no_val(void)
516 : : {
517 : : struct rte_argparse *obj;
518 : 1 : int val_saver = 0;
519 : : char *argv[2];
520 : : int ret;
521 : :
522 : : obj = test_argparse_init_obj();
523 : 1 : obj->callback = opt_callback_parse_int_of_no_val;
524 : 1 : obj->opaque = (void *)&val_saver;
525 : 1 : obj->args[0].name_long = "--test-long";
526 : 1 : obj->args[0].name_short = "-t";
527 : 1 : obj->args[0].val_saver = NULL;
528 : 1 : obj->args[0].val_set = (void *)1;
529 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_NONE;
530 : 1 : obj->args[1].name_long = NULL;
531 : 1 : argv[0] = test_strdup(obj->prog_name);
532 : 1 : argv[1] = test_strdup("--test-long");
533 : 1 : ret = rte_argparse_parse(obj, 2, argv);
534 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
535 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
536 : :
537 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_NONE;
538 : 1 : val_saver = 0;
539 : 1 : argv[1] = test_strdup("-t");
540 : 1 : ret = rte_argparse_parse(obj, 2, argv);
541 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
542 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
543 : :
544 : : return 0;
545 : : }
546 : :
547 : : static int
548 : 3 : opt_callback_parse_int_of_required_val(uint32_t index, const char *value, void *opaque)
549 : : {
550 : 3 : char *s = NULL;
551 : :
552 [ + - ]: 3 : if (index != 1)
553 : : return -EINVAL;
554 : :
555 [ + - ]: 3 : if (value == NULL)
556 : : return -EINVAL;
557 : 3 : *(int *)opaque = strtol(value, &s, 0);
558 : :
559 [ + + ]: 3 : if (s[0] != '\0')
560 : 1 : return -EINVAL;
561 : :
562 : : return 0;
563 : : }
564 : :
565 : : static int
566 : 1 : test_argparse_opt_callback_parse_int_of_required_val(void)
567 : : {
568 : : struct rte_argparse *obj;
569 : 1 : int val_saver = 0;
570 : : char *argv[3];
571 : : int ret;
572 : :
573 : : obj = test_argparse_init_obj();
574 : 1 : obj->callback = opt_callback_parse_int_of_required_val;
575 : 1 : obj->opaque = (void *)&val_saver;
576 : 1 : obj->args[0].name_long = "--test-long";
577 : 1 : obj->args[0].name_short = "-t";
578 : 1 : obj->args[0].val_saver = NULL;
579 : 1 : obj->args[0].val_set = (void *)1;
580 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
581 : 1 : obj->args[1].name_long = NULL;
582 : 1 : argv[0] = test_strdup(obj->prog_name);
583 : 1 : argv[1] = test_strdup("--test-long");
584 : 1 : argv[2] = test_strdup("100");
585 : 1 : ret = rte_argparse_parse(obj, 3, argv);
586 [ - + ]: 1 : TEST_ASSERT(ret == 3, "Argparse parse expect success!");
587 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
588 : :
589 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
590 : 1 : val_saver = 0;
591 : 1 : argv[1] = test_strdup("-t");
592 : 1 : ret = rte_argparse_parse(obj, 3, argv);
593 [ - + ]: 1 : TEST_ASSERT(ret == 3, "Argparse parse expect success!");
594 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
595 : :
596 : : /* test no more parameters. */
597 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
598 : 1 : ret = rte_argparse_parse(obj, 2, argv);
599 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
600 : :
601 : : /* test callback return failed. */
602 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
603 : 1 : argv[2] = test_strdup("100a");
604 : 1 : ret = rte_argparse_parse(obj, 3, argv);
605 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
606 : :
607 : : return 0;
608 : : }
609 : :
610 : : static int
611 : 5 : opt_callback_parse_int_of_optional_val(uint32_t index, const char *value, void *opaque)
612 : : {
613 : 5 : char *s = NULL;
614 : :
615 [ + - ]: 5 : if (index != 1)
616 : : return -EINVAL;
617 : :
618 [ + + ]: 5 : if (value == NULL) {
619 : 2 : *(int *)opaque = 10;
620 : : } else {
621 : 3 : *(int *)opaque = strtol(value, &s, 0);
622 [ + + ]: 3 : if (s[0] != '\0')
623 : 1 : return -EINVAL;
624 : : }
625 : :
626 : : return 0;
627 : : }
628 : :
629 : : static int
630 : 1 : test_argparse_opt_callback_parse_int_of_optional_val(void)
631 : : {
632 : : struct rte_argparse *obj;
633 : 1 : int val_saver = 0;
634 : : char *argv[2];
635 : : int ret;
636 : :
637 : : obj = test_argparse_init_obj();
638 : 1 : obj->callback = opt_callback_parse_int_of_optional_val;
639 : 1 : obj->opaque = (void *)&val_saver;
640 : 1 : obj->args[0].name_long = "--test-long";
641 : 1 : obj->args[0].name_short = "-t";
642 : 1 : obj->args[0].val_saver = NULL;
643 : 1 : obj->args[0].val_set = (void *)1;
644 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
645 : 1 : obj->args[1].name_long = NULL;
646 : 1 : argv[0] = test_strdup(obj->prog_name);
647 : 1 : argv[1] = test_strdup("--test-long");
648 : 1 : ret = rte_argparse_parse(obj, 2, argv);
649 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
650 [ - + ]: 1 : TEST_ASSERT(val_saver == 10, "Argparse parse expect success!");
651 : :
652 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
653 : 1 : val_saver = 0;
654 : 1 : argv[1] = test_strdup("-t");
655 : 1 : ret = rte_argparse_parse(obj, 2, argv);
656 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
657 [ - + ]: 1 : TEST_ASSERT(val_saver == 10, "Argparse parse expect success!");
658 : :
659 : : /* test with value. */
660 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
661 : 1 : val_saver = 0;
662 : 1 : argv[1] = test_strdup("--test-long=100");
663 : 1 : ret = rte_argparse_parse(obj, 2, argv);
664 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
665 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
666 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
667 : 1 : val_saver = 0;
668 : 1 : argv[1] = test_strdup("-t=100");
669 : 1 : ret = rte_argparse_parse(obj, 2, argv);
670 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
671 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
672 : :
673 : : /* test callback return failed. */
674 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_OPTIONAL;
675 : 1 : argv[1] = test_strdup("-t=100a");
676 : 1 : ret = rte_argparse_parse(obj, 2, argv);
677 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
678 : :
679 : : return 0;
680 : : }
681 : :
682 : : static int
683 : 1 : test_argparse_pos_autosave_parse_int(void)
684 : : {
685 : : struct rte_argparse *obj;
686 : 1 : int val_saver = 0;
687 : : char *argv[3];
688 : : int ret;
689 : :
690 : : /* test positional autosave parse successful. */
691 : : obj = test_argparse_init_obj();
692 : 1 : obj->args[0].name_long = "test-long";
693 : 1 : obj->args[0].name_short = NULL;
694 : 1 : obj->args[0].val_saver = (void *)&val_saver;
695 : 1 : obj->args[0].val_set = NULL;
696 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
697 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
698 : 1 : obj->args[1].name_long = NULL;
699 : 1 : argv[0] = test_strdup(obj->prog_name);
700 : 1 : argv[1] = test_strdup("100");
701 : 1 : ret = rte_argparse_parse(obj, 2, argv);
702 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Argparse parse expect success!");
703 [ - + ]: 1 : TEST_ASSERT(val_saver == 100, "Argparse parse expect success!");
704 : :
705 : : /* test positional autosave parse failed. */
706 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
707 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
708 : 1 : val_saver = 0;
709 : 1 : argv[1] = test_strdup("100a");
710 : 1 : ret = rte_argparse_parse(obj, 2, argv);
711 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
712 : :
713 : : /* test too much position parameters. */
714 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
715 : 1 : obj->args[0].value_type = RTE_ARGPARSE_VALUE_TYPE_INT;
716 : 1 : argv[1] = test_strdup("100");
717 : 1 : argv[2] = test_strdup("200");
718 : 1 : ret = rte_argparse_parse(obj, 3, argv);
719 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
720 : :
721 : : return 0;
722 : : }
723 : :
724 : : static int
725 : 4 : pos_callback_parse_int(uint32_t index, const char *value, void *opaque)
726 : : {
727 : : uint32_t int_val;
728 : 4 : char *s = NULL;
729 : :
730 [ + - ]: 4 : if (index != 1 && index != 2)
731 : : return -EINVAL;
732 [ + - ]: 4 : if (value == NULL)
733 : : return -EINVAL;
734 : :
735 : 4 : int_val = strtol(value, &s, 0);
736 [ + + ]: 4 : if (s[0] != '\0')
737 : : return -EINVAL;
738 : :
739 : 3 : *((int *)opaque + index) = int_val;
740 : :
741 : 3 : return 0;
742 : : }
743 : :
744 : : static int
745 : 1 : test_argparse_pos_callback_parse_int(void)
746 : : {
747 : 1 : int val_saver[3] = { 0, 0, 0 };
748 : : struct rte_argparse *obj;
749 : : char *argv[3];
750 : : int ret;
751 : :
752 : : /* test positional callback parse successful. */
753 : : obj = test_argparse_init_obj();
754 : 1 : obj->callback = pos_callback_parse_int;
755 : 1 : obj->opaque = (void *)val_saver;
756 : 1 : obj->args[0].name_long = "test-long1";
757 : 1 : obj->args[0].name_short = NULL;
758 : 1 : obj->args[0].val_saver = NULL;
759 : 1 : obj->args[0].val_set = (void *)1;
760 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
761 : 1 : obj->args[1].name_long = "test-long2";
762 : 1 : obj->args[1].name_short = NULL;
763 : 1 : obj->args[1].val_saver = NULL;
764 : 1 : obj->args[1].val_set = (void *)2;
765 : 1 : obj->args[1].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
766 : 1 : obj->args[2].name_long = NULL;
767 : 1 : argv[0] = test_strdup(obj->prog_name);
768 : 1 : argv[1] = test_strdup("100");
769 : 1 : argv[2] = test_strdup("200");
770 : 1 : ret = rte_argparse_parse(obj, 3, argv);
771 [ - + ]: 1 : TEST_ASSERT(ret == 3, "Argparse parse expect success!");
772 [ - + ]: 1 : TEST_ASSERT(val_saver[1] == 100, "Argparse parse expect success!");
773 [ - + ]: 1 : TEST_ASSERT(val_saver[2] == 200, "Argparse parse expect success!");
774 : :
775 : : /* test positional callback parse failed. */
776 : 1 : obj->args[0].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
777 : 1 : obj->args[1].value_required = RTE_ARGPARSE_VALUE_REQUIRED;
778 : 1 : argv[2] = test_strdup("200a");
779 : 1 : ret = rte_argparse_parse(obj, 3, argv);
780 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Argparse parse expect failed!");
781 : :
782 : : return 0;
783 : : }
784 : :
785 : : static int
786 : 1 : test_argparse_parse_type(void)
787 : : {
788 : 1 : char *str_erange = test_strdup("9999999999999999999999999999999999");
789 : 1 : char *str_erange_u32 = test_strdup("4294967296");
790 : 1 : char *str_erange_u16 = test_strdup("65536");
791 : 1 : char *str_erange_u8 = test_strdup("256");
792 : 1 : char *str_invalid = test_strdup("1a");
793 : 1 : char *str_ok = test_strdup("123");
794 : 1 : char *bool_true = test_strdup("true");
795 : 1 : char *bool_false = test_strdup("false");
796 : 1 : char *bool_invalid = test_strdup("invalid");
797 : 1 : char *bool_numeric_true = test_strdup("1");
798 : 1 : char *bool_numeric_false = test_strdup("0");
799 : 1 : char *bool_numeric_invalid = test_strdup("2");
800 : : uint16_t val_u16;
801 : : uint32_t val_u32;
802 : : uint64_t val_u64;
803 : : uint8_t val_u8;
804 : : int val_int;
805 : : int ret;
806 : :
807 : : /* test for int parsing */
808 : 1 : ret = rte_argparse_parse_type(str_erange, RTE_ARGPARSE_VALUE_TYPE_INT, &val_int);
809 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
810 : 1 : ret = rte_argparse_parse_type(str_invalid, RTE_ARGPARSE_VALUE_TYPE_INT, &val_int);
811 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
812 : 1 : ret = rte_argparse_parse_type(str_ok, RTE_ARGPARSE_VALUE_TYPE_INT, &val_int);
813 [ - + ]: 1 : TEST_ASSERT(ret == 0, "Argparse parse type expect failed!");
814 [ - + ]: 1 : TEST_ASSERT(val_int == 123, "Argparse parse type expect failed!");
815 : :
816 : : /* test for u8 parsing */
817 : 1 : ret = rte_argparse_parse_type(str_erange, RTE_ARGPARSE_VALUE_TYPE_U8, &val_u8);
818 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
819 : 1 : ret = rte_argparse_parse_type(str_erange_u8, RTE_ARGPARSE_VALUE_TYPE_U8, &val_u8);
820 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
821 : 1 : ret = rte_argparse_parse_type(str_invalid, RTE_ARGPARSE_VALUE_TYPE_U8, &val_u8);
822 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
823 : 1 : val_u8 = 0;
824 : 1 : ret = rte_argparse_parse_type(str_ok, RTE_ARGPARSE_VALUE_TYPE_U8, &val_u8);
825 [ - + ]: 1 : TEST_ASSERT(ret == 0, "Argparse parse type expect failed!");
826 [ - + ]: 1 : TEST_ASSERT(val_u8 == 123, "Argparse parse type expect failed!");
827 : :
828 : : /* test for u16 parsing */
829 : 1 : ret = rte_argparse_parse_type(str_erange, RTE_ARGPARSE_VALUE_TYPE_U16, &val_u16);
830 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
831 : 1 : ret = rte_argparse_parse_type(str_erange_u16, RTE_ARGPARSE_VALUE_TYPE_U16, &val_u16);
832 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
833 : 1 : ret = rte_argparse_parse_type(str_invalid, RTE_ARGPARSE_VALUE_TYPE_U16, &val_u16);
834 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
835 : 1 : val_u16 = 0;
836 : 1 : ret = rte_argparse_parse_type(str_ok, RTE_ARGPARSE_VALUE_TYPE_U16, &val_u16);
837 [ - + ]: 1 : TEST_ASSERT(ret == 0, "Argparse parse type expect failed!");
838 [ - + ]: 1 : TEST_ASSERT(val_u16 == 123, "Argparse parse type expect failed!");
839 : :
840 : : /* test for u32 parsing */
841 : 1 : ret = rte_argparse_parse_type(str_erange, RTE_ARGPARSE_VALUE_TYPE_U32, &val_u32);
842 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
843 : 1 : ret = rte_argparse_parse_type(str_erange_u32, RTE_ARGPARSE_VALUE_TYPE_U32, &val_u32);
844 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
845 : 1 : ret = rte_argparse_parse_type(str_invalid, RTE_ARGPARSE_VALUE_TYPE_U32, &val_u32);
846 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
847 : 1 : val_u32 = 0;
848 : 1 : ret = rte_argparse_parse_type(str_ok, RTE_ARGPARSE_VALUE_TYPE_U32, &val_u32);
849 [ - + ]: 1 : TEST_ASSERT(ret == 0, "Argparse parse type expect failed!");
850 [ - + ]: 1 : TEST_ASSERT(val_u32 == 123, "Argparse parse type expect failed!");
851 : :
852 : : /* test for u64 parsing */
853 : 1 : ret = rte_argparse_parse_type(str_erange, RTE_ARGPARSE_VALUE_TYPE_U64, &val_u64);
854 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
855 : 1 : ret = rte_argparse_parse_type(str_invalid, RTE_ARGPARSE_VALUE_TYPE_U64, &val_u64);
856 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type expect failed!");
857 : 1 : val_u64 = 0;
858 : 1 : ret = rte_argparse_parse_type(str_ok, RTE_ARGPARSE_VALUE_TYPE_U64, &val_u64);
859 [ - + ]: 1 : TEST_ASSERT(ret == 0, "Argparse parse type expect failed!");
860 [ - + ]: 1 : TEST_ASSERT(val_u64 == 123, "Argparse parse type expect failed!");
861 : :
862 : : /* test for string parsing - all it does is save string, so all are valid */
863 : : const char *val_str;
864 : 1 : ret = rte_argparse_parse_type(str_erange, RTE_ARGPARSE_VALUE_TYPE_STR, &val_str);
865 [ - + ]: 1 : TEST_ASSERT(ret == 0, "Argparse parse a string failed unexpectedly!");
866 : :
867 : : /* test for boolean parsing */
868 : 1 : bool val_bool = false;
869 : 1 : ret = rte_argparse_parse_type(bool_true, RTE_ARGPARSE_VALUE_TYPE_BOOL, &val_bool);
870 [ + - - + ]: 1 : TEST_ASSERT(ret == 0 && val_bool == true, "Argparse parse type for bool (true) failed!");
871 : 1 : ret = rte_argparse_parse_type(bool_false, RTE_ARGPARSE_VALUE_TYPE_BOOL, &val_bool);
872 [ + - - + ]: 1 : TEST_ASSERT(ret == 0 && val_bool == false, "Argparse parse type for bool (false) failed!");
873 : 1 : ret = rte_argparse_parse_type(bool_invalid, RTE_ARGPARSE_VALUE_TYPE_BOOL, &val_bool);
874 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type for bool (invalid) passed unexpectedly!");
875 : 1 : ret = rte_argparse_parse_type(bool_numeric_true, RTE_ARGPARSE_VALUE_TYPE_BOOL, &val_bool);
876 [ + - - + ]: 1 : TEST_ASSERT(ret == 0 && val_bool == true, "Argparse parse type for bool (numeric true) failed!");
877 : 1 : ret = rte_argparse_parse_type(bool_numeric_false, RTE_ARGPARSE_VALUE_TYPE_BOOL,
878 : : &val_bool);
879 [ + - - + ]: 1 : TEST_ASSERT(ret == 0 && val_bool == false, "Argparse parse type for bool (numeric false) failed!");
880 : 1 : ret = rte_argparse_parse_type(bool_numeric_invalid, RTE_ARGPARSE_VALUE_TYPE_BOOL,
881 : : &val_bool);
882 [ - + ]: 1 : TEST_ASSERT(ret != 0, "Argparse parse type for bool (numeric invalid) passed unexpectedly!");
883 : : return 0;
884 : : }
885 : :
886 : : static struct unit_test_suite argparse_test_suite = {
887 : : .suite_name = "Argparse Unit Test Suite",
888 : : .setup = test_argparse_setup,
889 : : .teardown = test_argparse_teardown,
890 : : .unit_test_cases = {
891 : : TEST_CASE(test_argparse_invalid_basic_param),
892 : : TEST_CASE(test_argparse_invalid_arg_name),
893 : : TEST_CASE(test_argparse_invalid_arg_help),
894 : : TEST_CASE(test_argparse_invalid_has_val),
895 : : TEST_CASE(test_argparse_invalid_arg_saver),
896 : : TEST_CASE(test_argparse_invalid_arg_flags),
897 : : TEST_CASE(test_argparse_invalid_arg_repeat),
898 : : TEST_CASE(test_argparse_invalid_option),
899 : : TEST_CASE(test_argparse_invalid_repeated_option),
900 : : TEST_CASE(test_argparse_opt_autosave_parse_int_of_no_val),
901 : : TEST_CASE(test_argparse_opt_autosave_parse_int_of_required_val),
902 : : TEST_CASE(test_argparse_opt_autosave_parse_int_of_optional_val),
903 : : TEST_CASE(test_argparse_opt_callback_parse_int_of_no_val),
904 : : TEST_CASE(test_argparse_opt_callback_parse_int_of_required_val),
905 : : TEST_CASE(test_argparse_opt_callback_parse_int_of_optional_val),
906 : : TEST_CASE(test_argparse_pos_autosave_parse_int),
907 : : TEST_CASE(test_argparse_pos_callback_parse_int),
908 : : TEST_CASE(test_argparse_parse_type),
909 : :
910 : : TEST_CASES_END() /**< NULL terminate unit test array */
911 : : }
912 : : };
913 : :
914 : : static int
915 : 1 : test_argparse(void)
916 : : {
917 : 1 : return unit_test_suite_runner(&argparse_test_suite);
918 : : }
919 : :
920 : 254 : REGISTER_FAST_TEST(argparse_autotest, true, true, test_argparse);
|
