Line data Source code
1 : /* Test of command line argument processing.
2 : Copyright (C) 2009-2020 Free Software Foundation, Inc.
3 :
4 : This program is free software: you can redistribute it and/or modify
5 : it under the terms of the GNU General Public License as published by
6 : the Free Software Foundation; either version 3 of the License, or
7 : (at your option) any later version.
8 :
9 : This program is distributed in the hope that it will be useful,
10 : but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : GNU General Public License for more details.
13 :
14 : You should have received a copy of the GNU General Public License
15 : along with this program. If not, see <https://www.gnu.org/licenses/>. */
16 :
17 : /* Written by Bruno Haible <bruno@clisp.org>, 2009. */
18 :
19 : static int a_seen;
20 : static int b_seen;
21 : static int q_seen;
22 :
23 : static const struct option long_options_required[] =
24 : {
25 : { "alpha", no_argument, NULL, 'a' },
26 : { "beta", no_argument, &b_seen, 1 },
27 : { "prune", required_argument, NULL, 'p' },
28 : { "quetsche", required_argument, &q_seen, 1 },
29 : { "xtremely-",no_argument, NULL, 1003 },
30 : { "xtra", no_argument, NULL, 1001 },
31 : { "xtreme", no_argument, NULL, 1002 },
32 : { "xtremely", no_argument, NULL, 1003 },
33 : { NULL, 0, NULL, 0 }
34 : };
35 :
36 : static const struct option long_options_optional[] =
37 : {
38 : { "alpha", no_argument, NULL, 'a' },
39 : { "beta", no_argument, &b_seen, 1 },
40 : { "prune", optional_argument, NULL, 'p' },
41 : { "quetsche", optional_argument, &q_seen, 1 },
42 : { NULL, 0, NULL, 0 }
43 : };
44 :
45 : static void
46 94 : getopt_long_loop (int argc, const char **argv,
47 : const char *options, const struct option *long_options,
48 : const char **p_value, const char **q_value,
49 : int *non_options_count, const char **non_options,
50 : int *unrecognized)
51 : {
52 94 : int option_index = -1;
53 : int c;
54 :
55 94 : opterr = 0;
56 94 : q_seen = 0;
57 268 : while ((c = getopt_long (argc, (char **) argv, options, long_options,
58 : &option_index))
59 : != -1)
60 : {
61 174 : switch (c)
62 : {
63 16 : case 0:
64 : /* An option with a non-NULL flag pointer was processed. */
65 16 : if (q_seen)
66 4 : *q_value = optarg;
67 16 : break;
68 56 : case 'a':
69 56 : a_seen++;
70 56 : break;
71 14 : case 'b':
72 14 : b_seen = 1;
73 14 : break;
74 64 : case 'p':
75 64 : *p_value = optarg;
76 64 : break;
77 2 : case 'q':
78 2 : *q_value = optarg;
79 2 : break;
80 12 : case '\1':
81 : /* Must only happen with option '-' at the beginning. */
82 12 : ASSERT (options[0] == '-');
83 12 : non_options[(*non_options_count)++] = optarg;
84 12 : break;
85 0 : case ':':
86 : /* Must only happen with option ':' at the beginning. */
87 0 : ASSERT (options[0] == ':'
88 : || ((options[0] == '-' || options[0] == '+')
89 : && options[1] == ':'));
90 : FALLTHROUGH;
91 : case '?':
92 10 : *unrecognized = optopt;
93 10 : break;
94 0 : default:
95 0 : *unrecognized = c;
96 0 : break;
97 : }
98 : }
99 94 : }
100 :
101 : /* Reduce casting, so we can use string literals elsewhere.
102 : getopt_long takes an array of char*, but luckily does not modify
103 : those elements, so we can pass const char*. */
104 : static int
105 13 : do_getopt_long (int argc, const char **argv, const char *shortopts,
106 : const struct option *longopts, int *longind)
107 : {
108 13 : return getopt_long (argc, (char **) argv, shortopts, longopts, longind);
109 : }
110 :
111 : static void
112 1 : test_getopt_long (void)
113 : {
114 : int start;
115 :
116 : /* Test disambiguation of options. */
117 : {
118 1 : int argc = 0;
119 : const char *argv[10];
120 : int option_index;
121 : int c;
122 :
123 1 : argv[argc++] = "program";
124 1 : argv[argc++] = "--x";
125 1 : argv[argc] = NULL;
126 1 : optind = 1;
127 1 : opterr = 0;
128 1 : c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
129 1 : ASSERT (c == '?');
130 1 : ASSERT (optopt == 0);
131 : }
132 : {
133 1 : int argc = 0;
134 : const char *argv[10];
135 : int option_index;
136 : int c;
137 :
138 1 : argv[argc++] = "program";
139 1 : argv[argc++] = "--xt";
140 1 : argv[argc] = NULL;
141 1 : optind = 1;
142 1 : opterr = 0;
143 1 : c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
144 1 : ASSERT (c == '?');
145 1 : ASSERT (optopt == 0);
146 : }
147 : {
148 1 : int argc = 0;
149 : const char *argv[10];
150 : int option_index;
151 : int c;
152 :
153 1 : argv[argc++] = "program";
154 1 : argv[argc++] = "--xtr";
155 1 : argv[argc] = NULL;
156 1 : optind = 1;
157 1 : opterr = 0;
158 1 : c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
159 1 : ASSERT (c == '?');
160 1 : ASSERT (optopt == 0);
161 : }
162 : {
163 1 : int argc = 0;
164 : const char *argv[10];
165 : int option_index;
166 : int c;
167 :
168 1 : argv[argc++] = "program";
169 1 : argv[argc++] = "--xtra";
170 1 : argv[argc] = NULL;
171 1 : optind = 1;
172 1 : opterr = 0;
173 1 : c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
174 1 : ASSERT (c == 1001);
175 : }
176 : {
177 1 : int argc = 0;
178 : const char *argv[10];
179 : int option_index;
180 : int c;
181 :
182 1 : argv[argc++] = "program";
183 1 : argv[argc++] = "--xtre";
184 1 : argv[argc] = NULL;
185 1 : optind = 1;
186 1 : opterr = 0;
187 1 : c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
188 1 : ASSERT (c == '?');
189 1 : ASSERT (optopt == 0);
190 : }
191 : {
192 1 : int argc = 0;
193 : const char *argv[10];
194 : int option_index;
195 : int c;
196 :
197 1 : argv[argc++] = "program";
198 1 : argv[argc++] = "--xtrem";
199 1 : argv[argc] = NULL;
200 1 : optind = 1;
201 1 : opterr = 0;
202 1 : c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
203 1 : ASSERT (c == '?');
204 1 : ASSERT (optopt == 0);
205 : }
206 : {
207 1 : int argc = 0;
208 : const char *argv[10];
209 : int option_index;
210 : int c;
211 :
212 1 : argv[argc++] = "program";
213 1 : argv[argc++] = "--xtreme";
214 1 : argv[argc] = NULL;
215 1 : optind = 1;
216 1 : opterr = 0;
217 1 : c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
218 1 : ASSERT (c == 1002);
219 : }
220 : {
221 1 : int argc = 0;
222 : const char *argv[10];
223 : int option_index;
224 : int c;
225 :
226 1 : argv[argc++] = "program";
227 1 : argv[argc++] = "--xtremel";
228 1 : argv[argc] = NULL;
229 1 : optind = 1;
230 1 : opterr = 0;
231 1 : c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
232 1 : ASSERT (c == 1003);
233 : }
234 : {
235 1 : int argc = 0;
236 : const char *argv[10];
237 : int option_index;
238 : int c;
239 :
240 1 : argv[argc++] = "program";
241 1 : argv[argc++] = "--xtremely";
242 1 : argv[argc] = NULL;
243 1 : optind = 1;
244 1 : opterr = 0;
245 1 : c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
246 1 : ASSERT (c == 1003);
247 : }
248 :
249 : /* Check that -W handles unknown options. */
250 : {
251 1 : int argc = 0;
252 : const char *argv[10];
253 : int option_index;
254 : int c;
255 :
256 1 : argv[argc++] = "program";
257 1 : argv[argc++] = "-W";
258 1 : argv[argc] = NULL;
259 1 : optind = 1;
260 1 : opterr = 0;
261 1 : c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);
262 1 : ASSERT (c == '?');
263 1 : ASSERT (optopt == 'W');
264 : }
265 : {
266 1 : int argc = 0;
267 : const char *argv[10];
268 : int option_index;
269 : int c;
270 :
271 1 : argv[argc++] = "program";
272 1 : argv[argc++] = "-Wunknown";
273 1 : argv[argc] = NULL;
274 1 : optind = 1;
275 1 : opterr = 0;
276 1 : c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);
277 : /* glibc and BSD behave differently here, but for now, we allow
278 : both behaviors since W support is not frequently used. */
279 1 : if (c == '?')
280 : {
281 1 : ASSERT (optopt == 0);
282 1 : ASSERT (optarg == NULL);
283 : }
284 : else
285 : {
286 0 : ASSERT (c == 'W');
287 0 : ASSERT (strcmp (optarg, "unknown") == 0);
288 : }
289 : }
290 : {
291 1 : int argc = 0;
292 : const char *argv[10];
293 : int option_index;
294 : int c;
295 :
296 1 : argv[argc++] = "program";
297 1 : argv[argc++] = "-W";
298 1 : argv[argc++] = "unknown";
299 1 : argv[argc] = NULL;
300 1 : optind = 1;
301 1 : opterr = 0;
302 1 : c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);
303 : /* glibc and BSD behave differently here, but for now, we allow
304 : both behaviors since W support is not frequently used. */
305 1 : if (c == '?')
306 : {
307 1 : ASSERT (optopt == 0);
308 1 : ASSERT (optarg == NULL);
309 : }
310 : else
311 : {
312 0 : ASSERT (c == 'W');
313 0 : ASSERT (strcmp (optarg, "unknown") == 0);
314 : }
315 : }
316 :
317 : /* Test that 'W' does not dump core:
318 : https://sourceware.org/bugzilla/show_bug.cgi?id=12922 */
319 : {
320 1 : int argc = 0;
321 : const char *argv[10];
322 : int option_index;
323 : int c;
324 :
325 1 : argv[argc++] = "program";
326 1 : argv[argc++] = "-W";
327 1 : argv[argc++] = "dummy";
328 1 : argv[argc] = NULL;
329 1 : optind = 1;
330 1 : opterr = 0;
331 1 : c = do_getopt_long (argc, argv, "W;", NULL, &option_index);
332 1 : ASSERT (c == 'W');
333 1 : ASSERT (optind == 2);
334 : }
335 :
336 : /* Test processing of boolean short options. */
337 3 : for (start = 0; start <= 1; start++)
338 : {
339 2 : const char *p_value = NULL;
340 2 : const char *q_value = NULL;
341 2 : int non_options_count = 0;
342 : const char *non_options[10];
343 2 : int unrecognized = 0;
344 2 : int argc = 0;
345 : const char *argv[10];
346 2 : a_seen = 0;
347 2 : b_seen = 0;
348 :
349 2 : argv[argc++] = "program";
350 2 : argv[argc++] = "-a";
351 2 : argv[argc++] = "foo";
352 2 : argv[argc++] = "bar";
353 2 : argv[argc] = NULL;
354 2 : optind = start;
355 2 : getopt_long_loop (argc, argv, "ab", long_options_required,
356 : &p_value, &q_value,
357 : &non_options_count, non_options, &unrecognized);
358 2 : ASSERT (a_seen == 1);
359 2 : ASSERT (b_seen == 0);
360 2 : ASSERT (p_value == NULL);
361 2 : ASSERT (q_value == NULL);
362 2 : ASSERT (non_options_count == 0);
363 2 : ASSERT (unrecognized == 0);
364 2 : ASSERT (optind == 2);
365 : }
366 3 : for (start = 0; start <= 1; start++)
367 : {
368 2 : const char *p_value = NULL;
369 2 : const char *q_value = NULL;
370 2 : int non_options_count = 0;
371 : const char *non_options[10];
372 2 : int unrecognized = 0;
373 2 : int argc = 0;
374 : const char *argv[10];
375 2 : a_seen = 0;
376 2 : b_seen = 0;
377 :
378 2 : argv[argc++] = "program";
379 2 : argv[argc++] = "-b";
380 2 : argv[argc++] = "-a";
381 2 : argv[argc++] = "foo";
382 2 : argv[argc++] = "bar";
383 2 : argv[argc] = NULL;
384 2 : optind = start;
385 2 : getopt_long_loop (argc, argv, "ab", long_options_required,
386 : &p_value, &q_value,
387 : &non_options_count, non_options, &unrecognized);
388 2 : ASSERT (a_seen == 1);
389 2 : ASSERT (b_seen == 1);
390 2 : ASSERT (p_value == NULL);
391 2 : ASSERT (q_value == NULL);
392 2 : ASSERT (non_options_count == 0);
393 2 : ASSERT (unrecognized == 0);
394 2 : ASSERT (optind == 3);
395 : }
396 3 : for (start = 0; start <= 1; start++)
397 : {
398 2 : const char *p_value = NULL;
399 2 : const char *q_value = NULL;
400 2 : int non_options_count = 0;
401 : const char *non_options[10];
402 2 : int unrecognized = 0;
403 2 : int argc = 0;
404 : const char *argv[10];
405 2 : a_seen = 0;
406 2 : b_seen = 0;
407 :
408 2 : argv[argc++] = "program";
409 2 : argv[argc++] = "-ba";
410 2 : argv[argc++] = "foo";
411 2 : argv[argc++] = "bar";
412 2 : argv[argc] = NULL;
413 2 : optind = start;
414 2 : getopt_long_loop (argc, argv, "ab", long_options_required,
415 : &p_value, &q_value,
416 : &non_options_count, non_options, &unrecognized);
417 2 : ASSERT (a_seen == 1);
418 2 : ASSERT (b_seen == 1);
419 2 : ASSERT (p_value == NULL);
420 2 : ASSERT (q_value == NULL);
421 2 : ASSERT (non_options_count == 0);
422 2 : ASSERT (unrecognized == 0);
423 2 : ASSERT (optind == 2);
424 : }
425 3 : for (start = 0; start <= 1; start++)
426 : {
427 2 : const char *p_value = NULL;
428 2 : const char *q_value = NULL;
429 2 : int non_options_count = 0;
430 : const char *non_options[10];
431 2 : int unrecognized = 0;
432 2 : int argc = 0;
433 : const char *argv[10];
434 2 : a_seen = 0;
435 2 : b_seen = 0;
436 :
437 2 : argv[argc++] = "program";
438 2 : argv[argc++] = "-ab";
439 2 : argv[argc++] = "-a";
440 2 : argv[argc++] = "foo";
441 2 : argv[argc++] = "bar";
442 2 : argv[argc] = NULL;
443 2 : optind = start;
444 2 : getopt_long_loop (argc, argv, "ab", long_options_required,
445 : &p_value, &q_value,
446 : &non_options_count, non_options, &unrecognized);
447 2 : ASSERT (a_seen == 2);
448 2 : ASSERT (b_seen == 1);
449 2 : ASSERT (p_value == NULL);
450 2 : ASSERT (q_value == NULL);
451 2 : ASSERT (non_options_count == 0);
452 2 : ASSERT (unrecognized == 0);
453 2 : ASSERT (optind == 3);
454 : }
455 :
456 : /* Test processing of boolean long options. */
457 3 : for (start = 0; start <= 1; start++)
458 : {
459 2 : const char *p_value = NULL;
460 2 : const char *q_value = NULL;
461 2 : int non_options_count = 0;
462 : const char *non_options[10];
463 2 : int unrecognized = 0;
464 2 : int argc = 0;
465 : const char *argv[10];
466 2 : a_seen = 0;
467 2 : b_seen = 0;
468 :
469 2 : argv[argc++] = "program";
470 2 : argv[argc++] = "--alpha";
471 2 : argv[argc++] = "foo";
472 2 : argv[argc++] = "bar";
473 2 : argv[argc] = NULL;
474 2 : optind = start;
475 2 : getopt_long_loop (argc, argv, "ab", long_options_required,
476 : &p_value, &q_value,
477 : &non_options_count, non_options, &unrecognized);
478 2 : ASSERT (a_seen == 1);
479 2 : ASSERT (b_seen == 0);
480 2 : ASSERT (p_value == NULL);
481 2 : ASSERT (q_value == NULL);
482 2 : ASSERT (non_options_count == 0);
483 2 : ASSERT (unrecognized == 0);
484 2 : ASSERT (optind == 2);
485 : }
486 3 : for (start = 0; start <= 1; start++)
487 : {
488 2 : const char *p_value = NULL;
489 2 : const char *q_value = NULL;
490 2 : int non_options_count = 0;
491 : const char *non_options[10];
492 2 : int unrecognized = 0;
493 2 : int argc = 0;
494 : const char *argv[10];
495 2 : a_seen = 0;
496 2 : b_seen = 0;
497 :
498 2 : argv[argc++] = "program";
499 2 : argv[argc++] = "--beta";
500 2 : argv[argc++] = "--alpha";
501 2 : argv[argc++] = "foo";
502 2 : argv[argc++] = "bar";
503 2 : argv[argc] = NULL;
504 2 : optind = start;
505 2 : getopt_long_loop (argc, argv, "ab", long_options_required,
506 : &p_value, &q_value,
507 : &non_options_count, non_options, &unrecognized);
508 2 : ASSERT (a_seen == 1);
509 2 : ASSERT (b_seen == 1);
510 2 : ASSERT (p_value == NULL);
511 2 : ASSERT (q_value == NULL);
512 2 : ASSERT (non_options_count == 0);
513 2 : ASSERT (unrecognized == 0);
514 2 : ASSERT (optind == 3);
515 : }
516 3 : for (start = 0; start <= 1; start++)
517 : {
518 2 : const char *p_value = NULL;
519 2 : const char *q_value = NULL;
520 2 : int non_options_count = 0;
521 : const char *non_options[10];
522 2 : int unrecognized = 0;
523 2 : int argc = 0;
524 : const char *argv[10];
525 2 : a_seen = 0;
526 2 : b_seen = 0;
527 :
528 2 : argv[argc++] = "program";
529 2 : argv[argc++] = "--alpha";
530 2 : argv[argc++] = "--beta";
531 2 : argv[argc++] = "--alpha";
532 2 : argv[argc++] = "--beta";
533 2 : argv[argc++] = "foo";
534 2 : argv[argc++] = "bar";
535 2 : argv[argc] = NULL;
536 2 : optind = start;
537 2 : getopt_long_loop (argc, argv, "ab", long_options_required,
538 : &p_value, &q_value,
539 : &non_options_count, non_options, &unrecognized);
540 2 : ASSERT (a_seen == 2);
541 2 : ASSERT (b_seen == 1);
542 2 : ASSERT (p_value == NULL);
543 2 : ASSERT (q_value == NULL);
544 2 : ASSERT (non_options_count == 0);
545 2 : ASSERT (unrecognized == 0);
546 2 : ASSERT (optind == 5);
547 : }
548 :
549 : /* Test processing of boolean long options via -W. */
550 3 : for (start = 0; start <= 1; start++)
551 : {
552 2 : const char *p_value = NULL;
553 2 : const char *q_value = NULL;
554 2 : int non_options_count = 0;
555 : const char *non_options[10];
556 2 : int unrecognized = 0;
557 2 : int argc = 0;
558 : const char *argv[10];
559 2 : a_seen = 0;
560 2 : b_seen = 0;
561 :
562 2 : argv[argc++] = "program";
563 2 : argv[argc++] = "-Walpha";
564 2 : argv[argc++] = "foo";
565 2 : argv[argc++] = "bar";
566 2 : argv[argc] = NULL;
567 2 : optind = start;
568 2 : getopt_long_loop (argc, argv, "abW;", long_options_required,
569 : &p_value, &q_value,
570 : &non_options_count, non_options, &unrecognized);
571 2 : ASSERT (a_seen == 1);
572 2 : ASSERT (b_seen == 0);
573 2 : ASSERT (p_value == NULL);
574 2 : ASSERT (q_value == NULL);
575 2 : ASSERT (non_options_count == 0);
576 2 : ASSERT (unrecognized == 0);
577 2 : ASSERT (optind == 2);
578 : }
579 3 : for (start = 0; start <= 1; start++)
580 : {
581 2 : const char *p_value = NULL;
582 2 : const char *q_value = NULL;
583 2 : int non_options_count = 0;
584 : const char *non_options[10];
585 2 : int unrecognized = 0;
586 2 : int argc = 0;
587 : const char *argv[10];
588 2 : a_seen = 0;
589 2 : b_seen = 0;
590 :
591 2 : argv[argc++] = "program";
592 2 : argv[argc++] = "-W";
593 2 : argv[argc++] = "beta";
594 2 : argv[argc++] = "-W";
595 2 : argv[argc++] = "alpha";
596 2 : argv[argc++] = "foo";
597 2 : argv[argc++] = "bar";
598 2 : argv[argc] = NULL;
599 2 : optind = start;
600 2 : getopt_long_loop (argc, argv, "aW;b", long_options_required,
601 : &p_value, &q_value,
602 : &non_options_count, non_options, &unrecognized);
603 2 : ASSERT (a_seen == 1);
604 2 : ASSERT (b_seen == 1);
605 2 : ASSERT (p_value == NULL);
606 2 : ASSERT (q_value == NULL);
607 2 : ASSERT (non_options_count == 0);
608 2 : ASSERT (unrecognized == 0);
609 2 : ASSERT (optind == 5);
610 : }
611 3 : for (start = 0; start <= 1; start++)
612 : {
613 2 : const char *p_value = NULL;
614 2 : const char *q_value = NULL;
615 2 : int non_options_count = 0;
616 : const char *non_options[10];
617 2 : int unrecognized = 0;
618 2 : int argc = 0;
619 : const char *argv[10];
620 2 : a_seen = 0;
621 2 : b_seen = 0;
622 :
623 2 : argv[argc++] = "program";
624 2 : argv[argc++] = "-Walpha";
625 2 : argv[argc++] = "-Wbeta";
626 2 : argv[argc++] = "-Walpha";
627 2 : argv[argc++] = "-Wbeta";
628 2 : argv[argc++] = "foo";
629 2 : argv[argc++] = "bar";
630 2 : argv[argc] = NULL;
631 2 : optind = start;
632 2 : getopt_long_loop (argc, argv, "W;ab", long_options_required,
633 : &p_value, &q_value,
634 : &non_options_count, non_options, &unrecognized);
635 2 : ASSERT (a_seen == 2);
636 2 : ASSERT (b_seen == 1);
637 2 : ASSERT (p_value == NULL);
638 2 : ASSERT (q_value == NULL);
639 2 : ASSERT (non_options_count == 0);
640 2 : ASSERT (unrecognized == 0);
641 2 : ASSERT (optind == 5);
642 : }
643 :
644 : /* Test processing of short options with arguments. */
645 3 : for (start = 0; start <= 1; start++)
646 : {
647 2 : const char *p_value = NULL;
648 2 : const char *q_value = NULL;
649 2 : int non_options_count = 0;
650 : const char *non_options[10];
651 2 : int unrecognized = 0;
652 2 : int argc = 0;
653 : const char *argv[10];
654 2 : a_seen = 0;
655 2 : b_seen = 0;
656 :
657 2 : argv[argc++] = "program";
658 2 : argv[argc++] = "-pfoo";
659 2 : argv[argc++] = "bar";
660 2 : argv[argc] = NULL;
661 2 : optind = start;
662 2 : getopt_long_loop (argc, argv, "p:q:", long_options_required,
663 : &p_value, &q_value,
664 : &non_options_count, non_options, &unrecognized);
665 2 : ASSERT (a_seen == 0);
666 2 : ASSERT (b_seen == 0);
667 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
668 2 : ASSERT (q_value == NULL);
669 2 : ASSERT (non_options_count == 0);
670 2 : ASSERT (unrecognized == 0);
671 2 : ASSERT (optind == 2);
672 : }
673 3 : for (start = 0; start <= 1; start++)
674 : {
675 2 : const char *p_value = NULL;
676 2 : const char *q_value = NULL;
677 2 : int non_options_count = 0;
678 : const char *non_options[10];
679 2 : int unrecognized = 0;
680 2 : int argc = 0;
681 : const char *argv[10];
682 2 : a_seen = 0;
683 2 : b_seen = 0;
684 :
685 2 : argv[argc++] = "program";
686 2 : argv[argc++] = "-p";
687 2 : argv[argc++] = "foo";
688 2 : argv[argc++] = "bar";
689 2 : argv[argc] = NULL;
690 2 : optind = start;
691 2 : getopt_long_loop (argc, argv, "p:q:", long_options_required,
692 : &p_value, &q_value,
693 : &non_options_count, non_options, &unrecognized);
694 2 : ASSERT (a_seen == 0);
695 2 : ASSERT (b_seen == 0);
696 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
697 2 : ASSERT (q_value == NULL);
698 2 : ASSERT (non_options_count == 0);
699 2 : ASSERT (unrecognized == 0);
700 2 : ASSERT (optind == 3);
701 : }
702 3 : for (start = 0; start <= 1; start++)
703 : {
704 2 : const char *p_value = NULL;
705 2 : const char *q_value = NULL;
706 2 : int non_options_count = 0;
707 : const char *non_options[10];
708 2 : int unrecognized = 0;
709 2 : int argc = 0;
710 : const char *argv[10];
711 2 : a_seen = 0;
712 2 : b_seen = 0;
713 :
714 2 : argv[argc++] = "program";
715 2 : argv[argc++] = "-ab";
716 2 : argv[argc++] = "-q";
717 2 : argv[argc++] = "baz";
718 2 : argv[argc++] = "-pfoo";
719 2 : argv[argc++] = "bar";
720 2 : argv[argc] = NULL;
721 2 : optind = start;
722 2 : getopt_long_loop (argc, argv, "abp:q:", long_options_required,
723 : &p_value, &q_value,
724 : &non_options_count, non_options, &unrecognized);
725 2 : ASSERT (a_seen == 1);
726 2 : ASSERT (b_seen == 1);
727 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
728 2 : ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
729 2 : ASSERT (non_options_count == 0);
730 2 : ASSERT (unrecognized == 0);
731 2 : ASSERT (optind == 5);
732 : }
733 :
734 : /* Test processing of long options with arguments. */
735 3 : for (start = 0; start <= 1; start++)
736 : {
737 2 : const char *p_value = NULL;
738 2 : const char *q_value = NULL;
739 2 : int non_options_count = 0;
740 : const char *non_options[10];
741 2 : int unrecognized = 0;
742 2 : int argc = 0;
743 : const char *argv[10];
744 2 : a_seen = 0;
745 2 : b_seen = 0;
746 :
747 2 : argv[argc++] = "program";
748 2 : argv[argc++] = "--p=foo";
749 2 : argv[argc++] = "bar";
750 2 : argv[argc] = NULL;
751 2 : optind = start;
752 2 : getopt_long_loop (argc, argv, "p:q:", long_options_required,
753 : &p_value, &q_value,
754 : &non_options_count, non_options, &unrecognized);
755 2 : ASSERT (a_seen == 0);
756 2 : ASSERT (b_seen == 0);
757 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
758 2 : ASSERT (q_value == NULL);
759 2 : ASSERT (non_options_count == 0);
760 2 : ASSERT (unrecognized == 0);
761 2 : ASSERT (optind == 2);
762 : }
763 3 : for (start = 0; start <= 1; start++)
764 : {
765 2 : const char *p_value = NULL;
766 2 : const char *q_value = NULL;
767 2 : int non_options_count = 0;
768 : const char *non_options[10];
769 2 : int unrecognized = 0;
770 2 : int argc = 0;
771 : const char *argv[10];
772 2 : a_seen = 0;
773 2 : b_seen = 0;
774 :
775 2 : argv[argc++] = "program";
776 2 : argv[argc++] = "--p";
777 2 : argv[argc++] = "foo";
778 2 : argv[argc++] = "bar";
779 2 : argv[argc] = NULL;
780 2 : optind = start;
781 2 : getopt_long_loop (argc, argv, "p:q:", long_options_required,
782 : &p_value, &q_value,
783 : &non_options_count, non_options, &unrecognized);
784 2 : ASSERT (a_seen == 0);
785 2 : ASSERT (b_seen == 0);
786 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
787 2 : ASSERT (q_value == NULL);
788 2 : ASSERT (non_options_count == 0);
789 2 : ASSERT (unrecognized == 0);
790 2 : ASSERT (optind == 3);
791 : }
792 3 : for (start = 0; start <= 1; start++)
793 : {
794 2 : const char *p_value = NULL;
795 2 : const char *q_value = NULL;
796 2 : int non_options_count = 0;
797 : const char *non_options[10];
798 2 : int unrecognized = 0;
799 2 : int argc = 0;
800 : const char *argv[10];
801 2 : a_seen = 0;
802 2 : b_seen = 0;
803 :
804 2 : argv[argc++] = "program";
805 2 : argv[argc++] = "-ab";
806 2 : argv[argc++] = "--q";
807 2 : argv[argc++] = "baz";
808 2 : argv[argc++] = "--p=foo";
809 2 : argv[argc++] = "bar";
810 2 : argv[argc] = NULL;
811 2 : optind = start;
812 2 : getopt_long_loop (argc, argv, "abp:q:", long_options_required,
813 : &p_value, &q_value,
814 : &non_options_count, non_options, &unrecognized);
815 2 : ASSERT (a_seen == 1);
816 2 : ASSERT (b_seen == 1);
817 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
818 2 : ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
819 2 : ASSERT (non_options_count == 0);
820 2 : ASSERT (unrecognized == 0);
821 2 : ASSERT (optind == 5);
822 : }
823 :
824 : /* Test processing of long options with arguments via -W. */
825 3 : for (start = 0; start <= 1; start++)
826 : {
827 2 : const char *p_value = NULL;
828 2 : const char *q_value = NULL;
829 2 : int non_options_count = 0;
830 : const char *non_options[10];
831 2 : int unrecognized = 0;
832 2 : int argc = 0;
833 : const char *argv[10];
834 2 : a_seen = 0;
835 2 : b_seen = 0;
836 :
837 2 : argv[argc++] = "program";
838 2 : argv[argc++] = "-Wp=foo";
839 2 : argv[argc++] = "bar";
840 2 : argv[argc] = NULL;
841 2 : optind = start;
842 2 : getopt_long_loop (argc, argv, "p:q:W;", long_options_required,
843 : &p_value, &q_value,
844 : &non_options_count, non_options, &unrecognized);
845 2 : ASSERT (a_seen == 0);
846 2 : ASSERT (b_seen == 0);
847 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
848 2 : ASSERT (q_value == NULL);
849 2 : ASSERT (non_options_count == 0);
850 2 : ASSERT (unrecognized == 0);
851 2 : ASSERT (optind == 2);
852 : }
853 3 : for (start = 0; start <= 1; start++)
854 : {
855 2 : const char *p_value = NULL;
856 2 : const char *q_value = NULL;
857 2 : int non_options_count = 0;
858 : const char *non_options[10];
859 2 : int unrecognized = 0;
860 2 : int argc = 0;
861 : const char *argv[10];
862 2 : a_seen = 0;
863 2 : b_seen = 0;
864 :
865 2 : argv[argc++] = "program";
866 2 : argv[argc++] = "-W";
867 2 : argv[argc++] = "p";
868 2 : argv[argc++] = "foo";
869 2 : argv[argc++] = "bar";
870 2 : argv[argc] = NULL;
871 2 : optind = start;
872 2 : getopt_long_loop (argc, argv, "p:W;q:", long_options_required,
873 : &p_value, &q_value,
874 : &non_options_count, non_options, &unrecognized);
875 2 : ASSERT (a_seen == 0);
876 2 : ASSERT (b_seen == 0);
877 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
878 2 : ASSERT (q_value == NULL);
879 2 : ASSERT (non_options_count == 0);
880 2 : ASSERT (unrecognized == 0);
881 2 : ASSERT (optind == 4);
882 : }
883 3 : for (start = 0; start <= 1; start++)
884 : {
885 2 : const char *p_value = NULL;
886 2 : const char *q_value = NULL;
887 2 : int non_options_count = 0;
888 : const char *non_options[10];
889 2 : int unrecognized = 0;
890 2 : int argc = 0;
891 : const char *argv[10];
892 2 : a_seen = 0;
893 2 : b_seen = 0;
894 :
895 2 : argv[argc++] = "program";
896 2 : argv[argc++] = "-ab";
897 2 : argv[argc++] = "-Wq";
898 2 : argv[argc++] = "baz";
899 2 : argv[argc++] = "-W";
900 2 : argv[argc++] = "p=foo";
901 2 : argv[argc++] = "bar";
902 2 : argv[argc] = NULL;
903 2 : optind = start;
904 2 : getopt_long_loop (argc, argv, "W;abp:q:", long_options_required,
905 : &p_value, &q_value,
906 : &non_options_count, non_options, &unrecognized);
907 2 : ASSERT (a_seen == 1);
908 2 : ASSERT (b_seen == 1);
909 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
910 2 : ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
911 2 : ASSERT (non_options_count == 0);
912 2 : ASSERT (unrecognized == 0);
913 2 : ASSERT (optind == 6);
914 : }
915 :
916 : /* Test processing of short options with optional arguments. */
917 3 : for (start = 0; start <= 1; start++)
918 : {
919 2 : const char *p_value = NULL;
920 2 : const char *q_value = NULL;
921 2 : int non_options_count = 0;
922 : const char *non_options[10];
923 2 : int unrecognized = 0;
924 2 : int argc = 0;
925 : const char *argv[10];
926 2 : a_seen = 0;
927 2 : b_seen = 0;
928 :
929 2 : argv[argc++] = "program";
930 2 : argv[argc++] = "-pfoo";
931 2 : argv[argc++] = "bar";
932 2 : argv[argc] = NULL;
933 2 : optind = start;
934 2 : getopt_long_loop (argc, argv, "p::q::", long_options_optional,
935 : &p_value, &q_value,
936 : &non_options_count, non_options, &unrecognized);
937 2 : ASSERT (a_seen == 0);
938 2 : ASSERT (b_seen == 0);
939 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
940 2 : ASSERT (q_value == NULL);
941 2 : ASSERT (non_options_count == 0);
942 2 : ASSERT (unrecognized == 0);
943 2 : ASSERT (optind == 2);
944 : }
945 3 : for (start = 0; start <= 1; start++)
946 : {
947 2 : const char *p_value = NULL;
948 2 : const char *q_value = NULL;
949 2 : int non_options_count = 0;
950 : const char *non_options[10];
951 2 : int unrecognized = 0;
952 2 : int argc = 0;
953 : const char *argv[10];
954 2 : a_seen = 0;
955 2 : b_seen = 0;
956 :
957 2 : argv[argc++] = "program";
958 2 : argv[argc++] = "-p";
959 2 : argv[argc++] = "foo";
960 2 : argv[argc++] = "bar";
961 2 : argv[argc] = NULL;
962 2 : optind = start;
963 2 : getopt_long_loop (argc, argv, "p::q::", long_options_optional,
964 : &p_value, &q_value,
965 : &non_options_count, non_options, &unrecognized);
966 2 : ASSERT (a_seen == 0);
967 2 : ASSERT (b_seen == 0);
968 2 : ASSERT (p_value == NULL);
969 2 : ASSERT (q_value == NULL);
970 2 : ASSERT (non_options_count == 0);
971 2 : ASSERT (unrecognized == 0);
972 2 : ASSERT (optind == 2);
973 : }
974 3 : for (start = 0; start <= 1; start++)
975 : {
976 2 : const char *p_value = NULL;
977 2 : const char *q_value = NULL;
978 2 : int non_options_count = 0;
979 : const char *non_options[10];
980 2 : int unrecognized = 0;
981 2 : int argc = 0;
982 : const char *argv[10];
983 2 : a_seen = 0;
984 2 : b_seen = 0;
985 :
986 2 : argv[argc++] = "program";
987 2 : argv[argc++] = "-p";
988 2 : argv[argc++] = "-a";
989 2 : argv[argc++] = "bar";
990 2 : argv[argc] = NULL;
991 2 : optind = start;
992 2 : getopt_long_loop (argc, argv, "abp::q::", long_options_optional,
993 : &p_value, &q_value,
994 : &non_options_count, non_options, &unrecognized);
995 2 : ASSERT (a_seen == 1);
996 2 : ASSERT (b_seen == 0);
997 2 : ASSERT (p_value == NULL);
998 2 : ASSERT (q_value == NULL);
999 2 : ASSERT (non_options_count == 0);
1000 2 : ASSERT (unrecognized == 0);
1001 2 : ASSERT (optind == 3);
1002 : }
1003 :
1004 : /* Test processing of long options with optional arguments. */
1005 3 : for (start = 0; start <= 1; start++)
1006 : {
1007 2 : const char *p_value = NULL;
1008 2 : const char *q_value = NULL;
1009 2 : int non_options_count = 0;
1010 : const char *non_options[10];
1011 2 : int unrecognized = 0;
1012 2 : int argc = 0;
1013 : const char *argv[10];
1014 2 : a_seen = 0;
1015 2 : b_seen = 0;
1016 :
1017 2 : argv[argc++] = "program";
1018 2 : argv[argc++] = "--p=foo";
1019 2 : argv[argc++] = "bar";
1020 2 : argv[argc] = NULL;
1021 2 : optind = start;
1022 2 : getopt_long_loop (argc, argv, "p::q::", long_options_optional,
1023 : &p_value, &q_value,
1024 : &non_options_count, non_options, &unrecognized);
1025 2 : ASSERT (a_seen == 0);
1026 2 : ASSERT (b_seen == 0);
1027 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1028 2 : ASSERT (q_value == NULL);
1029 2 : ASSERT (non_options_count == 0);
1030 2 : ASSERT (unrecognized == 0);
1031 2 : ASSERT (optind == 2);
1032 : }
1033 3 : for (start = 0; start <= 1; start++)
1034 : {
1035 2 : const char *p_value = NULL;
1036 2 : const char *q_value = NULL;
1037 2 : int non_options_count = 0;
1038 : const char *non_options[10];
1039 2 : int unrecognized = 0;
1040 2 : int argc = 0;
1041 : const char *argv[10];
1042 2 : a_seen = 0;
1043 2 : b_seen = 0;
1044 :
1045 2 : argv[argc++] = "program";
1046 2 : argv[argc++] = "--p";
1047 2 : argv[argc++] = "foo";
1048 2 : argv[argc++] = "bar";
1049 2 : argv[argc] = NULL;
1050 2 : optind = start;
1051 2 : getopt_long_loop (argc, argv, "p::q::", long_options_optional,
1052 : &p_value, &q_value,
1053 : &non_options_count, non_options, &unrecognized);
1054 2 : ASSERT (a_seen == 0);
1055 2 : ASSERT (b_seen == 0);
1056 2 : ASSERT (p_value == NULL);
1057 2 : ASSERT (q_value == NULL);
1058 2 : ASSERT (non_options_count == 0);
1059 2 : ASSERT (unrecognized == 0);
1060 2 : ASSERT (optind == 2);
1061 : }
1062 3 : for (start = 0; start <= 1; start++)
1063 : {
1064 2 : const char *p_value = NULL;
1065 2 : const char *q_value = NULL;
1066 2 : int non_options_count = 0;
1067 : const char *non_options[10];
1068 2 : int unrecognized = 0;
1069 2 : int argc = 0;
1070 : const char *argv[10];
1071 2 : a_seen = 0;
1072 2 : b_seen = 0;
1073 :
1074 2 : argv[argc++] = "program";
1075 2 : argv[argc++] = "--p=";
1076 2 : argv[argc++] = "foo";
1077 2 : argv[argc++] = "bar";
1078 2 : argv[argc] = NULL;
1079 2 : optind = start;
1080 2 : getopt_long_loop (argc, argv, "p::q::", long_options_optional,
1081 : &p_value, &q_value,
1082 : &non_options_count, non_options, &unrecognized);
1083 2 : ASSERT (a_seen == 0);
1084 2 : ASSERT (b_seen == 0);
1085 2 : ASSERT (p_value != NULL && *p_value == '\0');
1086 2 : ASSERT (q_value == NULL);
1087 2 : ASSERT (non_options_count == 0);
1088 2 : ASSERT (unrecognized == 0);
1089 2 : ASSERT (optind == 2);
1090 : }
1091 3 : for (start = 0; start <= 1; start++)
1092 : {
1093 2 : const char *p_value = NULL;
1094 2 : const char *q_value = NULL;
1095 2 : int non_options_count = 0;
1096 : const char *non_options[10];
1097 2 : int unrecognized = 0;
1098 2 : int argc = 0;
1099 : const char *argv[10];
1100 2 : a_seen = 0;
1101 2 : b_seen = 0;
1102 :
1103 2 : argv[argc++] = "program";
1104 2 : argv[argc++] = "--p";
1105 2 : argv[argc++] = "-a";
1106 2 : argv[argc++] = "bar";
1107 2 : argv[argc] = NULL;
1108 2 : optind = start;
1109 2 : getopt_long_loop (argc, argv, "abp::q::", long_options_optional,
1110 : &p_value, &q_value,
1111 : &non_options_count, non_options, &unrecognized);
1112 2 : ASSERT (a_seen == 1);
1113 2 : ASSERT (b_seen == 0);
1114 2 : ASSERT (p_value == NULL);
1115 2 : ASSERT (q_value == NULL);
1116 2 : ASSERT (non_options_count == 0);
1117 2 : ASSERT (unrecognized == 0);
1118 2 : ASSERT (optind == 3);
1119 : }
1120 :
1121 : /* Test processing of long options with optional arguments via -W. */
1122 3 : for (start = 0; start <= 1; start++)
1123 : {
1124 2 : const char *p_value = NULL;
1125 2 : const char *q_value = NULL;
1126 2 : int non_options_count = 0;
1127 : const char *non_options[10];
1128 2 : int unrecognized = 0;
1129 2 : int argc = 0;
1130 : const char *argv[10];
1131 2 : a_seen = 0;
1132 2 : b_seen = 0;
1133 :
1134 2 : argv[argc++] = "program";
1135 2 : argv[argc++] = "-Wp=foo";
1136 2 : argv[argc++] = "bar";
1137 2 : argv[argc] = NULL;
1138 2 : optind = start;
1139 2 : getopt_long_loop (argc, argv, "p::q::W;", long_options_optional,
1140 : &p_value, &q_value,
1141 : &non_options_count, non_options, &unrecognized);
1142 2 : ASSERT (a_seen == 0);
1143 2 : ASSERT (b_seen == 0);
1144 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1145 2 : ASSERT (q_value == NULL);
1146 2 : ASSERT (non_options_count == 0);
1147 2 : ASSERT (unrecognized == 0);
1148 2 : ASSERT (optind == 2);
1149 : }
1150 3 : for (start = 0; start <= 1; start++)
1151 : {
1152 2 : const char *p_value = NULL;
1153 2 : const char *q_value = NULL;
1154 2 : int non_options_count = 0;
1155 : const char *non_options[10];
1156 2 : int unrecognized = 0;
1157 2 : int argc = 0;
1158 : const char *argv[10];
1159 2 : a_seen = 0;
1160 2 : b_seen = 0;
1161 :
1162 2 : argv[argc++] = "program";
1163 2 : argv[argc++] = "-Wp";
1164 2 : argv[argc++] = "foo";
1165 2 : argv[argc++] = "bar";
1166 2 : argv[argc] = NULL;
1167 2 : optind = start;
1168 2 : getopt_long_loop (argc, argv, "p::q::W;", long_options_optional,
1169 : &p_value, &q_value,
1170 : &non_options_count, non_options, &unrecognized);
1171 2 : ASSERT (a_seen == 0);
1172 2 : ASSERT (b_seen == 0);
1173 2 : ASSERT (p_value == NULL);
1174 2 : ASSERT (q_value == NULL);
1175 2 : ASSERT (non_options_count == 0);
1176 2 : ASSERT (unrecognized == 0);
1177 2 : ASSERT (optind == 2);
1178 : }
1179 3 : for (start = 0; start <= 1; start++)
1180 : {
1181 2 : const char *p_value = NULL;
1182 2 : const char *q_value = NULL;
1183 2 : int non_options_count = 0;
1184 : const char *non_options[10];
1185 2 : int unrecognized = 0;
1186 2 : int argc = 0;
1187 : const char *argv[10];
1188 2 : a_seen = 0;
1189 2 : b_seen = 0;
1190 :
1191 2 : argv[argc++] = "program";
1192 2 : argv[argc++] = "-Wp=";
1193 2 : argv[argc++] = "foo";
1194 2 : argv[argc++] = "bar";
1195 2 : argv[argc] = NULL;
1196 2 : optind = start;
1197 2 : getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1198 : &p_value, &q_value,
1199 : &non_options_count, non_options, &unrecognized);
1200 2 : ASSERT (a_seen == 0);
1201 2 : ASSERT (b_seen == 0);
1202 2 : ASSERT (p_value != NULL && *p_value == '\0');
1203 2 : ASSERT (q_value == NULL);
1204 2 : ASSERT (non_options_count == 0);
1205 2 : ASSERT (unrecognized == 0);
1206 2 : ASSERT (optind == 2);
1207 : }
1208 3 : for (start = 0; start <= 1; start++)
1209 : {
1210 2 : const char *p_value = NULL;
1211 2 : const char *q_value = NULL;
1212 2 : int non_options_count = 0;
1213 : const char *non_options[10];
1214 2 : int unrecognized = 0;
1215 2 : int argc = 0;
1216 : const char *argv[10];
1217 2 : a_seen = 0;
1218 2 : b_seen = 0;
1219 :
1220 2 : argv[argc++] = "program";
1221 2 : argv[argc++] = "-W";
1222 2 : argv[argc++] = "p=";
1223 2 : argv[argc++] = "foo";
1224 2 : argv[argc++] = "bar";
1225 2 : argv[argc] = NULL;
1226 2 : optind = start;
1227 2 : getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1228 : &p_value, &q_value,
1229 : &non_options_count, non_options, &unrecognized);
1230 2 : ASSERT (a_seen == 0);
1231 2 : ASSERT (b_seen == 0);
1232 2 : ASSERT (p_value != NULL && *p_value == '\0');
1233 2 : ASSERT (q_value == NULL);
1234 2 : ASSERT (non_options_count == 0);
1235 2 : ASSERT (unrecognized == 0);
1236 2 : ASSERT (optind == 3);
1237 : }
1238 3 : for (start = 0; start <= 1; start++)
1239 : {
1240 2 : const char *p_value = NULL;
1241 2 : const char *q_value = NULL;
1242 2 : int non_options_count = 0;
1243 : const char *non_options[10];
1244 2 : int unrecognized = 0;
1245 2 : int argc = 0;
1246 : const char *argv[10];
1247 2 : a_seen = 0;
1248 2 : b_seen = 0;
1249 :
1250 2 : argv[argc++] = "program";
1251 2 : argv[argc++] = "-W";
1252 2 : argv[argc++] = "p";
1253 2 : argv[argc++] = "-a";
1254 2 : argv[argc++] = "bar";
1255 2 : argv[argc] = NULL;
1256 2 : optind = start;
1257 2 : getopt_long_loop (argc, argv, "W;abp::q::", long_options_optional,
1258 : &p_value, &q_value,
1259 : &non_options_count, non_options, &unrecognized);
1260 2 : ASSERT (a_seen == 1);
1261 2 : ASSERT (b_seen == 0);
1262 : /* ASSERT (p_value == NULL); */
1263 2 : ASSERT (q_value == NULL);
1264 2 : ASSERT (non_options_count == 0);
1265 2 : ASSERT (unrecognized == 0);
1266 2 : ASSERT (optind == 4);
1267 : }
1268 :
1269 : /* Check that invalid options are recognized. */
1270 3 : for (start = 0; start <= 1; start++)
1271 : {
1272 2 : const char *p_value = NULL;
1273 2 : const char *q_value = NULL;
1274 2 : int non_options_count = 0;
1275 : const char *non_options[10];
1276 2 : int unrecognized = 0;
1277 2 : int argc = 0;
1278 : const char *argv[10];
1279 2 : a_seen = 0;
1280 2 : b_seen = 0;
1281 :
1282 2 : argv[argc++] = "program";
1283 2 : argv[argc++] = "-p";
1284 2 : argv[argc++] = "foo";
1285 2 : argv[argc++] = "-x";
1286 2 : argv[argc++] = "-a";
1287 2 : argv[argc++] = "bar";
1288 2 : argv[argc] = NULL;
1289 2 : optind = start;
1290 2 : getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1291 : &p_value, &q_value,
1292 : &non_options_count, non_options, &unrecognized);
1293 2 : ASSERT (a_seen == 1);
1294 2 : ASSERT (b_seen == 0);
1295 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1296 2 : ASSERT (q_value == NULL);
1297 2 : ASSERT (non_options_count == 0);
1298 2 : ASSERT (unrecognized == 'x');
1299 2 : ASSERT (optind == 5);
1300 : }
1301 3 : for (start = 0; start <= 1; start++)
1302 : {
1303 2 : const char *p_value = NULL;
1304 2 : const char *q_value = NULL;
1305 2 : int non_options_count = 0;
1306 : const char *non_options[10];
1307 2 : int unrecognized = 0;
1308 2 : int argc = 0;
1309 : const char *argv[10];
1310 2 : a_seen = 0;
1311 2 : b_seen = 0;
1312 :
1313 2 : argv[argc++] = "program";
1314 2 : argv[argc++] = "-p";
1315 2 : argv[argc++] = "foo";
1316 2 : argv[argc++] = "-:";
1317 2 : argv[argc++] = "-a";
1318 2 : argv[argc++] = "bar";
1319 2 : argv[argc] = NULL;
1320 2 : optind = start;
1321 2 : getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1322 : &p_value, &q_value,
1323 : &non_options_count, non_options, &unrecognized);
1324 2 : ASSERT (a_seen == 1);
1325 2 : ASSERT (b_seen == 0);
1326 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1327 2 : ASSERT (q_value == NULL);
1328 2 : ASSERT (non_options_count == 0);
1329 2 : ASSERT (unrecognized == ':');
1330 2 : ASSERT (optind == 5);
1331 : }
1332 :
1333 : /* Check that unexpected arguments are recognized. */
1334 3 : for (start = 0; start <= 1; start++)
1335 : {
1336 2 : const char *p_value = NULL;
1337 2 : const char *q_value = NULL;
1338 2 : int non_options_count = 0;
1339 : const char *non_options[10];
1340 2 : int unrecognized = 0;
1341 2 : int argc = 0;
1342 : const char *argv[10];
1343 2 : a_seen = 0;
1344 2 : b_seen = 0;
1345 :
1346 2 : argv[argc++] = "program";
1347 2 : argv[argc++] = "-p";
1348 2 : argv[argc++] = "foo";
1349 2 : argv[argc++] = "--a=";
1350 2 : argv[argc++] = "bar";
1351 2 : argv[argc] = NULL;
1352 2 : optind = start;
1353 2 : getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1354 : &p_value, &q_value,
1355 : &non_options_count, non_options, &unrecognized);
1356 2 : ASSERT (a_seen == 0);
1357 2 : ASSERT (b_seen == 0);
1358 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1359 2 : ASSERT (q_value == NULL);
1360 2 : ASSERT (non_options_count == 0);
1361 2 : ASSERT (unrecognized == 'a');
1362 2 : ASSERT (optind == 4);
1363 : }
1364 3 : for (start = 0; start <= 1; start++)
1365 : {
1366 2 : const char *p_value = NULL;
1367 2 : const char *q_value = NULL;
1368 2 : int non_options_count = 0;
1369 : const char *non_options[10];
1370 2 : int unrecognized = 0;
1371 2 : int argc = 0;
1372 : const char *argv[10];
1373 2 : a_seen = 0;
1374 2 : b_seen = 0;
1375 :
1376 2 : argv[argc++] = "program";
1377 2 : argv[argc++] = "-p";
1378 2 : argv[argc++] = "foo";
1379 2 : argv[argc++] = "--b=";
1380 2 : argv[argc++] = "bar";
1381 2 : argv[argc] = NULL;
1382 2 : optind = start;
1383 2 : getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1384 : &p_value, &q_value,
1385 : &non_options_count, non_options, &unrecognized);
1386 2 : ASSERT (a_seen == 0);
1387 2 : ASSERT (b_seen == 0);
1388 2 : ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1389 2 : ASSERT (q_value == NULL);
1390 2 : ASSERT (non_options_count == 0);
1391 : /* When flag is non-zero, glibc sets optopt anyway, but BSD
1392 : leaves optopt unchanged. */
1393 2 : ASSERT (unrecognized == 1 || unrecognized == 0);
1394 2 : ASSERT (optind == 4);
1395 : }
1396 :
1397 : /* Check that by default, non-options arguments are moved to the end. */
1398 3 : for (start = 0; start <= 1; start++)
1399 : {
1400 2 : const char *p_value = NULL;
1401 2 : const char *q_value = NULL;
1402 2 : int non_options_count = 0;
1403 : const char *non_options[10];
1404 2 : int unrecognized = 0;
1405 2 : int argc = 0;
1406 : const char *argv[10];
1407 2 : a_seen = 0;
1408 2 : b_seen = 0;
1409 :
1410 2 : argv[argc++] = "program";
1411 2 : argv[argc++] = "donald";
1412 2 : argv[argc++] = "-p";
1413 2 : argv[argc++] = "billy";
1414 2 : argv[argc++] = "duck";
1415 2 : argv[argc++] = "-a";
1416 2 : argv[argc++] = "bar";
1417 2 : argv[argc] = NULL;
1418 2 : optind = start;
1419 2 : getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1420 : &p_value, &q_value,
1421 : &non_options_count, non_options, &unrecognized);
1422 2 : ASSERT (strcmp (argv[0], "program") == 0);
1423 2 : ASSERT (strcmp (argv[1], "-p") == 0);
1424 2 : ASSERT (strcmp (argv[2], "billy") == 0);
1425 2 : ASSERT (strcmp (argv[3], "-a") == 0);
1426 2 : ASSERT (strcmp (argv[4], "donald") == 0);
1427 2 : ASSERT (strcmp (argv[5], "duck") == 0);
1428 2 : ASSERT (strcmp (argv[6], "bar") == 0);
1429 2 : ASSERT (argv[7] == NULL);
1430 2 : ASSERT (a_seen == 1);
1431 2 : ASSERT (b_seen == 0);
1432 2 : ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1433 2 : ASSERT (q_value == NULL);
1434 2 : ASSERT (non_options_count == 0);
1435 2 : ASSERT (unrecognized == 0);
1436 2 : ASSERT (optind == 4);
1437 : }
1438 :
1439 : /* Check that '--' ends the argument processing. */
1440 3 : for (start = 0; start <= 1; start++)
1441 : {
1442 2 : const char *p_value = NULL;
1443 2 : const char *q_value = NULL;
1444 2 : int non_options_count = 0;
1445 : const char *non_options[10];
1446 2 : int unrecognized = 0;
1447 2 : int argc = 0;
1448 : const char *argv[20];
1449 2 : a_seen = 0;
1450 2 : b_seen = 0;
1451 :
1452 2 : argv[argc++] = "program";
1453 2 : argv[argc++] = "donald";
1454 2 : argv[argc++] = "-p";
1455 2 : argv[argc++] = "billy";
1456 2 : argv[argc++] = "duck";
1457 2 : argv[argc++] = "-a";
1458 2 : argv[argc++] = "--";
1459 2 : argv[argc++] = "-b";
1460 2 : argv[argc++] = "foo";
1461 2 : argv[argc++] = "-q";
1462 2 : argv[argc++] = "johnny";
1463 2 : argv[argc++] = "bar";
1464 2 : argv[argc] = NULL;
1465 2 : optind = start;
1466 2 : getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1467 : &p_value, &q_value,
1468 : &non_options_count, non_options, &unrecognized);
1469 2 : ASSERT (strcmp (argv[0], "program") == 0);
1470 2 : ASSERT (strcmp (argv[1], "-p") == 0);
1471 2 : ASSERT (strcmp (argv[2], "billy") == 0);
1472 2 : ASSERT (strcmp (argv[3], "-a") == 0);
1473 2 : ASSERT (strcmp (argv[4], "--") == 0);
1474 2 : ASSERT (strcmp (argv[5], "donald") == 0);
1475 2 : ASSERT (strcmp (argv[6], "duck") == 0);
1476 2 : ASSERT (strcmp (argv[7], "-b") == 0);
1477 2 : ASSERT (strcmp (argv[8], "foo") == 0);
1478 2 : ASSERT (strcmp (argv[9], "-q") == 0);
1479 2 : ASSERT (strcmp (argv[10], "johnny") == 0);
1480 2 : ASSERT (strcmp (argv[11], "bar") == 0);
1481 2 : ASSERT (argv[12] == NULL);
1482 2 : ASSERT (a_seen == 1);
1483 2 : ASSERT (b_seen == 0);
1484 2 : ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1485 2 : ASSERT (q_value == NULL);
1486 2 : ASSERT (non_options_count == 0);
1487 2 : ASSERT (unrecognized == 0);
1488 2 : ASSERT (optind == 5);
1489 : }
1490 :
1491 : /* Check that the '-' flag causes non-options to be returned in order. */
1492 3 : for (start = 0; start <= 1; start++)
1493 : {
1494 2 : const char *p_value = NULL;
1495 2 : const char *q_value = NULL;
1496 2 : int non_options_count = 0;
1497 : const char *non_options[10];
1498 2 : int unrecognized = 0;
1499 2 : int argc = 0;
1500 : const char *argv[10];
1501 2 : a_seen = 0;
1502 2 : b_seen = 0;
1503 :
1504 2 : argv[argc++] = "program";
1505 2 : argv[argc++] = "donald";
1506 2 : argv[argc++] = "-p";
1507 2 : argv[argc++] = "billy";
1508 2 : argv[argc++] = "duck";
1509 2 : argv[argc++] = "-a";
1510 2 : argv[argc++] = "bar";
1511 2 : argv[argc] = NULL;
1512 2 : optind = start;
1513 2 : getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1514 : &p_value, &q_value,
1515 : &non_options_count, non_options, &unrecognized);
1516 2 : ASSERT (strcmp (argv[0], "program") == 0);
1517 2 : ASSERT (strcmp (argv[1], "donald") == 0);
1518 2 : ASSERT (strcmp (argv[2], "-p") == 0);
1519 2 : ASSERT (strcmp (argv[3], "billy") == 0);
1520 2 : ASSERT (strcmp (argv[4], "duck") == 0);
1521 2 : ASSERT (strcmp (argv[5], "-a") == 0);
1522 2 : ASSERT (strcmp (argv[6], "bar") == 0);
1523 2 : ASSERT (argv[7] == NULL);
1524 2 : ASSERT (a_seen == 1);
1525 2 : ASSERT (b_seen == 0);
1526 2 : ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1527 2 : ASSERT (q_value == NULL);
1528 2 : ASSERT (non_options_count == 3);
1529 2 : ASSERT (strcmp (non_options[0], "donald") == 0);
1530 2 : ASSERT (strcmp (non_options[1], "duck") == 0);
1531 2 : ASSERT (strcmp (non_options[2], "bar") == 0);
1532 2 : ASSERT (unrecognized == 0);
1533 2 : ASSERT (optind == 7);
1534 : }
1535 :
1536 : /* Check that '--' ends the argument processing. */
1537 3 : for (start = 0; start <= 1; start++)
1538 : {
1539 2 : const char *p_value = NULL;
1540 2 : const char *q_value = NULL;
1541 2 : int non_options_count = 0;
1542 : const char *non_options[10];
1543 2 : int unrecognized = 0;
1544 2 : int argc = 0;
1545 : const char *argv[20];
1546 2 : a_seen = 0;
1547 2 : b_seen = 0;
1548 :
1549 2 : argv[argc++] = "program";
1550 2 : argv[argc++] = "donald";
1551 2 : argv[argc++] = "-p";
1552 2 : argv[argc++] = "billy";
1553 2 : argv[argc++] = "duck";
1554 2 : argv[argc++] = "-a";
1555 2 : argv[argc++] = "--";
1556 2 : argv[argc++] = "-b";
1557 2 : argv[argc++] = "foo";
1558 2 : argv[argc++] = "-q";
1559 2 : argv[argc++] = "johnny";
1560 2 : argv[argc++] = "bar";
1561 2 : argv[argc] = NULL;
1562 2 : optind = start;
1563 2 : getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1564 : &p_value, &q_value,
1565 : &non_options_count, non_options, &unrecognized);
1566 2 : ASSERT (strcmp (argv[0], "program") == 0);
1567 2 : ASSERT (strcmp (argv[1], "donald") == 0);
1568 2 : ASSERT (strcmp (argv[2], "-p") == 0);
1569 2 : ASSERT (strcmp (argv[3], "billy") == 0);
1570 2 : ASSERT (strcmp (argv[4], "duck") == 0);
1571 2 : ASSERT (strcmp (argv[5], "-a") == 0);
1572 2 : ASSERT (strcmp (argv[6], "--") == 0);
1573 2 : ASSERT (strcmp (argv[7], "-b") == 0);
1574 2 : ASSERT (strcmp (argv[8], "foo") == 0);
1575 2 : ASSERT (strcmp (argv[9], "-q") == 0);
1576 2 : ASSERT (strcmp (argv[10], "johnny") == 0);
1577 2 : ASSERT (strcmp (argv[11], "bar") == 0);
1578 2 : ASSERT (argv[12] == NULL);
1579 2 : ASSERT (a_seen == 1);
1580 2 : ASSERT (b_seen == 0);
1581 2 : ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1582 2 : ASSERT (q_value == NULL);
1583 2 : if (non_options_count == 2)
1584 : {
1585 : /* glibc behaviour. */
1586 2 : ASSERT (non_options_count == 2);
1587 2 : ASSERT (strcmp (non_options[0], "donald") == 0);
1588 2 : ASSERT (strcmp (non_options[1], "duck") == 0);
1589 2 : ASSERT (unrecognized == 0);
1590 2 : ASSERT (optind == 7);
1591 : }
1592 : else
1593 : {
1594 : /* Another valid behaviour. */
1595 0 : ASSERT (non_options_count == 7);
1596 0 : ASSERT (strcmp (non_options[0], "donald") == 0);
1597 0 : ASSERT (strcmp (non_options[1], "duck") == 0);
1598 0 : ASSERT (strcmp (non_options[2], "-b") == 0);
1599 0 : ASSERT (strcmp (non_options[3], "foo") == 0);
1600 0 : ASSERT (strcmp (non_options[4], "-q") == 0);
1601 0 : ASSERT (strcmp (non_options[5], "johnny") == 0);
1602 0 : ASSERT (strcmp (non_options[6], "bar") == 0);
1603 0 : ASSERT (unrecognized == 0);
1604 0 : ASSERT (optind == 12);
1605 : }
1606 : }
1607 :
1608 : /* Check that the '-' flag has to come first. */
1609 3 : for (start = 0; start <= 1; start++)
1610 : {
1611 2 : const char *p_value = NULL;
1612 2 : const char *q_value = NULL;
1613 2 : int non_options_count = 0;
1614 : const char *non_options[10];
1615 2 : int unrecognized = 0;
1616 2 : int argc = 0;
1617 : const char *argv[10];
1618 2 : a_seen = 0;
1619 2 : b_seen = 0;
1620 :
1621 2 : argv[argc++] = "program";
1622 2 : argv[argc++] = "donald";
1623 2 : argv[argc++] = "-p";
1624 2 : argv[argc++] = "billy";
1625 2 : argv[argc++] = "duck";
1626 2 : argv[argc++] = "-a";
1627 2 : argv[argc++] = "bar";
1628 2 : argv[argc] = NULL;
1629 2 : optind = start;
1630 2 : getopt_long_loop (argc, argv, "abp:q:-", long_options_required,
1631 : &p_value, &q_value,
1632 : &non_options_count, non_options, &unrecognized);
1633 2 : ASSERT (strcmp (argv[0], "program") == 0);
1634 2 : ASSERT (strcmp (argv[1], "-p") == 0);
1635 2 : ASSERT (strcmp (argv[2], "billy") == 0);
1636 2 : ASSERT (strcmp (argv[3], "-a") == 0);
1637 2 : ASSERT (strcmp (argv[4], "donald") == 0);
1638 2 : ASSERT (strcmp (argv[5], "duck") == 0);
1639 2 : ASSERT (strcmp (argv[6], "bar") == 0);
1640 2 : ASSERT (argv[7] == NULL);
1641 2 : ASSERT (a_seen == 1);
1642 2 : ASSERT (b_seen == 0);
1643 2 : ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1644 2 : ASSERT (q_value == NULL);
1645 2 : ASSERT (non_options_count == 0);
1646 2 : ASSERT (unrecognized == 0);
1647 2 : ASSERT (optind == 4);
1648 : }
1649 :
1650 : /* Check that the '+' flag causes the first non-option to terminate the
1651 : loop. */
1652 3 : for (start = 0; start <= 1; start++)
1653 : {
1654 2 : const char *p_value = NULL;
1655 2 : const char *q_value = NULL;
1656 2 : int non_options_count = 0;
1657 : const char *non_options[10];
1658 2 : int unrecognized = 0;
1659 2 : int argc = 0;
1660 : const char *argv[10];
1661 2 : a_seen = 0;
1662 2 : b_seen = 0;
1663 :
1664 2 : argv[argc++] = "program";
1665 2 : argv[argc++] = "donald";
1666 2 : argv[argc++] = "-p";
1667 2 : argv[argc++] = "billy";
1668 2 : argv[argc++] = "duck";
1669 2 : argv[argc++] = "-a";
1670 2 : argv[argc++] = "bar";
1671 2 : argv[argc] = NULL;
1672 2 : optind = start;
1673 2 : getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1674 : &p_value, &q_value,
1675 : &non_options_count, non_options, &unrecognized);
1676 2 : ASSERT (strcmp (argv[0], "program") == 0);
1677 2 : ASSERT (strcmp (argv[1], "donald") == 0);
1678 2 : ASSERT (strcmp (argv[2], "-p") == 0);
1679 2 : ASSERT (strcmp (argv[3], "billy") == 0);
1680 2 : ASSERT (strcmp (argv[4], "duck") == 0);
1681 2 : ASSERT (strcmp (argv[5], "-a") == 0);
1682 2 : ASSERT (strcmp (argv[6], "bar") == 0);
1683 2 : ASSERT (argv[7] == NULL);
1684 2 : ASSERT (a_seen == 0);
1685 2 : ASSERT (b_seen == 0);
1686 2 : ASSERT (p_value == NULL);
1687 2 : ASSERT (q_value == NULL);
1688 2 : ASSERT (non_options_count == 0);
1689 2 : ASSERT (unrecognized == 0);
1690 2 : ASSERT (optind == 1);
1691 : }
1692 3 : for (start = 0; start <= 1; start++)
1693 : {
1694 2 : const char *p_value = NULL;
1695 2 : const char *q_value = NULL;
1696 2 : int non_options_count = 0;
1697 : const char *non_options[10];
1698 2 : int unrecognized = 0;
1699 2 : int argc = 0;
1700 : const char *argv[10];
1701 2 : a_seen = 0;
1702 2 : b_seen = 0;
1703 :
1704 2 : argv[argc++] = "program";
1705 2 : argv[argc++] = "-+";
1706 2 : argv[argc] = NULL;
1707 2 : optind = start;
1708 2 : getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1709 : &p_value, &q_value,
1710 : &non_options_count, non_options, &unrecognized);
1711 2 : ASSERT (a_seen == 0);
1712 2 : ASSERT (b_seen == 0);
1713 2 : ASSERT (p_value == NULL);
1714 2 : ASSERT (q_value == NULL);
1715 2 : ASSERT (non_options_count == 0);
1716 2 : ASSERT (unrecognized == '+');
1717 2 : ASSERT (optind == 2);
1718 : }
1719 :
1720 : /* Check that '--' ends the argument processing. */
1721 3 : for (start = 0; start <= 1; start++)
1722 : {
1723 2 : const char *p_value = NULL;
1724 2 : const char *q_value = NULL;
1725 2 : int non_options_count = 0;
1726 : const char *non_options[10];
1727 2 : int unrecognized = 0;
1728 2 : int argc = 0;
1729 : const char *argv[20];
1730 2 : a_seen = 0;
1731 2 : b_seen = 0;
1732 :
1733 2 : argv[argc++] = "program";
1734 2 : argv[argc++] = "donald";
1735 2 : argv[argc++] = "-p";
1736 2 : argv[argc++] = "billy";
1737 2 : argv[argc++] = "duck";
1738 2 : argv[argc++] = "-a";
1739 2 : argv[argc++] = "--";
1740 2 : argv[argc++] = "-b";
1741 2 : argv[argc++] = "foo";
1742 2 : argv[argc++] = "-q";
1743 2 : argv[argc++] = "johnny";
1744 2 : argv[argc++] = "bar";
1745 2 : argv[argc] = NULL;
1746 2 : optind = start;
1747 2 : getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1748 : &p_value, &q_value,
1749 : &non_options_count, non_options, &unrecognized);
1750 2 : ASSERT (strcmp (argv[0], "program") == 0);
1751 2 : ASSERT (strcmp (argv[1], "donald") == 0);
1752 2 : ASSERT (strcmp (argv[2], "-p") == 0);
1753 2 : ASSERT (strcmp (argv[3], "billy") == 0);
1754 2 : ASSERT (strcmp (argv[4], "duck") == 0);
1755 2 : ASSERT (strcmp (argv[5], "-a") == 0);
1756 2 : ASSERT (strcmp (argv[6], "--") == 0);
1757 2 : ASSERT (strcmp (argv[7], "-b") == 0);
1758 2 : ASSERT (strcmp (argv[8], "foo") == 0);
1759 2 : ASSERT (strcmp (argv[9], "-q") == 0);
1760 2 : ASSERT (strcmp (argv[10], "johnny") == 0);
1761 2 : ASSERT (strcmp (argv[11], "bar") == 0);
1762 2 : ASSERT (argv[12] == NULL);
1763 2 : ASSERT (a_seen == 0);
1764 2 : ASSERT (b_seen == 0);
1765 2 : ASSERT (p_value == NULL);
1766 2 : ASSERT (q_value == NULL);
1767 2 : ASSERT (non_options_count == 0);
1768 2 : ASSERT (unrecognized == 0);
1769 2 : ASSERT (optind == 1);
1770 : }
1771 :
1772 : /* Check that the '+' flag has to come first. */
1773 3 : for (start = 0; start <= 1; start++)
1774 : {
1775 2 : const char *p_value = NULL;
1776 2 : const char *q_value = NULL;
1777 2 : int non_options_count = 0;
1778 : const char *non_options[10];
1779 2 : int unrecognized = 0;
1780 2 : int argc = 0;
1781 : const char *argv[10];
1782 2 : a_seen = 0;
1783 2 : b_seen = 0;
1784 :
1785 2 : argv[argc++] = "program";
1786 2 : argv[argc++] = "donald";
1787 2 : argv[argc++] = "-p";
1788 2 : argv[argc++] = "billy";
1789 2 : argv[argc++] = "duck";
1790 2 : argv[argc++] = "-a";
1791 2 : argv[argc++] = "bar";
1792 2 : argv[argc] = NULL;
1793 2 : optind = start;
1794 2 : getopt_long_loop (argc, argv, "abp:q:+", long_options_required,
1795 : &p_value, &q_value,
1796 : &non_options_count, non_options, &unrecognized);
1797 2 : ASSERT (strcmp (argv[0], "program") == 0);
1798 2 : ASSERT (strcmp (argv[1], "-p") == 0);
1799 2 : ASSERT (strcmp (argv[2], "billy") == 0);
1800 2 : ASSERT (strcmp (argv[3], "-a") == 0);
1801 2 : ASSERT (strcmp (argv[4], "donald") == 0);
1802 2 : ASSERT (strcmp (argv[5], "duck") == 0);
1803 2 : ASSERT (strcmp (argv[6], "bar") == 0);
1804 2 : ASSERT (argv[7] == NULL);
1805 2 : ASSERT (a_seen == 1);
1806 2 : ASSERT (b_seen == 0);
1807 2 : ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1808 2 : ASSERT (q_value == NULL);
1809 2 : ASSERT (non_options_count == 0);
1810 2 : ASSERT (unrecognized == 0);
1811 2 : ASSERT (optind == 4);
1812 : }
1813 1 : }
1814 :
1815 : /* Test behavior of getopt_long when POSIXLY_CORRECT is set in the
1816 : environment. Options with optional arguments should not change
1817 : behavior just because of an environment variable.
1818 : https://lists.gnu.org/r/bug-m4/2006-09/msg00028.html */
1819 : static void
1820 1 : test_getopt_long_posix (void)
1821 : {
1822 : int start;
1823 :
1824 : /* Check that POSIXLY_CORRECT stops parsing the same as leading '+'. */
1825 3 : for (start = 0; start <= 1; start++)
1826 : {
1827 2 : const char *p_value = NULL;
1828 2 : const char *q_value = NULL;
1829 2 : int non_options_count = 0;
1830 : const char *non_options[10];
1831 2 : int unrecognized = 0;
1832 2 : int argc = 0;
1833 : const char *argv[10];
1834 2 : a_seen = 0;
1835 2 : b_seen = 0;
1836 :
1837 2 : argv[argc++] = "program";
1838 2 : argv[argc++] = "donald";
1839 2 : argv[argc++] = "-p";
1840 2 : argv[argc++] = "billy";
1841 2 : argv[argc++] = "duck";
1842 2 : argv[argc++] = "-a";
1843 2 : argv[argc++] = "bar";
1844 2 : argv[argc] = NULL;
1845 2 : optind = start;
1846 2 : getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1847 : &p_value, &q_value,
1848 : &non_options_count, non_options, &unrecognized);
1849 2 : ASSERT (strcmp (argv[0], "program") == 0);
1850 2 : ASSERT (strcmp (argv[1], "donald") == 0);
1851 2 : ASSERT (strcmp (argv[2], "-p") == 0);
1852 2 : ASSERT (strcmp (argv[3], "billy") == 0);
1853 2 : ASSERT (strcmp (argv[4], "duck") == 0);
1854 2 : ASSERT (strcmp (argv[5], "-a") == 0);
1855 2 : ASSERT (strcmp (argv[6], "bar") == 0);
1856 2 : ASSERT (argv[7] == NULL);
1857 2 : ASSERT (a_seen == 0);
1858 2 : ASSERT (b_seen == 0);
1859 2 : ASSERT (p_value == NULL);
1860 2 : ASSERT (q_value == NULL);
1861 2 : ASSERT (non_options_count == 0);
1862 2 : ASSERT (unrecognized == 0);
1863 2 : ASSERT (optind == 1);
1864 : }
1865 :
1866 : /* Check that POSIXLY_CORRECT doesn't change optional arguments. */
1867 3 : for (start = 0; start <= 1; start++)
1868 : {
1869 2 : const char *p_value = NULL;
1870 2 : const char *q_value = NULL;
1871 2 : int non_options_count = 0;
1872 : const char *non_options[10];
1873 2 : int unrecognized = 0;
1874 2 : int argc = 0;
1875 : const char *argv[10];
1876 2 : a_seen = 0;
1877 2 : b_seen = 0;
1878 :
1879 2 : argv[argc++] = "program";
1880 2 : argv[argc++] = "-p";
1881 2 : argv[argc++] = "billy";
1882 2 : argv[argc] = NULL;
1883 2 : optind = start;
1884 2 : getopt_long_loop (argc, argv, "p::", long_options_required,
1885 : &p_value, &q_value,
1886 : &non_options_count, non_options, &unrecognized);
1887 2 : ASSERT (a_seen == 0);
1888 2 : ASSERT (b_seen == 0);
1889 2 : ASSERT (p_value == NULL);
1890 2 : ASSERT (q_value == NULL);
1891 2 : ASSERT (non_options_count == 0);
1892 2 : ASSERT (unrecognized == 0);
1893 2 : ASSERT (optind == 2);
1894 : }
1895 :
1896 : /* Check that leading - still sees options after non-options. */
1897 3 : for (start = 0; start <= 1; start++)
1898 : {
1899 2 : const char *p_value = NULL;
1900 2 : const char *q_value = NULL;
1901 2 : int non_options_count = 0;
1902 : const char *non_options[10];
1903 2 : int unrecognized = 0;
1904 2 : int argc = 0;
1905 : const char *argv[10];
1906 2 : a_seen = 0;
1907 2 : b_seen = 0;
1908 :
1909 2 : argv[argc++] = "program";
1910 2 : argv[argc++] = "-a";
1911 2 : argv[argc++] = "billy";
1912 2 : argv[argc++] = "-b";
1913 2 : argv[argc] = NULL;
1914 2 : optind = start;
1915 2 : getopt_long_loop (argc, argv, "-ab", long_options_required,
1916 : &p_value, &q_value,
1917 : &non_options_count, non_options, &unrecognized);
1918 2 : ASSERT (a_seen == 1);
1919 2 : ASSERT (b_seen == 1);
1920 2 : ASSERT (p_value == NULL);
1921 2 : ASSERT (q_value == NULL);
1922 2 : ASSERT (non_options_count == 1);
1923 2 : ASSERT (strcmp (non_options[0], "billy") == 0);
1924 2 : ASSERT (unrecognized == 0);
1925 2 : ASSERT (optind == 4);
1926 : }
1927 1 : }
1928 :
1929 : /* Reduce casting, so we can use string literals elsewhere.
1930 : getopt_long_only takes an array of char*, but luckily does not
1931 : modify those elements, so we can pass const char*. */
1932 : static int
1933 12 : do_getopt_long_only (int argc, const char **argv, const char *shortopts,
1934 : const struct option *longopts, int *longind)
1935 : {
1936 12 : return getopt_long_only (argc, (char **) argv, shortopts, longopts, longind);
1937 : }
1938 :
1939 : static void
1940 1 : test_getopt_long_only (void)
1941 : {
1942 : /* Test disambiguation of options. */
1943 : {
1944 1 : int argc = 0;
1945 : const char *argv[10];
1946 : int option_index;
1947 : int c;
1948 :
1949 1 : argv[argc++] = "program";
1950 1 : argv[argc++] = "-x";
1951 1 : argv[argc] = NULL;
1952 1 : optind = 1;
1953 1 : opterr = 0;
1954 1 : c = do_getopt_long_only (argc, argv, "ab", long_options_required,
1955 : &option_index);
1956 1 : ASSERT (c == '?');
1957 1 : ASSERT (optopt == 0);
1958 : }
1959 : {
1960 1 : int argc = 0;
1961 : const char *argv[10];
1962 : int option_index;
1963 : int c;
1964 :
1965 1 : argv[argc++] = "program";
1966 1 : argv[argc++] = "-x";
1967 1 : argv[argc] = NULL;
1968 1 : optind = 1;
1969 1 : opterr = 0;
1970 1 : c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1971 : &option_index);
1972 1 : ASSERT (c == 'x');
1973 1 : ASSERT (optopt == 0);
1974 : }
1975 : {
1976 1 : int argc = 0;
1977 : const char *argv[10];
1978 : int option_index;
1979 : int c;
1980 :
1981 1 : argv[argc++] = "program";
1982 1 : argv[argc++] = "--x";
1983 1 : argv[argc] = NULL;
1984 1 : optind = 1;
1985 1 : opterr = 0;
1986 1 : c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1987 : &option_index);
1988 1 : ASSERT (c == '?');
1989 1 : ASSERT (optopt == 0);
1990 : }
1991 : {
1992 1 : int argc = 0;
1993 : const char *argv[10];
1994 : int option_index;
1995 : int c;
1996 :
1997 1 : argv[argc++] = "program";
1998 1 : argv[argc++] = "-b";
1999 1 : argv[argc] = NULL;
2000 1 : optind = 1;
2001 1 : opterr = 0;
2002 1 : b_seen = 0;
2003 1 : c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2004 : &option_index);
2005 1 : ASSERT (c == 'b');
2006 1 : ASSERT (b_seen == 0);
2007 : }
2008 : {
2009 1 : int argc = 0;
2010 : const char *argv[10];
2011 : int option_index;
2012 : int c;
2013 :
2014 1 : argv[argc++] = "program";
2015 1 : argv[argc++] = "--b";
2016 1 : argv[argc] = NULL;
2017 1 : optind = 1;
2018 1 : opterr = 0;
2019 1 : b_seen = 0;
2020 1 : c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2021 : &option_index);
2022 1 : ASSERT (c == 0);
2023 1 : ASSERT (b_seen == 1);
2024 : }
2025 : {
2026 1 : int argc = 0;
2027 : const char *argv[10];
2028 : int option_index;
2029 : int c;
2030 :
2031 1 : argv[argc++] = "program";
2032 1 : argv[argc++] = "-xt";
2033 1 : argv[argc] = NULL;
2034 1 : optind = 1;
2035 1 : opterr = 0;
2036 1 : c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2037 : &option_index);
2038 1 : ASSERT (c == '?');
2039 1 : ASSERT (optopt == 0);
2040 : }
2041 : {
2042 1 : int argc = 0;
2043 : const char *argv[10];
2044 : int option_index;
2045 : int c;
2046 :
2047 1 : argv[argc++] = "program";
2048 1 : argv[argc++] = "-xt";
2049 1 : argv[argc] = NULL;
2050 1 : optind = 1;
2051 1 : opterr = 0;
2052 1 : c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2053 : &option_index);
2054 1 : ASSERT (c == '?');
2055 1 : ASSERT (optopt == 0);
2056 : }
2057 : {
2058 1 : int argc = 0;
2059 : const char *argv[10];
2060 : int option_index;
2061 : int c;
2062 :
2063 1 : argv[argc++] = "program";
2064 1 : argv[argc++] = "-xtra";
2065 1 : argv[argc] = NULL;
2066 1 : optind = 1;
2067 1 : opterr = 0;
2068 1 : c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2069 : &option_index);
2070 1 : ASSERT (c == 1001);
2071 : }
2072 : {
2073 1 : int argc = 0;
2074 : const char *argv[10];
2075 : int option_index;
2076 : int c;
2077 :
2078 1 : argv[argc++] = "program";
2079 1 : argv[argc++] = "-xtreme";
2080 1 : argv[argc] = NULL;
2081 1 : optind = 1;
2082 1 : opterr = 0;
2083 1 : c = do_getopt_long_only (argc, argv, "abx:", long_options_required,
2084 : &option_index);
2085 1 : ASSERT (c == 1002);
2086 : }
2087 : {
2088 1 : int argc = 0;
2089 : const char *argv[10];
2090 : int option_index;
2091 : int c;
2092 :
2093 1 : argv[argc++] = "program";
2094 1 : argv[argc++] = "-xtremel";
2095 1 : argv[argc] = NULL;
2096 1 : optind = 1;
2097 1 : opterr = 0;
2098 1 : c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2099 : &option_index);
2100 : /* glibc getopt_long_only is intentionally different from
2101 : getopt_long when handling a prefix that is common to two
2102 : spellings, when both spellings have the same option directives.
2103 : BSD getopt_long_only treats both cases the same. */
2104 1 : ASSERT (c == 1003 || c == '?');
2105 1 : ASSERT (optind == 2);
2106 : }
2107 : {
2108 1 : int argc = 0;
2109 : const char *argv[10];
2110 : int option_index;
2111 : int c;
2112 :
2113 1 : argv[argc++] = "program";
2114 1 : argv[argc++] = "-xtremel";
2115 1 : argv[argc] = NULL;
2116 1 : optind = 1;
2117 1 : opterr = 0;
2118 1 : c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2119 : &option_index);
2120 : /* glibc getopt_long_only is intentionally different from
2121 : getopt_long when handling a prefix that is common to two
2122 : spellings, when both spellings have the same option directives.
2123 : BSD getopt_long_only treats both cases the same. */
2124 1 : ASSERT (c == 1003 || c == '?');
2125 1 : ASSERT (optind == 2);
2126 1 : ASSERT (optarg == NULL);
2127 : }
2128 : {
2129 1 : int argc = 0;
2130 : const char *argv[10];
2131 : int option_index;
2132 : int c;
2133 :
2134 1 : argv[argc++] = "program";
2135 1 : argv[argc++] = "-xtras";
2136 1 : argv[argc] = NULL;
2137 1 : optind = 1;
2138 1 : opterr = 0;
2139 1 : c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2140 : &option_index);
2141 1 : ASSERT (c == 'x');
2142 1 : ASSERT (strcmp (optarg, "tras") == 0);
2143 : }
2144 1 : }
|