1 /* Test of command line argument processing.
2 Copyright (C) 2009-2011 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 ASSERT (p_value == NULL);
1155 ASSERT (q_value == NULL);
1156 ASSERT (non_options_count == 0);
1157 ASSERT (unrecognized == 0);
1158 ASSERT (optind == 2);
1160 for (start = 0; start <= 1; start++)
1162 const char *p_value = NULL;
1163 const char *q_value = NULL;
1164 int non_options_count = 0;
1165 const char *non_options[10];
1166 int unrecognized = 0;
1168 const char *argv[10];
1172 argv[argc++] = "program";
1173 argv[argc++] = "-Wp=";
1174 argv[argc++] = "foo";
1175 argv[argc++] = "bar";
1178 getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1180 &non_options_count, non_options, &unrecognized);
1181 ASSERT (a_seen == 0);
1182 ASSERT (b_seen == 0);
1183 ASSERT (p_value != NULL && *p_value == '\0');
1184 ASSERT (q_value == NULL);
1185 ASSERT (non_options_count == 0);
1186 ASSERT (unrecognized == 0);
1187 ASSERT (optind == 2);
1189 for (start = 0; start <= 1; start++)
1191 const char *p_value = NULL;
1192 const char *q_value = NULL;
1193 int non_options_count = 0;
1194 const char *non_options[10];
1195 int unrecognized = 0;
1197 const char *argv[10];
1201 argv[argc++] = "program";
1202 argv[argc++] = "-W";
1203 argv[argc++] = "p=";
1204 argv[argc++] = "foo";
1205 argv[argc++] = "bar";
1208 getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1210 &non_options_count, non_options, &unrecognized);
1211 ASSERT (a_seen == 0);
1212 ASSERT (b_seen == 0);
1213 ASSERT (p_value != NULL && *p_value == '\0');
1214 ASSERT (q_value == NULL);
1215 ASSERT (non_options_count == 0);
1216 ASSERT (unrecognized == 0);
1217 ASSERT (optind == 3);
1219 for (start = 0; start <= 1; start++)
1221 const char *p_value = NULL;
1222 const char *q_value = NULL;
1223 int non_options_count = 0;
1224 const char *non_options[10];
1225 int unrecognized = 0;
1227 const char *argv[10];
1231 argv[argc++] = "program";
1232 argv[argc++] = "-W";
1234 argv[argc++] = "-a";
1235 argv[argc++] = "bar";
1238 getopt_long_loop (argc, argv, "W;abp::q::", long_options_optional,
1240 &non_options_count, non_options, &unrecognized);
1241 ASSERT (a_seen == 1);
1242 ASSERT (b_seen == 0);
1243 /* ASSERT (p_value == NULL); */
1244 ASSERT (q_value == NULL);
1245 ASSERT (non_options_count == 0);
1246 ASSERT (unrecognized == 0);
1247 ASSERT (optind == 4);
1250 /* Check that invalid options are recognized. */
1251 for (start = 0; start <= 1; start++)
1253 const char *p_value = NULL;
1254 const char *q_value = NULL;
1255 int non_options_count = 0;
1256 const char *non_options[10];
1257 int unrecognized = 0;
1259 const char *argv[10];
1263 argv[argc++] = "program";
1264 argv[argc++] = "-p";
1265 argv[argc++] = "foo";
1266 argv[argc++] = "-x";
1267 argv[argc++] = "-a";
1268 argv[argc++] = "bar";
1271 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1273 &non_options_count, non_options, &unrecognized);
1274 ASSERT (a_seen == 1);
1275 ASSERT (b_seen == 0);
1276 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1277 ASSERT (q_value == NULL);
1278 ASSERT (non_options_count == 0);
1279 ASSERT (unrecognized == 'x');
1280 ASSERT (optind == 5);
1282 for (start = 0; start <= 1; start++)
1284 const char *p_value = NULL;
1285 const char *q_value = NULL;
1286 int non_options_count = 0;
1287 const char *non_options[10];
1288 int unrecognized = 0;
1290 const char *argv[10];
1294 argv[argc++] = "program";
1295 argv[argc++] = "-p";
1296 argv[argc++] = "foo";
1297 argv[argc++] = "-:";
1298 argv[argc++] = "-a";
1299 argv[argc++] = "bar";
1302 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1304 &non_options_count, non_options, &unrecognized);
1305 ASSERT (a_seen == 1);
1306 ASSERT (b_seen == 0);
1307 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1308 ASSERT (q_value == NULL);
1309 ASSERT (non_options_count == 0);
1310 ASSERT (unrecognized == ':');
1311 ASSERT (optind == 5);
1314 /* Check that unexpected arguments are recognized. */
1315 for (start = 0; start <= 1; start++)
1317 const char *p_value = NULL;
1318 const char *q_value = NULL;
1319 int non_options_count = 0;
1320 const char *non_options[10];
1321 int unrecognized = 0;
1323 const char *argv[10];
1327 argv[argc++] = "program";
1328 argv[argc++] = "-p";
1329 argv[argc++] = "foo";
1330 argv[argc++] = "--a=";
1331 argv[argc++] = "bar";
1334 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1336 &non_options_count, non_options, &unrecognized);
1337 ASSERT (a_seen == 0);
1338 ASSERT (b_seen == 0);
1339 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1340 ASSERT (q_value == NULL);
1341 ASSERT (non_options_count == 0);
1342 ASSERT (unrecognized == 'a');
1343 ASSERT (optind == 4);
1345 for (start = 0; start <= 1; start++)
1347 const char *p_value = NULL;
1348 const char *q_value = NULL;
1349 int non_options_count = 0;
1350 const char *non_options[10];
1351 int unrecognized = 0;
1353 const char *argv[10];
1357 argv[argc++] = "program";
1358 argv[argc++] = "-p";
1359 argv[argc++] = "foo";
1360 argv[argc++] = "--b=";
1361 argv[argc++] = "bar";
1364 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1366 &non_options_count, non_options, &unrecognized);
1367 ASSERT (a_seen == 0);
1368 ASSERT (b_seen == 0);
1369 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1370 ASSERT (q_value == NULL);
1371 ASSERT (non_options_count == 0);
1372 /* When flag is non-zero, glibc sets optopt anyway, but BSD
1373 leaves optopt unchanged. */
1374 ASSERT (unrecognized == 1 || unrecognized == 0);
1375 ASSERT (optind == 4);
1378 /* Check that by default, non-options arguments are moved to the end. */
1379 for (start = 0; start <= 1; start++)
1381 const char *p_value = NULL;
1382 const char *q_value = NULL;
1383 int non_options_count = 0;
1384 const char *non_options[10];
1385 int unrecognized = 0;
1387 const char *argv[10];
1391 argv[argc++] = "program";
1392 argv[argc++] = "donald";
1393 argv[argc++] = "-p";
1394 argv[argc++] = "billy";
1395 argv[argc++] = "duck";
1396 argv[argc++] = "-a";
1397 argv[argc++] = "bar";
1400 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1402 &non_options_count, non_options, &unrecognized);
1403 ASSERT (strcmp (argv[0], "program") == 0);
1404 ASSERT (strcmp (argv[1], "-p") == 0);
1405 ASSERT (strcmp (argv[2], "billy") == 0);
1406 ASSERT (strcmp (argv[3], "-a") == 0);
1407 ASSERT (strcmp (argv[4], "donald") == 0);
1408 ASSERT (strcmp (argv[5], "duck") == 0);
1409 ASSERT (strcmp (argv[6], "bar") == 0);
1410 ASSERT (argv[7] == NULL);
1411 ASSERT (a_seen == 1);
1412 ASSERT (b_seen == 0);
1413 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1414 ASSERT (q_value == NULL);
1415 ASSERT (non_options_count == 0);
1416 ASSERT (unrecognized == 0);
1417 ASSERT (optind == 4);
1420 /* Check that '--' ends the argument processing. */
1421 for (start = 0; start <= 1; start++)
1423 const char *p_value = NULL;
1424 const char *q_value = NULL;
1425 int non_options_count = 0;
1426 const char *non_options[10];
1427 int unrecognized = 0;
1429 const char *argv[20];
1433 argv[argc++] = "program";
1434 argv[argc++] = "donald";
1435 argv[argc++] = "-p";
1436 argv[argc++] = "billy";
1437 argv[argc++] = "duck";
1438 argv[argc++] = "-a";
1439 argv[argc++] = "--";
1440 argv[argc++] = "-b";
1441 argv[argc++] = "foo";
1442 argv[argc++] = "-q";
1443 argv[argc++] = "johnny";
1444 argv[argc++] = "bar";
1447 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1449 &non_options_count, non_options, &unrecognized);
1450 ASSERT (strcmp (argv[0], "program") == 0);
1451 ASSERT (strcmp (argv[1], "-p") == 0);
1452 ASSERT (strcmp (argv[2], "billy") == 0);
1453 ASSERT (strcmp (argv[3], "-a") == 0);
1454 ASSERT (strcmp (argv[4], "--") == 0);
1455 ASSERT (strcmp (argv[5], "donald") == 0);
1456 ASSERT (strcmp (argv[6], "duck") == 0);
1457 ASSERT (strcmp (argv[7], "-b") == 0);
1458 ASSERT (strcmp (argv[8], "foo") == 0);
1459 ASSERT (strcmp (argv[9], "-q") == 0);
1460 ASSERT (strcmp (argv[10], "johnny") == 0);
1461 ASSERT (strcmp (argv[11], "bar") == 0);
1462 ASSERT (argv[12] == NULL);
1463 ASSERT (a_seen == 1);
1464 ASSERT (b_seen == 0);
1465 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1466 ASSERT (q_value == NULL);
1467 ASSERT (non_options_count == 0);
1468 ASSERT (unrecognized == 0);
1469 ASSERT (optind == 5);
1472 /* Check that the '-' flag causes non-options to be returned in order. */
1473 for (start = 0; start <= 1; start++)
1475 const char *p_value = NULL;
1476 const char *q_value = NULL;
1477 int non_options_count = 0;
1478 const char *non_options[10];
1479 int unrecognized = 0;
1481 const char *argv[10];
1485 argv[argc++] = "program";
1486 argv[argc++] = "donald";
1487 argv[argc++] = "-p";
1488 argv[argc++] = "billy";
1489 argv[argc++] = "duck";
1490 argv[argc++] = "-a";
1491 argv[argc++] = "bar";
1494 getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1496 &non_options_count, non_options, &unrecognized);
1497 ASSERT (strcmp (argv[0], "program") == 0);
1498 ASSERT (strcmp (argv[1], "donald") == 0);
1499 ASSERT (strcmp (argv[2], "-p") == 0);
1500 ASSERT (strcmp (argv[3], "billy") == 0);
1501 ASSERT (strcmp (argv[4], "duck") == 0);
1502 ASSERT (strcmp (argv[5], "-a") == 0);
1503 ASSERT (strcmp (argv[6], "bar") == 0);
1504 ASSERT (argv[7] == NULL);
1505 ASSERT (a_seen == 1);
1506 ASSERT (b_seen == 0);
1507 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1508 ASSERT (q_value == NULL);
1509 ASSERT (non_options_count == 3);
1510 ASSERT (strcmp (non_options[0], "donald") == 0);
1511 ASSERT (strcmp (non_options[1], "duck") == 0);
1512 ASSERT (strcmp (non_options[2], "bar") == 0);
1513 ASSERT (unrecognized == 0);
1514 ASSERT (optind == 7);
1517 /* Check that '--' ends the argument processing. */
1518 for (start = 0; start <= 1; start++)
1520 const char *p_value = NULL;
1521 const char *q_value = NULL;
1522 int non_options_count = 0;
1523 const char *non_options[10];
1524 int unrecognized = 0;
1526 const char *argv[20];
1530 argv[argc++] = "program";
1531 argv[argc++] = "donald";
1532 argv[argc++] = "-p";
1533 argv[argc++] = "billy";
1534 argv[argc++] = "duck";
1535 argv[argc++] = "-a";
1536 argv[argc++] = "--";
1537 argv[argc++] = "-b";
1538 argv[argc++] = "foo";
1539 argv[argc++] = "-q";
1540 argv[argc++] = "johnny";
1541 argv[argc++] = "bar";
1544 getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1546 &non_options_count, non_options, &unrecognized);
1547 ASSERT (strcmp (argv[0], "program") == 0);
1548 ASSERT (strcmp (argv[1], "donald") == 0);
1549 ASSERT (strcmp (argv[2], "-p") == 0);
1550 ASSERT (strcmp (argv[3], "billy") == 0);
1551 ASSERT (strcmp (argv[4], "duck") == 0);
1552 ASSERT (strcmp (argv[5], "-a") == 0);
1553 ASSERT (strcmp (argv[6], "--") == 0);
1554 ASSERT (strcmp (argv[7], "-b") == 0);
1555 ASSERT (strcmp (argv[8], "foo") == 0);
1556 ASSERT (strcmp (argv[9], "-q") == 0);
1557 ASSERT (strcmp (argv[10], "johnny") == 0);
1558 ASSERT (strcmp (argv[11], "bar") == 0);
1559 ASSERT (argv[12] == NULL);
1560 ASSERT (a_seen == 1);
1561 ASSERT (b_seen == 0);
1562 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1563 ASSERT (q_value == NULL);
1564 if (non_options_count == 2)
1566 /* glibc behaviour. */
1567 ASSERT (non_options_count == 2);
1568 ASSERT (strcmp (non_options[0], "donald") == 0);
1569 ASSERT (strcmp (non_options[1], "duck") == 0);
1570 ASSERT (unrecognized == 0);
1571 ASSERT (optind == 7);
1575 /* Another valid behaviour. */
1576 ASSERT (non_options_count == 7);
1577 ASSERT (strcmp (non_options[0], "donald") == 0);
1578 ASSERT (strcmp (non_options[1], "duck") == 0);
1579 ASSERT (strcmp (non_options[2], "-b") == 0);
1580 ASSERT (strcmp (non_options[3], "foo") == 0);
1581 ASSERT (strcmp (non_options[4], "-q") == 0);
1582 ASSERT (strcmp (non_options[5], "johnny") == 0);
1583 ASSERT (strcmp (non_options[6], "bar") == 0);
1584 ASSERT (unrecognized == 0);
1585 ASSERT (optind == 12);
1589 /* Check that the '-' flag has to come first. */
1590 for (start = 0; start <= 1; start++)
1592 const char *p_value = NULL;
1593 const char *q_value = NULL;
1594 int non_options_count = 0;
1595 const char *non_options[10];
1596 int unrecognized = 0;
1598 const char *argv[10];
1602 argv[argc++] = "program";
1603 argv[argc++] = "donald";
1604 argv[argc++] = "-p";
1605 argv[argc++] = "billy";
1606 argv[argc++] = "duck";
1607 argv[argc++] = "-a";
1608 argv[argc++] = "bar";
1611 getopt_long_loop (argc, argv, "abp:q:-", long_options_required,
1613 &non_options_count, non_options, &unrecognized);
1614 ASSERT (strcmp (argv[0], "program") == 0);
1615 ASSERT (strcmp (argv[1], "-p") == 0);
1616 ASSERT (strcmp (argv[2], "billy") == 0);
1617 ASSERT (strcmp (argv[3], "-a") == 0);
1618 ASSERT (strcmp (argv[4], "donald") == 0);
1619 ASSERT (strcmp (argv[5], "duck") == 0);
1620 ASSERT (strcmp (argv[6], "bar") == 0);
1621 ASSERT (argv[7] == NULL);
1622 ASSERT (a_seen == 1);
1623 ASSERT (b_seen == 0);
1624 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1625 ASSERT (q_value == NULL);
1626 ASSERT (non_options_count == 0);
1627 ASSERT (unrecognized == 0);
1628 ASSERT (optind == 4);
1631 /* Check that the '+' flag causes the first non-option to terminate the
1633 for (start = 0; start <= 1; start++)
1635 const char *p_value = NULL;
1636 const char *q_value = NULL;
1637 int non_options_count = 0;
1638 const char *non_options[10];
1639 int unrecognized = 0;
1641 const char *argv[10];
1645 argv[argc++] = "program";
1646 argv[argc++] = "donald";
1647 argv[argc++] = "-p";
1648 argv[argc++] = "billy";
1649 argv[argc++] = "duck";
1650 argv[argc++] = "-a";
1651 argv[argc++] = "bar";
1654 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1656 &non_options_count, non_options, &unrecognized);
1657 ASSERT (strcmp (argv[0], "program") == 0);
1658 ASSERT (strcmp (argv[1], "donald") == 0);
1659 ASSERT (strcmp (argv[2], "-p") == 0);
1660 ASSERT (strcmp (argv[3], "billy") == 0);
1661 ASSERT (strcmp (argv[4], "duck") == 0);
1662 ASSERT (strcmp (argv[5], "-a") == 0);
1663 ASSERT (strcmp (argv[6], "bar") == 0);
1664 ASSERT (argv[7] == NULL);
1665 ASSERT (a_seen == 0);
1666 ASSERT (b_seen == 0);
1667 ASSERT (p_value == NULL);
1668 ASSERT (q_value == NULL);
1669 ASSERT (non_options_count == 0);
1670 ASSERT (unrecognized == 0);
1671 ASSERT (optind == 1);
1673 for (start = 0; start <= 1; start++)
1675 const char *p_value = NULL;
1676 const char *q_value = NULL;
1677 int non_options_count = 0;
1678 const char *non_options[10];
1679 int unrecognized = 0;
1681 const char *argv[10];
1685 argv[argc++] = "program";
1686 argv[argc++] = "-+";
1689 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1691 &non_options_count, non_options, &unrecognized);
1692 ASSERT (a_seen == 0);
1693 ASSERT (b_seen == 0);
1694 ASSERT (p_value == NULL);
1695 ASSERT (q_value == NULL);
1696 ASSERT (non_options_count == 0);
1697 ASSERT (unrecognized == '+');
1698 ASSERT (optind == 2);
1701 /* Check that '--' ends the argument processing. */
1702 for (start = 0; start <= 1; start++)
1704 const char *p_value = NULL;
1705 const char *q_value = NULL;
1706 int non_options_count = 0;
1707 const char *non_options[10];
1708 int unrecognized = 0;
1710 const char *argv[20];
1714 argv[argc++] = "program";
1715 argv[argc++] = "donald";
1716 argv[argc++] = "-p";
1717 argv[argc++] = "billy";
1718 argv[argc++] = "duck";
1719 argv[argc++] = "-a";
1720 argv[argc++] = "--";
1721 argv[argc++] = "-b";
1722 argv[argc++] = "foo";
1723 argv[argc++] = "-q";
1724 argv[argc++] = "johnny";
1725 argv[argc++] = "bar";
1728 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1730 &non_options_count, non_options, &unrecognized);
1731 ASSERT (strcmp (argv[0], "program") == 0);
1732 ASSERT (strcmp (argv[1], "donald") == 0);
1733 ASSERT (strcmp (argv[2], "-p") == 0);
1734 ASSERT (strcmp (argv[3], "billy") == 0);
1735 ASSERT (strcmp (argv[4], "duck") == 0);
1736 ASSERT (strcmp (argv[5], "-a") == 0);
1737 ASSERT (strcmp (argv[6], "--") == 0);
1738 ASSERT (strcmp (argv[7], "-b") == 0);
1739 ASSERT (strcmp (argv[8], "foo") == 0);
1740 ASSERT (strcmp (argv[9], "-q") == 0);
1741 ASSERT (strcmp (argv[10], "johnny") == 0);
1742 ASSERT (strcmp (argv[11], "bar") == 0);
1743 ASSERT (argv[12] == NULL);
1744 ASSERT (a_seen == 0);
1745 ASSERT (b_seen == 0);
1746 ASSERT (p_value == NULL);
1747 ASSERT (q_value == NULL);
1748 ASSERT (non_options_count == 0);
1749 ASSERT (unrecognized == 0);
1750 ASSERT (optind == 1);
1753 /* Check that the '+' flag has to come first. */
1754 for (start = 0; start <= 1; start++)
1756 const char *p_value = NULL;
1757 const char *q_value = NULL;
1758 int non_options_count = 0;
1759 const char *non_options[10];
1760 int unrecognized = 0;
1762 const char *argv[10];
1766 argv[argc++] = "program";
1767 argv[argc++] = "donald";
1768 argv[argc++] = "-p";
1769 argv[argc++] = "billy";
1770 argv[argc++] = "duck";
1771 argv[argc++] = "-a";
1772 argv[argc++] = "bar";
1775 getopt_long_loop (argc, argv, "abp:q:+", long_options_required,
1777 &non_options_count, non_options, &unrecognized);
1778 ASSERT (strcmp (argv[0], "program") == 0);
1779 ASSERT (strcmp (argv[1], "-p") == 0);
1780 ASSERT (strcmp (argv[2], "billy") == 0);
1781 ASSERT (strcmp (argv[3], "-a") == 0);
1782 ASSERT (strcmp (argv[4], "donald") == 0);
1783 ASSERT (strcmp (argv[5], "duck") == 0);
1784 ASSERT (strcmp (argv[6], "bar") == 0);
1785 ASSERT (argv[7] == NULL);
1786 ASSERT (a_seen == 1);
1787 ASSERT (b_seen == 0);
1788 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1789 ASSERT (q_value == NULL);
1790 ASSERT (non_options_count == 0);
1791 ASSERT (unrecognized == 0);
1792 ASSERT (optind == 4);
1796 /* Test behavior of getopt_long when POSIXLY_CORRECT is set in the
1797 environment. Options with optional arguments should not change
1798 behavior just because of an environment variable.
1799 http://lists.gnu.org/archive/html/bug-m4/2006-09/msg00028.html */
1801 test_getopt_long_posix (void)
1805 /* Check that POSIXLY_CORRECT stops parsing the same as leading '+'. */
1806 for (start = 0; start <= 1; start++)
1808 const char *p_value = NULL;
1809 const char *q_value = NULL;
1810 int non_options_count = 0;
1811 const char *non_options[10];
1812 int unrecognized = 0;
1814 const char *argv[10];
1818 argv[argc++] = "program";
1819 argv[argc++] = "donald";
1820 argv[argc++] = "-p";
1821 argv[argc++] = "billy";
1822 argv[argc++] = "duck";
1823 argv[argc++] = "-a";
1824 argv[argc++] = "bar";
1827 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1829 &non_options_count, non_options, &unrecognized);
1830 ASSERT (strcmp (argv[0], "program") == 0);
1831 ASSERT (strcmp (argv[1], "donald") == 0);
1832 ASSERT (strcmp (argv[2], "-p") == 0);
1833 ASSERT (strcmp (argv[3], "billy") == 0);
1834 ASSERT (strcmp (argv[4], "duck") == 0);
1835 ASSERT (strcmp (argv[5], "-a") == 0);
1836 ASSERT (strcmp (argv[6], "bar") == 0);
1837 ASSERT (argv[7] == NULL);
1838 ASSERT (a_seen == 0);
1839 ASSERT (b_seen == 0);
1840 ASSERT (p_value == NULL);
1841 ASSERT (q_value == NULL);
1842 ASSERT (non_options_count == 0);
1843 ASSERT (unrecognized == 0);
1844 ASSERT (optind == 1);
1847 /* Check that POSIXLY_CORRECT doesn't change optional arguments. */
1848 for (start = 0; start <= 1; start++)
1850 const char *p_value = NULL;
1851 const char *q_value = NULL;
1852 int non_options_count = 0;
1853 const char *non_options[10];
1854 int unrecognized = 0;
1856 const char *argv[10];
1860 argv[argc++] = "program";
1861 argv[argc++] = "-p";
1862 argv[argc++] = "billy";
1865 getopt_long_loop (argc, argv, "p::", long_options_required,
1867 &non_options_count, non_options, &unrecognized);
1868 ASSERT (a_seen == 0);
1869 ASSERT (b_seen == 0);
1870 ASSERT (p_value == NULL);
1871 ASSERT (q_value == NULL);
1872 ASSERT (non_options_count == 0);
1873 ASSERT (unrecognized == 0);
1874 ASSERT (optind == 2);
1877 /* Check that leading - still sees options after non-options. */
1878 for (start = 0; start <= 1; start++)
1880 const char *p_value = NULL;
1881 const char *q_value = NULL;
1882 int non_options_count = 0;
1883 const char *non_options[10];
1884 int unrecognized = 0;
1886 const char *argv[10];
1890 argv[argc++] = "program";
1891 argv[argc++] = "-a";
1892 argv[argc++] = "billy";
1893 argv[argc++] = "-b";
1896 getopt_long_loop (argc, argv, "-ab", long_options_required,
1898 &non_options_count, non_options, &unrecognized);
1899 ASSERT (a_seen == 1);
1900 ASSERT (b_seen == 1);
1901 ASSERT (p_value == NULL);
1902 ASSERT (q_value == NULL);
1903 ASSERT (non_options_count == 1);
1904 ASSERT (strcmp (non_options[0], "billy") == 0);
1905 ASSERT (unrecognized == 0);
1906 ASSERT (optind == 4);
1910 /* Reduce casting, so we can use string literals elsewhere.
1911 getopt_long_only takes an array of char*, but luckily does not
1912 modify those elements, so we can pass const char*. */
1914 do_getopt_long_only (int argc, const char **argv, const char *shortopts,
1915 const struct option *longopts, int *longind)
1917 return getopt_long_only (argc, (char **) argv, shortopts, longopts, longind);
1921 test_getopt_long_only (void)
1923 /* Test disambiguation of options. */
1926 const char *argv[10];
1930 argv[argc++] = "program";
1931 argv[argc++] = "-x";
1935 c = do_getopt_long_only (argc, argv, "ab", long_options_required,
1938 ASSERT (optopt == 0);
1942 const char *argv[10];
1946 argv[argc++] = "program";
1947 argv[argc++] = "-x";
1951 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1954 ASSERT (optopt == 0);
1958 const char *argv[10];
1962 argv[argc++] = "program";
1963 argv[argc++] = "--x";
1967 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1970 ASSERT (optopt == 0);
1974 const char *argv[10];
1978 argv[argc++] = "program";
1979 argv[argc++] = "-b";
1984 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1987 ASSERT (b_seen == 0);
1991 const char *argv[10];
1995 argv[argc++] = "program";
1996 argv[argc++] = "--b";
2001 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2004 ASSERT (b_seen == 1);
2008 const char *argv[10];
2012 argv[argc++] = "program";
2013 argv[argc++] = "-xt";
2017 c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2020 ASSERT (optopt == 0);
2024 const char *argv[10];
2028 argv[argc++] = "program";
2029 argv[argc++] = "-xt";
2033 c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2036 ASSERT (optopt == 0);
2040 const char *argv[10];
2044 argv[argc++] = "program";
2045 argv[argc++] = "-xtra";
2049 c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2055 const char *argv[10];
2059 argv[argc++] = "program";
2060 argv[argc++] = "-xtreme";
2064 c = do_getopt_long_only (argc, argv, "abx:", long_options_required,
2070 const char *argv[10];
2074 argv[argc++] = "program";
2075 argv[argc++] = "-xtremel";
2079 c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2081 /* glibc getopt_long_only is intentionally different from
2082 getopt_long when handling a prefix that is common to two
2083 spellings, when both spellings have the same option directives.
2084 BSD getopt_long_only treats both cases the same. */
2085 ASSERT (c == 1003 || c == '?');
2086 ASSERT (optind == 2);
2090 const char *argv[10];
2094 argv[argc++] = "program";
2095 argv[argc++] = "-xtremel";
2099 c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2101 /* glibc getopt_long_only is intentionally different from
2102 getopt_long when handling a prefix that is common to two
2103 spellings, when both spellings have the same option directives.
2104 BSD getopt_long_only treats both cases the same. */
2105 ASSERT (c == 1003 || c == '?');
2106 ASSERT (optind == 2);
2107 ASSERT (optarg == NULL);
2111 const char *argv[10];
2115 argv[argc++] = "program";
2116 argv[argc++] = "-xtras";
2120 c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2123 ASSERT (strcmp (optarg, "tras") == 0);