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 static const struct option long_options_required[] =
24 { "alpha", no_argument, NULL, 'a' },
25 { "beta", no_argument, &b_seen, 1 },
26 { "prune", required_argument, NULL, 'p' },
27 { "quetsche", required_argument, NULL, 'q' },
28 { "xtra", no_argument, NULL, 1001 },
29 { "xtreme", no_argument, NULL, 1002 },
30 { "xtremely", no_argument, NULL, 1003 },
34 static const struct option long_options_optional[] =
36 { "alpha", no_argument, NULL, 'a' },
37 { "beta", no_argument, &b_seen, 1 },
38 { "prune", optional_argument, NULL, 'p' },
39 { "quetsche", optional_argument, NULL, 'q' },
44 getopt_long_loop (int argc, const char **argv,
45 const char *options, const struct option *long_options,
46 const char **p_value, const char **q_value,
47 int *non_options_count, const char **non_options,
54 while ((c = getopt_long (argc, (char **) argv, options, long_options,
61 /* An option with a non-NULL flag pointer was processed. */
76 /* Must only happen with option '-' at the beginning. */
77 ASSERT (options[0] == '-');
78 non_options[(*non_options_count)++] = optarg;
81 *unrecognized = optopt;
90 /* Reduce casting, so we can use string literals elsewhere.
91 getopt_long takes an array of char*, but luckily does not modify
92 those elements, so we can pass const char*. */
94 do_getopt_long (int argc, const char **argv, const char *shortopts,
95 const struct option *longopts, int *longind)
97 return getopt_long (argc, (char **) argv, shortopts, longopts, longind);
101 test_getopt_long (void)
105 /* Test disambiguation of options. */
108 const char *argv[10];
112 argv[argc++] = "program";
113 argv[argc++] = "--x";
116 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
118 ASSERT (optopt == 0);
122 const char *argv[10];
126 argv[argc++] = "program";
127 argv[argc++] = "--xt";
130 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
132 ASSERT (optopt == 0);
136 const char *argv[10];
140 argv[argc++] = "program";
141 argv[argc++] = "--xtr";
144 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
146 ASSERT (optopt == 0);
150 const char *argv[10];
154 argv[argc++] = "program";
155 argv[argc++] = "--xtra";
158 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
163 const char *argv[10];
167 argv[argc++] = "program";
168 argv[argc++] = "--xtre";
171 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
173 ASSERT (optopt == 0);
177 const char *argv[10];
181 argv[argc++] = "program";
182 argv[argc++] = "--xtrem";
185 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
187 ASSERT (optopt == 0);
191 const char *argv[10];
195 argv[argc++] = "program";
196 argv[argc++] = "--xtreme";
199 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
204 const char *argv[10];
208 argv[argc++] = "program";
209 argv[argc++] = "--xtremel";
212 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
217 const char *argv[10];
221 argv[argc++] = "program";
222 argv[argc++] = "--xtremely";
225 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
229 /* Test processing of boolean options. */
230 for (start = OPTIND_MIN; start <= 1; start++)
232 const char *p_value = NULL;
233 const char *q_value = NULL;
234 int non_options_count = 0;
235 const char *non_options[10];
236 int unrecognized = 0;
238 const char *argv[10];
242 argv[argc++] = "program";
244 argv[argc++] = "foo";
245 argv[argc++] = "bar";
247 getopt_long_loop (argc, argv, "ab", long_options_required,
249 &non_options_count, non_options, &unrecognized);
250 ASSERT (a_seen == 1);
251 ASSERT (b_seen == 0);
252 ASSERT (p_value == NULL);
253 ASSERT (q_value == NULL);
254 ASSERT (non_options_count == 0);
255 ASSERT (unrecognized == 0);
256 ASSERT (optind == 2);
258 for (start = OPTIND_MIN; start <= 1; start++)
260 const char *p_value = NULL;
261 const char *q_value = NULL;
262 int non_options_count = 0;
263 const char *non_options[10];
264 int unrecognized = 0;
266 const char *argv[10];
270 argv[argc++] = "program";
273 argv[argc++] = "foo";
274 argv[argc++] = "bar";
276 getopt_long_loop (argc, argv, "ab", long_options_required,
278 &non_options_count, non_options, &unrecognized);
279 ASSERT (a_seen == 1);
280 ASSERT (b_seen == 1);
281 ASSERT (p_value == NULL);
282 ASSERT (q_value == NULL);
283 ASSERT (non_options_count == 0);
284 ASSERT (unrecognized == 0);
285 ASSERT (optind == 3);
287 for (start = OPTIND_MIN; start <= 1; start++)
289 const char *p_value = NULL;
290 const char *q_value = NULL;
291 int non_options_count = 0;
292 const char *non_options[10];
293 int unrecognized = 0;
295 const char *argv[10];
299 argv[argc++] = "program";
300 argv[argc++] = "-ba";
301 argv[argc++] = "foo";
302 argv[argc++] = "bar";
304 getopt_long_loop (argc, argv, "ab", long_options_required,
306 &non_options_count, non_options, &unrecognized);
307 ASSERT (a_seen == 1);
308 ASSERT (b_seen == 1);
309 ASSERT (p_value == NULL);
310 ASSERT (q_value == NULL);
311 ASSERT (non_options_count == 0);
312 ASSERT (unrecognized == 0);
313 ASSERT (optind == 2);
315 for (start = OPTIND_MIN; start <= 1; start++)
317 const char *p_value = NULL;
318 const char *q_value = NULL;
319 int non_options_count = 0;
320 const char *non_options[10];
321 int unrecognized = 0;
323 const char *argv[10];
327 argv[argc++] = "program";
328 argv[argc++] = "-ab";
330 argv[argc++] = "foo";
331 argv[argc++] = "bar";
333 getopt_long_loop (argc, argv, "ab", long_options_required,
335 &non_options_count, non_options, &unrecognized);
336 ASSERT (a_seen == 2);
337 ASSERT (b_seen == 1);
338 ASSERT (p_value == NULL);
339 ASSERT (q_value == NULL);
340 ASSERT (non_options_count == 0);
341 ASSERT (unrecognized == 0);
342 ASSERT (optind == 3);
345 /* Test processing of options with arguments. */
346 for (start = OPTIND_MIN; start <= 1; start++)
348 const char *p_value = NULL;
349 const char *q_value = NULL;
350 int non_options_count = 0;
351 const char *non_options[10];
352 int unrecognized = 0;
354 const char *argv[10];
358 argv[argc++] = "program";
359 argv[argc++] = "-pfoo";
360 argv[argc++] = "bar";
362 getopt_long_loop (argc, argv, "p:q:", long_options_required,
364 &non_options_count, non_options, &unrecognized);
365 ASSERT (a_seen == 0);
366 ASSERT (b_seen == 0);
367 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
368 ASSERT (q_value == NULL);
369 ASSERT (non_options_count == 0);
370 ASSERT (unrecognized == 0);
371 ASSERT (optind == 2);
373 for (start = OPTIND_MIN; start <= 1; start++)
375 const char *p_value = NULL;
376 const char *q_value = NULL;
377 int non_options_count = 0;
378 const char *non_options[10];
379 int unrecognized = 0;
381 const char *argv[10];
385 argv[argc++] = "program";
387 argv[argc++] = "foo";
388 argv[argc++] = "bar";
390 getopt_long_loop (argc, argv, "p:q:", long_options_required,
392 &non_options_count, non_options, &unrecognized);
393 ASSERT (a_seen == 0);
394 ASSERT (b_seen == 0);
395 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
396 ASSERT (q_value == NULL);
397 ASSERT (non_options_count == 0);
398 ASSERT (unrecognized == 0);
399 ASSERT (optind == 3);
401 for (start = OPTIND_MIN; start <= 1; start++)
403 const char *p_value = NULL;
404 const char *q_value = NULL;
405 int non_options_count = 0;
406 const char *non_options[10];
407 int unrecognized = 0;
409 const char *argv[10];
413 argv[argc++] = "program";
414 argv[argc++] = "-ab";
416 argv[argc++] = "baz";
417 argv[argc++] = "-pfoo";
418 argv[argc++] = "bar";
420 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
422 &non_options_count, non_options, &unrecognized);
423 ASSERT (a_seen == 1);
424 ASSERT (b_seen == 1);
425 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
426 ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
427 ASSERT (non_options_count == 0);
428 ASSERT (unrecognized == 0);
429 ASSERT (optind == 5);
432 /* Test processing of options with optional arguments. */
433 for (start = OPTIND_MIN; start <= 1; start++)
435 const char *p_value = NULL;
436 const char *q_value = NULL;
437 int non_options_count = 0;
438 const char *non_options[10];
439 int unrecognized = 0;
441 const char *argv[10];
445 argv[argc++] = "program";
446 argv[argc++] = "-pfoo";
447 argv[argc++] = "bar";
449 getopt_long_loop (argc, argv, "p::q::", long_options_optional,
451 &non_options_count, non_options, &unrecognized);
452 ASSERT (a_seen == 0);
453 ASSERT (b_seen == 0);
454 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
455 ASSERT (q_value == NULL);
456 ASSERT (non_options_count == 0);
457 ASSERT (unrecognized == 0);
458 ASSERT (optind == 2);
460 for (start = OPTIND_MIN; start <= 1; start++)
462 const char *p_value = NULL;
463 const char *q_value = NULL;
464 int non_options_count = 0;
465 const char *non_options[10];
466 int unrecognized = 0;
468 const char *argv[10];
472 argv[argc++] = "program";
474 argv[argc++] = "foo";
475 argv[argc++] = "bar";
477 getopt_long_loop (argc, argv, "p::q::", long_options_optional,
479 &non_options_count, non_options, &unrecognized);
480 ASSERT (a_seen == 0);
481 ASSERT (b_seen == 0);
482 ASSERT (p_value == NULL);
483 ASSERT (q_value == NULL);
484 ASSERT (non_options_count == 0);
485 ASSERT (unrecognized == 0);
486 ASSERT (optind == 2);
488 for (start = OPTIND_MIN; start <= 1; start++)
490 const char *p_value = NULL;
491 const char *q_value = NULL;
492 int non_options_count = 0;
493 const char *non_options[10];
494 int unrecognized = 0;
496 const char *argv[10];
500 argv[argc++] = "program";
503 argv[argc++] = "bar";
505 getopt_long_loop (argc, argv, "abp::q::", long_options_optional,
507 &non_options_count, non_options, &unrecognized);
508 ASSERT (a_seen == 1);
509 ASSERT (b_seen == 0);
510 ASSERT (p_value == NULL);
511 ASSERT (q_value == NULL);
512 ASSERT (non_options_count == 0);
513 ASSERT (unrecognized == 0);
514 ASSERT (optind == 3);
517 /* Check that invalid options are recognized. */
518 for (start = OPTIND_MIN; start <= 1; start++)
520 const char *p_value = NULL;
521 const char *q_value = NULL;
522 int non_options_count = 0;
523 const char *non_options[10];
524 int unrecognized = 0;
526 const char *argv[10];
530 argv[argc++] = "program";
532 argv[argc++] = "foo";
535 argv[argc++] = "bar";
537 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
539 &non_options_count, non_options, &unrecognized);
540 ASSERT (a_seen == 1);
541 ASSERT (b_seen == 0);
542 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
543 ASSERT (q_value == NULL);
544 ASSERT (non_options_count == 0);
545 ASSERT (unrecognized == 'x');
546 ASSERT (optind == 5);
549 /* Check that by default, non-options arguments are moved to the end. */
550 for (start = OPTIND_MIN; start <= 1; start++)
552 const char *p_value = NULL;
553 const char *q_value = NULL;
554 int non_options_count = 0;
555 const char *non_options[10];
556 int unrecognized = 0;
558 const char *argv[10];
562 argv[argc++] = "program";
563 argv[argc++] = "donald";
565 argv[argc++] = "billy";
566 argv[argc++] = "duck";
568 argv[argc++] = "bar";
570 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
572 &non_options_count, non_options, &unrecognized);
573 ASSERT (strcmp (argv[0], "program") == 0);
574 ASSERT (strcmp (argv[1], "-p") == 0);
575 ASSERT (strcmp (argv[2], "billy") == 0);
576 ASSERT (strcmp (argv[3], "-a") == 0);
577 ASSERT (strcmp (argv[4], "donald") == 0);
578 ASSERT (strcmp (argv[5], "duck") == 0);
579 ASSERT (strcmp (argv[6], "bar") == 0);
580 ASSERT (a_seen == 1);
581 ASSERT (b_seen == 0);
582 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
583 ASSERT (q_value == NULL);
584 ASSERT (non_options_count == 0);
585 ASSERT (unrecognized == 0);
586 ASSERT (optind == 4);
589 /* Check that '--' ends the argument processing. */
590 for (start = OPTIND_MIN; start <= 1; start++)
592 const char *p_value = NULL;
593 const char *q_value = NULL;
594 int non_options_count = 0;
595 const char *non_options[10];
596 int unrecognized = 0;
598 const char *argv[20];
602 argv[argc++] = "program";
603 argv[argc++] = "donald";
605 argv[argc++] = "billy";
606 argv[argc++] = "duck";
610 argv[argc++] = "foo";
612 argv[argc++] = "johnny";
613 argv[argc++] = "bar";
615 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
617 &non_options_count, non_options, &unrecognized);
618 ASSERT (strcmp (argv[0], "program") == 0);
619 ASSERT (strcmp (argv[1], "-p") == 0);
620 ASSERT (strcmp (argv[2], "billy") == 0);
621 ASSERT (strcmp (argv[3], "-a") == 0);
622 ASSERT (strcmp (argv[4], "--") == 0);
623 ASSERT (strcmp (argv[5], "donald") == 0);
624 ASSERT (strcmp (argv[6], "duck") == 0);
625 ASSERT (strcmp (argv[7], "-b") == 0);
626 ASSERT (strcmp (argv[8], "foo") == 0);
627 ASSERT (strcmp (argv[9], "-q") == 0);
628 ASSERT (strcmp (argv[10], "johnny") == 0);
629 ASSERT (strcmp (argv[11], "bar") == 0);
630 ASSERT (a_seen == 1);
631 ASSERT (b_seen == 0);
632 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
633 ASSERT (q_value == NULL);
634 ASSERT (non_options_count == 0);
635 ASSERT (unrecognized == 0);
636 ASSERT (optind == 5);
639 /* Check that the '-' flag causes non-options to be returned in order. */
640 for (start = OPTIND_MIN; start <= 1; start++)
642 const char *p_value = NULL;
643 const char *q_value = NULL;
644 int non_options_count = 0;
645 const char *non_options[10];
646 int unrecognized = 0;
648 const char *argv[10];
652 argv[argc++] = "program";
653 argv[argc++] = "donald";
655 argv[argc++] = "billy";
656 argv[argc++] = "duck";
658 argv[argc++] = "bar";
660 getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
662 &non_options_count, non_options, &unrecognized);
663 ASSERT (strcmp (argv[0], "program") == 0);
664 ASSERT (strcmp (argv[1], "donald") == 0);
665 ASSERT (strcmp (argv[2], "-p") == 0);
666 ASSERT (strcmp (argv[3], "billy") == 0);
667 ASSERT (strcmp (argv[4], "duck") == 0);
668 ASSERT (strcmp (argv[5], "-a") == 0);
669 ASSERT (strcmp (argv[6], "bar") == 0);
670 ASSERT (a_seen == 1);
671 ASSERT (b_seen == 0);
672 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
673 ASSERT (q_value == NULL);
674 ASSERT (non_options_count == 3);
675 ASSERT (strcmp (non_options[0], "donald") == 0);
676 ASSERT (strcmp (non_options[1], "duck") == 0);
677 ASSERT (strcmp (non_options[2], "bar") == 0);
678 ASSERT (unrecognized == 0);
679 ASSERT (optind == 7);
682 /* Check that '--' ends the argument processing. */
683 for (start = OPTIND_MIN; start <= 1; start++)
685 const char *p_value = NULL;
686 const char *q_value = NULL;
687 int non_options_count = 0;
688 const char *non_options[10];
689 int unrecognized = 0;
691 const char *argv[20];
695 argv[argc++] = "program";
696 argv[argc++] = "donald";
698 argv[argc++] = "billy";
699 argv[argc++] = "duck";
703 argv[argc++] = "foo";
705 argv[argc++] = "johnny";
706 argv[argc++] = "bar";
708 getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
710 &non_options_count, non_options, &unrecognized);
711 ASSERT (strcmp (argv[0], "program") == 0);
712 ASSERT (strcmp (argv[1], "donald") == 0);
713 ASSERT (strcmp (argv[2], "-p") == 0);
714 ASSERT (strcmp (argv[3], "billy") == 0);
715 ASSERT (strcmp (argv[4], "duck") == 0);
716 ASSERT (strcmp (argv[5], "-a") == 0);
717 ASSERT (strcmp (argv[6], "--") == 0);
718 ASSERT (strcmp (argv[7], "-b") == 0);
719 ASSERT (strcmp (argv[8], "foo") == 0);
720 ASSERT (strcmp (argv[9], "-q") == 0);
721 ASSERT (strcmp (argv[10], "johnny") == 0);
722 ASSERT (strcmp (argv[11], "bar") == 0);
723 ASSERT (a_seen == 1);
724 ASSERT (b_seen == 0);
725 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
726 ASSERT (q_value == NULL);
727 if (non_options_count == 2)
729 /* glibc behaviour. */
730 ASSERT (non_options_count == 2);
731 ASSERT (strcmp (non_options[0], "donald") == 0);
732 ASSERT (strcmp (non_options[1], "duck") == 0);
733 ASSERT (unrecognized == 0);
734 ASSERT (optind == 7);
738 /* Another valid behaviour. */
739 ASSERT (non_options_count == 7);
740 ASSERT (strcmp (non_options[0], "donald") == 0);
741 ASSERT (strcmp (non_options[1], "duck") == 0);
742 ASSERT (strcmp (non_options[2], "-b") == 0);
743 ASSERT (strcmp (non_options[3], "foo") == 0);
744 ASSERT (strcmp (non_options[4], "-q") == 0);
745 ASSERT (strcmp (non_options[5], "johnny") == 0);
746 ASSERT (strcmp (non_options[6], "bar") == 0);
747 ASSERT (unrecognized == 0);
748 ASSERT (optind == 12);
752 /* Check that the '-' flag has to come first. */
753 for (start = OPTIND_MIN; start <= 1; start++)
755 const char *p_value = NULL;
756 const char *q_value = NULL;
757 int non_options_count = 0;
758 const char *non_options[10];
759 int unrecognized = 0;
761 const char *argv[10];
765 argv[argc++] = "program";
766 argv[argc++] = "donald";
768 argv[argc++] = "billy";
769 argv[argc++] = "duck";
771 argv[argc++] = "bar";
773 getopt_long_loop (argc, argv, "abp:q:-", long_options_required,
775 &non_options_count, non_options, &unrecognized);
776 ASSERT (strcmp (argv[0], "program") == 0);
777 ASSERT (strcmp (argv[1], "-p") == 0);
778 ASSERT (strcmp (argv[2], "billy") == 0);
779 ASSERT (strcmp (argv[3], "-a") == 0);
780 ASSERT (strcmp (argv[4], "donald") == 0);
781 ASSERT (strcmp (argv[5], "duck") == 0);
782 ASSERT (strcmp (argv[6], "bar") == 0);
783 ASSERT (a_seen == 1);
784 ASSERT (b_seen == 0);
785 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
786 ASSERT (q_value == NULL);
787 ASSERT (non_options_count == 0);
788 ASSERT (unrecognized == 0);
789 ASSERT (optind == 4);
792 /* Check that the '+' flag causes the first non-option to terminate the
794 for (start = OPTIND_MIN; start <= 1; start++)
796 const char *p_value = NULL;
797 const char *q_value = NULL;
798 int non_options_count = 0;
799 const char *non_options[10];
800 int unrecognized = 0;
802 const char *argv[10];
806 argv[argc++] = "program";
807 argv[argc++] = "donald";
809 argv[argc++] = "billy";
810 argv[argc++] = "duck";
812 argv[argc++] = "bar";
814 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
816 &non_options_count, non_options, &unrecognized);
817 ASSERT (strcmp (argv[0], "program") == 0);
818 ASSERT (strcmp (argv[1], "donald") == 0);
819 ASSERT (strcmp (argv[2], "-p") == 0);
820 ASSERT (strcmp (argv[3], "billy") == 0);
821 ASSERT (strcmp (argv[4], "duck") == 0);
822 ASSERT (strcmp (argv[5], "-a") == 0);
823 ASSERT (strcmp (argv[6], "bar") == 0);
824 ASSERT (a_seen == 0);
825 ASSERT (b_seen == 0);
826 ASSERT (p_value == NULL);
827 ASSERT (q_value == NULL);
828 ASSERT (non_options_count == 0);
829 ASSERT (unrecognized == 0);
830 ASSERT (optind == 1);
832 for (start = OPTIND_MIN; start <= 1; start++)
834 const char *p_value = NULL;
835 const char *q_value = NULL;
836 int non_options_count = 0;
837 const char *non_options[10];
838 int unrecognized = 0;
840 const char *argv[10];
844 argv[argc++] = "program";
847 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
849 &non_options_count, non_options, &unrecognized);
850 ASSERT (a_seen == 0);
851 ASSERT (b_seen == 0);
852 ASSERT (p_value == NULL);
853 ASSERT (q_value == NULL);
854 ASSERT (non_options_count == 0);
855 ASSERT (unrecognized == '+');
856 ASSERT (optind == 2);
859 /* Check that '--' ends the argument processing. */
860 for (start = OPTIND_MIN; start <= 1; start++)
862 const char *p_value = NULL;
863 const char *q_value = NULL;
864 int non_options_count = 0;
865 const char *non_options[10];
866 int unrecognized = 0;
868 const char *argv[20];
872 argv[argc++] = "program";
873 argv[argc++] = "donald";
875 argv[argc++] = "billy";
876 argv[argc++] = "duck";
880 argv[argc++] = "foo";
882 argv[argc++] = "johnny";
883 argv[argc++] = "bar";
885 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
887 &non_options_count, non_options, &unrecognized);
888 ASSERT (strcmp (argv[0], "program") == 0);
889 ASSERT (strcmp (argv[1], "donald") == 0);
890 ASSERT (strcmp (argv[2], "-p") == 0);
891 ASSERT (strcmp (argv[3], "billy") == 0);
892 ASSERT (strcmp (argv[4], "duck") == 0);
893 ASSERT (strcmp (argv[5], "-a") == 0);
894 ASSERT (strcmp (argv[6], "--") == 0);
895 ASSERT (strcmp (argv[7], "-b") == 0);
896 ASSERT (strcmp (argv[8], "foo") == 0);
897 ASSERT (strcmp (argv[9], "-q") == 0);
898 ASSERT (strcmp (argv[10], "johnny") == 0);
899 ASSERT (strcmp (argv[11], "bar") == 0);
900 ASSERT (a_seen == 0);
901 ASSERT (b_seen == 0);
902 ASSERT (p_value == NULL);
903 ASSERT (q_value == NULL);
904 ASSERT (non_options_count == 0);
905 ASSERT (unrecognized == 0);
909 /* Check that the '+' flag has to come first. */
910 for (start = OPTIND_MIN; start <= 1; start++)
912 const char *p_value = NULL;
913 const char *q_value = NULL;
914 int non_options_count = 0;
915 const char *non_options[10];
916 int unrecognized = 0;
918 const char *argv[10];
922 argv[argc++] = "program";
923 argv[argc++] = "donald";
925 argv[argc++] = "billy";
926 argv[argc++] = "duck";
928 argv[argc++] = "bar";
930 getopt_long_loop (argc, argv, "abp:q:+", long_options_required,
932 &non_options_count, non_options, &unrecognized);
933 ASSERT (strcmp (argv[0], "program") == 0);
934 ASSERT (strcmp (argv[1], "-p") == 0);
935 ASSERT (strcmp (argv[2], "billy") == 0);
936 ASSERT (strcmp (argv[3], "-a") == 0);
937 ASSERT (strcmp (argv[4], "donald") == 0);
938 ASSERT (strcmp (argv[5], "duck") == 0);
939 ASSERT (strcmp (argv[6], "bar") == 0);
940 ASSERT (a_seen == 1);
941 ASSERT (b_seen == 0);
942 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
943 ASSERT (q_value == NULL);
944 ASSERT (non_options_count == 0);
945 ASSERT (unrecognized == 0);
946 ASSERT (optind == 4);
950 /* Test behavior of getopt_long when POSIXLY_CORRECT is set in the
951 environment. Options with optional arguments should not change
952 behavior just because of an environment variable.
953 http://lists.gnu.org/archive/html/bug-m4/2006-09/msg00028.html */
955 test_getopt_long_posix (void)
958 const char *v[4] = {"test", "-r", "foo", NULL};
959 struct option l[] = {{NULL, 0, NULL, 0}};
962 for (start = OPTIND_MIN; start <= 1; start++)
965 result = do_getopt_long (c, v, "r::", l, NULL);
967 ASSERT (result == 'r');
968 ASSERT (optarg == NULL);