1 /* Test of command line argument processing.
2 Copyright (C) 2009, 2010 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. */
23 static const struct option long_options_required[] =
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 },
36 static const struct option long_options_optional[] =
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 },
46 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,
52 int option_index = -1;
57 while ((c = getopt_long (argc, (char **) argv, options, long_options,
64 /* An option with a non-NULL flag pointer was processed. */
81 /* Must only happen with option '-' at the beginning. */
82 ASSERT (options[0] == '-');
83 non_options[(*non_options_count)++] = optarg;
86 /* Must only happen with option ':' at the beginning. */
87 ASSERT (options[0] == ':'
88 || ((options[0] == '-' || options[0] == '+')
89 && options[1] == ':'));
92 *unrecognized = optopt;
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*. */
105 do_getopt_long (int argc, const char **argv, const char *shortopts,
106 const struct option *longopts, int *longind)
108 return getopt_long (argc, (char **) argv, shortopts, longopts, longind);
112 test_getopt_long (void)
116 /* Test disambiguation of options. */
119 const char *argv[10];
123 argv[argc++] = "program";
124 argv[argc++] = "--x";
128 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
130 ASSERT (optopt == 0);
134 const char *argv[10];
138 argv[argc++] = "program";
139 argv[argc++] = "--xt";
143 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
145 ASSERT (optopt == 0);
149 const char *argv[10];
153 argv[argc++] = "program";
154 argv[argc++] = "--xtr";
158 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
160 ASSERT (optopt == 0);
164 const char *argv[10];
168 argv[argc++] = "program";
169 argv[argc++] = "--xtra";
173 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
178 const char *argv[10];
182 argv[argc++] = "program";
183 argv[argc++] = "--xtre";
187 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
189 ASSERT (optopt == 0);
193 const char *argv[10];
197 argv[argc++] = "program";
198 argv[argc++] = "--xtrem";
202 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
204 ASSERT (optopt == 0);
208 const char *argv[10];
212 argv[argc++] = "program";
213 argv[argc++] = "--xtreme";
217 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
222 const char *argv[10];
226 argv[argc++] = "program";
227 argv[argc++] = "--xtremel";
231 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
236 const char *argv[10];
240 argv[argc++] = "program";
241 argv[argc++] = "--xtremely";
245 c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
249 /* Check that -W handles unknown options. */
252 const char *argv[10];
256 argv[argc++] = "program";
261 c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);
263 ASSERT (optopt == 'W');
267 const char *argv[10];
271 argv[argc++] = "program";
272 argv[argc++] = "-Wunknown";
276 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. */
281 ASSERT (optopt == 0);
282 ASSERT (optarg == NULL);
287 ASSERT (strcmp (optarg, "unknown") == 0);
292 const char *argv[10];
296 argv[argc++] = "program";
298 argv[argc++] = "unknown";
302 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. */
307 ASSERT (optopt == 0);
308 ASSERT (optarg == NULL);
313 ASSERT (strcmp (optarg, "unknown") == 0);
317 /* Test processing of boolean short options. */
318 for (start = 0; 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];
330 argv[argc++] = "program";
332 argv[argc++] = "foo";
333 argv[argc++] = "bar";
336 getopt_long_loop (argc, argv, "ab", long_options_required,
338 &non_options_count, non_options, &unrecognized);
339 ASSERT (a_seen == 1);
340 ASSERT (b_seen == 0);
341 ASSERT (p_value == NULL);
342 ASSERT (q_value == NULL);
343 ASSERT (non_options_count == 0);
344 ASSERT (unrecognized == 0);
345 ASSERT (optind == 2);
347 for (start = 0; 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];
359 argv[argc++] = "program";
362 argv[argc++] = "foo";
363 argv[argc++] = "bar";
366 getopt_long_loop (argc, argv, "ab", long_options_required,
368 &non_options_count, non_options, &unrecognized);
369 ASSERT (a_seen == 1);
370 ASSERT (b_seen == 1);
371 ASSERT (p_value == NULL);
372 ASSERT (q_value == NULL);
373 ASSERT (non_options_count == 0);
374 ASSERT (unrecognized == 0);
375 ASSERT (optind == 3);
377 for (start = 0; start <= 1; start++)
379 const char *p_value = NULL;
380 const char *q_value = NULL;
381 int non_options_count = 0;
382 const char *non_options[10];
383 int unrecognized = 0;
385 const char *argv[10];
389 argv[argc++] = "program";
390 argv[argc++] = "-ba";
391 argv[argc++] = "foo";
392 argv[argc++] = "bar";
395 getopt_long_loop (argc, argv, "ab", long_options_required,
397 &non_options_count, non_options, &unrecognized);
398 ASSERT (a_seen == 1);
399 ASSERT (b_seen == 1);
400 ASSERT (p_value == NULL);
401 ASSERT (q_value == NULL);
402 ASSERT (non_options_count == 0);
403 ASSERT (unrecognized == 0);
404 ASSERT (optind == 2);
406 for (start = 0; start <= 1; start++)
408 const char *p_value = NULL;
409 const char *q_value = NULL;
410 int non_options_count = 0;
411 const char *non_options[10];
412 int unrecognized = 0;
414 const char *argv[10];
418 argv[argc++] = "program";
419 argv[argc++] = "-ab";
421 argv[argc++] = "foo";
422 argv[argc++] = "bar";
425 getopt_long_loop (argc, argv, "ab", long_options_required,
427 &non_options_count, non_options, &unrecognized);
428 ASSERT (a_seen == 2);
429 ASSERT (b_seen == 1);
430 ASSERT (p_value == NULL);
431 ASSERT (q_value == NULL);
432 ASSERT (non_options_count == 0);
433 ASSERT (unrecognized == 0);
434 ASSERT (optind == 3);
437 /* Test processing of boolean long options. */
438 for (start = 0; start <= 1; start++)
440 const char *p_value = NULL;
441 const char *q_value = NULL;
442 int non_options_count = 0;
443 const char *non_options[10];
444 int unrecognized = 0;
446 const char *argv[10];
450 argv[argc++] = "program";
451 argv[argc++] = "--alpha";
452 argv[argc++] = "foo";
453 argv[argc++] = "bar";
456 getopt_long_loop (argc, argv, "ab", long_options_required,
458 &non_options_count, non_options, &unrecognized);
459 ASSERT (a_seen == 1);
460 ASSERT (b_seen == 0);
461 ASSERT (p_value == NULL);
462 ASSERT (q_value == NULL);
463 ASSERT (non_options_count == 0);
464 ASSERT (unrecognized == 0);
465 ASSERT (optind == 2);
467 for (start = 0; start <= 1; start++)
469 const char *p_value = NULL;
470 const char *q_value = NULL;
471 int non_options_count = 0;
472 const char *non_options[10];
473 int unrecognized = 0;
475 const char *argv[10];
479 argv[argc++] = "program";
480 argv[argc++] = "--beta";
481 argv[argc++] = "--alpha";
482 argv[argc++] = "foo";
483 argv[argc++] = "bar";
486 getopt_long_loop (argc, argv, "ab", long_options_required,
488 &non_options_count, non_options, &unrecognized);
489 ASSERT (a_seen == 1);
490 ASSERT (b_seen == 1);
491 ASSERT (p_value == NULL);
492 ASSERT (q_value == NULL);
493 ASSERT (non_options_count == 0);
494 ASSERT (unrecognized == 0);
495 ASSERT (optind == 3);
497 for (start = 0; start <= 1; start++)
499 const char *p_value = NULL;
500 const char *q_value = NULL;
501 int non_options_count = 0;
502 const char *non_options[10];
503 int unrecognized = 0;
505 const char *argv[10];
509 argv[argc++] = "program";
510 argv[argc++] = "--alpha";
511 argv[argc++] = "--beta";
512 argv[argc++] = "--alpha";
513 argv[argc++] = "--beta";
514 argv[argc++] = "foo";
515 argv[argc++] = "bar";
518 getopt_long_loop (argc, argv, "ab", long_options_required,
520 &non_options_count, non_options, &unrecognized);
521 ASSERT (a_seen == 2);
522 ASSERT (b_seen == 1);
523 ASSERT (p_value == NULL);
524 ASSERT (q_value == NULL);
525 ASSERT (non_options_count == 0);
526 ASSERT (unrecognized == 0);
527 ASSERT (optind == 5);
530 /* Test processing of boolean long options via -W. */
531 for (start = 0; start <= 1; start++)
533 const char *p_value = NULL;
534 const char *q_value = NULL;
535 int non_options_count = 0;
536 const char *non_options[10];
537 int unrecognized = 0;
539 const char *argv[10];
543 argv[argc++] = "program";
544 argv[argc++] = "-Walpha";
545 argv[argc++] = "foo";
546 argv[argc++] = "bar";
549 getopt_long_loop (argc, argv, "abW;", long_options_required,
551 &non_options_count, non_options, &unrecognized);
552 ASSERT (a_seen == 1);
553 ASSERT (b_seen == 0);
554 ASSERT (p_value == NULL);
555 ASSERT (q_value == NULL);
556 ASSERT (non_options_count == 0);
557 ASSERT (unrecognized == 0);
558 ASSERT (optind == 2);
560 for (start = 0; start <= 1; start++)
562 const char *p_value = NULL;
563 const char *q_value = NULL;
564 int non_options_count = 0;
565 const char *non_options[10];
566 int unrecognized = 0;
568 const char *argv[10];
572 argv[argc++] = "program";
574 argv[argc++] = "beta";
576 argv[argc++] = "alpha";
577 argv[argc++] = "foo";
578 argv[argc++] = "bar";
581 getopt_long_loop (argc, argv, "aW;b", long_options_required,
583 &non_options_count, non_options, &unrecognized);
584 ASSERT (a_seen == 1);
585 ASSERT (b_seen == 1);
586 ASSERT (p_value == NULL);
587 ASSERT (q_value == NULL);
588 ASSERT (non_options_count == 0);
589 ASSERT (unrecognized == 0);
590 ASSERT (optind == 5);
592 for (start = 0; start <= 1; start++)
594 const char *p_value = NULL;
595 const char *q_value = NULL;
596 int non_options_count = 0;
597 const char *non_options[10];
598 int unrecognized = 0;
600 const char *argv[10];
604 argv[argc++] = "program";
605 argv[argc++] = "-Walpha";
606 argv[argc++] = "-Wbeta";
607 argv[argc++] = "-Walpha";
608 argv[argc++] = "-Wbeta";
609 argv[argc++] = "foo";
610 argv[argc++] = "bar";
613 getopt_long_loop (argc, argv, "W;ab", long_options_required,
615 &non_options_count, non_options, &unrecognized);
616 ASSERT (a_seen == 2);
617 ASSERT (b_seen == 1);
618 ASSERT (p_value == NULL);
619 ASSERT (q_value == NULL);
620 ASSERT (non_options_count == 0);
621 ASSERT (unrecognized == 0);
622 ASSERT (optind == 5);
625 /* Test processing of short options with arguments. */
626 for (start = 0; start <= 1; start++)
628 const char *p_value = NULL;
629 const char *q_value = NULL;
630 int non_options_count = 0;
631 const char *non_options[10];
632 int unrecognized = 0;
634 const char *argv[10];
638 argv[argc++] = "program";
639 argv[argc++] = "-pfoo";
640 argv[argc++] = "bar";
643 getopt_long_loop (argc, argv, "p:q:", long_options_required,
645 &non_options_count, non_options, &unrecognized);
646 ASSERT (a_seen == 0);
647 ASSERT (b_seen == 0);
648 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
649 ASSERT (q_value == NULL);
650 ASSERT (non_options_count == 0);
651 ASSERT (unrecognized == 0);
652 ASSERT (optind == 2);
654 for (start = 0; start <= 1; start++)
656 const char *p_value = NULL;
657 const char *q_value = NULL;
658 int non_options_count = 0;
659 const char *non_options[10];
660 int unrecognized = 0;
662 const char *argv[10];
666 argv[argc++] = "program";
668 argv[argc++] = "foo";
669 argv[argc++] = "bar";
672 getopt_long_loop (argc, argv, "p:q:", long_options_required,
674 &non_options_count, non_options, &unrecognized);
675 ASSERT (a_seen == 0);
676 ASSERT (b_seen == 0);
677 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
678 ASSERT (q_value == NULL);
679 ASSERT (non_options_count == 0);
680 ASSERT (unrecognized == 0);
681 ASSERT (optind == 3);
683 for (start = 0; 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[10];
695 argv[argc++] = "program";
696 argv[argc++] = "-ab";
698 argv[argc++] = "baz";
699 argv[argc++] = "-pfoo";
700 argv[argc++] = "bar";
703 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
705 &non_options_count, non_options, &unrecognized);
706 ASSERT (a_seen == 1);
707 ASSERT (b_seen == 1);
708 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
709 ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
710 ASSERT (non_options_count == 0);
711 ASSERT (unrecognized == 0);
712 ASSERT (optind == 5);
715 /* Test processing of long options with arguments. */
716 for (start = 0; start <= 1; start++)
718 const char *p_value = NULL;
719 const char *q_value = NULL;
720 int non_options_count = 0;
721 const char *non_options[10];
722 int unrecognized = 0;
724 const char *argv[10];
728 argv[argc++] = "program";
729 argv[argc++] = "--p=foo";
730 argv[argc++] = "bar";
733 getopt_long_loop (argc, argv, "p:q:", long_options_required,
735 &non_options_count, non_options, &unrecognized);
736 ASSERT (a_seen == 0);
737 ASSERT (b_seen == 0);
738 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
739 ASSERT (q_value == NULL);
740 ASSERT (non_options_count == 0);
741 ASSERT (unrecognized == 0);
742 ASSERT (optind == 2);
744 for (start = 0; start <= 1; start++)
746 const char *p_value = NULL;
747 const char *q_value = NULL;
748 int non_options_count = 0;
749 const char *non_options[10];
750 int unrecognized = 0;
752 const char *argv[10];
756 argv[argc++] = "program";
757 argv[argc++] = "--p";
758 argv[argc++] = "foo";
759 argv[argc++] = "bar";
762 getopt_long_loop (argc, argv, "p:q:", long_options_required,
764 &non_options_count, non_options, &unrecognized);
765 ASSERT (a_seen == 0);
766 ASSERT (b_seen == 0);
767 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
768 ASSERT (q_value == NULL);
769 ASSERT (non_options_count == 0);
770 ASSERT (unrecognized == 0);
771 ASSERT (optind == 3);
773 for (start = 0; start <= 1; start++)
775 const char *p_value = NULL;
776 const char *q_value = NULL;
777 int non_options_count = 0;
778 const char *non_options[10];
779 int unrecognized = 0;
781 const char *argv[10];
785 argv[argc++] = "program";
786 argv[argc++] = "-ab";
787 argv[argc++] = "--q";
788 argv[argc++] = "baz";
789 argv[argc++] = "--p=foo";
790 argv[argc++] = "bar";
793 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
795 &non_options_count, non_options, &unrecognized);
796 ASSERT (a_seen == 1);
797 ASSERT (b_seen == 1);
798 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
799 ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
800 ASSERT (non_options_count == 0);
801 ASSERT (unrecognized == 0);
802 ASSERT (optind == 5);
805 /* Test processing of long options with arguments via -W. */
806 for (start = 0; start <= 1; start++)
808 const char *p_value = NULL;
809 const char *q_value = NULL;
810 int non_options_count = 0;
811 const char *non_options[10];
812 int unrecognized = 0;
814 const char *argv[10];
818 argv[argc++] = "program";
819 argv[argc++] = "-Wp=foo";
820 argv[argc++] = "bar";
823 getopt_long_loop (argc, argv, "p:q:W;", long_options_required,
825 &non_options_count, non_options, &unrecognized);
826 ASSERT (a_seen == 0);
827 ASSERT (b_seen == 0);
828 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
829 ASSERT (q_value == NULL);
830 ASSERT (non_options_count == 0);
831 ASSERT (unrecognized == 0);
832 ASSERT (optind == 2);
834 for (start = 0; start <= 1; start++)
836 const char *p_value = NULL;
837 const char *q_value = NULL;
838 int non_options_count = 0;
839 const char *non_options[10];
840 int unrecognized = 0;
842 const char *argv[10];
846 argv[argc++] = "program";
849 argv[argc++] = "foo";
850 argv[argc++] = "bar";
853 getopt_long_loop (argc, argv, "p:W;q:", long_options_required,
855 &non_options_count, non_options, &unrecognized);
856 ASSERT (a_seen == 0);
857 ASSERT (b_seen == 0);
858 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
859 ASSERT (q_value == NULL);
860 ASSERT (non_options_count == 0);
861 ASSERT (unrecognized == 0);
862 ASSERT (optind == 4);
864 for (start = 0; start <= 1; start++)
866 const char *p_value = NULL;
867 const char *q_value = NULL;
868 int non_options_count = 0;
869 const char *non_options[10];
870 int unrecognized = 0;
872 const char *argv[10];
876 argv[argc++] = "program";
877 argv[argc++] = "-ab";
878 argv[argc++] = "-Wq";
879 argv[argc++] = "baz";
881 argv[argc++] = "p=foo";
882 argv[argc++] = "bar";
885 getopt_long_loop (argc, argv, "W;abp:q:", long_options_required,
887 &non_options_count, non_options, &unrecognized);
888 ASSERT (a_seen == 1);
889 ASSERT (b_seen == 1);
890 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
891 ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
892 ASSERT (non_options_count == 0);
893 ASSERT (unrecognized == 0);
894 ASSERT (optind == 6);
897 /* Test processing of short options with optional arguments. */
898 for (start = 0; start <= 1; start++)
900 const char *p_value = NULL;
901 const char *q_value = NULL;
902 int non_options_count = 0;
903 const char *non_options[10];
904 int unrecognized = 0;
906 const char *argv[10];
910 argv[argc++] = "program";
911 argv[argc++] = "-pfoo";
912 argv[argc++] = "bar";
915 getopt_long_loop (argc, argv, "p::q::", long_options_optional,
917 &non_options_count, non_options, &unrecognized);
918 ASSERT (a_seen == 0);
919 ASSERT (b_seen == 0);
920 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
921 ASSERT (q_value == NULL);
922 ASSERT (non_options_count == 0);
923 ASSERT (unrecognized == 0);
924 ASSERT (optind == 2);
926 for (start = 0; start <= 1; start++)
928 const char *p_value = NULL;
929 const char *q_value = NULL;
930 int non_options_count = 0;
931 const char *non_options[10];
932 int unrecognized = 0;
934 const char *argv[10];
938 argv[argc++] = "program";
940 argv[argc++] = "foo";
941 argv[argc++] = "bar";
944 getopt_long_loop (argc, argv, "p::q::", long_options_optional,
946 &non_options_count, non_options, &unrecognized);
947 ASSERT (a_seen == 0);
948 ASSERT (b_seen == 0);
949 ASSERT (p_value == NULL);
950 ASSERT (q_value == NULL);
951 ASSERT (non_options_count == 0);
952 ASSERT (unrecognized == 0);
953 ASSERT (optind == 2);
955 for (start = 0; start <= 1; start++)
957 const char *p_value = NULL;
958 const char *q_value = NULL;
959 int non_options_count = 0;
960 const char *non_options[10];
961 int unrecognized = 0;
963 const char *argv[10];
967 argv[argc++] = "program";
970 argv[argc++] = "bar";
973 getopt_long_loop (argc, argv, "abp::q::", long_options_optional,
975 &non_options_count, non_options, &unrecognized);
976 ASSERT (a_seen == 1);
977 ASSERT (b_seen == 0);
978 ASSERT (p_value == NULL);
979 ASSERT (q_value == NULL);
980 ASSERT (non_options_count == 0);
981 ASSERT (unrecognized == 0);
982 ASSERT (optind == 3);
985 /* Test processing of long options with optional arguments. */
986 for (start = 0; start <= 1; start++)
988 const char *p_value = NULL;
989 const char *q_value = NULL;
990 int non_options_count = 0;
991 const char *non_options[10];
992 int unrecognized = 0;
994 const char *argv[10];
998 argv[argc++] = "program";
999 argv[argc++] = "--p=foo";
1000 argv[argc++] = "bar";
1003 getopt_long_loop (argc, argv, "p::q::", long_options_optional,
1005 &non_options_count, non_options, &unrecognized);
1006 ASSERT (a_seen == 0);
1007 ASSERT (b_seen == 0);
1008 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1009 ASSERT (q_value == NULL);
1010 ASSERT (non_options_count == 0);
1011 ASSERT (unrecognized == 0);
1012 ASSERT (optind == 2);
1014 for (start = 0; start <= 1; start++)
1016 const char *p_value = NULL;
1017 const char *q_value = NULL;
1018 int non_options_count = 0;
1019 const char *non_options[10];
1020 int unrecognized = 0;
1022 const char *argv[10];
1026 argv[argc++] = "program";
1027 argv[argc++] = "--p";
1028 argv[argc++] = "foo";
1029 argv[argc++] = "bar";
1032 getopt_long_loop (argc, argv, "p::q::", long_options_optional,
1034 &non_options_count, non_options, &unrecognized);
1035 ASSERT (a_seen == 0);
1036 ASSERT (b_seen == 0);
1037 ASSERT (p_value == NULL);
1038 ASSERT (q_value == NULL);
1039 ASSERT (non_options_count == 0);
1040 ASSERT (unrecognized == 0);
1041 ASSERT (optind == 2);
1043 for (start = 0; start <= 1; start++)
1045 const char *p_value = NULL;
1046 const char *q_value = NULL;
1047 int non_options_count = 0;
1048 const char *non_options[10];
1049 int unrecognized = 0;
1051 const char *argv[10];
1055 argv[argc++] = "program";
1056 argv[argc++] = "--p=";
1057 argv[argc++] = "foo";
1058 argv[argc++] = "bar";
1061 getopt_long_loop (argc, argv, "p::q::", long_options_optional,
1063 &non_options_count, non_options, &unrecognized);
1064 ASSERT (a_seen == 0);
1065 ASSERT (b_seen == 0);
1066 ASSERT (p_value != NULL && *p_value == '\0');
1067 ASSERT (q_value == NULL);
1068 ASSERT (non_options_count == 0);
1069 ASSERT (unrecognized == 0);
1070 ASSERT (optind == 2);
1072 for (start = 0; start <= 1; start++)
1074 const char *p_value = NULL;
1075 const char *q_value = NULL;
1076 int non_options_count = 0;
1077 const char *non_options[10];
1078 int unrecognized = 0;
1080 const char *argv[10];
1084 argv[argc++] = "program";
1085 argv[argc++] = "--p";
1086 argv[argc++] = "-a";
1087 argv[argc++] = "bar";
1090 getopt_long_loop (argc, argv, "abp::q::", long_options_optional,
1092 &non_options_count, non_options, &unrecognized);
1093 ASSERT (a_seen == 1);
1094 ASSERT (b_seen == 0);
1095 ASSERT (p_value == NULL);
1096 ASSERT (q_value == NULL);
1097 ASSERT (non_options_count == 0);
1098 ASSERT (unrecognized == 0);
1099 ASSERT (optind == 3);
1102 /* Test processing of long options with optional arguments via -W. */
1103 for (start = 0; start <= 1; start++)
1105 const char *p_value = NULL;
1106 const char *q_value = NULL;
1107 int non_options_count = 0;
1108 const char *non_options[10];
1109 int unrecognized = 0;
1111 const char *argv[10];
1115 argv[argc++] = "program";
1116 argv[argc++] = "-Wp=foo";
1117 argv[argc++] = "bar";
1120 getopt_long_loop (argc, argv, "p::q::W;", long_options_optional,
1122 &non_options_count, non_options, &unrecognized);
1123 ASSERT (a_seen == 0);
1124 ASSERT (b_seen == 0);
1125 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1126 ASSERT (q_value == NULL);
1127 ASSERT (non_options_count == 0);
1128 ASSERT (unrecognized == 0);
1129 ASSERT (optind == 2);
1131 for (start = 0; start <= 1; start++)
1133 const char *p_value = NULL;
1134 const char *q_value = NULL;
1135 int non_options_count = 0;
1136 const char *non_options[10];
1137 int unrecognized = 0;
1139 const char *argv[10];
1143 argv[argc++] = "program";
1144 argv[argc++] = "-Wp";
1145 argv[argc++] = "foo";
1146 argv[argc++] = "bar";
1149 getopt_long_loop (argc, argv, "p::q::W;", long_options_optional,
1151 &non_options_count, non_options, &unrecognized);
1152 ASSERT (a_seen == 0);
1153 ASSERT (b_seen == 0);
1154 /* glibc bug http://sources.redhat.com/bugzilla/show_bug.cgi?id=11041 */
1155 /* ASSERT (p_value == NULL); */
1156 ASSERT (q_value == NULL);
1157 ASSERT (non_options_count == 0);
1158 ASSERT (unrecognized == 0);
1159 ASSERT (optind == 2);
1161 for (start = 0; start <= 1; start++)
1163 const char *p_value = NULL;
1164 const char *q_value = NULL;
1165 int non_options_count = 0;
1166 const char *non_options[10];
1167 int unrecognized = 0;
1169 const char *argv[10];
1173 argv[argc++] = "program";
1174 argv[argc++] = "-Wp=";
1175 argv[argc++] = "foo";
1176 argv[argc++] = "bar";
1179 getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1181 &non_options_count, non_options, &unrecognized);
1182 ASSERT (a_seen == 0);
1183 ASSERT (b_seen == 0);
1184 ASSERT (p_value != NULL && *p_value == '\0');
1185 ASSERT (q_value == NULL);
1186 ASSERT (non_options_count == 0);
1187 ASSERT (unrecognized == 0);
1188 ASSERT (optind == 2);
1190 for (start = 0; start <= 1; start++)
1192 const char *p_value = NULL;
1193 const char *q_value = NULL;
1194 int non_options_count = 0;
1195 const char *non_options[10];
1196 int unrecognized = 0;
1198 const char *argv[10];
1202 argv[argc++] = "program";
1203 argv[argc++] = "-W";
1204 argv[argc++] = "p=";
1205 argv[argc++] = "foo";
1206 argv[argc++] = "bar";
1209 getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1211 &non_options_count, non_options, &unrecognized);
1212 ASSERT (a_seen == 0);
1213 ASSERT (b_seen == 0);
1214 ASSERT (p_value != NULL && *p_value == '\0');
1215 ASSERT (q_value == NULL);
1216 ASSERT (non_options_count == 0);
1217 ASSERT (unrecognized == 0);
1218 ASSERT (optind == 3);
1220 for (start = 0; start <= 1; start++)
1222 const char *p_value = NULL;
1223 const char *q_value = NULL;
1224 int non_options_count = 0;
1225 const char *non_options[10];
1226 int unrecognized = 0;
1228 const char *argv[10];
1232 argv[argc++] = "program";
1233 argv[argc++] = "-W";
1235 argv[argc++] = "-a";
1236 argv[argc++] = "bar";
1239 getopt_long_loop (argc, argv, "W;abp::q::", long_options_optional,
1241 &non_options_count, non_options, &unrecognized);
1242 ASSERT (a_seen == 1);
1243 ASSERT (b_seen == 0);
1244 /* ASSERT (p_value == NULL); */
1245 ASSERT (q_value == NULL);
1246 ASSERT (non_options_count == 0);
1247 ASSERT (unrecognized == 0);
1248 ASSERT (optind == 4);
1251 /* Check that invalid options are recognized. */
1252 for (start = 0; start <= 1; start++)
1254 const char *p_value = NULL;
1255 const char *q_value = NULL;
1256 int non_options_count = 0;
1257 const char *non_options[10];
1258 int unrecognized = 0;
1260 const char *argv[10];
1264 argv[argc++] = "program";
1265 argv[argc++] = "-p";
1266 argv[argc++] = "foo";
1267 argv[argc++] = "-x";
1268 argv[argc++] = "-a";
1269 argv[argc++] = "bar";
1272 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1274 &non_options_count, non_options, &unrecognized);
1275 ASSERT (a_seen == 1);
1276 ASSERT (b_seen == 0);
1277 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1278 ASSERT (q_value == NULL);
1279 ASSERT (non_options_count == 0);
1280 ASSERT (unrecognized == 'x');
1281 ASSERT (optind == 5);
1283 for (start = 0; start <= 1; start++)
1285 const char *p_value = NULL;
1286 const char *q_value = NULL;
1287 int non_options_count = 0;
1288 const char *non_options[10];
1289 int unrecognized = 0;
1291 const char *argv[10];
1295 argv[argc++] = "program";
1296 argv[argc++] = "-p";
1297 argv[argc++] = "foo";
1298 argv[argc++] = "-:";
1299 argv[argc++] = "-a";
1300 argv[argc++] = "bar";
1303 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1305 &non_options_count, non_options, &unrecognized);
1306 ASSERT (a_seen == 1);
1307 ASSERT (b_seen == 0);
1308 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1309 ASSERT (q_value == NULL);
1310 ASSERT (non_options_count == 0);
1311 ASSERT (unrecognized == ':');
1312 ASSERT (optind == 5);
1315 /* Check that unexpected arguments are recognized. */
1316 for (start = 0; start <= 1; start++)
1318 const char *p_value = NULL;
1319 const char *q_value = NULL;
1320 int non_options_count = 0;
1321 const char *non_options[10];
1322 int unrecognized = 0;
1324 const char *argv[10];
1328 argv[argc++] = "program";
1329 argv[argc++] = "-p";
1330 argv[argc++] = "foo";
1331 argv[argc++] = "--a=";
1332 argv[argc++] = "bar";
1335 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1337 &non_options_count, non_options, &unrecognized);
1338 ASSERT (a_seen == 0);
1339 ASSERT (b_seen == 0);
1340 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1341 ASSERT (q_value == NULL);
1342 ASSERT (non_options_count == 0);
1343 ASSERT (unrecognized == 'a');
1344 ASSERT (optind == 4);
1346 for (start = 0; start <= 1; start++)
1348 const char *p_value = NULL;
1349 const char *q_value = NULL;
1350 int non_options_count = 0;
1351 const char *non_options[10];
1352 int unrecognized = 0;
1354 const char *argv[10];
1358 argv[argc++] = "program";
1359 argv[argc++] = "-p";
1360 argv[argc++] = "foo";
1361 argv[argc++] = "--b=";
1362 argv[argc++] = "bar";
1365 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1367 &non_options_count, non_options, &unrecognized);
1368 ASSERT (a_seen == 0);
1369 ASSERT (b_seen == 0);
1370 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1371 ASSERT (q_value == NULL);
1372 ASSERT (non_options_count == 0);
1373 /* When flag is non-zero, glibc sets optopt anyway, but BSD
1374 leaves optopt unchanged. */
1375 ASSERT (unrecognized == 1 || unrecognized == 0);
1376 ASSERT (optind == 4);
1379 /* Check that by default, non-options arguments are moved to the end. */
1380 for (start = 0; start <= 1; start++)
1382 const char *p_value = NULL;
1383 const char *q_value = NULL;
1384 int non_options_count = 0;
1385 const char *non_options[10];
1386 int unrecognized = 0;
1388 const char *argv[10];
1392 argv[argc++] = "program";
1393 argv[argc++] = "donald";
1394 argv[argc++] = "-p";
1395 argv[argc++] = "billy";
1396 argv[argc++] = "duck";
1397 argv[argc++] = "-a";
1398 argv[argc++] = "bar";
1401 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1403 &non_options_count, non_options, &unrecognized);
1404 ASSERT (strcmp (argv[0], "program") == 0);
1405 ASSERT (strcmp (argv[1], "-p") == 0);
1406 ASSERT (strcmp (argv[2], "billy") == 0);
1407 ASSERT (strcmp (argv[3], "-a") == 0);
1408 ASSERT (strcmp (argv[4], "donald") == 0);
1409 ASSERT (strcmp (argv[5], "duck") == 0);
1410 ASSERT (strcmp (argv[6], "bar") == 0);
1411 ASSERT (argv[7] == NULL);
1412 ASSERT (a_seen == 1);
1413 ASSERT (b_seen == 0);
1414 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1415 ASSERT (q_value == NULL);
1416 ASSERT (non_options_count == 0);
1417 ASSERT (unrecognized == 0);
1418 ASSERT (optind == 4);
1421 /* Check that '--' ends the argument processing. */
1422 for (start = 0; start <= 1; start++)
1424 const char *p_value = NULL;
1425 const char *q_value = NULL;
1426 int non_options_count = 0;
1427 const char *non_options[10];
1428 int unrecognized = 0;
1430 const char *argv[20];
1434 argv[argc++] = "program";
1435 argv[argc++] = "donald";
1436 argv[argc++] = "-p";
1437 argv[argc++] = "billy";
1438 argv[argc++] = "duck";
1439 argv[argc++] = "-a";
1440 argv[argc++] = "--";
1441 argv[argc++] = "-b";
1442 argv[argc++] = "foo";
1443 argv[argc++] = "-q";
1444 argv[argc++] = "johnny";
1445 argv[argc++] = "bar";
1448 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1450 &non_options_count, non_options, &unrecognized);
1451 ASSERT (strcmp (argv[0], "program") == 0);
1452 ASSERT (strcmp (argv[1], "-p") == 0);
1453 ASSERT (strcmp (argv[2], "billy") == 0);
1454 ASSERT (strcmp (argv[3], "-a") == 0);
1455 ASSERT (strcmp (argv[4], "--") == 0);
1456 ASSERT (strcmp (argv[5], "donald") == 0);
1457 ASSERT (strcmp (argv[6], "duck") == 0);
1458 ASSERT (strcmp (argv[7], "-b") == 0);
1459 ASSERT (strcmp (argv[8], "foo") == 0);
1460 ASSERT (strcmp (argv[9], "-q") == 0);
1461 ASSERT (strcmp (argv[10], "johnny") == 0);
1462 ASSERT (strcmp (argv[11], "bar") == 0);
1463 ASSERT (argv[12] == NULL);
1464 ASSERT (a_seen == 1);
1465 ASSERT (b_seen == 0);
1466 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1467 ASSERT (q_value == NULL);
1468 ASSERT (non_options_count == 0);
1469 ASSERT (unrecognized == 0);
1470 ASSERT (optind == 5);
1473 /* Check that the '-' flag causes non-options to be returned in order. */
1474 for (start = 0; start <= 1; start++)
1476 const char *p_value = NULL;
1477 const char *q_value = NULL;
1478 int non_options_count = 0;
1479 const char *non_options[10];
1480 int unrecognized = 0;
1482 const char *argv[10];
1486 argv[argc++] = "program";
1487 argv[argc++] = "donald";
1488 argv[argc++] = "-p";
1489 argv[argc++] = "billy";
1490 argv[argc++] = "duck";
1491 argv[argc++] = "-a";
1492 argv[argc++] = "bar";
1495 getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1497 &non_options_count, non_options, &unrecognized);
1498 ASSERT (strcmp (argv[0], "program") == 0);
1499 ASSERT (strcmp (argv[1], "donald") == 0);
1500 ASSERT (strcmp (argv[2], "-p") == 0);
1501 ASSERT (strcmp (argv[3], "billy") == 0);
1502 ASSERT (strcmp (argv[4], "duck") == 0);
1503 ASSERT (strcmp (argv[5], "-a") == 0);
1504 ASSERT (strcmp (argv[6], "bar") == 0);
1505 ASSERT (argv[7] == NULL);
1506 ASSERT (a_seen == 1);
1507 ASSERT (b_seen == 0);
1508 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1509 ASSERT (q_value == NULL);
1510 ASSERT (non_options_count == 3);
1511 ASSERT (strcmp (non_options[0], "donald") == 0);
1512 ASSERT (strcmp (non_options[1], "duck") == 0);
1513 ASSERT (strcmp (non_options[2], "bar") == 0);
1514 ASSERT (unrecognized == 0);
1515 ASSERT (optind == 7);
1518 /* Check that '--' ends the argument processing. */
1519 for (start = 0; start <= 1; start++)
1521 const char *p_value = NULL;
1522 const char *q_value = NULL;
1523 int non_options_count = 0;
1524 const char *non_options[10];
1525 int unrecognized = 0;
1527 const char *argv[20];
1531 argv[argc++] = "program";
1532 argv[argc++] = "donald";
1533 argv[argc++] = "-p";
1534 argv[argc++] = "billy";
1535 argv[argc++] = "duck";
1536 argv[argc++] = "-a";
1537 argv[argc++] = "--";
1538 argv[argc++] = "-b";
1539 argv[argc++] = "foo";
1540 argv[argc++] = "-q";
1541 argv[argc++] = "johnny";
1542 argv[argc++] = "bar";
1545 getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1547 &non_options_count, non_options, &unrecognized);
1548 ASSERT (strcmp (argv[0], "program") == 0);
1549 ASSERT (strcmp (argv[1], "donald") == 0);
1550 ASSERT (strcmp (argv[2], "-p") == 0);
1551 ASSERT (strcmp (argv[3], "billy") == 0);
1552 ASSERT (strcmp (argv[4], "duck") == 0);
1553 ASSERT (strcmp (argv[5], "-a") == 0);
1554 ASSERT (strcmp (argv[6], "--") == 0);
1555 ASSERT (strcmp (argv[7], "-b") == 0);
1556 ASSERT (strcmp (argv[8], "foo") == 0);
1557 ASSERT (strcmp (argv[9], "-q") == 0);
1558 ASSERT (strcmp (argv[10], "johnny") == 0);
1559 ASSERT (strcmp (argv[11], "bar") == 0);
1560 ASSERT (argv[12] == NULL);
1561 ASSERT (a_seen == 1);
1562 ASSERT (b_seen == 0);
1563 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1564 ASSERT (q_value == NULL);
1565 if (non_options_count == 2)
1567 /* glibc behaviour. */
1568 ASSERT (non_options_count == 2);
1569 ASSERT (strcmp (non_options[0], "donald") == 0);
1570 ASSERT (strcmp (non_options[1], "duck") == 0);
1571 ASSERT (unrecognized == 0);
1572 ASSERT (optind == 7);
1576 /* Another valid behaviour. */
1577 ASSERT (non_options_count == 7);
1578 ASSERT (strcmp (non_options[0], "donald") == 0);
1579 ASSERT (strcmp (non_options[1], "duck") == 0);
1580 ASSERT (strcmp (non_options[2], "-b") == 0);
1581 ASSERT (strcmp (non_options[3], "foo") == 0);
1582 ASSERT (strcmp (non_options[4], "-q") == 0);
1583 ASSERT (strcmp (non_options[5], "johnny") == 0);
1584 ASSERT (strcmp (non_options[6], "bar") == 0);
1585 ASSERT (unrecognized == 0);
1586 ASSERT (optind == 12);
1590 /* Check that the '-' flag has to come first. */
1591 for (start = 0; start <= 1; start++)
1593 const char *p_value = NULL;
1594 const char *q_value = NULL;
1595 int non_options_count = 0;
1596 const char *non_options[10];
1597 int unrecognized = 0;
1599 const char *argv[10];
1603 argv[argc++] = "program";
1604 argv[argc++] = "donald";
1605 argv[argc++] = "-p";
1606 argv[argc++] = "billy";
1607 argv[argc++] = "duck";
1608 argv[argc++] = "-a";
1609 argv[argc++] = "bar";
1612 getopt_long_loop (argc, argv, "abp:q:-", long_options_required,
1614 &non_options_count, non_options, &unrecognized);
1615 ASSERT (strcmp (argv[0], "program") == 0);
1616 ASSERT (strcmp (argv[1], "-p") == 0);
1617 ASSERT (strcmp (argv[2], "billy") == 0);
1618 ASSERT (strcmp (argv[3], "-a") == 0);
1619 ASSERT (strcmp (argv[4], "donald") == 0);
1620 ASSERT (strcmp (argv[5], "duck") == 0);
1621 ASSERT (strcmp (argv[6], "bar") == 0);
1622 ASSERT (argv[7] == NULL);
1623 ASSERT (a_seen == 1);
1624 ASSERT (b_seen == 0);
1625 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1626 ASSERT (q_value == NULL);
1627 ASSERT (non_options_count == 0);
1628 ASSERT (unrecognized == 0);
1629 ASSERT (optind == 4);
1632 /* Check that the '+' flag causes the first non-option to terminate the
1634 for (start = 0; start <= 1; start++)
1636 const char *p_value = NULL;
1637 const char *q_value = NULL;
1638 int non_options_count = 0;
1639 const char *non_options[10];
1640 int unrecognized = 0;
1642 const char *argv[10];
1646 argv[argc++] = "program";
1647 argv[argc++] = "donald";
1648 argv[argc++] = "-p";
1649 argv[argc++] = "billy";
1650 argv[argc++] = "duck";
1651 argv[argc++] = "-a";
1652 argv[argc++] = "bar";
1655 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1657 &non_options_count, non_options, &unrecognized);
1658 ASSERT (strcmp (argv[0], "program") == 0);
1659 ASSERT (strcmp (argv[1], "donald") == 0);
1660 ASSERT (strcmp (argv[2], "-p") == 0);
1661 ASSERT (strcmp (argv[3], "billy") == 0);
1662 ASSERT (strcmp (argv[4], "duck") == 0);
1663 ASSERT (strcmp (argv[5], "-a") == 0);
1664 ASSERT (strcmp (argv[6], "bar") == 0);
1665 ASSERT (argv[7] == NULL);
1666 ASSERT (a_seen == 0);
1667 ASSERT (b_seen == 0);
1668 ASSERT (p_value == NULL);
1669 ASSERT (q_value == NULL);
1670 ASSERT (non_options_count == 0);
1671 ASSERT (unrecognized == 0);
1672 ASSERT (optind == 1);
1674 for (start = 0; start <= 1; start++)
1676 const char *p_value = NULL;
1677 const char *q_value = NULL;
1678 int non_options_count = 0;
1679 const char *non_options[10];
1680 int unrecognized = 0;
1682 const char *argv[10];
1686 argv[argc++] = "program";
1687 argv[argc++] = "-+";
1690 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1692 &non_options_count, non_options, &unrecognized);
1693 ASSERT (a_seen == 0);
1694 ASSERT (b_seen == 0);
1695 ASSERT (p_value == NULL);
1696 ASSERT (q_value == NULL);
1697 ASSERT (non_options_count == 0);
1698 ASSERT (unrecognized == '+');
1699 ASSERT (optind == 2);
1702 /* Check that '--' ends the argument processing. */
1703 for (start = 0; start <= 1; start++)
1705 const char *p_value = NULL;
1706 const char *q_value = NULL;
1707 int non_options_count = 0;
1708 const char *non_options[10];
1709 int unrecognized = 0;
1711 const char *argv[20];
1715 argv[argc++] = "program";
1716 argv[argc++] = "donald";
1717 argv[argc++] = "-p";
1718 argv[argc++] = "billy";
1719 argv[argc++] = "duck";
1720 argv[argc++] = "-a";
1721 argv[argc++] = "--";
1722 argv[argc++] = "-b";
1723 argv[argc++] = "foo";
1724 argv[argc++] = "-q";
1725 argv[argc++] = "johnny";
1726 argv[argc++] = "bar";
1729 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1731 &non_options_count, non_options, &unrecognized);
1732 ASSERT (strcmp (argv[0], "program") == 0);
1733 ASSERT (strcmp (argv[1], "donald") == 0);
1734 ASSERT (strcmp (argv[2], "-p") == 0);
1735 ASSERT (strcmp (argv[3], "billy") == 0);
1736 ASSERT (strcmp (argv[4], "duck") == 0);
1737 ASSERT (strcmp (argv[5], "-a") == 0);
1738 ASSERT (strcmp (argv[6], "--") == 0);
1739 ASSERT (strcmp (argv[7], "-b") == 0);
1740 ASSERT (strcmp (argv[8], "foo") == 0);
1741 ASSERT (strcmp (argv[9], "-q") == 0);
1742 ASSERT (strcmp (argv[10], "johnny") == 0);
1743 ASSERT (strcmp (argv[11], "bar") == 0);
1744 ASSERT (argv[12] == NULL);
1745 ASSERT (a_seen == 0);
1746 ASSERT (b_seen == 0);
1747 ASSERT (p_value == NULL);
1748 ASSERT (q_value == NULL);
1749 ASSERT (non_options_count == 0);
1750 ASSERT (unrecognized == 0);
1751 ASSERT (optind = 1);
1754 /* Check that the '+' flag has to come first. */
1755 for (start = 0; start <= 1; start++)
1757 const char *p_value = NULL;
1758 const char *q_value = NULL;
1759 int non_options_count = 0;
1760 const char *non_options[10];
1761 int unrecognized = 0;
1763 const char *argv[10];
1767 argv[argc++] = "program";
1768 argv[argc++] = "donald";
1769 argv[argc++] = "-p";
1770 argv[argc++] = "billy";
1771 argv[argc++] = "duck";
1772 argv[argc++] = "-a";
1773 argv[argc++] = "bar";
1776 getopt_long_loop (argc, argv, "abp:q:+", long_options_required,
1778 &non_options_count, non_options, &unrecognized);
1779 ASSERT (strcmp (argv[0], "program") == 0);
1780 ASSERT (strcmp (argv[1], "-p") == 0);
1781 ASSERT (strcmp (argv[2], "billy") == 0);
1782 ASSERT (strcmp (argv[3], "-a") == 0);
1783 ASSERT (strcmp (argv[4], "donald") == 0);
1784 ASSERT (strcmp (argv[5], "duck") == 0);
1785 ASSERT (strcmp (argv[6], "bar") == 0);
1786 ASSERT (argv[7] == NULL);
1787 ASSERT (a_seen == 1);
1788 ASSERT (b_seen == 0);
1789 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1790 ASSERT (q_value == NULL);
1791 ASSERT (non_options_count == 0);
1792 ASSERT (unrecognized == 0);
1793 ASSERT (optind == 4);
1797 /* Test behavior of getopt_long when POSIXLY_CORRECT is set in the
1798 environment. Options with optional arguments should not change
1799 behavior just because of an environment variable.
1800 http://lists.gnu.org/archive/html/bug-m4/2006-09/msg00028.html */
1802 test_getopt_long_posix (void)
1806 /* Check that POSIXLY_CORRECT stops parsing the same as leading '+'. */
1807 for (start = 0; start <= 1; start++)
1809 const char *p_value = NULL;
1810 const char *q_value = NULL;
1811 int non_options_count = 0;
1812 const char *non_options[10];
1813 int unrecognized = 0;
1815 const char *argv[10];
1819 argv[argc++] = "program";
1820 argv[argc++] = "donald";
1821 argv[argc++] = "-p";
1822 argv[argc++] = "billy";
1823 argv[argc++] = "duck";
1824 argv[argc++] = "-a";
1825 argv[argc++] = "bar";
1828 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1830 &non_options_count, non_options, &unrecognized);
1831 ASSERT (strcmp (argv[0], "program") == 0);
1832 ASSERT (strcmp (argv[1], "donald") == 0);
1833 ASSERT (strcmp (argv[2], "-p") == 0);
1834 ASSERT (strcmp (argv[3], "billy") == 0);
1835 ASSERT (strcmp (argv[4], "duck") == 0);
1836 ASSERT (strcmp (argv[5], "-a") == 0);
1837 ASSERT (strcmp (argv[6], "bar") == 0);
1838 ASSERT (argv[7] == NULL);
1839 ASSERT (a_seen == 0);
1840 ASSERT (b_seen == 0);
1841 ASSERT (p_value == NULL);
1842 ASSERT (q_value == NULL);
1843 ASSERT (non_options_count == 0);
1844 ASSERT (unrecognized == 0);
1845 ASSERT (optind == 1);
1848 /* Check that POSIXLY_CORRECT doesn't change optional arguments. */
1849 for (start = 0; start <= 1; start++)
1851 const char *p_value = NULL;
1852 const char *q_value = NULL;
1853 int non_options_count = 0;
1854 const char *non_options[10];
1855 int unrecognized = 0;
1857 const char *argv[10];
1861 argv[argc++] = "program";
1862 argv[argc++] = "-p";
1863 argv[argc++] = "billy";
1866 getopt_long_loop (argc, argv, "p::", long_options_required,
1868 &non_options_count, non_options, &unrecognized);
1869 ASSERT (a_seen == 0);
1870 ASSERT (b_seen == 0);
1871 ASSERT (p_value == NULL);
1872 ASSERT (q_value == NULL);
1873 ASSERT (non_options_count == 0);
1874 ASSERT (unrecognized == 0);
1875 ASSERT (optind == 2);
1878 /* Check that leading - still sees options after non-options. */
1879 for (start = 0; start <= 1; start++)
1881 const char *p_value = NULL;
1882 const char *q_value = NULL;
1883 int non_options_count = 0;
1884 const char *non_options[10];
1885 int unrecognized = 0;
1887 const char *argv[10];
1891 argv[argc++] = "program";
1892 argv[argc++] = "-a";
1893 argv[argc++] = "billy";
1894 argv[argc++] = "-b";
1897 getopt_long_loop (argc, argv, "-ab", long_options_required,
1899 &non_options_count, non_options, &unrecognized);
1900 ASSERT (a_seen == 1);
1901 ASSERT (b_seen == 1);
1902 ASSERT (p_value == NULL);
1903 ASSERT (q_value == NULL);
1904 ASSERT (non_options_count == 1);
1905 ASSERT (strcmp (non_options[0], "billy") == 0);
1906 ASSERT (unrecognized == 0);
1907 ASSERT (optind == 4);
1911 /* Reduce casting, so we can use string literals elsewhere.
1912 getopt_long_only takes an array of char*, but luckily does not
1913 modify those elements, so we can pass const char*. */
1915 do_getopt_long_only (int argc, const char **argv, const char *shortopts,
1916 const struct option *longopts, int *longind)
1918 return getopt_long_only (argc, (char **) argv, shortopts, longopts, longind);
1922 test_getopt_long_only (void)
1924 /* Test disambiguation of options. */
1927 const char *argv[10];
1931 argv[argc++] = "program";
1932 argv[argc++] = "-x";
1936 c = do_getopt_long_only (argc, argv, "ab", long_options_required,
1939 ASSERT (optopt == 0);
1943 const char *argv[10];
1947 argv[argc++] = "program";
1948 argv[argc++] = "-x";
1952 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1955 ASSERT (optopt == 0);
1959 const char *argv[10];
1963 argv[argc++] = "program";
1964 argv[argc++] = "--x";
1968 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1971 ASSERT (optopt == 0);
1975 const char *argv[10];
1979 argv[argc++] = "program";
1980 argv[argc++] = "-b";
1985 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1988 ASSERT (b_seen == 0);
1992 const char *argv[10];
1996 argv[argc++] = "program";
1997 argv[argc++] = "--b";
2002 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2005 ASSERT (b_seen == 1);
2009 const char *argv[10];
2013 argv[argc++] = "program";
2014 argv[argc++] = "-xt";
2018 c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2021 ASSERT (optopt == 0);
2025 const char *argv[10];
2029 argv[argc++] = "program";
2030 argv[argc++] = "-xt";
2034 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2037 ASSERT (optopt == 0);
2041 const char *argv[10];
2045 argv[argc++] = "program";
2046 argv[argc++] = "-xtra";
2050 c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2056 const char *argv[10];
2060 argv[argc++] = "program";
2061 argv[argc++] = "-xtreme";
2065 c = do_getopt_long_only (argc, argv, "abx:", long_options_required,
2071 const char *argv[10];
2075 argv[argc++] = "program";
2076 argv[argc++] = "-xtremel";
2080 c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2082 /* glibc bug http://sources.redhat.com/bugzilla/show_bug.cgi?id=11041 */
2083 /* ASSERT (c == 1003); */
2084 ASSERT (optind == 2);
2088 const char *argv[10];
2092 argv[argc++] = "program";
2093 argv[argc++] = "-xtremel";
2097 c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2099 /* glibc bug http://sources.redhat.com/bugzilla/show_bug.cgi?id=11041 */
2100 /* ASSERT (c == 1003); */
2101 ASSERT (optind == 2);
2102 ASSERT (optarg == NULL);
2106 const char *argv[10];
2110 argv[argc++] = "program";
2111 argv[argc++] = "-xtras";
2115 c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2118 ASSERT (strcmp (optarg, "tras") == 0);