tests/test-getopt.h

   1 /* Test of command line argument processing.
   2    Copyright (C) 2009-2024 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 }