1 /* Test of command line argument processing.
2 Copyright (C) 2009 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* Written by Bruno Haible <bruno@clisp.org>, 2009. */
22 static const struct option long_options_required[] =
24 { "alpha", no_argument, NULL, 'a' },
25 { "beta", no_argument, &b_seen, 1 },
26 { "prune", required_argument, NULL, 'p' },
27 { "quetsche", required_argument, NULL, 'q' },
28 { "xtra", no_argument, NULL, 1001 },
29 { "xtreme", no_argument, NULL, 1002 },
30 { "xtremely", no_argument, NULL, 1003 },
34 static const struct option long_options_optional[] =
36 { "alpha", no_argument, NULL, 'a' },
37 { "beta", no_argument, &b_seen, 1 },
38 { "prune", optional_argument, NULL, 'p' },
39 { "quetsche", optional_argument, NULL, 'q' },
44 getopt_long_loop (int argc, char **argv,
45 const char *options, const struct option *long_options,
46 const char **p_value, const char **q_value,
47 int *non_options_count, const char **non_options,
54 while ((c = getopt_long (argc, argv, options, long_options, &option_index))
60 /* An option with a non-NULL flag pointer was processed. */
75 /* Must only happen with option '-' at the beginning. */
76 ASSERT (options[0] == '-');
77 non_options[(*non_options_count)++] = optarg;
80 *unrecognized = optopt;
90 test_getopt_long (void)
94 /* Test disambiguation of options. */
101 argv[argc++] = "program";
102 argv[argc++] = "--x";
105 c = getopt_long (argc, argv, "ab", long_options_required, &option_index);
107 ASSERT (optopt == 0);
115 argv[argc++] = "program";
116 argv[argc++] = "--xt";
119 c = getopt_long (argc, argv, "ab", long_options_required, &option_index);
121 ASSERT (optopt == 0);
129 argv[argc++] = "program";
130 argv[argc++] = "--xtr";
133 c = getopt_long (argc, argv, "ab", long_options_required, &option_index);
135 ASSERT (optopt == 0);
143 argv[argc++] = "program";
144 argv[argc++] = "--xtra";
147 c = getopt_long (argc, argv, "ab", long_options_required, &option_index);
156 argv[argc++] = "program";
157 argv[argc++] = "--xtre";
160 c = getopt_long (argc, argv, "ab", long_options_required, &option_index);
162 ASSERT (optopt == 0);
170 argv[argc++] = "program";
171 argv[argc++] = "--xtrem";
174 c = getopt_long (argc, argv, "ab", long_options_required, &option_index);
176 ASSERT (optopt == 0);
184 argv[argc++] = "program";
185 argv[argc++] = "--xtreme";
188 c = getopt_long (argc, argv, "ab", long_options_required, &option_index);
197 argv[argc++] = "program";
198 argv[argc++] = "--xtremel";
201 c = getopt_long (argc, argv, "ab", long_options_required, &option_index);
210 argv[argc++] = "program";
211 argv[argc++] = "--xtremely";
214 c = getopt_long (argc, argv, "ab", long_options_required, &option_index);
218 /* Test processing of boolean options. */
219 for (start = OPTIND_MIN; start <= 1; start++)
221 const char *p_value = NULL;
222 const char *q_value = NULL;
223 int non_options_count = 0;
224 const char *non_options[10];
225 int unrecognized = 0;
231 argv[argc++] = "program";
233 argv[argc++] = "foo";
234 argv[argc++] = "bar";
236 getopt_long_loop (argc, argv, "ab", long_options_required,
238 &non_options_count, non_options, &unrecognized);
239 ASSERT (a_seen == 1);
240 ASSERT (b_seen == 0);
241 ASSERT (p_value == NULL);
242 ASSERT (q_value == NULL);
243 ASSERT (non_options_count == 0);
244 ASSERT (unrecognized == 0);
245 ASSERT (optind == 2);
247 for (start = OPTIND_MIN; start <= 1; start++)
249 const char *p_value = NULL;
250 const char *q_value = NULL;
251 int non_options_count = 0;
252 const char *non_options[10];
253 int unrecognized = 0;
259 argv[argc++] = "program";
262 argv[argc++] = "foo";
263 argv[argc++] = "bar";
265 getopt_long_loop (argc, argv, "ab", long_options_required,
267 &non_options_count, non_options, &unrecognized);
268 ASSERT (a_seen == 1);
269 ASSERT (b_seen == 1);
270 ASSERT (p_value == NULL);
271 ASSERT (q_value == NULL);
272 ASSERT (non_options_count == 0);
273 ASSERT (unrecognized == 0);
274 ASSERT (optind == 3);
276 for (start = OPTIND_MIN; start <= 1; start++)
278 const char *p_value = NULL;
279 const char *q_value = NULL;
280 int non_options_count = 0;
281 const char *non_options[10];
282 int unrecognized = 0;
288 argv[argc++] = "program";
289 argv[argc++] = "-ba";
290 argv[argc++] = "foo";
291 argv[argc++] = "bar";
293 getopt_long_loop (argc, argv, "ab", long_options_required,
295 &non_options_count, non_options, &unrecognized);
296 ASSERT (a_seen == 1);
297 ASSERT (b_seen == 1);
298 ASSERT (p_value == NULL);
299 ASSERT (q_value == NULL);
300 ASSERT (non_options_count == 0);
301 ASSERT (unrecognized == 0);
302 ASSERT (optind == 2);
304 for (start = OPTIND_MIN; start <= 1; start++)
306 const char *p_value = NULL;
307 const char *q_value = NULL;
308 int non_options_count = 0;
309 const char *non_options[10];
310 int unrecognized = 0;
316 argv[argc++] = "program";
317 argv[argc++] = "-ab";
319 argv[argc++] = "foo";
320 argv[argc++] = "bar";
322 getopt_long_loop (argc, argv, "ab", long_options_required,
324 &non_options_count, non_options, &unrecognized);
325 ASSERT (a_seen == 2);
326 ASSERT (b_seen == 1);
327 ASSERT (p_value == NULL);
328 ASSERT (q_value == NULL);
329 ASSERT (non_options_count == 0);
330 ASSERT (unrecognized == 0);
331 ASSERT (optind == 3);
334 /* Test processing of options with arguments. */
335 for (start = OPTIND_MIN; start <= 1; start++)
337 const char *p_value = NULL;
338 const char *q_value = NULL;
339 int non_options_count = 0;
340 const char *non_options[10];
341 int unrecognized = 0;
347 argv[argc++] = "program";
348 argv[argc++] = "-pfoo";
349 argv[argc++] = "bar";
351 getopt_long_loop (argc, argv, "p:q:", long_options_required,
353 &non_options_count, non_options, &unrecognized);
354 ASSERT (a_seen == 0);
355 ASSERT (b_seen == 0);
356 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
357 ASSERT (q_value == NULL);
358 ASSERT (non_options_count == 0);
359 ASSERT (unrecognized == 0);
360 ASSERT (optind == 2);
362 for (start = OPTIND_MIN; start <= 1; start++)
364 const char *p_value = NULL;
365 const char *q_value = NULL;
366 int non_options_count = 0;
367 const char *non_options[10];
368 int unrecognized = 0;
374 argv[argc++] = "program";
376 argv[argc++] = "foo";
377 argv[argc++] = "bar";
379 getopt_long_loop (argc, argv, "p:q:", long_options_required,
381 &non_options_count, non_options, &unrecognized);
382 ASSERT (a_seen == 0);
383 ASSERT (b_seen == 0);
384 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
385 ASSERT (q_value == NULL);
386 ASSERT (non_options_count == 0);
387 ASSERT (unrecognized == 0);
388 ASSERT (optind == 3);
390 for (start = OPTIND_MIN; start <= 1; start++)
392 const char *p_value = NULL;
393 const char *q_value = NULL;
394 int non_options_count = 0;
395 const char *non_options[10];
396 int unrecognized = 0;
402 argv[argc++] = "program";
403 argv[argc++] = "-ab";
405 argv[argc++] = "baz";
406 argv[argc++] = "-pfoo";
407 argv[argc++] = "bar";
409 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
411 &non_options_count, non_options, &unrecognized);
412 ASSERT (a_seen == 1);
413 ASSERT (b_seen == 1);
414 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
415 ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
416 ASSERT (non_options_count == 0);
417 ASSERT (unrecognized == 0);
418 ASSERT (optind == 5);
421 /* Test processing of options with optional arguments. */
422 for (start = OPTIND_MIN; start <= 1; start++)
424 const char *p_value = NULL;
425 const char *q_value = NULL;
426 int non_options_count = 0;
427 const char *non_options[10];
428 int unrecognized = 0;
434 argv[argc++] = "program";
435 argv[argc++] = "-pfoo";
436 argv[argc++] = "bar";
438 getopt_long_loop (argc, argv, "p::q::", long_options_optional,
440 &non_options_count, non_options, &unrecognized);
441 ASSERT (a_seen == 0);
442 ASSERT (b_seen == 0);
443 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
444 ASSERT (q_value == NULL);
445 ASSERT (non_options_count == 0);
446 ASSERT (unrecognized == 0);
447 ASSERT (optind == 2);
449 for (start = OPTIND_MIN; start <= 1; start++)
451 const char *p_value = NULL;
452 const char *q_value = NULL;
453 int non_options_count = 0;
454 const char *non_options[10];
455 int unrecognized = 0;
461 argv[argc++] = "program";
463 argv[argc++] = "foo";
464 argv[argc++] = "bar";
466 getopt_long_loop (argc, argv, "p::q::", long_options_optional,
468 &non_options_count, non_options, &unrecognized);
469 ASSERT (a_seen == 0);
470 ASSERT (b_seen == 0);
471 ASSERT (p_value == NULL);
472 ASSERT (q_value == NULL);
473 ASSERT (non_options_count == 0);
474 ASSERT (unrecognized == 0);
475 ASSERT (optind == 2);
477 for (start = OPTIND_MIN; start <= 1; start++)
479 const char *p_value = NULL;
480 const char *q_value = NULL;
481 int non_options_count = 0;
482 const char *non_options[10];
483 int unrecognized = 0;
489 argv[argc++] = "program";
492 argv[argc++] = "bar";
494 getopt_long_loop (argc, argv, "abp::q::", long_options_optional,
496 &non_options_count, non_options, &unrecognized);
497 ASSERT (a_seen == 1);
498 ASSERT (b_seen == 0);
499 ASSERT (p_value == NULL);
500 ASSERT (q_value == NULL);
501 ASSERT (non_options_count == 0);
502 ASSERT (unrecognized == 0);
503 ASSERT (optind == 3);
506 /* Check that invalid options are recognized. */
507 for (start = OPTIND_MIN; start <= 1; start++)
509 const char *p_value = NULL;
510 const char *q_value = NULL;
511 int non_options_count = 0;
512 const char *non_options[10];
513 int unrecognized = 0;
519 argv[argc++] = "program";
521 argv[argc++] = "foo";
524 argv[argc++] = "bar";
526 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
528 &non_options_count, non_options, &unrecognized);
529 ASSERT (a_seen == 1);
530 ASSERT (b_seen == 0);
531 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
532 ASSERT (q_value == NULL);
533 ASSERT (non_options_count == 0);
534 ASSERT (unrecognized == 'x');
535 ASSERT (optind == 5);
538 /* Check that by default, non-options arguments are moved to the end. */
539 for (start = OPTIND_MIN; start <= 1; start++)
541 const char *p_value = NULL;
542 const char *q_value = NULL;
543 int non_options_count = 0;
544 const char *non_options[10];
545 int unrecognized = 0;
551 argv[argc++] = "program";
552 argv[argc++] = "donald";
554 argv[argc++] = "billy";
555 argv[argc++] = "duck";
557 argv[argc++] = "bar";
559 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
561 &non_options_count, non_options, &unrecognized);
562 ASSERT (strcmp (argv[0], "program") == 0);
563 ASSERT (strcmp (argv[1], "-p") == 0);
564 ASSERT (strcmp (argv[2], "billy") == 0);
565 ASSERT (strcmp (argv[3], "-a") == 0);
566 ASSERT (strcmp (argv[4], "donald") == 0);
567 ASSERT (strcmp (argv[5], "duck") == 0);
568 ASSERT (strcmp (argv[6], "bar") == 0);
569 ASSERT (a_seen == 1);
570 ASSERT (b_seen == 0);
571 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
572 ASSERT (q_value == NULL);
573 ASSERT (non_options_count == 0);
574 ASSERT (unrecognized == 0);
575 ASSERT (optind == 4);
578 /* Check that '--' ends the argument processing. */
579 for (start = OPTIND_MIN; start <= 1; start++)
581 const char *p_value = NULL;
582 const char *q_value = NULL;
583 int non_options_count = 0;
584 const char *non_options[10];
585 int unrecognized = 0;
591 argv[argc++] = "program";
592 argv[argc++] = "donald";
594 argv[argc++] = "billy";
595 argv[argc++] = "duck";
599 argv[argc++] = "foo";
601 argv[argc++] = "johnny";
602 argv[argc++] = "bar";
604 getopt_long_loop (argc, argv, "abp:q:", long_options_required,
606 &non_options_count, non_options, &unrecognized);
607 ASSERT (strcmp (argv[0], "program") == 0);
608 ASSERT (strcmp (argv[1], "-p") == 0);
609 ASSERT (strcmp (argv[2], "billy") == 0);
610 ASSERT (strcmp (argv[3], "-a") == 0);
611 ASSERT (strcmp (argv[4], "--") == 0);
612 ASSERT (strcmp (argv[5], "donald") == 0);
613 ASSERT (strcmp (argv[6], "duck") == 0);
614 ASSERT (strcmp (argv[7], "-b") == 0);
615 ASSERT (strcmp (argv[8], "foo") == 0);
616 ASSERT (strcmp (argv[9], "-q") == 0);
617 ASSERT (strcmp (argv[10], "johnny") == 0);
618 ASSERT (strcmp (argv[11], "bar") == 0);
619 ASSERT (a_seen == 1);
620 ASSERT (b_seen == 0);
621 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
622 ASSERT (q_value == NULL);
623 ASSERT (non_options_count == 0);
624 ASSERT (unrecognized == 0);
625 ASSERT (optind == 5);
628 /* Check that the '-' flag causes non-options to be returned in order. */
629 for (start = OPTIND_MIN; start <= 1; start++)
631 const char *p_value = NULL;
632 const char *q_value = NULL;
633 int non_options_count = 0;
634 const char *non_options[10];
635 int unrecognized = 0;
641 argv[argc++] = "program";
642 argv[argc++] = "donald";
644 argv[argc++] = "billy";
645 argv[argc++] = "duck";
647 argv[argc++] = "bar";
649 getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
651 &non_options_count, non_options, &unrecognized);
652 ASSERT (strcmp (argv[0], "program") == 0);
653 ASSERT (strcmp (argv[1], "donald") == 0);
654 ASSERT (strcmp (argv[2], "-p") == 0);
655 ASSERT (strcmp (argv[3], "billy") == 0);
656 ASSERT (strcmp (argv[4], "duck") == 0);
657 ASSERT (strcmp (argv[5], "-a") == 0);
658 ASSERT (strcmp (argv[6], "bar") == 0);
659 ASSERT (a_seen == 1);
660 ASSERT (b_seen == 0);
661 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
662 ASSERT (q_value == NULL);
663 ASSERT (non_options_count == 3);
664 ASSERT (strcmp (non_options[0], "donald") == 0);
665 ASSERT (strcmp (non_options[1], "duck") == 0);
666 ASSERT (strcmp (non_options[2], "bar") == 0);
667 ASSERT (unrecognized == 0);
668 ASSERT (optind == 7);
671 /* Check that '--' ends the argument processing. */
672 for (start = OPTIND_MIN; start <= 1; start++)
674 const char *p_value = NULL;
675 const char *q_value = NULL;
676 int non_options_count = 0;
677 const char *non_options[10];
678 int unrecognized = 0;
684 argv[argc++] = "program";
685 argv[argc++] = "donald";
687 argv[argc++] = "billy";
688 argv[argc++] = "duck";
692 argv[argc++] = "foo";
694 argv[argc++] = "johnny";
695 argv[argc++] = "bar";
697 getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
699 &non_options_count, non_options, &unrecognized);
700 ASSERT (strcmp (argv[0], "program") == 0);
701 ASSERT (strcmp (argv[1], "donald") == 0);
702 ASSERT (strcmp (argv[2], "-p") == 0);
703 ASSERT (strcmp (argv[3], "billy") == 0);
704 ASSERT (strcmp (argv[4], "duck") == 0);
705 ASSERT (strcmp (argv[5], "-a") == 0);
706 ASSERT (strcmp (argv[6], "--") == 0);
707 ASSERT (strcmp (argv[7], "-b") == 0);
708 ASSERT (strcmp (argv[8], "foo") == 0);
709 ASSERT (strcmp (argv[9], "-q") == 0);
710 ASSERT (strcmp (argv[10], "johnny") == 0);
711 ASSERT (strcmp (argv[11], "bar") == 0);
712 ASSERT (a_seen == 1);
713 ASSERT (b_seen == 0);
714 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
715 ASSERT (q_value == NULL);
716 if (non_options_count == 2)
718 /* glibc behaviour. */
719 ASSERT (non_options_count == 2);
720 ASSERT (strcmp (non_options[0], "donald") == 0);
721 ASSERT (strcmp (non_options[1], "duck") == 0);
722 ASSERT (unrecognized == 0);
723 ASSERT (optind == 7);
727 /* Another valid behaviour. */
728 ASSERT (non_options_count == 7);
729 ASSERT (strcmp (non_options[0], "donald") == 0);
730 ASSERT (strcmp (non_options[1], "duck") == 0);
731 ASSERT (strcmp (non_options[2], "-b") == 0);
732 ASSERT (strcmp (non_options[3], "foo") == 0);
733 ASSERT (strcmp (non_options[4], "-q") == 0);
734 ASSERT (strcmp (non_options[5], "johnny") == 0);
735 ASSERT (strcmp (non_options[6], "bar") == 0);
736 ASSERT (unrecognized == 0);
737 ASSERT (optind == 12);
741 /* Check that the '-' flag has to come first. */
742 for (start = OPTIND_MIN; start <= 1; start++)
744 const char *p_value = NULL;
745 const char *q_value = NULL;
746 int non_options_count = 0;
747 const char *non_options[10];
748 int unrecognized = 0;
754 argv[argc++] = "program";
755 argv[argc++] = "donald";
757 argv[argc++] = "billy";
758 argv[argc++] = "duck";
760 argv[argc++] = "bar";
762 getopt_long_loop (argc, argv, "abp:q:-", long_options_required,
764 &non_options_count, non_options, &unrecognized);
765 ASSERT (strcmp (argv[0], "program") == 0);
766 ASSERT (strcmp (argv[1], "-p") == 0);
767 ASSERT (strcmp (argv[2], "billy") == 0);
768 ASSERT (strcmp (argv[3], "-a") == 0);
769 ASSERT (strcmp (argv[4], "donald") == 0);
770 ASSERT (strcmp (argv[5], "duck") == 0);
771 ASSERT (strcmp (argv[6], "bar") == 0);
772 ASSERT (a_seen == 1);
773 ASSERT (b_seen == 0);
774 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
775 ASSERT (q_value == NULL);
776 ASSERT (non_options_count == 0);
777 ASSERT (unrecognized == 0);
778 ASSERT (optind == 4);
781 /* Check that the '+' flag causes the first non-option to terminate the
783 for (start = OPTIND_MIN; start <= 1; start++)
785 const char *p_value = NULL;
786 const char *q_value = NULL;
787 int non_options_count = 0;
788 const char *non_options[10];
789 int unrecognized = 0;
795 argv[argc++] = "program";
796 argv[argc++] = "donald";
798 argv[argc++] = "billy";
799 argv[argc++] = "duck";
801 argv[argc++] = "bar";
803 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
805 &non_options_count, non_options, &unrecognized);
806 ASSERT (strcmp (argv[0], "program") == 0);
807 ASSERT (strcmp (argv[1], "donald") == 0);
808 ASSERT (strcmp (argv[2], "-p") == 0);
809 ASSERT (strcmp (argv[3], "billy") == 0);
810 ASSERT (strcmp (argv[4], "duck") == 0);
811 ASSERT (strcmp (argv[5], "-a") == 0);
812 ASSERT (strcmp (argv[6], "bar") == 0);
813 ASSERT (a_seen == 0);
814 ASSERT (b_seen == 0);
815 ASSERT (p_value == NULL);
816 ASSERT (q_value == NULL);
817 ASSERT (non_options_count == 0);
818 ASSERT (unrecognized == 0);
819 ASSERT (optind == 1);
821 for (start = OPTIND_MIN; start <= 1; start++)
823 const char *p_value = NULL;
824 const char *q_value = NULL;
825 int non_options_count = 0;
826 const char *non_options[10];
827 int unrecognized = 0;
833 argv[argc++] = "program";
836 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
838 &non_options_count, non_options, &unrecognized);
839 ASSERT (a_seen == 0);
840 ASSERT (b_seen == 0);
841 ASSERT (p_value == NULL);
842 ASSERT (q_value == NULL);
843 ASSERT (non_options_count == 0);
844 ASSERT (unrecognized == '+');
845 ASSERT (optind == 2);
848 /* Check that '--' ends the argument processing. */
849 for (start = OPTIND_MIN; start <= 1; start++)
851 const char *p_value = NULL;
852 const char *q_value = NULL;
853 int non_options_count = 0;
854 const char *non_options[10];
855 int unrecognized = 0;
861 argv[argc++] = "program";
862 argv[argc++] = "donald";
864 argv[argc++] = "billy";
865 argv[argc++] = "duck";
869 argv[argc++] = "foo";
871 argv[argc++] = "johnny";
872 argv[argc++] = "bar";
874 getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
876 &non_options_count, non_options, &unrecognized);
877 ASSERT (strcmp (argv[0], "program") == 0);
878 ASSERT (strcmp (argv[1], "donald") == 0);
879 ASSERT (strcmp (argv[2], "-p") == 0);
880 ASSERT (strcmp (argv[3], "billy") == 0);
881 ASSERT (strcmp (argv[4], "duck") == 0);
882 ASSERT (strcmp (argv[5], "-a") == 0);
883 ASSERT (strcmp (argv[6], "--") == 0);
884 ASSERT (strcmp (argv[7], "-b") == 0);
885 ASSERT (strcmp (argv[8], "foo") == 0);
886 ASSERT (strcmp (argv[9], "-q") == 0);
887 ASSERT (strcmp (argv[10], "johnny") == 0);
888 ASSERT (strcmp (argv[11], "bar") == 0);
889 ASSERT (a_seen == 0);
890 ASSERT (b_seen == 0);
891 ASSERT (p_value == NULL);
892 ASSERT (q_value == NULL);
893 ASSERT (non_options_count == 0);
894 ASSERT (unrecognized == 0);
898 /* Check that the '+' flag has to come first. */
899 for (start = OPTIND_MIN; start <= 1; start++)
901 const char *p_value = NULL;
902 const char *q_value = NULL;
903 int non_options_count = 0;
904 const char *non_options[10];
905 int unrecognized = 0;
911 argv[argc++] = "program";
912 argv[argc++] = "donald";
914 argv[argc++] = "billy";
915 argv[argc++] = "duck";
917 argv[argc++] = "bar";
919 getopt_long_loop (argc, argv, "abp:q:+", long_options_required,
921 &non_options_count, non_options, &unrecognized);
922 ASSERT (strcmp (argv[0], "program") == 0);
923 ASSERT (strcmp (argv[1], "-p") == 0);
924 ASSERT (strcmp (argv[2], "billy") == 0);
925 ASSERT (strcmp (argv[3], "-a") == 0);
926 ASSERT (strcmp (argv[4], "donald") == 0);
927 ASSERT (strcmp (argv[5], "duck") == 0);
928 ASSERT (strcmp (argv[6], "bar") == 0);
929 ASSERT (a_seen == 1);
930 ASSERT (b_seen == 0);
931 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
932 ASSERT (q_value == NULL);
933 ASSERT (non_options_count == 0);
934 ASSERT (unrecognized == 0);
935 ASSERT (optind == 4);