1 /* Test of command line argument processing.
2 Copyright (C) 2009-2023 Free Software Foundation, Inc.
3
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.
8
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.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17 /* Written by Bruno Haible <bruno@clisp.org>, 2009. */
18
19
20 /* The glibc/gnulib implementation of getopt supports setting optind =
21 0, but not all other implementations do. This matters for getopt.
22 But for getopt_long, we require GNU compatibility. */
23 #if defined __GETOPT_PREFIX || (__GLIBC__ >= 2 && !defined __UCLIBC__)
24 # define OPTIND_MIN 0
25 #elif HAVE_DECL_OPTRESET
26 # define OPTIND_MIN (optreset = 1)
27 #else
28 # define OPTIND_MIN 1
29 #endif
30
31 static void
32 getopt_loop (int argc, const char **argv,
33 const char *options,
34 int *a_seen, int *b_seen,
35 const char **p_value, const char **q_value,
36 int *non_options_count, const char **non_options,
37 int *unrecognized, bool *message_issued)
38 {
39 int c;
40 int pos = ftell (stderr);
41
42 while ((c = getopt (argc, (char **) argv, options)) != -1)
43 {
44 switch (c)
45 {
46 case 'a':
47 (*a_seen)++;
48 break;
49 case 'b':
50 (*b_seen)++;
51 break;
52 case 'p':
53 *p_value = optarg;
54 break;
55 case 'q':
56 *q_value = optarg;
57 break;
58 case '\1':
59 /* Must only happen with option '-' at the beginning. */
60 ASSERT (options[0] == '-');
61 non_options[(*non_options_count)++] = optarg;
62 break;
63 case ':':
64 /* Must only happen with option ':' at the beginning. */
65 ASSERT (options[0] == ':'
66 || ((options[0] == '-' || options[0] == '+')
67 && options[1] == ':'));
68 FALLTHROUGH;
69 case '?':
70 *unrecognized = optopt;
71 break;
72 default:
73 *unrecognized = c;
74 break;
75 }
76 }
77
78 *message_issued = pos < ftell (stderr);
79 }
80
81 static void
82 test_getopt (void)
83 {
84 int start;
85 bool posixly = !!getenv ("POSIXLY_CORRECT");
86 /* See comment in getopt.c:
87 glibc gets a LSB-compliant getopt.
88 Standalone applications get a POSIX-compliant getopt. */
89 #if defined __GETOPT_PREFIX || !(__GLIBC__ >= 2 || defined __MINGW32__)
90 /* Using getopt from gnulib or from a non-glibc system. */
91 posixly = true;
92 #endif
93
94 /* Test processing of boolean options. */
95 for (start = OPTIND_MIN; start <= 1; start++)
96 {
97 int a_seen = 0;
98 int b_seen = 0;
99 const char *p_value = NULL;
100 const char *q_value = NULL;
101 int non_options_count = 0;
102 const char *non_options[10];
103 int unrecognized = 0;
104 bool output;
105 int argc = 0;
106 const char *argv[10];
107
108 argv[argc++] = "program";
109 argv[argc++] = "-a";
110 argv[argc++] = "foo";
111 argv[argc++] = "bar";
112 argv[argc] = NULL;
113 optind = start;
114 opterr = 1;
115 getopt_loop (argc, argv, "ab",
116 &a_seen, &b_seen, &p_value, &q_value,
117 &non_options_count, non_options, &unrecognized, &output);
118 ASSERT (a_seen == 1);
119 ASSERT (b_seen == 0);
120 ASSERT (p_value == NULL);
121 ASSERT (q_value == NULL);
122 ASSERT (non_options_count == 0);
123 ASSERT (unrecognized == 0);
124 ASSERT (optind == 2);
125 ASSERT (!output);
126 }
127 for (start = OPTIND_MIN; start <= 1; start++)
128 {
129 int a_seen = 0;
130 int b_seen = 0;
131 const char *p_value = NULL;
132 const char *q_value = NULL;
133 int non_options_count = 0;
134 const char *non_options[10];
135 int unrecognized = 0;
136 bool output;
137 int argc = 0;
138 const char *argv[10];
139
140 argv[argc++] = "program";
141 argv[argc++] = "-b";
142 argv[argc++] = "-a";
143 argv[argc++] = "foo";
144 argv[argc++] = "bar";
145 argv[argc] = NULL;
146 optind = start;
147 opterr = 1;
148 getopt_loop (argc, argv, "ab",
149 &a_seen, &b_seen, &p_value, &q_value,
150 &non_options_count, non_options, &unrecognized, &output);
151 ASSERT (a_seen == 1);
152 ASSERT (b_seen == 1);
153 ASSERT (p_value == NULL);
154 ASSERT (q_value == NULL);
155 ASSERT (non_options_count == 0);
156 ASSERT (unrecognized == 0);
157 ASSERT (optind == 3);
158 ASSERT (!output);
159 }
160 for (start = OPTIND_MIN; start <= 1; start++)
161 {
162 int a_seen = 0;
163 int b_seen = 0;
164 const char *p_value = NULL;
165 const char *q_value = NULL;
166 int non_options_count = 0;
167 const char *non_options[10];
168 int unrecognized = 0;
169 bool output;
170 int argc = 0;
171 const char *argv[10];
172
173 argv[argc++] = "program";
174 argv[argc++] = "-ba";
175 argv[argc++] = "foo";
176 argv[argc++] = "bar";
177 argv[argc] = NULL;
178 optind = start;
179 opterr = 1;
180 getopt_loop (argc, argv, "ab",
181 &a_seen, &b_seen, &p_value, &q_value,
182 &non_options_count, non_options, &unrecognized, &output);
183 ASSERT (a_seen == 1);
184 ASSERT (b_seen == 1);
185 ASSERT (p_value == NULL);
186 ASSERT (q_value == NULL);
187 ASSERT (non_options_count == 0);
188 ASSERT (unrecognized == 0);
189 ASSERT (optind == 2);
190 ASSERT (!output);
191 }
192 for (start = OPTIND_MIN; start <= 1; start++)
193 {
194 int a_seen = 0;
195 int b_seen = 0;
196 const char *p_value = NULL;
197 const char *q_value = NULL;
198 int non_options_count = 0;
199 const char *non_options[10];
200 int unrecognized = 0;
201 bool output;
202 int argc = 0;
203 const char *argv[10];
204
205 argv[argc++] = "program";
206 argv[argc++] = "-ab";
207 argv[argc++] = "-a";
208 argv[argc++] = "foo";
209 argv[argc++] = "bar";
210 argv[argc] = NULL;
211 optind = start;
212 opterr = 1;
213 getopt_loop (argc, argv, "ab",
214 &a_seen, &b_seen, &p_value, &q_value,
215 &non_options_count, non_options, &unrecognized, &output);
216 ASSERT (a_seen == 2);
217 ASSERT (b_seen == 1);
218 ASSERT (p_value == NULL);
219 ASSERT (q_value == NULL);
220 ASSERT (non_options_count == 0);
221 ASSERT (unrecognized == 0);
222 ASSERT (optind == 3);
223 ASSERT (!output);
224 }
225
226 /* Test processing of options with arguments. */
227 for (start = OPTIND_MIN; start <= 1; start++)
228 {
229 int a_seen = 0;
230 int b_seen = 0;
231 const char *p_value = NULL;
232 const char *q_value = NULL;
233 int non_options_count = 0;
234 const char *non_options[10];
235 int unrecognized = 0;
236 bool output;
237 int argc = 0;
238 const char *argv[10];
239
240 argv[argc++] = "program";
241 argv[argc++] = "-pfoo";
242 argv[argc++] = "bar";
243 argv[argc] = NULL;
244 optind = start;
245 opterr = 1;
246 getopt_loop (argc, argv, "p:q:",
247 &a_seen, &b_seen, &p_value, &q_value,
248 &non_options_count, non_options, &unrecognized, &output);
249 ASSERT (a_seen == 0);
250 ASSERT (b_seen == 0);
251 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
252 ASSERT (q_value == NULL);
253 ASSERT (non_options_count == 0);
254 ASSERT (unrecognized == 0);
255 ASSERT (optind == 2);
256 ASSERT (!output);
257 }
258 for (start = OPTIND_MIN; start <= 1; start++)
259 {
260 int a_seen = 0;
261 int b_seen = 0;
262 const char *p_value = NULL;
263 const char *q_value = NULL;
264 int non_options_count = 0;
265 const char *non_options[10];
266 int unrecognized = 0;
267 bool output;
268 int argc = 0;
269 const char *argv[10];
270
271 argv[argc++] = "program";
272 argv[argc++] = "-p";
273 argv[argc++] = "foo";
274 argv[argc++] = "bar";
275 argv[argc] = NULL;
276 optind = start;
277 opterr = 1;
278 getopt_loop (argc, argv, "p:q:",
279 &a_seen, &b_seen, &p_value, &q_value,
280 &non_options_count, non_options, &unrecognized, &output);
281 ASSERT (a_seen == 0);
282 ASSERT (b_seen == 0);
283 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
284 ASSERT (q_value == NULL);
285 ASSERT (non_options_count == 0);
286 ASSERT (unrecognized == 0);
287 ASSERT (optind == 3);
288 ASSERT (!output);
289 }
290 for (start = OPTIND_MIN; start <= 1; start++)
291 {
292 int a_seen = 0;
293 int b_seen = 0;
294 const char *p_value = NULL;
295 const char *q_value = NULL;
296 int non_options_count = 0;
297 const char *non_options[10];
298 int unrecognized = 0;
299 bool output;
300 int argc = 0;
301 const char *argv[10];
302
303 argv[argc++] = "program";
304 argv[argc++] = "-ab";
305 argv[argc++] = "-q";
306 argv[argc++] = "baz";
307 argv[argc++] = "-pfoo";
308 argv[argc++] = "bar";
309 argv[argc] = NULL;
310 optind = start;
311 opterr = 1;
312 getopt_loop (argc, argv, "abp:q:",
313 &a_seen, &b_seen, &p_value, &q_value,
314 &non_options_count, non_options, &unrecognized, &output);
315 ASSERT (a_seen == 1);
316 ASSERT (b_seen == 1);
317 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
318 ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
319 ASSERT (non_options_count == 0);
320 ASSERT (unrecognized == 0);
321 ASSERT (optind == 5);
322 ASSERT (!output);
323 }
324
325 #if GNULIB_TEST_GETOPT_GNU
326 /* Test processing of options with optional arguments. */
327 for (start = OPTIND_MIN; start <= 1; start++)
328 {
329 int a_seen = 0;
330 int b_seen = 0;
331 const char *p_value = NULL;
332 const char *q_value = NULL;
333 int non_options_count = 0;
334 const char *non_options[10];
335 int unrecognized = 0;
336 bool output;
337 int argc = 0;
338 const char *argv[10];
339
340 argv[argc++] = "program";
341 argv[argc++] = "-pfoo";
342 argv[argc++] = "bar";
343 argv[argc] = NULL;
344 optind = start;
345 opterr = 1;
346 getopt_loop (argc, argv, "p::q::",
347 &a_seen, &b_seen, &p_value, &q_value,
348 &non_options_count, non_options, &unrecognized, &output);
349 ASSERT (a_seen == 0);
350 ASSERT (b_seen == 0);
351 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
352 ASSERT (q_value == NULL);
353 ASSERT (non_options_count == 0);
354 ASSERT (unrecognized == 0);
355 ASSERT (optind == 2);
356 ASSERT (!output);
357 }
358 for (start = OPTIND_MIN; start <= 1; start++)
359 {
360 int a_seen = 0;
361 int b_seen = 0;
362 const char *p_value = NULL;
363 const char *q_value = NULL;
364 int non_options_count = 0;
365 const char *non_options[10];
366 int unrecognized = 0;
367 bool output;
368 int argc = 0;
369 const char *argv[10];
370
371 argv[argc++] = "program";
372 argv[argc++] = "-p";
373 argv[argc++] = "foo";
374 argv[argc++] = "bar";
375 argv[argc] = NULL;
376 optind = start;
377 opterr = 1;
378 getopt_loop (argc, argv, "p::q::",
379 &a_seen, &b_seen, &p_value, &q_value,
380 &non_options_count, non_options, &unrecognized, &output);
381 ASSERT (a_seen == 0);
382 ASSERT (b_seen == 0);
383 ASSERT (p_value == NULL);
384 ASSERT (q_value == NULL);
385 ASSERT (non_options_count == 0);
386 ASSERT (unrecognized == 0);
387 ASSERT (optind == 2);
388 ASSERT (!output);
389 }
390 for (start = OPTIND_MIN; start <= 1; start++)
391 {
392 int a_seen = 0;
393 int b_seen = 0;
394 const char *p_value = NULL;
395 const char *q_value = NULL;
396 int non_options_count = 0;
397 const char *non_options[10];
398 int unrecognized = 0;
399 bool output;
400 int argc = 0;
401 const char *argv[10];
402
403 argv[argc++] = "program";
404 argv[argc++] = "-p";
405 argv[argc++] = "-a";
406 argv[argc++] = "bar";
407 argv[argc] = NULL;
408 optind = start;
409 opterr = 1;
410 getopt_loop (argc, argv, "abp::q::",
411 &a_seen, &b_seen, &p_value, &q_value,
412 &non_options_count, non_options, &unrecognized, &output);
413 ASSERT (a_seen == 1);
414 ASSERT (b_seen == 0);
415 ASSERT (p_value == NULL);
416 ASSERT (q_value == NULL);
417 ASSERT (non_options_count == 0);
418 ASSERT (unrecognized == 0);
419 ASSERT (optind == 3);
420 ASSERT (!output);
421 }
422 #endif /* GNULIB_TEST_GETOPT_GNU */
423
424 /* Check that invalid options are recognized; and that both opterr
425 and leading ':' can silence output. */
426 for (start = OPTIND_MIN; start <= 1; start++)
427 {
428 int a_seen = 0;
429 int b_seen = 0;
430 const char *p_value = NULL;
431 const char *q_value = NULL;
432 int non_options_count = 0;
433 const char *non_options[10];
434 int unrecognized = 0;
435 bool output;
436 int argc = 0;
437 const char *argv[10];
438
439 argv[argc++] = "program";
440 argv[argc++] = "-p";
441 argv[argc++] = "foo";
442 argv[argc++] = "-x";
443 argv[argc++] = "-a";
444 argv[argc++] = "bar";
445 argv[argc] = NULL;
446 optind = start;
447 opterr = 42;
448 getopt_loop (argc, argv, "abp:q:",
449 &a_seen, &b_seen, &p_value, &q_value,
450 &non_options_count, non_options, &unrecognized, &output);
451 ASSERT (a_seen == 1);
452 ASSERT (b_seen == 0);
453 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
454 ASSERT (q_value == NULL);
455 ASSERT (non_options_count == 0);
456 ASSERT (unrecognized == 'x');
457 ASSERT (optind == 5);
458 ASSERT (output);
459 }
460 for (start = OPTIND_MIN; start <= 1; start++)
461 {
462 int a_seen = 0;
463 int b_seen = 0;
464 const char *p_value = NULL;
465 const char *q_value = NULL;
466 int non_options_count = 0;
467 const char *non_options[10];
468 int unrecognized = 0;
469 bool output;
470 int argc = 0;
471 const char *argv[10];
472
473 argv[argc++] = "program";
474 argv[argc++] = "-p";
475 argv[argc++] = "foo";
476 argv[argc++] = "-x";
477 argv[argc++] = "-a";
478 argv[argc++] = "bar";
479 argv[argc] = NULL;
480 optind = start;
481 opterr = 0;
482 getopt_loop (argc, argv, "abp:q:",
483 &a_seen, &b_seen, &p_value, &q_value,
484 &non_options_count, non_options, &unrecognized, &output);
485 ASSERT (a_seen == 1);
486 ASSERT (b_seen == 0);
487 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
488 ASSERT (q_value == NULL);
489 ASSERT (non_options_count == 0);
490 ASSERT (unrecognized == 'x');
491 ASSERT (optind == 5);
492 ASSERT (!output);
493 }
494 for (start = OPTIND_MIN; start <= 1; start++)
495 {
496 int a_seen = 0;
497 int b_seen = 0;
498 const char *p_value = NULL;
499 const char *q_value = NULL;
500 int non_options_count = 0;
501 const char *non_options[10];
502 int unrecognized = 0;
503 bool output;
504 int argc = 0;
505 const char *argv[10];
506
507 argv[argc++] = "program";
508 argv[argc++] = "-p";
509 argv[argc++] = "foo";
510 argv[argc++] = "-x";
511 argv[argc++] = "-a";
512 argv[argc++] = "bar";
513 argv[argc] = NULL;
514 optind = start;
515 opterr = 1;
516 getopt_loop (argc, argv, ":abp:q:",
517 &a_seen, &b_seen, &p_value, &q_value,
518 &non_options_count, non_options, &unrecognized, &output);
519 ASSERT (a_seen == 1);
520 ASSERT (b_seen == 0);
521 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
522 ASSERT (q_value == NULL);
523 ASSERT (non_options_count == 0);
524 ASSERT (unrecognized == 'x');
525 ASSERT (optind == 5);
526 ASSERT (!output);
527 }
528 for (start = OPTIND_MIN; start <= 1; start++)
529 {
530 int a_seen = 0;
531 int b_seen = 0;
532 const char *p_value = NULL;
533 const char *q_value = NULL;
534 int non_options_count = 0;
535 const char *non_options[10];
536 int unrecognized = 0;
537 bool output;
538 int argc = 0;
539 const char *argv[10];
540
541 argv[argc++] = "program";
542 argv[argc++] = "-p";
543 argv[argc++] = "foo";
544 argv[argc++] = "-:";
545 argv[argc++] = "-a";
546 argv[argc++] = "bar";
547 argv[argc] = NULL;
548 optind = start;
549 opterr = 42;
550 getopt_loop (argc, argv, "abp:q:",
551 &a_seen, &b_seen, &p_value, &q_value,
552 &non_options_count, non_options, &unrecognized, &output);
553 ASSERT (a_seen == 1);
554 ASSERT (b_seen == 0);
555 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
556 ASSERT (q_value == NULL);
557 ASSERT (non_options_count == 0);
558 ASSERT (unrecognized == ':');
559 ASSERT (optind == 5);
560 ASSERT (output);
561 }
562 for (start = OPTIND_MIN; start <= 1; start++)
563 {
564 int a_seen = 0;
565 int b_seen = 0;
566 const char *p_value = NULL;
567 const char *q_value = NULL;
568 int non_options_count = 0;
569 const char *non_options[10];
570 int unrecognized = 0;
571 bool output;
572 int argc = 0;
573 const char *argv[10];
574
575 argv[argc++] = "program";
576 argv[argc++] = "-p";
577 argv[argc++] = "foo";
578 argv[argc++] = "-:";
579 argv[argc++] = "-a";
580 argv[argc++] = "bar";
581 argv[argc] = NULL;
582 optind = start;
583 opterr = 0;
584 getopt_loop (argc, argv, "abp:q:",
585 &a_seen, &b_seen, &p_value, &q_value,
586 &non_options_count, non_options, &unrecognized, &output);
587 ASSERT (a_seen == 1);
588 ASSERT (b_seen == 0);
589 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
590 ASSERT (q_value == NULL);
591 ASSERT (non_options_count == 0);
592 ASSERT (unrecognized == ':');
593 ASSERT (optind == 5);
594 ASSERT (!output);
595 }
596 for (start = OPTIND_MIN; start <= 1; start++)
597 {
598 int a_seen = 0;
599 int b_seen = 0;
600 const char *p_value = NULL;
601 const char *q_value = NULL;
602 int non_options_count = 0;
603 const char *non_options[10];
604 int unrecognized = 0;
605 bool output;
606 int argc = 0;
607 const char *argv[10];
608
609 argv[argc++] = "program";
610 argv[argc++] = "-p";
611 argv[argc++] = "foo";
612 argv[argc++] = "-:";
613 argv[argc++] = "-a";
614 argv[argc++] = "bar";
615 argv[argc] = NULL;
616 optind = start;
617 opterr = 1;
618 getopt_loop (argc, argv, ":abp:q:",
619 &a_seen, &b_seen, &p_value, &q_value,
620 &non_options_count, non_options, &unrecognized, &output);
621 ASSERT (a_seen == 1);
622 ASSERT (b_seen == 0);
623 ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
624 ASSERT (q_value == NULL);
625 ASSERT (non_options_count == 0);
626 ASSERT (unrecognized == ':');
627 ASSERT (optind == 5);
628 ASSERT (!output);
629 }
630
631 /* Check for missing argument behavior. */
632 for (start = OPTIND_MIN; start <= 1; start++)
633 {
634 int a_seen = 0;
635 int b_seen = 0;
636 const char *p_value = NULL;
637 const char *q_value = NULL;
638 int non_options_count = 0;
639 const char *non_options[10];
640 int unrecognized = 0;
641 bool output;
642 int argc = 0;
643 const char *argv[10];
644
645 argv[argc++] = "program";
646 argv[argc++] = "-ap";
647 argv[argc] = NULL;
648 optind = start;
649 opterr = 1;
650 getopt_loop (argc, argv, "abp:q:",
651 &a_seen, &b_seen, &p_value, &q_value,
652 &non_options_count, non_options, &unrecognized, &output);
653 ASSERT (a_seen == 1);
654 ASSERT (b_seen == 0);
655 ASSERT (p_value == NULL);
656 ASSERT (q_value == NULL);
657 ASSERT (non_options_count == 0);
658 ASSERT (unrecognized == 'p');
659 ASSERT (optind == 2);
660 ASSERT (output);
661 }
662 for (start = OPTIND_MIN; start <= 1; start++)
663 {
664 int a_seen = 0;
665 int b_seen = 0;
666 const char *p_value = NULL;
667 const char *q_value = NULL;
668 int non_options_count = 0;
669 const char *non_options[10];
670 int unrecognized = 0;
671 bool output;
672 int argc = 0;
673 const char *argv[10];
674
675 argv[argc++] = "program";
676 argv[argc++] = "-ap";
677 argv[argc] = NULL;
678 optind = start;
679 opterr = 0;
680 getopt_loop (argc, argv, "abp:q:",
681 &a_seen, &b_seen, &p_value, &q_value,
682 &non_options_count, non_options, &unrecognized, &output);
683 ASSERT (a_seen == 1);
684 ASSERT (b_seen == 0);
685 ASSERT (p_value == NULL);
686 ASSERT (q_value == NULL);
687 ASSERT (non_options_count == 0);
688 ASSERT (unrecognized == 'p');
689 ASSERT (optind == 2);
690 ASSERT (!output);
691 }
692 for (start = OPTIND_MIN; start <= 1; start++)
693 {
694 int a_seen = 0;
695 int b_seen = 0;
696 const char *p_value = NULL;
697 const char *q_value = NULL;
698 int non_options_count = 0;
699 const char *non_options[10];
700 int unrecognized = 0;
701 bool output;
702 int argc = 0;
703 const char *argv[10];
704
705 argv[argc++] = "program";
706 argv[argc++] = "-ap";
707 argv[argc] = NULL;
708 optind = start;
709 opterr = 1;
710 getopt_loop (argc, argv, ":abp:q:",
711 &a_seen, &b_seen, &p_value, &q_value,
712 &non_options_count, non_options, &unrecognized, &output);
713 ASSERT (a_seen == 1);
714 ASSERT (b_seen == 0);
715 ASSERT (p_value == NULL);
716 ASSERT (q_value == NULL);
717 ASSERT (non_options_count == 0);
718 ASSERT (unrecognized == 'p');
719 ASSERT (optind == 2);
720 ASSERT (!output);
721 }
722
723 /* Check that by default, non-options arguments are moved to the end. */
724 for (start = OPTIND_MIN; start <= 1; start++)
725 {
726 int a_seen = 0;
727 int b_seen = 0;
728 const char *p_value = NULL;
729 const char *q_value = NULL;
730 int non_options_count = 0;
731 const char *non_options[10];
732 int unrecognized = 0;
733 bool output;
734 int argc = 0;
735 const char *argv[10];
736
737 argv[argc++] = "program";
738 argv[argc++] = "donald";
739 argv[argc++] = "-p";
740 argv[argc++] = "billy";
741 argv[argc++] = "duck";
742 argv[argc++] = "-a";
743 argv[argc++] = "bar";
744 argv[argc] = NULL;
745 optind = start;
746 opterr = 1;
747 getopt_loop (argc, argv, "abp:q:",
748 &a_seen, &b_seen, &p_value, &q_value,
749 &non_options_count, non_options, &unrecognized, &output);
750 if (posixly)
751 {
752 ASSERT (strcmp (argv[0], "program") == 0);
753 ASSERT (strcmp (argv[1], "donald") == 0);
754 ASSERT (strcmp (argv[2], "-p") == 0);
755 ASSERT (strcmp (argv[3], "billy") == 0);
756 ASSERT (strcmp (argv[4], "duck") == 0);
757 ASSERT (strcmp (argv[5], "-a") == 0);
758 ASSERT (strcmp (argv[6], "bar") == 0);
759 ASSERT (argv[7] == NULL);
760 ASSERT (a_seen == 0);
761 ASSERT (b_seen == 0);
762 ASSERT (p_value == NULL);
763 ASSERT (q_value == NULL);
764 ASSERT (non_options_count == 0);
765 ASSERT (unrecognized == 0);
766 ASSERT (optind == 1);
767 ASSERT (!output);
768 }
769 else
770 {
771 ASSERT (strcmp (argv[0], "program") == 0);
772 ASSERT (strcmp (argv[1], "-p") == 0);
773 ASSERT (strcmp (argv[2], "billy") == 0);
774 ASSERT (strcmp (argv[3], "-a") == 0);
775 ASSERT (strcmp (argv[4], "donald") == 0);
776 ASSERT (strcmp (argv[5], "duck") == 0);
777 ASSERT (strcmp (argv[6], "bar") == 0);
778 ASSERT (argv[7] == NULL);
779 ASSERT (a_seen == 1);
780 ASSERT (b_seen == 0);
781 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
782 ASSERT (q_value == NULL);
783 ASSERT (non_options_count == 0);
784 ASSERT (unrecognized == 0);
785 ASSERT (optind == 4);
786 ASSERT (!output);
787 }
788 }
789
790 /* Check that '--' ends the argument processing. */
791 for (start = OPTIND_MIN; start <= 1; start++)
792 {
793 int a_seen = 0;
794 int b_seen = 0;
795 const char *p_value = NULL;
796 const char *q_value = NULL;
797 int non_options_count = 0;
798 const char *non_options[10];
799 int unrecognized = 0;
800 bool output;
801 int argc = 0;
802 const char *argv[20];
803
804 argv[argc++] = "program";
805 argv[argc++] = "donald";
806 argv[argc++] = "-p";
807 argv[argc++] = "billy";
808 argv[argc++] = "duck";
809 argv[argc++] = "-a";
810 argv[argc++] = "--";
811 argv[argc++] = "-b";
812 argv[argc++] = "foo";
813 argv[argc++] = "-q";
814 argv[argc++] = "johnny";
815 argv[argc++] = "bar";
816 argv[argc] = NULL;
817 optind = start;
818 opterr = 1;
819 getopt_loop (argc, argv, "abp:q:",
820 &a_seen, &b_seen, &p_value, &q_value,
821 &non_options_count, non_options, &unrecognized, &output);
822 if (posixly)
823 {
824 ASSERT (strcmp (argv[0], "program") == 0);
825 ASSERT (strcmp (argv[1], "donald") == 0);
826 ASSERT (strcmp (argv[2], "-p") == 0);
827 ASSERT (strcmp (argv[3], "billy") == 0);
828 ASSERT (strcmp (argv[4], "duck") == 0);
829 ASSERT (strcmp (argv[5], "-a") == 0);
830 ASSERT (strcmp (argv[6], "--") == 0);
831 ASSERT (strcmp (argv[7], "-b") == 0);
832 ASSERT (strcmp (argv[8], "foo") == 0);
833 ASSERT (strcmp (argv[9], "-q") == 0);
834 ASSERT (strcmp (argv[10], "johnny") == 0);
835 ASSERT (strcmp (argv[11], "bar") == 0);
836 ASSERT (argv[12] == NULL);
837 ASSERT (a_seen == 0);
838 ASSERT (b_seen == 0);
839 ASSERT (p_value == NULL);
840 ASSERT (q_value == NULL);
841 ASSERT (non_options_count == 0);
842 ASSERT (unrecognized == 0);
843 ASSERT (optind == 1);
844 ASSERT (!output);
845 }
846 else
847 {
848 ASSERT (strcmp (argv[0], "program") == 0);
849 ASSERT (strcmp (argv[1], "-p") == 0);
850 ASSERT (strcmp (argv[2], "billy") == 0);
851 ASSERT (strcmp (argv[3], "-a") == 0);
852 ASSERT (strcmp (argv[4], "--") == 0);
853 ASSERT (strcmp (argv[5], "donald") == 0);
854 ASSERT (strcmp (argv[6], "duck") == 0);
855 ASSERT (strcmp (argv[7], "-b") == 0);
856 ASSERT (strcmp (argv[8], "foo") == 0);
857 ASSERT (strcmp (argv[9], "-q") == 0);
858 ASSERT (strcmp (argv[10], "johnny") == 0);
859 ASSERT (strcmp (argv[11], "bar") == 0);
860 ASSERT (argv[12] == NULL);
861 ASSERT (a_seen == 1);
862 ASSERT (b_seen == 0);
863 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
864 ASSERT (q_value == NULL);
865 ASSERT (non_options_count == 0);
866 ASSERT (unrecognized == 0);
867 ASSERT (optind == 5);
868 ASSERT (!output);
869 }
870 }
871
872 #if GNULIB_TEST_GETOPT_GNU
873 /* Check that the '-' flag causes non-options to be returned in order. */
874 for (start = OPTIND_MIN; start <= 1; start++)
875 {
876 int a_seen = 0;
877 int b_seen = 0;
878 const char *p_value = NULL;
879 const char *q_value = NULL;
880 int non_options_count = 0;
881 const char *non_options[10];
882 int unrecognized = 0;
883 bool output;
884 int argc = 0;
885 const char *argv[10];
886
887 argv[argc++] = "program";
888 argv[argc++] = "donald";
889 argv[argc++] = "-p";
890 argv[argc++] = "billy";
891 argv[argc++] = "duck";
892 argv[argc++] = "-a";
893 argv[argc++] = "bar";
894 argv[argc] = NULL;
895 optind = start;
896 opterr = 1;
897 getopt_loop (argc, argv, "-abp:q:",
898 &a_seen, &b_seen, &p_value, &q_value,
899 &non_options_count, non_options, &unrecognized, &output);
900 ASSERT (strcmp (argv[0], "program") == 0);
901 ASSERT (strcmp (argv[1], "donald") == 0);
902 ASSERT (strcmp (argv[2], "-p") == 0);
903 ASSERT (strcmp (argv[3], "billy") == 0);
904 ASSERT (strcmp (argv[4], "duck") == 0);
905 ASSERT (strcmp (argv[5], "-a") == 0);
906 ASSERT (strcmp (argv[6], "bar") == 0);
907 ASSERT (argv[7] == NULL);
908 ASSERT (a_seen == 1);
909 ASSERT (b_seen == 0);
910 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
911 ASSERT (q_value == NULL);
912 ASSERT (non_options_count == 3);
913 ASSERT (strcmp (non_options[0], "donald") == 0);
914 ASSERT (strcmp (non_options[1], "duck") == 0);
915 ASSERT (strcmp (non_options[2], "bar") == 0);
916 ASSERT (unrecognized == 0);
917 ASSERT (optind == 7);
918 ASSERT (!output);
919 }
920
921 /* Check that '--' ends the argument processing. */
922 for (start = OPTIND_MIN; start <= 1; start++)
923 {
924 int a_seen = 0;
925 int b_seen = 0;
926 const char *p_value = NULL;
927 const char *q_value = NULL;
928 int non_options_count = 0;
929 const char *non_options[10];
930 int unrecognized = 0;
931 bool output;
932 int argc = 0;
933 const char *argv[20];
934
935 argv[argc++] = "program";
936 argv[argc++] = "donald";
937 argv[argc++] = "-p";
938 argv[argc++] = "billy";
939 argv[argc++] = "duck";
940 argv[argc++] = "-a";
941 argv[argc++] = "--";
942 argv[argc++] = "-b";
943 argv[argc++] = "foo";
944 argv[argc++] = "-q";
945 argv[argc++] = "johnny";
946 argv[argc++] = "bar";
947 argv[argc] = NULL;
948 optind = start;
949 opterr = 1;
950 getopt_loop (argc, argv, "-abp:q:",
951 &a_seen, &b_seen, &p_value, &q_value,
952 &non_options_count, non_options, &unrecognized, &output);
953 ASSERT (strcmp (argv[0], "program") == 0);
954 ASSERT (strcmp (argv[1], "donald") == 0);
955 ASSERT (strcmp (argv[2], "-p") == 0);
956 ASSERT (strcmp (argv[3], "billy") == 0);
957 ASSERT (strcmp (argv[4], "duck") == 0);
958 ASSERT (strcmp (argv[5], "-a") == 0);
959 ASSERT (strcmp (argv[6], "--") == 0);
960 ASSERT (strcmp (argv[7], "-b") == 0);
961 ASSERT (strcmp (argv[8], "foo") == 0);
962 ASSERT (strcmp (argv[9], "-q") == 0);
963 ASSERT (strcmp (argv[10], "johnny") == 0);
964 ASSERT (strcmp (argv[11], "bar") == 0);
965 ASSERT (argv[12] == NULL);
966 ASSERT (a_seen == 1);
967 ASSERT (b_seen == 0);
968 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
969 ASSERT (q_value == NULL);
970 ASSERT (!output);
971 if (non_options_count == 2)
972 {
973 /* glibc behaviour. */
974 ASSERT (non_options_count == 2);
975 ASSERT (strcmp (non_options[0], "donald") == 0);
976 ASSERT (strcmp (non_options[1], "duck") == 0);
977 ASSERT (unrecognized == 0);
978 ASSERT (optind == 7);
979 }
980 else
981 {
982 /* Another valid behaviour. */
983 ASSERT (non_options_count == 7);
984 ASSERT (strcmp (non_options[0], "donald") == 0);
985 ASSERT (strcmp (non_options[1], "duck") == 0);
986 ASSERT (strcmp (non_options[2], "-b") == 0);
987 ASSERT (strcmp (non_options[3], "foo") == 0);
988 ASSERT (strcmp (non_options[4], "-q") == 0);
989 ASSERT (strcmp (non_options[5], "johnny") == 0);
990 ASSERT (strcmp (non_options[6], "bar") == 0);
991 ASSERT (unrecognized == 0);
992 ASSERT (optind == 12);
993 }
994 }
995
996 /* Check that the '-' flag has to come first. */
997 for (start = OPTIND_MIN; start <= 1; start++)
998 {
999 int a_seen = 0;
1000 int b_seen = 0;
1001 const char *p_value = NULL;
1002 const char *q_value = NULL;
1003 int non_options_count = 0;
1004 const char *non_options[10];
1005 int unrecognized = 0;
1006 bool output;
1007 int argc = 0;
1008 const char *argv[10];
1009
1010 argv[argc++] = "program";
1011 argv[argc++] = "donald";
1012 argv[argc++] = "-p";
1013 argv[argc++] = "billy";
1014 argv[argc++] = "duck";
1015 argv[argc++] = "-a";
1016 argv[argc++] = "bar";
1017 argv[argc] = NULL;
1018 optind = start;
1019 opterr = 1;
1020 getopt_loop (argc, argv, "abp:q:-",
1021 &a_seen, &b_seen, &p_value, &q_value,
1022 &non_options_count, non_options, &unrecognized, &output);
1023 if (posixly)
1024 {
1025 ASSERT (strcmp (argv[0], "program") == 0);
1026 ASSERT (strcmp (argv[1], "donald") == 0);
1027 ASSERT (strcmp (argv[2], "-p") == 0);
1028 ASSERT (strcmp (argv[3], "billy") == 0);
1029 ASSERT (strcmp (argv[4], "duck") == 0);
1030 ASSERT (strcmp (argv[5], "-a") == 0);
1031 ASSERT (strcmp (argv[6], "bar") == 0);
1032 ASSERT (argv[7] == NULL);
1033 ASSERT (a_seen == 0);
1034 ASSERT (b_seen == 0);
1035 ASSERT (p_value == NULL);
1036 ASSERT (q_value == NULL);
1037 ASSERT (non_options_count == 0);
1038 ASSERT (unrecognized == 0);
1039 ASSERT (optind == 1);
1040 ASSERT (!output);
1041 }
1042 else
1043 {
1044 ASSERT (strcmp (argv[0], "program") == 0);
1045 ASSERT (strcmp (argv[1], "-p") == 0);
1046 ASSERT (strcmp (argv[2], "billy") == 0);
1047 ASSERT (strcmp (argv[3], "-a") == 0);
1048 ASSERT (strcmp (argv[4], "donald") == 0);
1049 ASSERT (strcmp (argv[5], "duck") == 0);
1050 ASSERT (strcmp (argv[6], "bar") == 0);
1051 ASSERT (argv[7] == NULL);
1052 ASSERT (a_seen == 1);
1053 ASSERT (b_seen == 0);
1054 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1055 ASSERT (q_value == NULL);
1056 ASSERT (non_options_count == 0);
1057 ASSERT (unrecognized == 0);
1058 ASSERT (optind == 4);
1059 ASSERT (!output);
1060 }
1061 }
1062
1063 /* Check that the '+' flag causes the first non-option to terminate the
1064 loop. */
1065 for (start = OPTIND_MIN; start <= 1; start++)
1066 {
1067 int a_seen = 0;
1068 int b_seen = 0;
1069 const char *p_value = NULL;
1070 const char *q_value = NULL;
1071 int non_options_count = 0;
1072 const char *non_options[10];
1073 int unrecognized = 0;
1074 bool output;
1075 int argc = 0;
1076 const char *argv[10];
1077
1078 argv[argc++] = "program";
1079 argv[argc++] = "donald";
1080 argv[argc++] = "-p";
1081 argv[argc++] = "billy";
1082 argv[argc++] = "duck";
1083 argv[argc++] = "-a";
1084 argv[argc++] = "bar";
1085 argv[argc] = NULL;
1086 optind = start;
1087 opterr = 1;
1088 getopt_loop (argc, argv, "+abp:q:",
1089 &a_seen, &b_seen, &p_value, &q_value,
1090 &non_options_count, non_options, &unrecognized, &output);
1091 ASSERT (strcmp (argv[0], "program") == 0);
1092 ASSERT (strcmp (argv[1], "donald") == 0);
1093 ASSERT (strcmp (argv[2], "-p") == 0);
1094 ASSERT (strcmp (argv[3], "billy") == 0);
1095 ASSERT (strcmp (argv[4], "duck") == 0);
1096 ASSERT (strcmp (argv[5], "-a") == 0);
1097 ASSERT (strcmp (argv[6], "bar") == 0);
1098 ASSERT (argv[7] == NULL);
1099 ASSERT (a_seen == 0);
1100 ASSERT (b_seen == 0);
1101 ASSERT (p_value == NULL);
1102 ASSERT (q_value == NULL);
1103 ASSERT (non_options_count == 0);
1104 ASSERT (unrecognized == 0);
1105 ASSERT (optind == 1);
1106 ASSERT (!output);
1107 }
1108 for (start = OPTIND_MIN; start <= 1; start++)
1109 {
1110 int a_seen = 0;
1111 int b_seen = 0;
1112 const char *p_value = NULL;
1113 const char *q_value = NULL;
1114 int non_options_count = 0;
1115 const char *non_options[10];
1116 int unrecognized = 0;
1117 bool output;
1118 int argc = 0;
1119 const char *argv[10];
1120
1121 argv[argc++] = "program";
1122 argv[argc++] = "-+";
1123 argv[argc] = NULL;
1124 optind = start;
1125 getopt_loop (argc, argv, "+abp:q:",
1126 &a_seen, &b_seen, &p_value, &q_value,
1127 &non_options_count, non_options, &unrecognized, &output);
1128 ASSERT (a_seen == 0);
1129 ASSERT (b_seen == 0);
1130 ASSERT (p_value == NULL);
1131 ASSERT (q_value == NULL);
1132 ASSERT (non_options_count == 0);
1133 ASSERT (unrecognized == '+');
1134 ASSERT (optind == 2);
1135 ASSERT (output);
1136 }
1137
1138 /* Check that '--' ends the argument processing. */
1139 for (start = OPTIND_MIN; start <= 1; start++)
1140 {
1141 int a_seen = 0;
1142 int b_seen = 0;
1143 const char *p_value = NULL;
1144 const char *q_value = NULL;
1145 int non_options_count = 0;
1146 const char *non_options[10];
1147 int unrecognized = 0;
1148 bool output;
1149 int argc = 0;
1150 const char *argv[20];
1151
1152 argv[argc++] = "program";
1153 argv[argc++] = "donald";
1154 argv[argc++] = "-p";
1155 argv[argc++] = "billy";
1156 argv[argc++] = "duck";
1157 argv[argc++] = "-a";
1158 argv[argc++] = "--";
1159 argv[argc++] = "-b";
1160 argv[argc++] = "foo";
1161 argv[argc++] = "-q";
1162 argv[argc++] = "johnny";
1163 argv[argc++] = "bar";
1164 argv[argc] = NULL;
1165 optind = start;
1166 opterr = 1;
1167 getopt_loop (argc, argv, "+abp:q:",
1168 &a_seen, &b_seen, &p_value, &q_value,
1169 &non_options_count, non_options, &unrecognized, &output);
1170 ASSERT (strcmp (argv[0], "program") == 0);
1171 ASSERT (strcmp (argv[1], "donald") == 0);
1172 ASSERT (strcmp (argv[2], "-p") == 0);
1173 ASSERT (strcmp (argv[3], "billy") == 0);
1174 ASSERT (strcmp (argv[4], "duck") == 0);
1175 ASSERT (strcmp (argv[5], "-a") == 0);
1176 ASSERT (strcmp (argv[6], "--") == 0);
1177 ASSERT (strcmp (argv[7], "-b") == 0);
1178 ASSERT (strcmp (argv[8], "foo") == 0);
1179 ASSERT (strcmp (argv[9], "-q") == 0);
1180 ASSERT (strcmp (argv[10], "johnny") == 0);
1181 ASSERT (strcmp (argv[11], "bar") == 0);
1182 ASSERT (argv[12] == NULL);
1183 ASSERT (a_seen == 0);
1184 ASSERT (b_seen == 0);
1185 ASSERT (p_value == NULL);
1186 ASSERT (q_value == NULL);
1187 ASSERT (non_options_count == 0);
1188 ASSERT (unrecognized == 0);
1189 ASSERT (optind == 1);
1190 ASSERT (!output);
1191 }
1192 #endif /* GNULIB_TEST_GETOPT_GNU */
1193
1194 /* Check that the '+' flag has to come first. */
1195 for (start = OPTIND_MIN; start <= 1; start++)
1196 {
1197 int a_seen = 0;
1198 int b_seen = 0;
1199 const char *p_value = NULL;
1200 const char *q_value = NULL;
1201 int non_options_count = 0;
1202 const char *non_options[10];
1203 int unrecognized = 0;
1204 bool output;
1205 int argc = 0;
1206 const char *argv[10];
1207
1208 argv[argc++] = "program";
1209 argv[argc++] = "donald";
1210 argv[argc++] = "-p";
1211 argv[argc++] = "billy";
1212 argv[argc++] = "duck";
1213 argv[argc++] = "-a";
1214 argv[argc++] = "bar";
1215 argv[argc] = NULL;
1216 optind = start;
1217 opterr = 1;
1218 getopt_loop (argc, argv, "abp:q:+",
1219 &a_seen, &b_seen, &p_value, &q_value,
1220 &non_options_count, non_options, &unrecognized, &output);
1221 if (posixly)
1222 {
1223 ASSERT (strcmp (argv[0], "program") == 0);
1224 ASSERT (strcmp (argv[1], "donald") == 0);
1225 ASSERT (strcmp (argv[2], "-p") == 0);
1226 ASSERT (strcmp (argv[3], "billy") == 0);
1227 ASSERT (strcmp (argv[4], "duck") == 0);
1228 ASSERT (strcmp (argv[5], "-a") == 0);
1229 ASSERT (strcmp (argv[6], "bar") == 0);
1230 ASSERT (argv[7] == NULL);
1231 ASSERT (a_seen == 0);
1232 ASSERT (b_seen == 0);
1233 ASSERT (p_value == NULL);
1234 ASSERT (q_value == NULL);
1235 ASSERT (non_options_count == 0);
1236 ASSERT (unrecognized == 0);
1237 ASSERT (optind == 1);
1238 ASSERT (!output);
1239 }
1240 else
1241 {
1242 ASSERT (strcmp (argv[0], "program") == 0);
1243 ASSERT (strcmp (argv[1], "-p") == 0);
1244 ASSERT (strcmp (argv[2], "billy") == 0);
1245 ASSERT (strcmp (argv[3], "-a") == 0);
1246 ASSERT (strcmp (argv[4], "donald") == 0);
1247 ASSERT (strcmp (argv[5], "duck") == 0);
1248 ASSERT (strcmp (argv[6], "bar") == 0);
1249 ASSERT (argv[7] == NULL);
1250 ASSERT (a_seen == 1);
1251 ASSERT (b_seen == 0);
1252 ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1253 ASSERT (q_value == NULL);
1254 ASSERT (non_options_count == 0);
1255 ASSERT (unrecognized == 0);
1256 ASSERT (optind == 4);
1257 ASSERT (!output);
1258 }
1259 }
1260
1261 #if GNULIB_TEST_GETOPT_GNU
1262 /* If GNU extensions are supported, require compliance with POSIX
1263 interpretation on leading '+' behavior.
1264 http://austingroupbugs.net/view.php?id=191 */
1265 for (start = OPTIND_MIN; start <= 1; start++)
1266 {
1267 int a_seen = 0;
1268 int b_seen = 0;
1269 const char *p_value = NULL;
1270 const char *q_value = NULL;
1271 int non_options_count = 0;
1272 const char *non_options[10];
1273 int unrecognized = 0;
1274 bool output;
1275 int argc = 0;
1276 const char *argv[10];
1277
1278 argv[argc++] = "program";
1279 argv[argc++] = "donald";
1280 argv[argc++] = "-p";
1281 argv[argc++] = "billy";
1282 argv[argc++] = "duck";
1283 argv[argc++] = "-a";
1284 argv[argc++] = "bar";
1285 argv[argc] = NULL;
1286 optind = start;
1287 opterr = 1;
1288 getopt_loop (argc, argv, "+:abp:q:",
1289 &a_seen, &b_seen, &p_value, &q_value,
1290 &non_options_count, non_options, &unrecognized, &output);
1291 ASSERT (strcmp (argv[0], "program") == 0);
1292 ASSERT (strcmp (argv[1], "donald") == 0);
1293 ASSERT (strcmp (argv[2], "-p") == 0);
1294 ASSERT (strcmp (argv[3], "billy") == 0);
1295 ASSERT (strcmp (argv[4], "duck") == 0);
1296 ASSERT (strcmp (argv[5], "-a") == 0);
1297 ASSERT (strcmp (argv[6], "bar") == 0);
1298 ASSERT (argv[7] == NULL);
1299 ASSERT (a_seen == 0);
1300 ASSERT (b_seen == 0);
1301 ASSERT (p_value == NULL);
1302 ASSERT (q_value == NULL);
1303 ASSERT (non_options_count == 0);
1304 ASSERT (unrecognized == 0);
1305 ASSERT (optind == 1);
1306 ASSERT (!output);
1307 }
1308 for (start = OPTIND_MIN; start <= 1; start++)
1309 {
1310 int a_seen = 0;
1311 int b_seen = 0;
1312 const char *p_value = NULL;
1313 const char *q_value = NULL;
1314 int non_options_count = 0;
1315 const char *non_options[10];
1316 int unrecognized = 0;
1317 bool output;
1318 int argc = 0;
1319 const char *argv[10];
1320
1321 argv[argc++] = "program";
1322 argv[argc++] = "-p";
1323 argv[argc] = NULL;
1324 optind = start;
1325 getopt_loop (argc, argv, "+:abp:q:",
1326 &a_seen, &b_seen, &p_value, &q_value,
1327 &non_options_count, non_options, &unrecognized, &output);
1328 ASSERT (a_seen == 0);
1329 ASSERT (b_seen == 0);
1330 ASSERT (p_value == NULL);
1331 ASSERT (q_value == NULL);
1332 ASSERT (non_options_count == 0);
1333 ASSERT (unrecognized == 'p');
1334 ASSERT (optind == 2);
1335 ASSERT (!output);
1336 }
1337 for (start = OPTIND_MIN; start <= 1; start++)
1338 {
1339 int a_seen = 0;
1340 int b_seen = 0;
1341 const char *p_value = NULL;
1342 const char *q_value = NULL;
1343 int non_options_count = 0;
1344 const char *non_options[10];
1345 int unrecognized = 0;
1346 bool output;
1347 int argc = 0;
1348 const char *argv[10];
1349
1350 argv[argc++] = "program";
1351 argv[argc++] = "-b";
1352 argv[argc++] = "-p";
1353 argv[argc] = NULL;
1354 optind = start;
1355 getopt_loop (argc, argv, "+:abp:q:",
1356 &a_seen, &b_seen, &p_value, &q_value,
1357 &non_options_count, non_options, &unrecognized, &output);
1358 ASSERT (a_seen == 0);
1359 ASSERT (b_seen == 1);
1360 ASSERT (p_value == NULL);
1361 ASSERT (q_value == NULL);
1362 ASSERT (non_options_count == 0);
1363 ASSERT (unrecognized == 'p');
1364 ASSERT (optind == 3);
1365 ASSERT (!output);
1366 }
1367
1368 /* Check that 'W' does not dump core:
1369 https://sourceware.org/bugzilla/show_bug.cgi?id=12922
1370 Technically, POSIX says the presence of ';' in the opt-string
1371 gives unspecified behavior, so we only test this when GNU compliance
1372 is desired. */
1373 for (start = OPTIND_MIN; start <= 1; start++)
1374 {
1375 int argc = 0;
1376 const char *argv[10];
1377 int pos = ftell (stderr);
1378
1379 argv[argc++] = "program";
1380 argv[argc++] = "-W";
1381 argv[argc++] = "dummy";
1382 argv[argc] = NULL;
1383 optind = start;
1384 opterr = 1;
1385 ASSERT (getopt (argc, (char **) argv, "W;") == 'W');
1386 ASSERT (ftell (stderr) == pos);
1387 ASSERT (optind == 2);
1388 }
1389 #endif /* GNULIB_TEST_GETOPT_GNU */
1390 }