1 /* Test of command line argument processing.
2 Copyright (C) 2009 Free Software Foundation, Inc.
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.
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.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* Written by Bruno Haible <bruno@clisp.org>, 2009. */
22 getopt_loop (int argc, const char **argv,
24 int *a_seen, int *b_seen,
25 const char **p_value, const char **q_value,
26 int *non_options_count, const char **non_options,
32 while ((c = getopt (argc, (char **) argv, options)) != -1)
49 /* Must only happen with option '-' at the beginning. */
50 ASSERT (options[0] == '-');
51 non_options[(*non_options_count)++] = optarg;
54 *unrecognized = optopt;
67 bool posixly = !!getenv ("POSIXLY_CORRECT");
68 /* See comment in getopt.c:
69 glibc gets a LSB-compliant getopt.
70 Standalone applications get a POSIX-compliant getopt. */
71 #if defined __GETOPT_PREFIX || !(__GLIBC__ >= 2 || defined __MINGW32__)
72 /* Using getopt from gnulib or from a non-glibc system. */
76 /* Test processing of boolean options. */
77 for (start = OPTIND_MIN; start <= 1; start++)
81 const char *p_value = NULL;
82 const char *q_value = NULL;
83 int non_options_count = 0;
84 const char *non_options[10];
89 argv[argc++] = "program";
95 getopt_loop (argc, argv, "ab",
96 &a_seen, &b_seen, &p_value, &q_value,
97 &non_options_count, non_options, &unrecognized);
100 ASSERT (p_value == NULL);
101 ASSERT (q_value == NULL);
102 ASSERT (non_options_count == 0);
103 ASSERT (unrecognized == 0);
104 ASSERT (optind == 2);
106 for (start = OPTIND_MIN; start <= 1; start++)
110 const char *p_value = NULL;
111 const char *q_value = NULL;
112 int non_options_count = 0;
113 const char *non_options[10];
114 int unrecognized = 0;
116 const char *argv[10];
118 argv[argc++] = "program";
121 argv[argc++] = "foo";
122 argv[argc++] = "bar";
125 getopt_loop (argc, argv, "ab",
126 &a_seen, &b_seen, &p_value, &q_value,
127 &non_options_count, non_options, &unrecognized);
128 ASSERT (a_seen == 1);
129 ASSERT (b_seen == 1);
130 ASSERT (p_value == NULL);
131 ASSERT (q_value == NULL);
132 ASSERT (non_options_count == 0);
133 ASSERT (unrecognized == 0);
134 ASSERT (optind == 3);
136 for (start = OPTIND_MIN; start <= 1; start++)
140 const char *p_value = NULL;
141 const char *q_value = NULL;
142 int non_options_count = 0;
143 const char *non_options[10];
144 int unrecognized = 0;
146 const char *argv[10];
148 argv[argc++] = "program";
149 argv[argc++] = "-ba";
150 argv[argc++] = "foo";
151 argv[argc++] = "bar";
154 getopt_loop (argc, argv, "ab",
155 &a_seen, &b_seen, &p_value, &q_value,
156 &non_options_count, non_options, &unrecognized);
157 ASSERT (a_seen == 1);
158 ASSERT (b_seen == 1);
159 ASSERT (p_value == NULL);
160 ASSERT (q_value == NULL);
161 ASSERT (non_options_count == 0);
162 ASSERT (unrecognized == 0);
163 ASSERT (optind == 2);
165 for (start = OPTIND_MIN; start <= 1; start++)
169 const char *p_value = NULL;
170 const char *q_value = NULL;
171 int non_options_count = 0;
172 const char *non_options[10];
173 int unrecognized = 0;
175 const char *argv[10];
177 argv[argc++] = "program";
178 argv[argc++] = "-ab";
180 argv[argc++] = "foo";
181 argv[argc++] = "bar";
184 getopt_loop (argc, argv, "ab",
185 &a_seen, &b_seen, &p_value, &q_value,
186 &non_options_count, non_options, &unrecognized);
187 ASSERT (a_seen == 2);
188 ASSERT (b_seen == 1);
189 ASSERT (p_value == NULL);
190 ASSERT (q_value == NULL);
191 ASSERT (non_options_count == 0);
192 ASSERT (unrecognized == 0);
193 ASSERT (optind == 3);
196 /* Test processing of options with arguments. */
197 for (start = OPTIND_MIN; start <= 1; start++)
201 const char *p_value = NULL;
202 const char *q_value = NULL;
203 int non_options_count = 0;
204 const char *non_options[10];
205 int unrecognized = 0;
207 const char *argv[10];
209 argv[argc++] = "program";
210 argv[argc++] = "-pfoo";
211 argv[argc++] = "bar";
214 getopt_loop (argc, argv, "p:q:",
215 &a_seen, &b_seen, &p_value, &q_value,
216 &non_options_count, non_options, &unrecognized);
217 ASSERT (a_seen == 0);
218 ASSERT (b_seen == 0);
219 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
220 ASSERT (q_value == NULL);
221 ASSERT (non_options_count == 0);
222 ASSERT (unrecognized == 0);
223 ASSERT (optind == 2);
225 for (start = OPTIND_MIN; start <= 1; start++)
229 const char *p_value = NULL;
230 const char *q_value = NULL;
231 int non_options_count = 0;
232 const char *non_options[10];
233 int unrecognized = 0;
235 const char *argv[10];
237 argv[argc++] = "program";
239 argv[argc++] = "foo";
240 argv[argc++] = "bar";
243 getopt_loop (argc, argv, "p:q:",
244 &a_seen, &b_seen, &p_value, &q_value,
245 &non_options_count, non_options, &unrecognized);
246 ASSERT (a_seen == 0);
247 ASSERT (b_seen == 0);
248 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
249 ASSERT (q_value == NULL);
250 ASSERT (non_options_count == 0);
251 ASSERT (unrecognized == 0);
252 ASSERT (optind == 3);
254 for (start = OPTIND_MIN; start <= 1; start++)
258 const char *p_value = NULL;
259 const char *q_value = NULL;
260 int non_options_count = 0;
261 const char *non_options[10];
262 int unrecognized = 0;
264 const char *argv[10];
266 argv[argc++] = "program";
267 argv[argc++] = "-ab";
269 argv[argc++] = "baz";
270 argv[argc++] = "-pfoo";
271 argv[argc++] = "bar";
274 getopt_loop (argc, argv, "abp:q:",
275 &a_seen, &b_seen, &p_value, &q_value,
276 &non_options_count, non_options, &unrecognized);
277 ASSERT (a_seen == 1);
278 ASSERT (b_seen == 1);
279 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
280 ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
281 ASSERT (non_options_count == 0);
282 ASSERT (unrecognized == 0);
283 ASSERT (optind == 5);
286 #if GNULIB_GETOPT_GNU
287 /* Test processing of options with optional arguments. */
288 for (start = OPTIND_MIN; start <= 1; start++)
292 const char *p_value = NULL;
293 const char *q_value = NULL;
294 int non_options_count = 0;
295 const char *non_options[10];
296 int unrecognized = 0;
298 const char *argv[10];
300 argv[argc++] = "program";
301 argv[argc++] = "-pfoo";
302 argv[argc++] = "bar";
305 getopt_loop (argc, argv, "p::q::",
306 &a_seen, &b_seen, &p_value, &q_value,
307 &non_options_count, non_options, &unrecognized);
308 ASSERT (a_seen == 0);
309 ASSERT (b_seen == 0);
310 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
311 ASSERT (q_value == NULL);
312 ASSERT (non_options_count == 0);
313 ASSERT (unrecognized == 0);
314 ASSERT (optind == 2);
316 for (start = OPTIND_MIN; start <= 1; start++)
320 const char *p_value = NULL;
321 const char *q_value = NULL;
322 int non_options_count = 0;
323 const char *non_options[10];
324 int unrecognized = 0;
326 const char *argv[10];
328 argv[argc++] = "program";
330 argv[argc++] = "foo";
331 argv[argc++] = "bar";
334 getopt_loop (argc, argv, "p::q::",
335 &a_seen, &b_seen, &p_value, &q_value,
336 &non_options_count, non_options, &unrecognized);
337 ASSERT (a_seen == 0);
338 ASSERT (b_seen == 0);
339 ASSERT (p_value == NULL);
340 ASSERT (q_value == NULL);
341 ASSERT (non_options_count == 0);
342 ASSERT (unrecognized == 0);
343 ASSERT (optind == 2);
345 for (start = OPTIND_MIN; start <= 1; start++)
349 const char *p_value = NULL;
350 const char *q_value = NULL;
351 int non_options_count = 0;
352 const char *non_options[10];
353 int unrecognized = 0;
355 const char *argv[10];
357 argv[argc++] = "program";
360 argv[argc++] = "bar";
363 getopt_loop (argc, argv, "abp::q::",
364 &a_seen, &b_seen, &p_value, &q_value,
365 &non_options_count, non_options, &unrecognized);
366 ASSERT (a_seen == 1);
367 ASSERT (b_seen == 0);
368 ASSERT (p_value == NULL);
369 ASSERT (q_value == NULL);
370 ASSERT (non_options_count == 0);
371 ASSERT (unrecognized == 0);
372 ASSERT (optind == 3);
376 /* Check that invalid options are recognized. */
377 for (start = OPTIND_MIN; start <= 1; start++)
381 const char *p_value = NULL;
382 const char *q_value = NULL;
383 int non_options_count = 0;
384 const char *non_options[10];
385 int unrecognized = 0;
387 const char *argv[10];
389 argv[argc++] = "program";
391 argv[argc++] = "foo";
394 argv[argc++] = "bar";
397 getopt_loop (argc, argv, "abp:q:",
398 &a_seen, &b_seen, &p_value, &q_value,
399 &non_options_count, non_options, &unrecognized);
400 ASSERT (a_seen == 1);
401 ASSERT (b_seen == 0);
402 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
403 ASSERT (q_value == NULL);
404 ASSERT (non_options_count == 0);
405 ASSERT (unrecognized == 'x');
406 ASSERT (optind == 5);
409 /* Check that by default, non-options arguments are moved to the end. */
410 for (start = OPTIND_MIN; start <= 1; start++)
414 const char *p_value = NULL;
415 const char *q_value = NULL;
416 int non_options_count = 0;
417 const char *non_options[10];
418 int unrecognized = 0;
420 const char *argv[10];
422 argv[argc++] = "program";
423 argv[argc++] = "donald";
425 argv[argc++] = "billy";
426 argv[argc++] = "duck";
428 argv[argc++] = "bar";
431 getopt_loop (argc, argv, "abp:q:",
432 &a_seen, &b_seen, &p_value, &q_value,
433 &non_options_count, non_options, &unrecognized);
436 ASSERT (strcmp (argv[0], "program") == 0);
437 ASSERT (strcmp (argv[1], "donald") == 0);
438 ASSERT (strcmp (argv[2], "-p") == 0);
439 ASSERT (strcmp (argv[3], "billy") == 0);
440 ASSERT (strcmp (argv[4], "duck") == 0);
441 ASSERT (strcmp (argv[5], "-a") == 0);
442 ASSERT (strcmp (argv[6], "bar") == 0);
443 ASSERT (argv[7] == NULL);
444 ASSERT (a_seen == 0);
445 ASSERT (b_seen == 0);
446 ASSERT (p_value == NULL);
447 ASSERT (q_value == NULL);
448 ASSERT (non_options_count == 0);
449 ASSERT (unrecognized == 0);
450 ASSERT (optind == 1);
454 ASSERT (strcmp (argv[0], "program") == 0);
455 ASSERT (strcmp (argv[1], "-p") == 0);
456 ASSERT (strcmp (argv[2], "billy") == 0);
457 ASSERT (strcmp (argv[3], "-a") == 0);
458 ASSERT (strcmp (argv[4], "donald") == 0);
459 ASSERT (strcmp (argv[5], "duck") == 0);
460 ASSERT (strcmp (argv[6], "bar") == 0);
461 ASSERT (argv[7] == NULL);
462 ASSERT (a_seen == 1);
463 ASSERT (b_seen == 0);
464 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
465 ASSERT (q_value == NULL);
466 ASSERT (non_options_count == 0);
467 ASSERT (unrecognized == 0);
468 ASSERT (optind == 4);
472 /* Check that '--' ends the argument processing. */
473 for (start = OPTIND_MIN; start <= 1; start++)
477 const char *p_value = NULL;
478 const char *q_value = NULL;
479 int non_options_count = 0;
480 const char *non_options[10];
481 int unrecognized = 0;
483 const char *argv[20];
485 argv[argc++] = "program";
486 argv[argc++] = "donald";
488 argv[argc++] = "billy";
489 argv[argc++] = "duck";
493 argv[argc++] = "foo";
495 argv[argc++] = "johnny";
496 argv[argc++] = "bar";
499 getopt_loop (argc, argv, "abp:q:",
500 &a_seen, &b_seen, &p_value, &q_value,
501 &non_options_count, non_options, &unrecognized);
504 ASSERT (strcmp (argv[0], "program") == 0);
505 ASSERT (strcmp (argv[1], "donald") == 0);
506 ASSERT (strcmp (argv[2], "-p") == 0);
507 ASSERT (strcmp (argv[3], "billy") == 0);
508 ASSERT (strcmp (argv[4], "duck") == 0);
509 ASSERT (strcmp (argv[5], "-a") == 0);
510 ASSERT (strcmp (argv[6], "--") == 0);
511 ASSERT (strcmp (argv[7], "-b") == 0);
512 ASSERT (strcmp (argv[8], "foo") == 0);
513 ASSERT (strcmp (argv[9], "-q") == 0);
514 ASSERT (strcmp (argv[10], "johnny") == 0);
515 ASSERT (strcmp (argv[11], "bar") == 0);
516 ASSERT (argv[12] == NULL);
517 ASSERT (a_seen == 0);
518 ASSERT (b_seen == 0);
519 ASSERT (p_value == NULL);
520 ASSERT (q_value == NULL);
521 ASSERT (non_options_count == 0);
522 ASSERT (unrecognized == 0);
523 ASSERT (optind == 1);
527 ASSERT (strcmp (argv[0], "program") == 0);
528 ASSERT (strcmp (argv[1], "-p") == 0);
529 ASSERT (strcmp (argv[2], "billy") == 0);
530 ASSERT (strcmp (argv[3], "-a") == 0);
531 ASSERT (strcmp (argv[4], "--") == 0);
532 ASSERT (strcmp (argv[5], "donald") == 0);
533 ASSERT (strcmp (argv[6], "duck") == 0);
534 ASSERT (strcmp (argv[7], "-b") == 0);
535 ASSERT (strcmp (argv[8], "foo") == 0);
536 ASSERT (strcmp (argv[9], "-q") == 0);
537 ASSERT (strcmp (argv[10], "johnny") == 0);
538 ASSERT (strcmp (argv[11], "bar") == 0);
539 ASSERT (argv[12] == NULL);
540 ASSERT (a_seen == 1);
541 ASSERT (b_seen == 0);
542 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
543 ASSERT (q_value == NULL);
544 ASSERT (non_options_count == 0);
545 ASSERT (unrecognized == 0);
546 ASSERT (optind == 5);
550 #if GNULIB_GETOPT_GNU
551 /* Check that the '-' flag causes non-options to be returned in order. */
552 for (start = OPTIND_MIN; start <= 1; start++)
556 const char *p_value = NULL;
557 const char *q_value = NULL;
558 int non_options_count = 0;
559 const char *non_options[10];
560 int unrecognized = 0;
562 const char *argv[10];
564 argv[argc++] = "program";
565 argv[argc++] = "donald";
567 argv[argc++] = "billy";
568 argv[argc++] = "duck";
570 argv[argc++] = "bar";
573 getopt_loop (argc, argv, "-abp:q:",
574 &a_seen, &b_seen, &p_value, &q_value,
575 &non_options_count, non_options, &unrecognized);
576 ASSERT (strcmp (argv[0], "program") == 0);
577 ASSERT (strcmp (argv[1], "donald") == 0);
578 ASSERT (strcmp (argv[2], "-p") == 0);
579 ASSERT (strcmp (argv[3], "billy") == 0);
580 ASSERT (strcmp (argv[4], "duck") == 0);
581 ASSERT (strcmp (argv[5], "-a") == 0);
582 ASSERT (strcmp (argv[6], "bar") == 0);
583 ASSERT (argv[7] == NULL);
584 ASSERT (a_seen == 1);
585 ASSERT (b_seen == 0);
586 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
587 ASSERT (q_value == NULL);
588 ASSERT (non_options_count == 3);
589 ASSERT (strcmp (non_options[0], "donald") == 0);
590 ASSERT (strcmp (non_options[1], "duck") == 0);
591 ASSERT (strcmp (non_options[2], "bar") == 0);
592 ASSERT (unrecognized == 0);
593 ASSERT (optind == 7);
596 /* Check that '--' ends the argument processing. */
597 for (start = OPTIND_MIN; start <= 1; start++)
601 const char *p_value = NULL;
602 const char *q_value = NULL;
603 int non_options_count = 0;
604 const char *non_options[10];
605 int unrecognized = 0;
607 const char *argv[20];
609 argv[argc++] = "program";
610 argv[argc++] = "donald";
612 argv[argc++] = "billy";
613 argv[argc++] = "duck";
617 argv[argc++] = "foo";
619 argv[argc++] = "johnny";
620 argv[argc++] = "bar";
623 getopt_loop (argc, argv, "-abp:q:",
624 &a_seen, &b_seen, &p_value, &q_value,
625 &non_options_count, non_options, &unrecognized);
626 ASSERT (strcmp (argv[0], "program") == 0);
627 ASSERT (strcmp (argv[1], "donald") == 0);
628 ASSERT (strcmp (argv[2], "-p") == 0);
629 ASSERT (strcmp (argv[3], "billy") == 0);
630 ASSERT (strcmp (argv[4], "duck") == 0);
631 ASSERT (strcmp (argv[5], "-a") == 0);
632 ASSERT (strcmp (argv[6], "--") == 0);
633 ASSERT (strcmp (argv[7], "-b") == 0);
634 ASSERT (strcmp (argv[8], "foo") == 0);
635 ASSERT (strcmp (argv[9], "-q") == 0);
636 ASSERT (strcmp (argv[10], "johnny") == 0);
637 ASSERT (strcmp (argv[11], "bar") == 0);
638 ASSERT (argv[12] == NULL);
639 ASSERT (a_seen == 1);
640 ASSERT (b_seen == 0);
641 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
642 ASSERT (q_value == NULL);
643 if (non_options_count == 2)
645 /* glibc behaviour. */
646 ASSERT (non_options_count == 2);
647 ASSERT (strcmp (non_options[0], "donald") == 0);
648 ASSERT (strcmp (non_options[1], "duck") == 0);
649 ASSERT (unrecognized == 0);
650 ASSERT (optind == 7);
654 /* Another valid behaviour. */
655 ASSERT (non_options_count == 7);
656 ASSERT (strcmp (non_options[0], "donald") == 0);
657 ASSERT (strcmp (non_options[1], "duck") == 0);
658 ASSERT (strcmp (non_options[2], "-b") == 0);
659 ASSERT (strcmp (non_options[3], "foo") == 0);
660 ASSERT (strcmp (non_options[4], "-q") == 0);
661 ASSERT (strcmp (non_options[5], "johnny") == 0);
662 ASSERT (strcmp (non_options[6], "bar") == 0);
663 ASSERT (unrecognized == 0);
664 ASSERT (optind == 12);
669 /* Check that the '-' flag has to come first. */
670 for (start = OPTIND_MIN; start <= 1; start++)
674 const char *p_value = NULL;
675 const char *q_value = NULL;
676 int non_options_count = 0;
677 const char *non_options[10];
678 int unrecognized = 0;
680 const char *argv[10];
682 argv[argc++] = "program";
683 argv[argc++] = "donald";
685 argv[argc++] = "billy";
686 argv[argc++] = "duck";
688 argv[argc++] = "bar";
691 getopt_loop (argc, argv, "abp:q:-",
692 &a_seen, &b_seen, &p_value, &q_value,
693 &non_options_count, non_options, &unrecognized);
696 ASSERT (strcmp (argv[0], "program") == 0);
697 ASSERT (strcmp (argv[1], "donald") == 0);
698 ASSERT (strcmp (argv[2], "-p") == 0);
699 ASSERT (strcmp (argv[3], "billy") == 0);
700 ASSERT (strcmp (argv[4], "duck") == 0);
701 ASSERT (strcmp (argv[5], "-a") == 0);
702 ASSERT (strcmp (argv[6], "bar") == 0);
703 ASSERT (argv[7] == NULL);
704 ASSERT (a_seen == 0);
705 ASSERT (b_seen == 0);
706 ASSERT (p_value == NULL);
707 ASSERT (q_value == NULL);
708 ASSERT (non_options_count == 0);
709 ASSERT (unrecognized == 0);
710 ASSERT (optind == 1);
714 ASSERT (strcmp (argv[0], "program") == 0);
715 ASSERT (strcmp (argv[1], "-p") == 0);
716 ASSERT (strcmp (argv[2], "billy") == 0);
717 ASSERT (strcmp (argv[3], "-a") == 0);
718 ASSERT (strcmp (argv[4], "donald") == 0);
719 ASSERT (strcmp (argv[5], "duck") == 0);
720 ASSERT (strcmp (argv[6], "bar") == 0);
721 ASSERT (argv[7] == NULL);
722 ASSERT (a_seen == 1);
723 ASSERT (b_seen == 0);
724 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
725 ASSERT (q_value == NULL);
726 ASSERT (non_options_count == 0);
727 ASSERT (unrecognized == 0);
728 ASSERT (optind == 4);
732 /* Check that the '+' flag causes the first non-option to terminate the
734 for (start = OPTIND_MIN; start <= 1; start++)
738 const char *p_value = NULL;
739 const char *q_value = NULL;
740 int non_options_count = 0;
741 const char *non_options[10];
742 int unrecognized = 0;
744 const char *argv[10];
746 argv[argc++] = "program";
747 argv[argc++] = "donald";
749 argv[argc++] = "billy";
750 argv[argc++] = "duck";
752 argv[argc++] = "bar";
755 getopt_loop (argc, argv, "+abp:q:",
756 &a_seen, &b_seen, &p_value, &q_value,
757 &non_options_count, non_options, &unrecognized);
758 ASSERT (strcmp (argv[0], "program") == 0);
759 ASSERT (strcmp (argv[1], "donald") == 0);
760 ASSERT (strcmp (argv[2], "-p") == 0);
761 ASSERT (strcmp (argv[3], "billy") == 0);
762 ASSERT (strcmp (argv[4], "duck") == 0);
763 ASSERT (strcmp (argv[5], "-a") == 0);
764 ASSERT (strcmp (argv[6], "bar") == 0);
765 ASSERT (argv[7] == NULL);
766 ASSERT (a_seen == 0);
767 ASSERT (b_seen == 0);
768 ASSERT (p_value == NULL);
769 ASSERT (q_value == NULL);
770 ASSERT (non_options_count == 0);
771 ASSERT (unrecognized == 0);
772 ASSERT (optind == 1);
774 for (start = OPTIND_MIN; start <= 1; start++)
778 const char *p_value = NULL;
779 const char *q_value = NULL;
780 int non_options_count = 0;
781 const char *non_options[10];
782 int unrecognized = 0;
784 const char *argv[10];
786 argv[argc++] = "program";
790 getopt_loop (argc, argv, "+abp:q:",
791 &a_seen, &b_seen, &p_value, &q_value,
792 &non_options_count, non_options, &unrecognized);
793 ASSERT (a_seen == 0);
794 ASSERT (b_seen == 0);
795 ASSERT (p_value == NULL);
796 ASSERT (q_value == NULL);
797 ASSERT (non_options_count == 0);
798 ASSERT (unrecognized == '+');
799 ASSERT (optind == 2);
802 /* Check that '--' ends the argument processing. */
803 for (start = OPTIND_MIN; start <= 1; start++)
807 const char *p_value = NULL;
808 const char *q_value = NULL;
809 int non_options_count = 0;
810 const char *non_options[10];
811 int unrecognized = 0;
813 const char *argv[20];
815 argv[argc++] = "program";
816 argv[argc++] = "donald";
818 argv[argc++] = "billy";
819 argv[argc++] = "duck";
823 argv[argc++] = "foo";
825 argv[argc++] = "johnny";
826 argv[argc++] = "bar";
829 getopt_loop (argc, argv, "+abp:q:",
830 &a_seen, &b_seen, &p_value, &q_value,
831 &non_options_count, non_options, &unrecognized);
832 ASSERT (strcmp (argv[0], "program") == 0);
833 ASSERT (strcmp (argv[1], "donald") == 0);
834 ASSERT (strcmp (argv[2], "-p") == 0);
835 ASSERT (strcmp (argv[3], "billy") == 0);
836 ASSERT (strcmp (argv[4], "duck") == 0);
837 ASSERT (strcmp (argv[5], "-a") == 0);
838 ASSERT (strcmp (argv[6], "--") == 0);
839 ASSERT (strcmp (argv[7], "-b") == 0);
840 ASSERT (strcmp (argv[8], "foo") == 0);
841 ASSERT (strcmp (argv[9], "-q") == 0);
842 ASSERT (strcmp (argv[10], "johnny") == 0);
843 ASSERT (strcmp (argv[11], "bar") == 0);
844 ASSERT (argv[12] == NULL);
845 ASSERT (a_seen == 0);
846 ASSERT (b_seen == 0);
847 ASSERT (p_value == NULL);
848 ASSERT (q_value == NULL);
849 ASSERT (non_options_count == 0);
850 ASSERT (unrecognized == 0);
854 /* Check that the '+' flag has to come first. */
855 for (start = OPTIND_MIN; start <= 1; start++)
859 const char *p_value = NULL;
860 const char *q_value = NULL;
861 int non_options_count = 0;
862 const char *non_options[10];
863 int unrecognized = 0;
865 const char *argv[10];
867 argv[argc++] = "program";
868 argv[argc++] = "donald";
870 argv[argc++] = "billy";
871 argv[argc++] = "duck";
873 argv[argc++] = "bar";
876 getopt_loop (argc, argv, "abp:q:+",
877 &a_seen, &b_seen, &p_value, &q_value,
878 &non_options_count, non_options, &unrecognized);
881 ASSERT (strcmp (argv[0], "program") == 0);
882 ASSERT (strcmp (argv[1], "donald") == 0);
883 ASSERT (strcmp (argv[2], "-p") == 0);
884 ASSERT (strcmp (argv[3], "billy") == 0);
885 ASSERT (strcmp (argv[4], "duck") == 0);
886 ASSERT (strcmp (argv[5], "-a") == 0);
887 ASSERT (strcmp (argv[6], "bar") == 0);
888 ASSERT (argv[7] == NULL);
889 ASSERT (a_seen == 0);
890 ASSERT (b_seen == 0);
891 ASSERT (p_value == NULL);
892 ASSERT (q_value == NULL);
893 ASSERT (non_options_count == 0);
894 ASSERT (unrecognized == 0);
895 ASSERT (optind == 1);
899 ASSERT (strcmp (argv[0], "program") == 0);
900 ASSERT (strcmp (argv[1], "-p") == 0);
901 ASSERT (strcmp (argv[2], "billy") == 0);
902 ASSERT (strcmp (argv[3], "-a") == 0);
903 ASSERT (strcmp (argv[4], "donald") == 0);
904 ASSERT (strcmp (argv[5], "duck") == 0);
905 ASSERT (strcmp (argv[6], "bar") == 0);
906 ASSERT (argv[7] == NULL);
907 ASSERT (a_seen == 1);
908 ASSERT (b_seen == 0);
909 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
910 ASSERT (q_value == NULL);
911 ASSERT (non_options_count == 0);
912 ASSERT (unrecognized == 0);
913 ASSERT (optind == 4);