tests/test-getopt_long.h

   1 /* Test of command line argument processing.
   2    Copyright (C) 2009-2011 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 <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Bruno Haible <bruno@clisp.org>, 2009.  */
  18
  19 static int a_seen;
  20 static int b_seen;
  21 static int q_seen;
  22
  23 static const struct option long_options_required[] =
  24   {
  25     { "alpha",    no_argument,       NULL, 'a' },
  26     { "beta",     no_argument,       &b_seen, 1 },
  27     { "prune",    required_argument, NULL, 'p' },
  28     { "quetsche", required_argument, &q_seen, 1 },
  29     { "xtremely-",no_argument,       NULL, 1003 },
  30     { "xtra",     no_argument,       NULL, 1001 },
  31     { "xtreme",   no_argument,       NULL, 1002 },
  32     { "xtremely", no_argument,       NULL, 1003 },
  33     { NULL,       0,                 NULL, 0 }
  34   };
  35
  36 static const struct option long_options_optional[] =
  37   {
  38     { "alpha",    no_argument,       NULL, 'a' },
  39     { "beta",     no_argument,       &b_seen, 1 },
  40     { "prune",    optional_argument, NULL, 'p' },
  41     { "quetsche", optional_argument, &q_seen, 1 },
  42     { NULL,       0,                 NULL, 0 }
  43   };
  44
  45 static void
  46 getopt_long_loop (int argc, const char **argv,
  47                   const char *options, const struct option *long_options,
  48                   const char **p_value, const char **q_value,
  49                   int *non_options_count, const char **non_options,
  50                   int *unrecognized)
  51 {
  52   int option_index = -1;
  53   int c;
  54
  55   opterr = 0;
  56   q_seen = 0;
  57   while ((c = getopt_long (argc, (char **) argv, options, long_options,
  58                            &option_index))
  59          != -1)
  60     {
  61       switch (c)
  62         {
  63         case 0:
  64           /* An option with a non-NULL flag pointer was processed.  */
  65           if (q_seen)
  66             *q_value = optarg;
  67           break;
  68         case 'a':
  69           a_seen++;
  70           break;
  71         case 'b':
  72           b_seen = 1;
  73           break;
  74         case 'p':
  75           *p_value = optarg;
  76           break;
  77         case 'q':
  78           *q_value = optarg;
  79           break;
  80         case '\1':
  81           /* Must only happen with option '-' at the beginning.  */
  82           ASSERT (options[0] == '-');
  83           non_options[(*non_options_count)++] = optarg;
  84           break;
  85         case ':':
  86           /* Must only happen with option ':' at the beginning.  */
  87           ASSERT (options[0] == ':'
  88                   || ((options[0] == '-' || options[0] == '+')
  89                       && options[1] == ':'));
  90           /* fall through */
  91         case '?':
  92           *unrecognized = optopt;
  93           break;
  94         default:
  95           *unrecognized = c;
  96           break;
  97         }
  98     }
  99 }
 100
 101 /* Reduce casting, so we can use string literals elsewhere.
 102    getopt_long takes an array of char*, but luckily does not modify
 103    those elements, so we can pass const char*.  */
 104 static int
 105 do_getopt_long (int argc, const char **argv, const char *shortopts,
 106                 const struct option *longopts, int *longind)
 107 {
 108   return getopt_long (argc, (char **) argv, shortopts, longopts, longind);
 109 }
 110
 111 static void
 112 test_getopt_long (void)
 113 {
 114   int start;
 115
 116   /* Test disambiguation of options.  */
 117   {
 118     int argc = 0;
 119     const char *argv[10];
 120     int option_index;
 121     int c;
 122
 123     argv[argc++] = "program";
 124     argv[argc++] = "--x";
 125     argv[argc] = NULL;
 126     optind = 1;
 127     opterr = 0;
 128     c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
 129     ASSERT (c == '?');
 130     ASSERT (optopt == 0);
 131   }
 132   {
 133     int argc = 0;
 134     const char *argv[10];
 135     int option_index;
 136     int c;
 137
 138     argv[argc++] = "program";
 139     argv[argc++] = "--xt";
 140     argv[argc] = NULL;
 141     optind = 1;
 142     opterr = 0;
 143     c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
 144     ASSERT (c == '?');
 145     ASSERT (optopt == 0);
 146   }
 147   {
 148     int argc = 0;
 149     const char *argv[10];
 150     int option_index;
 151     int c;
 152
 153     argv[argc++] = "program";
 154     argv[argc++] = "--xtr";
 155     argv[argc] = NULL;
 156     optind = 1;
 157     opterr = 0;
 158     c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
 159     ASSERT (c == '?');
 160     ASSERT (optopt == 0);
 161   }
 162   {
 163     int argc = 0;
 164     const char *argv[10];
 165     int option_index;
 166     int c;
 167
 168     argv[argc++] = "program";
 169     argv[argc++] = "--xtra";
 170     argv[argc] = NULL;
 171     optind = 1;
 172     opterr = 0;
 173     c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
 174     ASSERT (c == 1001);
 175   }
 176   {
 177     int argc = 0;
 178     const char *argv[10];
 179     int option_index;
 180     int c;
 181
 182     argv[argc++] = "program";
 183     argv[argc++] = "--xtre";
 184     argv[argc] = NULL;
 185     optind = 1;
 186     opterr = 0;
 187     c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
 188     ASSERT (c == '?');
 189     ASSERT (optopt == 0);
 190   }
 191   {
 192     int argc = 0;
 193     const char *argv[10];
 194     int option_index;
 195     int c;
 196
 197     argv[argc++] = "program";
 198     argv[argc++] = "--xtrem";
 199     argv[argc] = NULL;
 200     optind = 1;
 201     opterr = 0;
 202     c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
 203     ASSERT (c == '?');
 204     ASSERT (optopt == 0);
 205   }
 206   {
 207     int argc = 0;
 208     const char *argv[10];
 209     int option_index;
 210     int c;
 211
 212     argv[argc++] = "program";
 213     argv[argc++] = "--xtreme";
 214     argv[argc] = NULL;
 215     optind = 1;
 216     opterr = 0;
 217     c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
 218     ASSERT (c == 1002);
 219   }
 220   {
 221     int argc = 0;
 222     const char *argv[10];
 223     int option_index;
 224     int c;
 225
 226     argv[argc++] = "program";
 227     argv[argc++] = "--xtremel";
 228     argv[argc] = NULL;
 229     optind = 1;
 230     opterr = 0;
 231     c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
 232     ASSERT (c == 1003);
 233   }
 234   {
 235     int argc = 0;
 236     const char *argv[10];
 237     int option_index;
 238     int c;
 239
 240     argv[argc++] = "program";
 241     argv[argc++] = "--xtremely";
 242     argv[argc] = NULL;
 243     optind = 1;
 244     opterr = 0;
 245     c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);
 246     ASSERT (c == 1003);
 247   }
 248
 249   /* Check that -W handles unknown options.  */
 250   {
 251     int argc = 0;
 252     const char *argv[10];
 253     int option_index;
 254     int c;
 255
 256     argv[argc++] = "program";
 257     argv[argc++] = "-W";
 258     argv[argc] = NULL;
 259     optind = 1;
 260     opterr = 0;
 261     c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);
 262     ASSERT (c == '?');
 263     ASSERT (optopt == 'W');
 264   }
 265   {
 266     int argc = 0;
 267     const char *argv[10];
 268     int option_index;
 269     int c;
 270
 271     argv[argc++] = "program";
 272     argv[argc++] = "-Wunknown";
 273     argv[argc] = NULL;
 274     optind = 1;
 275     opterr = 0;
 276     c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);
 277     /* glibc and BSD behave differently here, but for now, we allow
 278        both behaviors since W support is not frequently used.  */
 279     if (c == '?')
 280       {
 281         ASSERT (optopt == 0);
 282         ASSERT (optarg == NULL);
 283       }
 284     else
 285       {
 286         ASSERT (c == 'W');
 287         ASSERT (strcmp (optarg, "unknown") == 0);
 288       }
 289   }
 290   {
 291     int argc = 0;
 292     const char *argv[10];
 293     int option_index;
 294     int c;
 295
 296     argv[argc++] = "program";
 297     argv[argc++] = "-W";
 298     argv[argc++] = "unknown";
 299     argv[argc] = NULL;
 300     optind = 1;
 301     opterr = 0;
 302     c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);
 303     /* glibc and BSD behave differently here, but for now, we allow
 304        both behaviors since W support is not frequently used.  */
 305     if (c == '?')
 306       {
 307         ASSERT (optopt == 0);
 308         ASSERT (optarg == NULL);
 309       }
 310     else
 311       {
 312         ASSERT (c == 'W');
 313         ASSERT (strcmp (optarg, "unknown") == 0);
 314       }
 315   }
 316
 317   /* Test processing of boolean short options.  */
 318   for (start = 0; start <= 1; start++)
 319     {
 320       const char *p_value = NULL;
 321       const char *q_value = NULL;
 322       int non_options_count = 0;
 323       const char *non_options[10];
 324       int unrecognized = 0;
 325       int argc = 0;
 326       const char *argv[10];
 327       a_seen = 0;
 328       b_seen = 0;
 329
 330       argv[argc++] = "program";
 331       argv[argc++] = "-a";
 332       argv[argc++] = "foo";
 333       argv[argc++] = "bar";
 334       argv[argc] = NULL;
 335       optind = start;
 336       getopt_long_loop (argc, argv, "ab", long_options_required,
 337                         &p_value, &q_value,
 338                         &non_options_count, non_options, &unrecognized);
 339       ASSERT (a_seen == 1);
 340       ASSERT (b_seen == 0);
 341       ASSERT (p_value == NULL);
 342       ASSERT (q_value == NULL);
 343       ASSERT (non_options_count == 0);
 344       ASSERT (unrecognized == 0);
 345       ASSERT (optind == 2);
 346     }
 347   for (start = 0; start <= 1; start++)
 348     {
 349       const char *p_value = NULL;
 350       const char *q_value = NULL;
 351       int non_options_count = 0;
 352       const char *non_options[10];
 353       int unrecognized = 0;
 354       int argc = 0;
 355       const char *argv[10];
 356       a_seen = 0;
 357       b_seen = 0;
 358
 359       argv[argc++] = "program";
 360       argv[argc++] = "-b";
 361       argv[argc++] = "-a";
 362       argv[argc++] = "foo";
 363       argv[argc++] = "bar";
 364       argv[argc] = NULL;
 365       optind = start;
 366       getopt_long_loop (argc, argv, "ab", long_options_required,
 367                         &p_value, &q_value,
 368                         &non_options_count, non_options, &unrecognized);
 369       ASSERT (a_seen == 1);
 370       ASSERT (b_seen == 1);
 371       ASSERT (p_value == NULL);
 372       ASSERT (q_value == NULL);
 373       ASSERT (non_options_count == 0);
 374       ASSERT (unrecognized == 0);
 375       ASSERT (optind == 3);
 376     }
 377   for (start = 0; start <= 1; start++)
 378     {
 379       const char *p_value = NULL;
 380       const char *q_value = NULL;
 381       int non_options_count = 0;
 382       const char *non_options[10];
 383       int unrecognized = 0;
 384       int argc = 0;
 385       const char *argv[10];
 386       a_seen = 0;
 387       b_seen = 0;
 388
 389       argv[argc++] = "program";
 390       argv[argc++] = "-ba";
 391       argv[argc++] = "foo";
 392       argv[argc++] = "bar";
 393       argv[argc] = NULL;
 394       optind = start;
 395       getopt_long_loop (argc, argv, "ab", long_options_required,
 396                         &p_value, &q_value,
 397                         &non_options_count, non_options, &unrecognized);
 398       ASSERT (a_seen == 1);
 399       ASSERT (b_seen == 1);
 400       ASSERT (p_value == NULL);
 401       ASSERT (q_value == NULL);
 402       ASSERT (non_options_count == 0);
 403       ASSERT (unrecognized == 0);
 404       ASSERT (optind == 2);
 405     }
 406   for (start = 0; start <= 1; start++)
 407     {
 408       const char *p_value = NULL;
 409       const char *q_value = NULL;
 410       int non_options_count = 0;
 411       const char *non_options[10];
 412       int unrecognized = 0;
 413       int argc = 0;
 414       const char *argv[10];
 415       a_seen = 0;
 416       b_seen = 0;
 417
 418       argv[argc++] = "program";
 419       argv[argc++] = "-ab";
 420       argv[argc++] = "-a";
 421       argv[argc++] = "foo";
 422       argv[argc++] = "bar";
 423       argv[argc] = NULL;
 424       optind = start;
 425       getopt_long_loop (argc, argv, "ab", long_options_required,
 426                         &p_value, &q_value,
 427                         &non_options_count, non_options, &unrecognized);
 428       ASSERT (a_seen == 2);
 429       ASSERT (b_seen == 1);
 430       ASSERT (p_value == NULL);
 431       ASSERT (q_value == NULL);
 432       ASSERT (non_options_count == 0);
 433       ASSERT (unrecognized == 0);
 434       ASSERT (optind == 3);
 435     }
 436
 437   /* Test processing of boolean long options.  */
 438   for (start = 0; start <= 1; start++)
 439     {
 440       const char *p_value = NULL;
 441       const char *q_value = NULL;
 442       int non_options_count = 0;
 443       const char *non_options[10];
 444       int unrecognized = 0;
 445       int argc = 0;
 446       const char *argv[10];
 447       a_seen = 0;
 448       b_seen = 0;
 449
 450       argv[argc++] = "program";
 451       argv[argc++] = "--alpha";
 452       argv[argc++] = "foo";
 453       argv[argc++] = "bar";
 454       argv[argc] = NULL;
 455       optind = start;
 456       getopt_long_loop (argc, argv, "ab", long_options_required,
 457                         &p_value, &q_value,
 458                         &non_options_count, non_options, &unrecognized);
 459       ASSERT (a_seen == 1);
 460       ASSERT (b_seen == 0);
 461       ASSERT (p_value == NULL);
 462       ASSERT (q_value == NULL);
 463       ASSERT (non_options_count == 0);
 464       ASSERT (unrecognized == 0);
 465       ASSERT (optind == 2);
 466     }
 467   for (start = 0; start <= 1; start++)
 468     {
 469       const char *p_value = NULL;
 470       const char *q_value = NULL;
 471       int non_options_count = 0;
 472       const char *non_options[10];
 473       int unrecognized = 0;
 474       int argc = 0;
 475       const char *argv[10];
 476       a_seen = 0;
 477       b_seen = 0;
 478
 479       argv[argc++] = "program";
 480       argv[argc++] = "--beta";
 481       argv[argc++] = "--alpha";
 482       argv[argc++] = "foo";
 483       argv[argc++] = "bar";
 484       argv[argc] = NULL;
 485       optind = start;
 486       getopt_long_loop (argc, argv, "ab", long_options_required,
 487                         &p_value, &q_value,
 488                         &non_options_count, non_options, &unrecognized);
 489       ASSERT (a_seen == 1);
 490       ASSERT (b_seen == 1);
 491       ASSERT (p_value == NULL);
 492       ASSERT (q_value == NULL);
 493       ASSERT (non_options_count == 0);
 494       ASSERT (unrecognized == 0);
 495       ASSERT (optind == 3);
 496     }
 497   for (start = 0; start <= 1; start++)
 498     {
 499       const char *p_value = NULL;
 500       const char *q_value = NULL;
 501       int non_options_count = 0;
 502       const char *non_options[10];
 503       int unrecognized = 0;
 504       int argc = 0;
 505       const char *argv[10];
 506       a_seen = 0;
 507       b_seen = 0;
 508
 509       argv[argc++] = "program";
 510       argv[argc++] = "--alpha";
 511       argv[argc++] = "--beta";
 512       argv[argc++] = "--alpha";
 513       argv[argc++] = "--beta";
 514       argv[argc++] = "foo";
 515       argv[argc++] = "bar";
 516       argv[argc] = NULL;
 517       optind = start;
 518       getopt_long_loop (argc, argv, "ab", long_options_required,
 519                         &p_value, &q_value,
 520                         &non_options_count, non_options, &unrecognized);
 521       ASSERT (a_seen == 2);
 522       ASSERT (b_seen == 1);
 523       ASSERT (p_value == NULL);
 524       ASSERT (q_value == NULL);
 525       ASSERT (non_options_count == 0);
 526       ASSERT (unrecognized == 0);
 527       ASSERT (optind == 5);
 528     }
 529
 530   /* Test processing of boolean long options via -W.  */
 531   for (start = 0; start <= 1; start++)
 532     {
 533       const char *p_value = NULL;
 534       const char *q_value = NULL;
 535       int non_options_count = 0;
 536       const char *non_options[10];
 537       int unrecognized = 0;
 538       int argc = 0;
 539       const char *argv[10];
 540       a_seen = 0;
 541       b_seen = 0;
 542
 543       argv[argc++] = "program";
 544       argv[argc++] = "-Walpha";
 545       argv[argc++] = "foo";
 546       argv[argc++] = "bar";
 547       argv[argc] = NULL;
 548       optind = start;
 549       getopt_long_loop (argc, argv, "abW;", long_options_required,
 550                         &p_value, &q_value,
 551                         &non_options_count, non_options, &unrecognized);
 552       ASSERT (a_seen == 1);
 553       ASSERT (b_seen == 0);
 554       ASSERT (p_value == NULL);
 555       ASSERT (q_value == NULL);
 556       ASSERT (non_options_count == 0);
 557       ASSERT (unrecognized == 0);
 558       ASSERT (optind == 2);
 559     }
 560   for (start = 0; start <= 1; start++)
 561     {
 562       const char *p_value = NULL;
 563       const char *q_value = NULL;
 564       int non_options_count = 0;
 565       const char *non_options[10];
 566       int unrecognized = 0;
 567       int argc = 0;
 568       const char *argv[10];
 569       a_seen = 0;
 570       b_seen = 0;
 571
 572       argv[argc++] = "program";
 573       argv[argc++] = "-W";
 574       argv[argc++] = "beta";
 575       argv[argc++] = "-W";
 576       argv[argc++] = "alpha";
 577       argv[argc++] = "foo";
 578       argv[argc++] = "bar";
 579       argv[argc] = NULL;
 580       optind = start;
 581       getopt_long_loop (argc, argv, "aW;b", long_options_required,
 582                         &p_value, &q_value,
 583                         &non_options_count, non_options, &unrecognized);
 584       ASSERT (a_seen == 1);
 585       ASSERT (b_seen == 1);
 586       ASSERT (p_value == NULL);
 587       ASSERT (q_value == NULL);
 588       ASSERT (non_options_count == 0);
 589       ASSERT (unrecognized == 0);
 590       ASSERT (optind == 5);
 591     }
 592   for (start = 0; start <= 1; start++)
 593     {
 594       const char *p_value = NULL;
 595       const char *q_value = NULL;
 596       int non_options_count = 0;
 597       const char *non_options[10];
 598       int unrecognized = 0;
 599       int argc = 0;
 600       const char *argv[10];
 601       a_seen = 0;
 602       b_seen = 0;
 603
 604       argv[argc++] = "program";
 605       argv[argc++] = "-Walpha";
 606       argv[argc++] = "-Wbeta";
 607       argv[argc++] = "-Walpha";
 608       argv[argc++] = "-Wbeta";
 609       argv[argc++] = "foo";
 610       argv[argc++] = "bar";
 611       argv[argc] = NULL;
 612       optind = start;
 613       getopt_long_loop (argc, argv, "W;ab", long_options_required,
 614                         &p_value, &q_value,
 615                         &non_options_count, non_options, &unrecognized);
 616       ASSERT (a_seen == 2);
 617       ASSERT (b_seen == 1);
 618       ASSERT (p_value == NULL);
 619       ASSERT (q_value == NULL);
 620       ASSERT (non_options_count == 0);
 621       ASSERT (unrecognized == 0);
 622       ASSERT (optind == 5);
 623     }
 624
 625   /* Test processing of short options with arguments.  */
 626   for (start = 0; start <= 1; start++)
 627     {
 628       const char *p_value = NULL;
 629       const char *q_value = NULL;
 630       int non_options_count = 0;
 631       const char *non_options[10];
 632       int unrecognized = 0;
 633       int argc = 0;
 634       const char *argv[10];
 635       a_seen = 0;
 636       b_seen = 0;
 637
 638       argv[argc++] = "program";
 639       argv[argc++] = "-pfoo";
 640       argv[argc++] = "bar";
 641       argv[argc] = NULL;
 642       optind = start;
 643       getopt_long_loop (argc, argv, "p:q:", long_options_required,
 644                         &p_value, &q_value,
 645                         &non_options_count, non_options, &unrecognized);
 646       ASSERT (a_seen == 0);
 647       ASSERT (b_seen == 0);
 648       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 649       ASSERT (q_value == NULL);
 650       ASSERT (non_options_count == 0);
 651       ASSERT (unrecognized == 0);
 652       ASSERT (optind == 2);
 653     }
 654   for (start = 0; start <= 1; start++)
 655     {
 656       const char *p_value = NULL;
 657       const char *q_value = NULL;
 658       int non_options_count = 0;
 659       const char *non_options[10];
 660       int unrecognized = 0;
 661       int argc = 0;
 662       const char *argv[10];
 663       a_seen = 0;
 664       b_seen = 0;
 665
 666       argv[argc++] = "program";
 667       argv[argc++] = "-p";
 668       argv[argc++] = "foo";
 669       argv[argc++] = "bar";
 670       argv[argc] = NULL;
 671       optind = start;
 672       getopt_long_loop (argc, argv, "p:q:", long_options_required,
 673                         &p_value, &q_value,
 674                         &non_options_count, non_options, &unrecognized);
 675       ASSERT (a_seen == 0);
 676       ASSERT (b_seen == 0);
 677       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 678       ASSERT (q_value == NULL);
 679       ASSERT (non_options_count == 0);
 680       ASSERT (unrecognized == 0);
 681       ASSERT (optind == 3);
 682     }
 683   for (start = 0; start <= 1; start++)
 684     {
 685       const char *p_value = NULL;
 686       const char *q_value = NULL;
 687       int non_options_count = 0;
 688       const char *non_options[10];
 689       int unrecognized = 0;
 690       int argc = 0;
 691       const char *argv[10];
 692       a_seen = 0;
 693       b_seen = 0;
 694
 695       argv[argc++] = "program";
 696       argv[argc++] = "-ab";
 697       argv[argc++] = "-q";
 698       argv[argc++] = "baz";
 699       argv[argc++] = "-pfoo";
 700       argv[argc++] = "bar";
 701       argv[argc] = NULL;
 702       optind = start;
 703       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
 704                         &p_value, &q_value,
 705                         &non_options_count, non_options, &unrecognized);
 706       ASSERT (a_seen == 1);
 707       ASSERT (b_seen == 1);
 708       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 709       ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
 710       ASSERT (non_options_count == 0);
 711       ASSERT (unrecognized == 0);
 712       ASSERT (optind == 5);
 713     }
 714
 715   /* Test processing of long options with arguments.  */
 716   for (start = 0; start <= 1; start++)
 717     {
 718       const char *p_value = NULL;
 719       const char *q_value = NULL;
 720       int non_options_count = 0;
 721       const char *non_options[10];
 722       int unrecognized = 0;
 723       int argc = 0;
 724       const char *argv[10];
 725       a_seen = 0;
 726       b_seen = 0;
 727
 728       argv[argc++] = "program";
 729       argv[argc++] = "--p=foo";
 730       argv[argc++] = "bar";
 731       argv[argc] = NULL;
 732       optind = start;
 733       getopt_long_loop (argc, argv, "p:q:", long_options_required,
 734                         &p_value, &q_value,
 735                         &non_options_count, non_options, &unrecognized);
 736       ASSERT (a_seen == 0);
 737       ASSERT (b_seen == 0);
 738       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 739       ASSERT (q_value == NULL);
 740       ASSERT (non_options_count == 0);
 741       ASSERT (unrecognized == 0);
 742       ASSERT (optind == 2);
 743     }
 744   for (start = 0; start <= 1; start++)
 745     {
 746       const char *p_value = NULL;
 747       const char *q_value = NULL;
 748       int non_options_count = 0;
 749       const char *non_options[10];
 750       int unrecognized = 0;
 751       int argc = 0;
 752       const char *argv[10];
 753       a_seen = 0;
 754       b_seen = 0;
 755
 756       argv[argc++] = "program";
 757       argv[argc++] = "--p";
 758       argv[argc++] = "foo";
 759       argv[argc++] = "bar";
 760       argv[argc] = NULL;
 761       optind = start;
 762       getopt_long_loop (argc, argv, "p:q:", long_options_required,
 763                         &p_value, &q_value,
 764                         &non_options_count, non_options, &unrecognized);
 765       ASSERT (a_seen == 0);
 766       ASSERT (b_seen == 0);
 767       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 768       ASSERT (q_value == NULL);
 769       ASSERT (non_options_count == 0);
 770       ASSERT (unrecognized == 0);
 771       ASSERT (optind == 3);
 772     }
 773   for (start = 0; start <= 1; start++)
 774     {
 775       const char *p_value = NULL;
 776       const char *q_value = NULL;
 777       int non_options_count = 0;
 778       const char *non_options[10];
 779       int unrecognized = 0;
 780       int argc = 0;
 781       const char *argv[10];
 782       a_seen = 0;
 783       b_seen = 0;
 784
 785       argv[argc++] = "program";
 786       argv[argc++] = "-ab";
 787       argv[argc++] = "--q";
 788       argv[argc++] = "baz";
 789       argv[argc++] = "--p=foo";
 790       argv[argc++] = "bar";
 791       argv[argc] = NULL;
 792       optind = start;
 793       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
 794                         &p_value, &q_value,
 795                         &non_options_count, non_options, &unrecognized);
 796       ASSERT (a_seen == 1);
 797       ASSERT (b_seen == 1);
 798       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 799       ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
 800       ASSERT (non_options_count == 0);
 801       ASSERT (unrecognized == 0);
 802       ASSERT (optind == 5);
 803     }
 804
 805   /* Test processing of long options with arguments via -W.  */
 806   for (start = 0; start <= 1; start++)
 807     {
 808       const char *p_value = NULL;
 809       const char *q_value = NULL;
 810       int non_options_count = 0;
 811       const char *non_options[10];
 812       int unrecognized = 0;
 813       int argc = 0;
 814       const char *argv[10];
 815       a_seen = 0;
 816       b_seen = 0;
 817
 818       argv[argc++] = "program";
 819       argv[argc++] = "-Wp=foo";
 820       argv[argc++] = "bar";
 821       argv[argc] = NULL;
 822       optind = start;
 823       getopt_long_loop (argc, argv, "p:q:W;", long_options_required,
 824                         &p_value, &q_value,
 825                         &non_options_count, non_options, &unrecognized);
 826       ASSERT (a_seen == 0);
 827       ASSERT (b_seen == 0);
 828       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 829       ASSERT (q_value == NULL);
 830       ASSERT (non_options_count == 0);
 831       ASSERT (unrecognized == 0);
 832       ASSERT (optind == 2);
 833     }
 834   for (start = 0; start <= 1; start++)
 835     {
 836       const char *p_value = NULL;
 837       const char *q_value = NULL;
 838       int non_options_count = 0;
 839       const char *non_options[10];
 840       int unrecognized = 0;
 841       int argc = 0;
 842       const char *argv[10];
 843       a_seen = 0;
 844       b_seen = 0;
 845
 846       argv[argc++] = "program";
 847       argv[argc++] = "-W";
 848       argv[argc++] = "p";
 849       argv[argc++] = "foo";
 850       argv[argc++] = "bar";
 851       argv[argc] = NULL;
 852       optind = start;
 853       getopt_long_loop (argc, argv, "p:W;q:", long_options_required,
 854                         &p_value, &q_value,
 855                         &non_options_count, non_options, &unrecognized);
 856       ASSERT (a_seen == 0);
 857       ASSERT (b_seen == 0);
 858       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 859       ASSERT (q_value == NULL);
 860       ASSERT (non_options_count == 0);
 861       ASSERT (unrecognized == 0);
 862       ASSERT (optind == 4);
 863     }
 864   for (start = 0; start <= 1; start++)
 865     {
 866       const char *p_value = NULL;
 867       const char *q_value = NULL;
 868       int non_options_count = 0;
 869       const char *non_options[10];
 870       int unrecognized = 0;
 871       int argc = 0;
 872       const char *argv[10];
 873       a_seen = 0;
 874       b_seen = 0;
 875
 876       argv[argc++] = "program";
 877       argv[argc++] = "-ab";
 878       argv[argc++] = "-Wq";
 879       argv[argc++] = "baz";
 880       argv[argc++] = "-W";
 881       argv[argc++] = "p=foo";
 882       argv[argc++] = "bar";
 883       argv[argc] = NULL;
 884       optind = start;
 885       getopt_long_loop (argc, argv, "W;abp:q:", long_options_required,
 886                         &p_value, &q_value,
 887                         &non_options_count, non_options, &unrecognized);
 888       ASSERT (a_seen == 1);
 889       ASSERT (b_seen == 1);
 890       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 891       ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);
 892       ASSERT (non_options_count == 0);
 893       ASSERT (unrecognized == 0);
 894       ASSERT (optind == 6);
 895     }
 896
 897   /* Test processing of short options with optional arguments.  */
 898   for (start = 0; start <= 1; start++)
 899     {
 900       const char *p_value = NULL;
 901       const char *q_value = NULL;
 902       int non_options_count = 0;
 903       const char *non_options[10];
 904       int unrecognized = 0;
 905       int argc = 0;
 906       const char *argv[10];
 907       a_seen = 0;
 908       b_seen = 0;
 909
 910       argv[argc++] = "program";
 911       argv[argc++] = "-pfoo";
 912       argv[argc++] = "bar";
 913       argv[argc] = NULL;
 914       optind = start;
 915       getopt_long_loop (argc, argv, "p::q::", long_options_optional,
 916                         &p_value, &q_value,
 917                         &non_options_count, non_options, &unrecognized);
 918       ASSERT (a_seen == 0);
 919       ASSERT (b_seen == 0);
 920       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
 921       ASSERT (q_value == NULL);
 922       ASSERT (non_options_count == 0);
 923       ASSERT (unrecognized == 0);
 924       ASSERT (optind == 2);
 925     }
 926   for (start = 0; start <= 1; start++)
 927     {
 928       const char *p_value = NULL;
 929       const char *q_value = NULL;
 930       int non_options_count = 0;
 931       const char *non_options[10];
 932       int unrecognized = 0;
 933       int argc = 0;
 934       const char *argv[10];
 935       a_seen = 0;
 936       b_seen = 0;
 937
 938       argv[argc++] = "program";
 939       argv[argc++] = "-p";
 940       argv[argc++] = "foo";
 941       argv[argc++] = "bar";
 942       argv[argc] = NULL;
 943       optind = start;
 944       getopt_long_loop (argc, argv, "p::q::", long_options_optional,
 945                         &p_value, &q_value,
 946                         &non_options_count, non_options, &unrecognized);
 947       ASSERT (a_seen == 0);
 948       ASSERT (b_seen == 0);
 949       ASSERT (p_value == NULL);
 950       ASSERT (q_value == NULL);
 951       ASSERT (non_options_count == 0);
 952       ASSERT (unrecognized == 0);
 953       ASSERT (optind == 2);
 954     }
 955   for (start = 0; start <= 1; start++)
 956     {
 957       const char *p_value = NULL;
 958       const char *q_value = NULL;
 959       int non_options_count = 0;
 960       const char *non_options[10];
 961       int unrecognized = 0;
 962       int argc = 0;
 963       const char *argv[10];
 964       a_seen = 0;
 965       b_seen = 0;
 966
 967       argv[argc++] = "program";
 968       argv[argc++] = "-p";
 969       argv[argc++] = "-a";
 970       argv[argc++] = "bar";
 971       argv[argc] = NULL;
 972       optind = start;
 973       getopt_long_loop (argc, argv, "abp::q::", long_options_optional,
 974                         &p_value, &q_value,
 975                         &non_options_count, non_options, &unrecognized);
 976       ASSERT (a_seen == 1);
 977       ASSERT (b_seen == 0);
 978       ASSERT (p_value == NULL);
 979       ASSERT (q_value == NULL);
 980       ASSERT (non_options_count == 0);
 981       ASSERT (unrecognized == 0);
 982       ASSERT (optind == 3);
 983     }
 984
 985   /* Test processing of long options with optional arguments.  */
 986   for (start = 0; start <= 1; start++)
 987     {
 988       const char *p_value = NULL;
 989       const char *q_value = NULL;
 990       int non_options_count = 0;
 991       const char *non_options[10];
 992       int unrecognized = 0;
 993       int argc = 0;
 994       const char *argv[10];
 995       a_seen = 0;
 996       b_seen = 0;
 997
 998       argv[argc++] = "program";
 999       argv[argc++] = "--p=foo";
1000       argv[argc++] = "bar";
1001       argv[argc] = NULL;
1002       optind = start;
1003       getopt_long_loop (argc, argv, "p::q::", long_options_optional,
1004                         &p_value, &q_value,
1005                         &non_options_count, non_options, &unrecognized);
1006       ASSERT (a_seen == 0);
1007       ASSERT (b_seen == 0);
1008       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1009       ASSERT (q_value == NULL);
1010       ASSERT (non_options_count == 0);
1011       ASSERT (unrecognized == 0);
1012       ASSERT (optind == 2);
1013     }
1014   for (start = 0; start <= 1; start++)
1015     {
1016       const char *p_value = NULL;
1017       const char *q_value = NULL;
1018       int non_options_count = 0;
1019       const char *non_options[10];
1020       int unrecognized = 0;
1021       int argc = 0;
1022       const char *argv[10];
1023       a_seen = 0;
1024       b_seen = 0;
1025
1026       argv[argc++] = "program";
1027       argv[argc++] = "--p";
1028       argv[argc++] = "foo";
1029       argv[argc++] = "bar";
1030       argv[argc] = NULL;
1031       optind = start;
1032       getopt_long_loop (argc, argv, "p::q::", long_options_optional,
1033                         &p_value, &q_value,
1034                         &non_options_count, non_options, &unrecognized);
1035       ASSERT (a_seen == 0);
1036       ASSERT (b_seen == 0);
1037       ASSERT (p_value == NULL);
1038       ASSERT (q_value == NULL);
1039       ASSERT (non_options_count == 0);
1040       ASSERT (unrecognized == 0);
1041       ASSERT (optind == 2);
1042     }
1043   for (start = 0; start <= 1; start++)
1044     {
1045       const char *p_value = NULL;
1046       const char *q_value = NULL;
1047       int non_options_count = 0;
1048       const char *non_options[10];
1049       int unrecognized = 0;
1050       int argc = 0;
1051       const char *argv[10];
1052       a_seen = 0;
1053       b_seen = 0;
1054
1055       argv[argc++] = "program";
1056       argv[argc++] = "--p=";
1057       argv[argc++] = "foo";
1058       argv[argc++] = "bar";
1059       argv[argc] = NULL;
1060       optind = start;
1061       getopt_long_loop (argc, argv, "p::q::", long_options_optional,
1062                         &p_value, &q_value,
1063                         &non_options_count, non_options, &unrecognized);
1064       ASSERT (a_seen == 0);
1065       ASSERT (b_seen == 0);
1066       ASSERT (p_value != NULL && *p_value == '\0');
1067       ASSERT (q_value == NULL);
1068       ASSERT (non_options_count == 0);
1069       ASSERT (unrecognized == 0);
1070       ASSERT (optind == 2);
1071     }
1072   for (start = 0; start <= 1; start++)
1073     {
1074       const char *p_value = NULL;
1075       const char *q_value = NULL;
1076       int non_options_count = 0;
1077       const char *non_options[10];
1078       int unrecognized = 0;
1079       int argc = 0;
1080       const char *argv[10];
1081       a_seen = 0;
1082       b_seen = 0;
1083
1084       argv[argc++] = "program";
1085       argv[argc++] = "--p";
1086       argv[argc++] = "-a";
1087       argv[argc++] = "bar";
1088       argv[argc] = NULL;
1089       optind = start;
1090       getopt_long_loop (argc, argv, "abp::q::", long_options_optional,
1091                         &p_value, &q_value,
1092                         &non_options_count, non_options, &unrecognized);
1093       ASSERT (a_seen == 1);
1094       ASSERT (b_seen == 0);
1095       ASSERT (p_value == NULL);
1096       ASSERT (q_value == NULL);
1097       ASSERT (non_options_count == 0);
1098       ASSERT (unrecognized == 0);
1099       ASSERT (optind == 3);
1100     }
1101
1102   /* Test processing of long options with optional arguments via -W.  */
1103   for (start = 0; start <= 1; start++)
1104     {
1105       const char *p_value = NULL;
1106       const char *q_value = NULL;
1107       int non_options_count = 0;
1108       const char *non_options[10];
1109       int unrecognized = 0;
1110       int argc = 0;
1111       const char *argv[10];
1112       a_seen = 0;
1113       b_seen = 0;
1114
1115       argv[argc++] = "program";
1116       argv[argc++] = "-Wp=foo";
1117       argv[argc++] = "bar";
1118       argv[argc] = NULL;
1119       optind = start;
1120       getopt_long_loop (argc, argv, "p::q::W;", long_options_optional,
1121                         &p_value, &q_value,
1122                         &non_options_count, non_options, &unrecognized);
1123       ASSERT (a_seen == 0);
1124       ASSERT (b_seen == 0);
1125       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1126       ASSERT (q_value == NULL);
1127       ASSERT (non_options_count == 0);
1128       ASSERT (unrecognized == 0);
1129       ASSERT (optind == 2);
1130     }
1131   for (start = 0; start <= 1; start++)
1132     {
1133       const char *p_value = NULL;
1134       const char *q_value = NULL;
1135       int non_options_count = 0;
1136       const char *non_options[10];
1137       int unrecognized = 0;
1138       int argc = 0;
1139       const char *argv[10];
1140       a_seen = 0;
1141       b_seen = 0;
1142
1143       argv[argc++] = "program";
1144       argv[argc++] = "-Wp";
1145       argv[argc++] = "foo";
1146       argv[argc++] = "bar";
1147       argv[argc] = NULL;
1148       optind = start;
1149       getopt_long_loop (argc, argv, "p::q::W;", long_options_optional,
1150                         &p_value, &q_value,
1151                         &non_options_count, non_options, &unrecognized);
1152       ASSERT (a_seen == 0);
1153       ASSERT (b_seen == 0);
1154       ASSERT (p_value == NULL);
1155       ASSERT (q_value == NULL);
1156       ASSERT (non_options_count == 0);
1157       ASSERT (unrecognized == 0);
1158       ASSERT (optind == 2);
1159     }
1160   for (start = 0; start <= 1; start++)
1161     {
1162       const char *p_value = NULL;
1163       const char *q_value = NULL;
1164       int non_options_count = 0;
1165       const char *non_options[10];
1166       int unrecognized = 0;
1167       int argc = 0;
1168       const char *argv[10];
1169       a_seen = 0;
1170       b_seen = 0;
1171
1172       argv[argc++] = "program";
1173       argv[argc++] = "-Wp=";
1174       argv[argc++] = "foo";
1175       argv[argc++] = "bar";
1176       argv[argc] = NULL;
1177       optind = start;
1178       getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1179                         &p_value, &q_value,
1180                         &non_options_count, non_options, &unrecognized);
1181       ASSERT (a_seen == 0);
1182       ASSERT (b_seen == 0);
1183       ASSERT (p_value != NULL && *p_value == '\0');
1184       ASSERT (q_value == NULL);
1185       ASSERT (non_options_count == 0);
1186       ASSERT (unrecognized == 0);
1187       ASSERT (optind == 2);
1188     }
1189   for (start = 0; start <= 1; start++)
1190     {
1191       const char *p_value = NULL;
1192       const char *q_value = NULL;
1193       int non_options_count = 0;
1194       const char *non_options[10];
1195       int unrecognized = 0;
1196       int argc = 0;
1197       const char *argv[10];
1198       a_seen = 0;
1199       b_seen = 0;
1200
1201       argv[argc++] = "program";
1202       argv[argc++] = "-W";
1203       argv[argc++] = "p=";
1204       argv[argc++] = "foo";
1205       argv[argc++] = "bar";
1206       argv[argc] = NULL;
1207       optind = start;
1208       getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1209                         &p_value, &q_value,
1210                         &non_options_count, non_options, &unrecognized);
1211       ASSERT (a_seen == 0);
1212       ASSERT (b_seen == 0);
1213       ASSERT (p_value != NULL && *p_value == '\0');
1214       ASSERT (q_value == NULL);
1215       ASSERT (non_options_count == 0);
1216       ASSERT (unrecognized == 0);
1217       ASSERT (optind == 3);
1218     }
1219   for (start = 0; start <= 1; start++)
1220     {
1221       const char *p_value = NULL;
1222       const char *q_value = NULL;
1223       int non_options_count = 0;
1224       const char *non_options[10];
1225       int unrecognized = 0;
1226       int argc = 0;
1227       const char *argv[10];
1228       a_seen = 0;
1229       b_seen = 0;
1230
1231       argv[argc++] = "program";
1232       argv[argc++] = "-W";
1233       argv[argc++] = "p";
1234       argv[argc++] = "-a";
1235       argv[argc++] = "bar";
1236       argv[argc] = NULL;
1237       optind = start;
1238       getopt_long_loop (argc, argv, "W;abp::q::", long_options_optional,
1239                         &p_value, &q_value,
1240                         &non_options_count, non_options, &unrecognized);
1241       ASSERT (a_seen == 1);
1242       ASSERT (b_seen == 0);
1243       /* ASSERT (p_value == NULL); */
1244       ASSERT (q_value == NULL);
1245       ASSERT (non_options_count == 0);
1246       ASSERT (unrecognized == 0);
1247       ASSERT (optind == 4);
1248     }
1249
1250   /* Check that invalid options are recognized.  */
1251   for (start = 0; start <= 1; start++)
1252     {
1253       const char *p_value = NULL;
1254       const char *q_value = NULL;
1255       int non_options_count = 0;
1256       const char *non_options[10];
1257       int unrecognized = 0;
1258       int argc = 0;
1259       const char *argv[10];
1260       a_seen = 0;
1261       b_seen = 0;
1262
1263       argv[argc++] = "program";
1264       argv[argc++] = "-p";
1265       argv[argc++] = "foo";
1266       argv[argc++] = "-x";
1267       argv[argc++] = "-a";
1268       argv[argc++] = "bar";
1269       argv[argc] = NULL;
1270       optind = start;
1271       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1272                         &p_value, &q_value,
1273                         &non_options_count, non_options, &unrecognized);
1274       ASSERT (a_seen == 1);
1275       ASSERT (b_seen == 0);
1276       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1277       ASSERT (q_value == NULL);
1278       ASSERT (non_options_count == 0);
1279       ASSERT (unrecognized == 'x');
1280       ASSERT (optind == 5);
1281     }
1282   for (start = 0; start <= 1; start++)
1283     {
1284       const char *p_value = NULL;
1285       const char *q_value = NULL;
1286       int non_options_count = 0;
1287       const char *non_options[10];
1288       int unrecognized = 0;
1289       int argc = 0;
1290       const char *argv[10];
1291       a_seen = 0;
1292       b_seen = 0;
1293
1294       argv[argc++] = "program";
1295       argv[argc++] = "-p";
1296       argv[argc++] = "foo";
1297       argv[argc++] = "-:";
1298       argv[argc++] = "-a";
1299       argv[argc++] = "bar";
1300       argv[argc] = NULL;
1301       optind = start;
1302       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1303                         &p_value, &q_value,
1304                         &non_options_count, non_options, &unrecognized);
1305       ASSERT (a_seen == 1);
1306       ASSERT (b_seen == 0);
1307       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1308       ASSERT (q_value == NULL);
1309       ASSERT (non_options_count == 0);
1310       ASSERT (unrecognized == ':');
1311       ASSERT (optind == 5);
1312     }
1313
1314   /* Check that unexpected arguments are recognized.  */
1315   for (start = 0; start <= 1; start++)
1316     {
1317       const char *p_value = NULL;
1318       const char *q_value = NULL;
1319       int non_options_count = 0;
1320       const char *non_options[10];
1321       int unrecognized = 0;
1322       int argc = 0;
1323       const char *argv[10];
1324       a_seen = 0;
1325       b_seen = 0;
1326
1327       argv[argc++] = "program";
1328       argv[argc++] = "-p";
1329       argv[argc++] = "foo";
1330       argv[argc++] = "--a=";
1331       argv[argc++] = "bar";
1332       argv[argc] = NULL;
1333       optind = start;
1334       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1335                         &p_value, &q_value,
1336                         &non_options_count, non_options, &unrecognized);
1337       ASSERT (a_seen == 0);
1338       ASSERT (b_seen == 0);
1339       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1340       ASSERT (q_value == NULL);
1341       ASSERT (non_options_count == 0);
1342       ASSERT (unrecognized == 'a');
1343       ASSERT (optind == 4);
1344     }
1345   for (start = 0; start <= 1; start++)
1346     {
1347       const char *p_value = NULL;
1348       const char *q_value = NULL;
1349       int non_options_count = 0;
1350       const char *non_options[10];
1351       int unrecognized = 0;
1352       int argc = 0;
1353       const char *argv[10];
1354       a_seen = 0;
1355       b_seen = 0;
1356
1357       argv[argc++] = "program";
1358       argv[argc++] = "-p";
1359       argv[argc++] = "foo";
1360       argv[argc++] = "--b=";
1361       argv[argc++] = "bar";
1362       argv[argc] = NULL;
1363       optind = start;
1364       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1365                         &p_value, &q_value,
1366                         &non_options_count, non_options, &unrecognized);
1367       ASSERT (a_seen == 0);
1368       ASSERT (b_seen == 0);
1369       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1370       ASSERT (q_value == NULL);
1371       ASSERT (non_options_count == 0);
1372       /* When flag is non-zero, glibc sets optopt anyway, but BSD
1373          leaves optopt unchanged.  */
1374       ASSERT (unrecognized == 1 || unrecognized == 0);
1375       ASSERT (optind == 4);
1376     }
1377
1378   /* Check that by default, non-options arguments are moved to the end.  */
1379   for (start = 0; start <= 1; start++)
1380     {
1381       const char *p_value = NULL;
1382       const char *q_value = NULL;
1383       int non_options_count = 0;
1384       const char *non_options[10];
1385       int unrecognized = 0;
1386       int argc = 0;
1387       const char *argv[10];
1388       a_seen = 0;
1389       b_seen = 0;
1390
1391       argv[argc++] = "program";
1392       argv[argc++] = "donald";
1393       argv[argc++] = "-p";
1394       argv[argc++] = "billy";
1395       argv[argc++] = "duck";
1396       argv[argc++] = "-a";
1397       argv[argc++] = "bar";
1398       argv[argc] = NULL;
1399       optind = start;
1400       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1401                         &p_value, &q_value,
1402                         &non_options_count, non_options, &unrecognized);
1403       ASSERT (strcmp (argv[0], "program") == 0);
1404       ASSERT (strcmp (argv[1], "-p") == 0);
1405       ASSERT (strcmp (argv[2], "billy") == 0);
1406       ASSERT (strcmp (argv[3], "-a") == 0);
1407       ASSERT (strcmp (argv[4], "donald") == 0);
1408       ASSERT (strcmp (argv[5], "duck") == 0);
1409       ASSERT (strcmp (argv[6], "bar") == 0);
1410       ASSERT (argv[7] == NULL);
1411       ASSERT (a_seen == 1);
1412       ASSERT (b_seen == 0);
1413       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1414       ASSERT (q_value == NULL);
1415       ASSERT (non_options_count == 0);
1416       ASSERT (unrecognized == 0);
1417       ASSERT (optind == 4);
1418     }
1419
1420   /* Check that '--' ends the argument processing.  */
1421   for (start = 0; start <= 1; start++)
1422     {
1423       const char *p_value = NULL;
1424       const char *q_value = NULL;
1425       int non_options_count = 0;
1426       const char *non_options[10];
1427       int unrecognized = 0;
1428       int argc = 0;
1429       const char *argv[20];
1430       a_seen = 0;
1431       b_seen = 0;
1432
1433       argv[argc++] = "program";
1434       argv[argc++] = "donald";
1435       argv[argc++] = "-p";
1436       argv[argc++] = "billy";
1437       argv[argc++] = "duck";
1438       argv[argc++] = "-a";
1439       argv[argc++] = "--";
1440       argv[argc++] = "-b";
1441       argv[argc++] = "foo";
1442       argv[argc++] = "-q";
1443       argv[argc++] = "johnny";
1444       argv[argc++] = "bar";
1445       argv[argc] = NULL;
1446       optind = start;
1447       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1448                         &p_value, &q_value,
1449                         &non_options_count, non_options, &unrecognized);
1450       ASSERT (strcmp (argv[0], "program") == 0);
1451       ASSERT (strcmp (argv[1], "-p") == 0);
1452       ASSERT (strcmp (argv[2], "billy") == 0);
1453       ASSERT (strcmp (argv[3], "-a") == 0);
1454       ASSERT (strcmp (argv[4], "--") == 0);
1455       ASSERT (strcmp (argv[5], "donald") == 0);
1456       ASSERT (strcmp (argv[6], "duck") == 0);
1457       ASSERT (strcmp (argv[7], "-b") == 0);
1458       ASSERT (strcmp (argv[8], "foo") == 0);
1459       ASSERT (strcmp (argv[9], "-q") == 0);
1460       ASSERT (strcmp (argv[10], "johnny") == 0);
1461       ASSERT (strcmp (argv[11], "bar") == 0);
1462       ASSERT (argv[12] == NULL);
1463       ASSERT (a_seen == 1);
1464       ASSERT (b_seen == 0);
1465       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1466       ASSERT (q_value == NULL);
1467       ASSERT (non_options_count == 0);
1468       ASSERT (unrecognized == 0);
1469       ASSERT (optind == 5);
1470     }
1471
1472   /* Check that the '-' flag causes non-options to be returned in order.  */
1473   for (start = 0; start <= 1; start++)
1474     {
1475       const char *p_value = NULL;
1476       const char *q_value = NULL;
1477       int non_options_count = 0;
1478       const char *non_options[10];
1479       int unrecognized = 0;
1480       int argc = 0;
1481       const char *argv[10];
1482       a_seen = 0;
1483       b_seen = 0;
1484
1485       argv[argc++] = "program";
1486       argv[argc++] = "donald";
1487       argv[argc++] = "-p";
1488       argv[argc++] = "billy";
1489       argv[argc++] = "duck";
1490       argv[argc++] = "-a";
1491       argv[argc++] = "bar";
1492       argv[argc] = NULL;
1493       optind = start;
1494       getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1495                         &p_value, &q_value,
1496                         &non_options_count, non_options, &unrecognized);
1497       ASSERT (strcmp (argv[0], "program") == 0);
1498       ASSERT (strcmp (argv[1], "donald") == 0);
1499       ASSERT (strcmp (argv[2], "-p") == 0);
1500       ASSERT (strcmp (argv[3], "billy") == 0);
1501       ASSERT (strcmp (argv[4], "duck") == 0);
1502       ASSERT (strcmp (argv[5], "-a") == 0);
1503       ASSERT (strcmp (argv[6], "bar") == 0);
1504       ASSERT (argv[7] == NULL);
1505       ASSERT (a_seen == 1);
1506       ASSERT (b_seen == 0);
1507       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1508       ASSERT (q_value == NULL);
1509       ASSERT (non_options_count == 3);
1510       ASSERT (strcmp (non_options[0], "donald") == 0);
1511       ASSERT (strcmp (non_options[1], "duck") == 0);
1512       ASSERT (strcmp (non_options[2], "bar") == 0);
1513       ASSERT (unrecognized == 0);
1514       ASSERT (optind == 7);
1515     }
1516
1517   /* Check that '--' ends the argument processing.  */
1518   for (start = 0; start <= 1; start++)
1519     {
1520       const char *p_value = NULL;
1521       const char *q_value = NULL;
1522       int non_options_count = 0;
1523       const char *non_options[10];
1524       int unrecognized = 0;
1525       int argc = 0;
1526       const char *argv[20];
1527       a_seen = 0;
1528       b_seen = 0;
1529
1530       argv[argc++] = "program";
1531       argv[argc++] = "donald";
1532       argv[argc++] = "-p";
1533       argv[argc++] = "billy";
1534       argv[argc++] = "duck";
1535       argv[argc++] = "-a";
1536       argv[argc++] = "--";
1537       argv[argc++] = "-b";
1538       argv[argc++] = "foo";
1539       argv[argc++] = "-q";
1540       argv[argc++] = "johnny";
1541       argv[argc++] = "bar";
1542       argv[argc] = NULL;
1543       optind = start;
1544       getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1545                         &p_value, &q_value,
1546                         &non_options_count, non_options, &unrecognized);
1547       ASSERT (strcmp (argv[0], "program") == 0);
1548       ASSERT (strcmp (argv[1], "donald") == 0);
1549       ASSERT (strcmp (argv[2], "-p") == 0);
1550       ASSERT (strcmp (argv[3], "billy") == 0);
1551       ASSERT (strcmp (argv[4], "duck") == 0);
1552       ASSERT (strcmp (argv[5], "-a") == 0);
1553       ASSERT (strcmp (argv[6], "--") == 0);
1554       ASSERT (strcmp (argv[7], "-b") == 0);
1555       ASSERT (strcmp (argv[8], "foo") == 0);
1556       ASSERT (strcmp (argv[9], "-q") == 0);
1557       ASSERT (strcmp (argv[10], "johnny") == 0);
1558       ASSERT (strcmp (argv[11], "bar") == 0);
1559       ASSERT (argv[12] == NULL);
1560       ASSERT (a_seen == 1);
1561       ASSERT (b_seen == 0);
1562       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1563       ASSERT (q_value == NULL);
1564       if (non_options_count == 2)
1565       {
1566         /* glibc behaviour.  */
1567         ASSERT (non_options_count == 2);
1568         ASSERT (strcmp (non_options[0], "donald") == 0);
1569         ASSERT (strcmp (non_options[1], "duck") == 0);
1570         ASSERT (unrecognized == 0);
1571         ASSERT (optind == 7);
1572       }
1573       else
1574       {
1575         /* Another valid behaviour.  */
1576         ASSERT (non_options_count == 7);
1577         ASSERT (strcmp (non_options[0], "donald") == 0);
1578         ASSERT (strcmp (non_options[1], "duck") == 0);
1579         ASSERT (strcmp (non_options[2], "-b") == 0);
1580         ASSERT (strcmp (non_options[3], "foo") == 0);
1581         ASSERT (strcmp (non_options[4], "-q") == 0);
1582         ASSERT (strcmp (non_options[5], "johnny") == 0);
1583         ASSERT (strcmp (non_options[6], "bar") == 0);
1584         ASSERT (unrecognized == 0);
1585         ASSERT (optind == 12);
1586       }
1587     }
1588
1589   /* Check that the '-' flag has to come first.  */
1590   for (start = 0; start <= 1; start++)
1591     {
1592       const char *p_value = NULL;
1593       const char *q_value = NULL;
1594       int non_options_count = 0;
1595       const char *non_options[10];
1596       int unrecognized = 0;
1597       int argc = 0;
1598       const char *argv[10];
1599       a_seen = 0;
1600       b_seen = 0;
1601
1602       argv[argc++] = "program";
1603       argv[argc++] = "donald";
1604       argv[argc++] = "-p";
1605       argv[argc++] = "billy";
1606       argv[argc++] = "duck";
1607       argv[argc++] = "-a";
1608       argv[argc++] = "bar";
1609       argv[argc] = NULL;
1610       optind = start;
1611       getopt_long_loop (argc, argv, "abp:q:-", long_options_required,
1612                         &p_value, &q_value,
1613                         &non_options_count, non_options, &unrecognized);
1614       ASSERT (strcmp (argv[0], "program") == 0);
1615       ASSERT (strcmp (argv[1], "-p") == 0);
1616       ASSERT (strcmp (argv[2], "billy") == 0);
1617       ASSERT (strcmp (argv[3], "-a") == 0);
1618       ASSERT (strcmp (argv[4], "donald") == 0);
1619       ASSERT (strcmp (argv[5], "duck") == 0);
1620       ASSERT (strcmp (argv[6], "bar") == 0);
1621       ASSERT (argv[7] == NULL);
1622       ASSERT (a_seen == 1);
1623       ASSERT (b_seen == 0);
1624       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1625       ASSERT (q_value == NULL);
1626       ASSERT (non_options_count == 0);
1627       ASSERT (unrecognized == 0);
1628       ASSERT (optind == 4);
1629     }
1630
1631   /* Check that the '+' flag causes the first non-option to terminate the
1632      loop.  */
1633   for (start = 0; start <= 1; start++)
1634     {
1635       const char *p_value = NULL;
1636       const char *q_value = NULL;
1637       int non_options_count = 0;
1638       const char *non_options[10];
1639       int unrecognized = 0;
1640       int argc = 0;
1641       const char *argv[10];
1642       a_seen = 0;
1643       b_seen = 0;
1644
1645       argv[argc++] = "program";
1646       argv[argc++] = "donald";
1647       argv[argc++] = "-p";
1648       argv[argc++] = "billy";
1649       argv[argc++] = "duck";
1650       argv[argc++] = "-a";
1651       argv[argc++] = "bar";
1652       argv[argc] = NULL;
1653       optind = start;
1654       getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1655                         &p_value, &q_value,
1656                         &non_options_count, non_options, &unrecognized);
1657       ASSERT (strcmp (argv[0], "program") == 0);
1658       ASSERT (strcmp (argv[1], "donald") == 0);
1659       ASSERT (strcmp (argv[2], "-p") == 0);
1660       ASSERT (strcmp (argv[3], "billy") == 0);
1661       ASSERT (strcmp (argv[4], "duck") == 0);
1662       ASSERT (strcmp (argv[5], "-a") == 0);
1663       ASSERT (strcmp (argv[6], "bar") == 0);
1664       ASSERT (argv[7] == NULL);
1665       ASSERT (a_seen == 0);
1666       ASSERT (b_seen == 0);
1667       ASSERT (p_value == NULL);
1668       ASSERT (q_value == NULL);
1669       ASSERT (non_options_count == 0);
1670       ASSERT (unrecognized == 0);
1671       ASSERT (optind == 1);
1672     }
1673   for (start = 0; start <= 1; start++)
1674     {
1675       const char *p_value = NULL;
1676       const char *q_value = NULL;
1677       int non_options_count = 0;
1678       const char *non_options[10];
1679       int unrecognized = 0;
1680       int argc = 0;
1681       const char *argv[10];
1682       a_seen = 0;
1683       b_seen = 0;
1684
1685       argv[argc++] = "program";
1686       argv[argc++] = "-+";
1687       argv[argc] = NULL;
1688       optind = start;
1689       getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1690                         &p_value, &q_value,
1691                         &non_options_count, non_options, &unrecognized);
1692       ASSERT (a_seen == 0);
1693       ASSERT (b_seen == 0);
1694       ASSERT (p_value == NULL);
1695       ASSERT (q_value == NULL);
1696       ASSERT (non_options_count == 0);
1697       ASSERT (unrecognized == '+');
1698       ASSERT (optind == 2);
1699     }
1700
1701   /* Check that '--' ends the argument processing.  */
1702   for (start = 0; start <= 1; start++)
1703     {
1704       const char *p_value = NULL;
1705       const char *q_value = NULL;
1706       int non_options_count = 0;
1707       const char *non_options[10];
1708       int unrecognized = 0;
1709       int argc = 0;
1710       const char *argv[20];
1711       a_seen = 0;
1712       b_seen = 0;
1713
1714       argv[argc++] = "program";
1715       argv[argc++] = "donald";
1716       argv[argc++] = "-p";
1717       argv[argc++] = "billy";
1718       argv[argc++] = "duck";
1719       argv[argc++] = "-a";
1720       argv[argc++] = "--";
1721       argv[argc++] = "-b";
1722       argv[argc++] = "foo";
1723       argv[argc++] = "-q";
1724       argv[argc++] = "johnny";
1725       argv[argc++] = "bar";
1726       argv[argc] = NULL;
1727       optind = start;
1728       getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1729                         &p_value, &q_value,
1730                         &non_options_count, non_options, &unrecognized);
1731       ASSERT (strcmp (argv[0], "program") == 0);
1732       ASSERT (strcmp (argv[1], "donald") == 0);
1733       ASSERT (strcmp (argv[2], "-p") == 0);
1734       ASSERT (strcmp (argv[3], "billy") == 0);
1735       ASSERT (strcmp (argv[4], "duck") == 0);
1736       ASSERT (strcmp (argv[5], "-a") == 0);
1737       ASSERT (strcmp (argv[6], "--") == 0);
1738       ASSERT (strcmp (argv[7], "-b") == 0);
1739       ASSERT (strcmp (argv[8], "foo") == 0);
1740       ASSERT (strcmp (argv[9], "-q") == 0);
1741       ASSERT (strcmp (argv[10], "johnny") == 0);
1742       ASSERT (strcmp (argv[11], "bar") == 0);
1743       ASSERT (argv[12] == NULL);
1744       ASSERT (a_seen == 0);
1745       ASSERT (b_seen == 0);
1746       ASSERT (p_value == NULL);
1747       ASSERT (q_value == NULL);
1748       ASSERT (non_options_count == 0);
1749       ASSERT (unrecognized == 0);
1750       ASSERT (optind == 1);
1751     }
1752
1753   /* Check that the '+' flag has to come first.  */
1754   for (start = 0; start <= 1; start++)
1755     {
1756       const char *p_value = NULL;
1757       const char *q_value = NULL;
1758       int non_options_count = 0;
1759       const char *non_options[10];
1760       int unrecognized = 0;
1761       int argc = 0;
1762       const char *argv[10];
1763       a_seen = 0;
1764       b_seen = 0;
1765
1766       argv[argc++] = "program";
1767       argv[argc++] = "donald";
1768       argv[argc++] = "-p";
1769       argv[argc++] = "billy";
1770       argv[argc++] = "duck";
1771       argv[argc++] = "-a";
1772       argv[argc++] = "bar";
1773       argv[argc] = NULL;
1774       optind = start;
1775       getopt_long_loop (argc, argv, "abp:q:+", long_options_required,
1776                         &p_value, &q_value,
1777                         &non_options_count, non_options, &unrecognized);
1778       ASSERT (strcmp (argv[0], "program") == 0);
1779       ASSERT (strcmp (argv[1], "-p") == 0);
1780       ASSERT (strcmp (argv[2], "billy") == 0);
1781       ASSERT (strcmp (argv[3], "-a") == 0);
1782       ASSERT (strcmp (argv[4], "donald") == 0);
1783       ASSERT (strcmp (argv[5], "duck") == 0);
1784       ASSERT (strcmp (argv[6], "bar") == 0);
1785       ASSERT (argv[7] == NULL);
1786       ASSERT (a_seen == 1);
1787       ASSERT (b_seen == 0);
1788       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1789       ASSERT (q_value == NULL);
1790       ASSERT (non_options_count == 0);
1791       ASSERT (unrecognized == 0);
1792       ASSERT (optind == 4);
1793     }
1794 }
1795
1796 /* Test behavior of getopt_long when POSIXLY_CORRECT is set in the
1797    environment.  Options with optional arguments should not change
1798    behavior just because of an environment variable.
1799    http://lists.gnu.org/archive/html/bug-m4/2006-09/msg00028.html  */
1800 static void
1801 test_getopt_long_posix (void)
1802 {
1803   int start;
1804
1805   /* Check that POSIXLY_CORRECT stops parsing the same as leading '+'.  */
1806   for (start = 0; start <= 1; start++)
1807     {
1808       const char *p_value = NULL;
1809       const char *q_value = NULL;
1810       int non_options_count = 0;
1811       const char *non_options[10];
1812       int unrecognized = 0;
1813       int argc = 0;
1814       const char *argv[10];
1815       a_seen = 0;
1816       b_seen = 0;
1817
1818       argv[argc++] = "program";
1819       argv[argc++] = "donald";
1820       argv[argc++] = "-p";
1821       argv[argc++] = "billy";
1822       argv[argc++] = "duck";
1823       argv[argc++] = "-a";
1824       argv[argc++] = "bar";
1825       argv[argc] = NULL;
1826       optind = start;
1827       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1828                         &p_value, &q_value,
1829                         &non_options_count, non_options, &unrecognized);
1830       ASSERT (strcmp (argv[0], "program") == 0);
1831       ASSERT (strcmp (argv[1], "donald") == 0);
1832       ASSERT (strcmp (argv[2], "-p") == 0);
1833       ASSERT (strcmp (argv[3], "billy") == 0);
1834       ASSERT (strcmp (argv[4], "duck") == 0);
1835       ASSERT (strcmp (argv[5], "-a") == 0);
1836       ASSERT (strcmp (argv[6], "bar") == 0);
1837       ASSERT (argv[7] == NULL);
1838       ASSERT (a_seen == 0);
1839       ASSERT (b_seen == 0);
1840       ASSERT (p_value == NULL);
1841       ASSERT (q_value == NULL);
1842       ASSERT (non_options_count == 0);
1843       ASSERT (unrecognized == 0);
1844       ASSERT (optind == 1);
1845     }
1846
1847   /* Check that POSIXLY_CORRECT doesn't change optional arguments.  */
1848   for (start = 0; start <= 1; start++)
1849     {
1850       const char *p_value = NULL;
1851       const char *q_value = NULL;
1852       int non_options_count = 0;
1853       const char *non_options[10];
1854       int unrecognized = 0;
1855       int argc = 0;
1856       const char *argv[10];
1857       a_seen = 0;
1858       b_seen = 0;
1859
1860       argv[argc++] = "program";
1861       argv[argc++] = "-p";
1862       argv[argc++] = "billy";
1863       argv[argc] = NULL;
1864       optind = start;
1865       getopt_long_loop (argc, argv, "p::", long_options_required,
1866                         &p_value, &q_value,
1867                         &non_options_count, non_options, &unrecognized);
1868       ASSERT (a_seen == 0);
1869       ASSERT (b_seen == 0);
1870       ASSERT (p_value == NULL);
1871       ASSERT (q_value == NULL);
1872       ASSERT (non_options_count == 0);
1873       ASSERT (unrecognized == 0);
1874       ASSERT (optind == 2);
1875     }
1876
1877   /* Check that leading - still sees options after non-options.  */
1878   for (start = 0; start <= 1; start++)
1879     {
1880       const char *p_value = NULL;
1881       const char *q_value = NULL;
1882       int non_options_count = 0;
1883       const char *non_options[10];
1884       int unrecognized = 0;
1885       int argc = 0;
1886       const char *argv[10];
1887       a_seen = 0;
1888       b_seen = 0;
1889
1890       argv[argc++] = "program";
1891       argv[argc++] = "-a";
1892       argv[argc++] = "billy";
1893       argv[argc++] = "-b";
1894       argv[argc] = NULL;
1895       optind = start;
1896       getopt_long_loop (argc, argv, "-ab", long_options_required,
1897                         &p_value, &q_value,
1898                         &non_options_count, non_options, &unrecognized);
1899       ASSERT (a_seen == 1);
1900       ASSERT (b_seen == 1);
1901       ASSERT (p_value == NULL);
1902       ASSERT (q_value == NULL);
1903       ASSERT (non_options_count == 1);
1904       ASSERT (strcmp (non_options[0], "billy") == 0);
1905       ASSERT (unrecognized == 0);
1906       ASSERT (optind == 4);
1907     }
1908 }
1909
1910 /* Reduce casting, so we can use string literals elsewhere.
1911    getopt_long_only takes an array of char*, but luckily does not
1912    modify those elements, so we can pass const char*.  */
1913 static int
1914 do_getopt_long_only (int argc, const char **argv, const char *shortopts,
1915                      const struct option *longopts, int *longind)
1916 {
1917   return getopt_long_only (argc, (char **) argv, shortopts, longopts, longind);
1918 }
1919
1920 static void
1921 test_getopt_long_only (void)
1922 {
1923   /* Test disambiguation of options.  */
1924   {
1925     int argc = 0;
1926     const char *argv[10];
1927     int option_index;
1928     int c;
1929
1930     argv[argc++] = "program";
1931     argv[argc++] = "-x";
1932     argv[argc] = NULL;
1933     optind = 1;
1934     opterr = 0;
1935     c = do_getopt_long_only (argc, argv, "ab", long_options_required,
1936                              &option_index);
1937     ASSERT (c == '?');
1938     ASSERT (optopt == 0);
1939   }
1940   {
1941     int argc = 0;
1942     const char *argv[10];
1943     int option_index;
1944     int c;
1945
1946     argv[argc++] = "program";
1947     argv[argc++] = "-x";
1948     argv[argc] = NULL;
1949     optind = 1;
1950     opterr = 0;
1951     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1952                              &option_index);
1953     ASSERT (c == 'x');
1954     ASSERT (optopt == 0);
1955   }
1956   {
1957     int argc = 0;
1958     const char *argv[10];
1959     int option_index;
1960     int c;
1961
1962     argv[argc++] = "program";
1963     argv[argc++] = "--x";
1964     argv[argc] = NULL;
1965     optind = 1;
1966     opterr = 0;
1967     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1968                              &option_index);
1969     ASSERT (c == '?');
1970     ASSERT (optopt == 0);
1971   }
1972   {
1973     int argc = 0;
1974     const char *argv[10];
1975     int option_index;
1976     int c;
1977
1978     argv[argc++] = "program";
1979     argv[argc++] = "-b";
1980     argv[argc] = NULL;
1981     optind = 1;
1982     opterr = 0;
1983     b_seen = 0;
1984     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1985                              &option_index);
1986     ASSERT (c == 'b');
1987     ASSERT (b_seen == 0);
1988   }
1989   {
1990     int argc = 0;
1991     const char *argv[10];
1992     int option_index;
1993     int c;
1994
1995     argv[argc++] = "program";
1996     argv[argc++] = "--b";
1997     argv[argc] = NULL;
1998     optind = 1;
1999     opterr = 0;
2000     b_seen = 0;
2001     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2002                              &option_index);
2003     ASSERT (c == 0);
2004     ASSERT (b_seen == 1);
2005   }
2006   {
2007     int argc = 0;
2008     const char *argv[10];
2009     int option_index;
2010     int c;
2011
2012     argv[argc++] = "program";
2013     argv[argc++] = "-xt";
2014     argv[argc] = NULL;
2015     optind = 1;
2016     opterr = 0;
2017     c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2018                              &option_index);
2019     ASSERT (c == '?');
2020     ASSERT (optopt == 0);
2021   }
2022   {
2023     int argc = 0;
2024     const char *argv[10];
2025     int option_index;
2026     int c;
2027
2028     argv[argc++] = "program";
2029     argv[argc++] = "-xt";
2030     argv[argc] = NULL;
2031     optind = 1;
2032     opterr = 0;
2033     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2034                              &option_index);
2035     ASSERT (c == '?');
2036     ASSERT (optopt == 0);
2037   }
2038   {
2039     int argc = 0;
2040     const char *argv[10];
2041     int option_index;
2042     int c;
2043
2044     argv[argc++] = "program";
2045     argv[argc++] = "-xtra";
2046     argv[argc] = NULL;
2047     optind = 1;
2048     opterr = 0;
2049     c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2050                              &option_index);
2051     ASSERT (c == 1001);
2052   }
2053   {
2054     int argc = 0;
2055     const char *argv[10];
2056     int option_index;
2057     int c;
2058
2059     argv[argc++] = "program";
2060     argv[argc++] = "-xtreme";
2061     argv[argc] = NULL;
2062     optind = 1;
2063     opterr = 0;
2064     c = do_getopt_long_only (argc, argv, "abx:", long_options_required,
2065                              &option_index);
2066     ASSERT (c == 1002);
2067   }
2068   {
2069     int argc = 0;
2070     const char *argv[10];
2071     int option_index;
2072     int c;
2073
2074     argv[argc++] = "program";
2075     argv[argc++] = "-xtremel";
2076     argv[argc] = NULL;
2077     optind = 1;
2078     opterr = 0;
2079     c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2080                              &option_index);
2081     /* glibc getopt_long_only is intentionally different from
2082        getopt_long when handling a prefix that is common to two
2083        spellings, when both spellings have the same option directives.
2084        BSD getopt_long_only treats both cases the same.  */
2085     ASSERT (c == 1003 || c == '?');
2086     ASSERT (optind == 2);
2087   }
2088   {
2089     int argc = 0;
2090     const char *argv[10];
2091     int option_index;
2092     int c;
2093
2094     argv[argc++] = "program";
2095     argv[argc++] = "-xtremel";
2096     argv[argc] = NULL;
2097     optind = 1;
2098     opterr = 0;
2099     c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2100                              &option_index);
2101     /* glibc getopt_long_only is intentionally different from
2102        getopt_long when handling a prefix that is common to two
2103        spellings, when both spellings have the same option directives.
2104        BSD getopt_long_only treats both cases the same.  */
2105     ASSERT (c == 1003 || c == '?');
2106     ASSERT (optind == 2);
2107     ASSERT (optarg == NULL);
2108   }
2109   {
2110     int argc = 0;
2111     const char *argv[10];
2112     int option_index;
2113     int c;
2114
2115     argv[argc++] = "program";
2116     argv[argc++] = "-xtras";
2117     argv[argc] = NULL;
2118     optind = 1;
2119     opterr = 0;
2120     c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2121                              &option_index);
2122     ASSERT (c == 'x');
2123     ASSERT (strcmp (optarg, "tras") == 0);
2124   }
2125 }