tests/test-getopt_long.h

   1 /* Test of command line argument processing.
   2    Copyright (C) 2009 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       /* glibc bug http://sources.redhat.com/bugzilla/show_bug.cgi?id=11041 */
1155       /* ASSERT (p_value == NULL); */
1156       ASSERT (q_value == NULL);
1157       ASSERT (non_options_count == 0);
1158       ASSERT (unrecognized == 0);
1159       ASSERT (optind == 2);
1160     }
1161   for (start = 0; start <= 1; start++)
1162     {
1163       const char *p_value = NULL;
1164       const char *q_value = NULL;
1165       int non_options_count = 0;
1166       const char *non_options[10];
1167       int unrecognized = 0;
1168       int argc = 0;
1169       const char *argv[10];
1170       a_seen = 0;
1171       b_seen = 0;
1172
1173       argv[argc++] = "program";
1174       argv[argc++] = "-Wp=";
1175       argv[argc++] = "foo";
1176       argv[argc++] = "bar";
1177       argv[argc] = NULL;
1178       optind = start;
1179       getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1180                         &p_value, &q_value,
1181                         &non_options_count, non_options, &unrecognized);
1182       ASSERT (a_seen == 0);
1183       ASSERT (b_seen == 0);
1184       ASSERT (p_value != NULL && *p_value == '\0');
1185       ASSERT (q_value == NULL);
1186       ASSERT (non_options_count == 0);
1187       ASSERT (unrecognized == 0);
1188       ASSERT (optind == 2);
1189     }
1190   for (start = 0; start <= 1; start++)
1191     {
1192       const char *p_value = NULL;
1193       const char *q_value = NULL;
1194       int non_options_count = 0;
1195       const char *non_options[10];
1196       int unrecognized = 0;
1197       int argc = 0;
1198       const char *argv[10];
1199       a_seen = 0;
1200       b_seen = 0;
1201
1202       argv[argc++] = "program";
1203       argv[argc++] = "-W";
1204       argv[argc++] = "p=";
1205       argv[argc++] = "foo";
1206       argv[argc++] = "bar";
1207       argv[argc] = NULL;
1208       optind = start;
1209       getopt_long_loop (argc, argv, "W;p::q::", long_options_optional,
1210                         &p_value, &q_value,
1211                         &non_options_count, non_options, &unrecognized);
1212       ASSERT (a_seen == 0);
1213       ASSERT (b_seen == 0);
1214       ASSERT (p_value != NULL && *p_value == '\0');
1215       ASSERT (q_value == NULL);
1216       ASSERT (non_options_count == 0);
1217       ASSERT (unrecognized == 0);
1218       ASSERT (optind == 3);
1219     }
1220   for (start = 0; start <= 1; start++)
1221     {
1222       const char *p_value = NULL;
1223       const char *q_value = NULL;
1224       int non_options_count = 0;
1225       const char *non_options[10];
1226       int unrecognized = 0;
1227       int argc = 0;
1228       const char *argv[10];
1229       a_seen = 0;
1230       b_seen = 0;
1231
1232       argv[argc++] = "program";
1233       argv[argc++] = "-W";
1234       argv[argc++] = "p";
1235       argv[argc++] = "-a";
1236       argv[argc++] = "bar";
1237       argv[argc] = NULL;
1238       optind = start;
1239       getopt_long_loop (argc, argv, "W;abp::q::", long_options_optional,
1240                         &p_value, &q_value,
1241                         &non_options_count, non_options, &unrecognized);
1242       ASSERT (a_seen == 1);
1243       ASSERT (b_seen == 0);
1244       /* ASSERT (p_value == NULL); */
1245       ASSERT (q_value == NULL);
1246       ASSERT (non_options_count == 0);
1247       ASSERT (unrecognized == 0);
1248       ASSERT (optind == 4);
1249     }
1250
1251   /* Check that invalid options are recognized.  */
1252   for (start = 0; start <= 1; start++)
1253     {
1254       const char *p_value = NULL;
1255       const char *q_value = NULL;
1256       int non_options_count = 0;
1257       const char *non_options[10];
1258       int unrecognized = 0;
1259       int argc = 0;
1260       const char *argv[10];
1261       a_seen = 0;
1262       b_seen = 0;
1263
1264       argv[argc++] = "program";
1265       argv[argc++] = "-p";
1266       argv[argc++] = "foo";
1267       argv[argc++] = "-x";
1268       argv[argc++] = "-a";
1269       argv[argc++] = "bar";
1270       argv[argc] = NULL;
1271       optind = start;
1272       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1273                         &p_value, &q_value,
1274                         &non_options_count, non_options, &unrecognized);
1275       ASSERT (a_seen == 1);
1276       ASSERT (b_seen == 0);
1277       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1278       ASSERT (q_value == NULL);
1279       ASSERT (non_options_count == 0);
1280       ASSERT (unrecognized == 'x');
1281       ASSERT (optind == 5);
1282     }
1283   for (start = 0; start <= 1; start++)
1284     {
1285       const char *p_value = NULL;
1286       const char *q_value = NULL;
1287       int non_options_count = 0;
1288       const char *non_options[10];
1289       int unrecognized = 0;
1290       int argc = 0;
1291       const char *argv[10];
1292       a_seen = 0;
1293       b_seen = 0;
1294
1295       argv[argc++] = "program";
1296       argv[argc++] = "-p";
1297       argv[argc++] = "foo";
1298       argv[argc++] = "-:";
1299       argv[argc++] = "-a";
1300       argv[argc++] = "bar";
1301       argv[argc] = NULL;
1302       optind = start;
1303       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1304                         &p_value, &q_value,
1305                         &non_options_count, non_options, &unrecognized);
1306       ASSERT (a_seen == 1);
1307       ASSERT (b_seen == 0);
1308       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1309       ASSERT (q_value == NULL);
1310       ASSERT (non_options_count == 0);
1311       ASSERT (unrecognized == ':');
1312       ASSERT (optind == 5);
1313     }
1314
1315   /* Check that unexpected arguments are recognized.  */
1316   for (start = 0; start <= 1; start++)
1317     {
1318       const char *p_value = NULL;
1319       const char *q_value = NULL;
1320       int non_options_count = 0;
1321       const char *non_options[10];
1322       int unrecognized = 0;
1323       int argc = 0;
1324       const char *argv[10];
1325       a_seen = 0;
1326       b_seen = 0;
1327
1328       argv[argc++] = "program";
1329       argv[argc++] = "-p";
1330       argv[argc++] = "foo";
1331       argv[argc++] = "--a=";
1332       argv[argc++] = "bar";
1333       argv[argc] = NULL;
1334       optind = start;
1335       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1336                         &p_value, &q_value,
1337                         &non_options_count, non_options, &unrecognized);
1338       ASSERT (a_seen == 0);
1339       ASSERT (b_seen == 0);
1340       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1341       ASSERT (q_value == NULL);
1342       ASSERT (non_options_count == 0);
1343       ASSERT (unrecognized == 'a');
1344       ASSERT (optind == 4);
1345     }
1346   for (start = 0; start <= 1; start++)
1347     {
1348       const char *p_value = NULL;
1349       const char *q_value = NULL;
1350       int non_options_count = 0;
1351       const char *non_options[10];
1352       int unrecognized = 0;
1353       int argc = 0;
1354       const char *argv[10];
1355       a_seen = 0;
1356       b_seen = 0;
1357
1358       argv[argc++] = "program";
1359       argv[argc++] = "-p";
1360       argv[argc++] = "foo";
1361       argv[argc++] = "--b=";
1362       argv[argc++] = "bar";
1363       argv[argc] = NULL;
1364       optind = start;
1365       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1366                         &p_value, &q_value,
1367                         &non_options_count, non_options, &unrecognized);
1368       ASSERT (a_seen == 0);
1369       ASSERT (b_seen == 0);
1370       ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
1371       ASSERT (q_value == NULL);
1372       ASSERT (non_options_count == 0);
1373       /* When flag is non-zero, glibc sets optopt anyway, but BSD
1374          leaves optopt unchanged.  */
1375       ASSERT (unrecognized == 1 || unrecognized == 0);
1376       ASSERT (optind == 4);
1377     }
1378
1379   /* Check that by default, non-options arguments are moved to the end.  */
1380   for (start = 0; start <= 1; start++)
1381     {
1382       const char *p_value = NULL;
1383       const char *q_value = NULL;
1384       int non_options_count = 0;
1385       const char *non_options[10];
1386       int unrecognized = 0;
1387       int argc = 0;
1388       const char *argv[10];
1389       a_seen = 0;
1390       b_seen = 0;
1391
1392       argv[argc++] = "program";
1393       argv[argc++] = "donald";
1394       argv[argc++] = "-p";
1395       argv[argc++] = "billy";
1396       argv[argc++] = "duck";
1397       argv[argc++] = "-a";
1398       argv[argc++] = "bar";
1399       argv[argc] = NULL;
1400       optind = start;
1401       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1402                         &p_value, &q_value,
1403                         &non_options_count, non_options, &unrecognized);
1404       ASSERT (strcmp (argv[0], "program") == 0);
1405       ASSERT (strcmp (argv[1], "-p") == 0);
1406       ASSERT (strcmp (argv[2], "billy") == 0);
1407       ASSERT (strcmp (argv[3], "-a") == 0);
1408       ASSERT (strcmp (argv[4], "donald") == 0);
1409       ASSERT (strcmp (argv[5], "duck") == 0);
1410       ASSERT (strcmp (argv[6], "bar") == 0);
1411       ASSERT (argv[7] == NULL);
1412       ASSERT (a_seen == 1);
1413       ASSERT (b_seen == 0);
1414       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1415       ASSERT (q_value == NULL);
1416       ASSERT (non_options_count == 0);
1417       ASSERT (unrecognized == 0);
1418       ASSERT (optind == 4);
1419     }
1420
1421   /* Check that '--' ends the argument processing.  */
1422   for (start = 0; start <= 1; start++)
1423     {
1424       const char *p_value = NULL;
1425       const char *q_value = NULL;
1426       int non_options_count = 0;
1427       const char *non_options[10];
1428       int unrecognized = 0;
1429       int argc = 0;
1430       const char *argv[20];
1431       a_seen = 0;
1432       b_seen = 0;
1433
1434       argv[argc++] = "program";
1435       argv[argc++] = "donald";
1436       argv[argc++] = "-p";
1437       argv[argc++] = "billy";
1438       argv[argc++] = "duck";
1439       argv[argc++] = "-a";
1440       argv[argc++] = "--";
1441       argv[argc++] = "-b";
1442       argv[argc++] = "foo";
1443       argv[argc++] = "-q";
1444       argv[argc++] = "johnny";
1445       argv[argc++] = "bar";
1446       argv[argc] = NULL;
1447       optind = start;
1448       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1449                         &p_value, &q_value,
1450                         &non_options_count, non_options, &unrecognized);
1451       ASSERT (strcmp (argv[0], "program") == 0);
1452       ASSERT (strcmp (argv[1], "-p") == 0);
1453       ASSERT (strcmp (argv[2], "billy") == 0);
1454       ASSERT (strcmp (argv[3], "-a") == 0);
1455       ASSERT (strcmp (argv[4], "--") == 0);
1456       ASSERT (strcmp (argv[5], "donald") == 0);
1457       ASSERT (strcmp (argv[6], "duck") == 0);
1458       ASSERT (strcmp (argv[7], "-b") == 0);
1459       ASSERT (strcmp (argv[8], "foo") == 0);
1460       ASSERT (strcmp (argv[9], "-q") == 0);
1461       ASSERT (strcmp (argv[10], "johnny") == 0);
1462       ASSERT (strcmp (argv[11], "bar") == 0);
1463       ASSERT (argv[12] == NULL);
1464       ASSERT (a_seen == 1);
1465       ASSERT (b_seen == 0);
1466       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1467       ASSERT (q_value == NULL);
1468       ASSERT (non_options_count == 0);
1469       ASSERT (unrecognized == 0);
1470       ASSERT (optind == 5);
1471     }
1472
1473   /* Check that the '-' flag causes non-options to be returned in order.  */
1474   for (start = 0; start <= 1; start++)
1475     {
1476       const char *p_value = NULL;
1477       const char *q_value = NULL;
1478       int non_options_count = 0;
1479       const char *non_options[10];
1480       int unrecognized = 0;
1481       int argc = 0;
1482       const char *argv[10];
1483       a_seen = 0;
1484       b_seen = 0;
1485
1486       argv[argc++] = "program";
1487       argv[argc++] = "donald";
1488       argv[argc++] = "-p";
1489       argv[argc++] = "billy";
1490       argv[argc++] = "duck";
1491       argv[argc++] = "-a";
1492       argv[argc++] = "bar";
1493       argv[argc] = NULL;
1494       optind = start;
1495       getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1496                         &p_value, &q_value,
1497                         &non_options_count, non_options, &unrecognized);
1498       ASSERT (strcmp (argv[0], "program") == 0);
1499       ASSERT (strcmp (argv[1], "donald") == 0);
1500       ASSERT (strcmp (argv[2], "-p") == 0);
1501       ASSERT (strcmp (argv[3], "billy") == 0);
1502       ASSERT (strcmp (argv[4], "duck") == 0);
1503       ASSERT (strcmp (argv[5], "-a") == 0);
1504       ASSERT (strcmp (argv[6], "bar") == 0);
1505       ASSERT (argv[7] == NULL);
1506       ASSERT (a_seen == 1);
1507       ASSERT (b_seen == 0);
1508       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1509       ASSERT (q_value == NULL);
1510       ASSERT (non_options_count == 3);
1511       ASSERT (strcmp (non_options[0], "donald") == 0);
1512       ASSERT (strcmp (non_options[1], "duck") == 0);
1513       ASSERT (strcmp (non_options[2], "bar") == 0);
1514       ASSERT (unrecognized == 0);
1515       ASSERT (optind == 7);
1516     }
1517
1518   /* Check that '--' ends the argument processing.  */
1519   for (start = 0; start <= 1; start++)
1520     {
1521       const char *p_value = NULL;
1522       const char *q_value = NULL;
1523       int non_options_count = 0;
1524       const char *non_options[10];
1525       int unrecognized = 0;
1526       int argc = 0;
1527       const char *argv[20];
1528       a_seen = 0;
1529       b_seen = 0;
1530
1531       argv[argc++] = "program";
1532       argv[argc++] = "donald";
1533       argv[argc++] = "-p";
1534       argv[argc++] = "billy";
1535       argv[argc++] = "duck";
1536       argv[argc++] = "-a";
1537       argv[argc++] = "--";
1538       argv[argc++] = "-b";
1539       argv[argc++] = "foo";
1540       argv[argc++] = "-q";
1541       argv[argc++] = "johnny";
1542       argv[argc++] = "bar";
1543       argv[argc] = NULL;
1544       optind = start;
1545       getopt_long_loop (argc, argv, "-abp:q:", long_options_required,
1546                         &p_value, &q_value,
1547                         &non_options_count, non_options, &unrecognized);
1548       ASSERT (strcmp (argv[0], "program") == 0);
1549       ASSERT (strcmp (argv[1], "donald") == 0);
1550       ASSERT (strcmp (argv[2], "-p") == 0);
1551       ASSERT (strcmp (argv[3], "billy") == 0);
1552       ASSERT (strcmp (argv[4], "duck") == 0);
1553       ASSERT (strcmp (argv[5], "-a") == 0);
1554       ASSERT (strcmp (argv[6], "--") == 0);
1555       ASSERT (strcmp (argv[7], "-b") == 0);
1556       ASSERT (strcmp (argv[8], "foo") == 0);
1557       ASSERT (strcmp (argv[9], "-q") == 0);
1558       ASSERT (strcmp (argv[10], "johnny") == 0);
1559       ASSERT (strcmp (argv[11], "bar") == 0);
1560       ASSERT (argv[12] == NULL);
1561       ASSERT (a_seen == 1);
1562       ASSERT (b_seen == 0);
1563       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1564       ASSERT (q_value == NULL);
1565       if (non_options_count == 2)
1566       {
1567         /* glibc behaviour.  */
1568         ASSERT (non_options_count == 2);
1569         ASSERT (strcmp (non_options[0], "donald") == 0);
1570         ASSERT (strcmp (non_options[1], "duck") == 0);
1571         ASSERT (unrecognized == 0);
1572         ASSERT (optind == 7);
1573       }
1574       else
1575       {
1576         /* Another valid behaviour.  */
1577         ASSERT (non_options_count == 7);
1578         ASSERT (strcmp (non_options[0], "donald") == 0);
1579         ASSERT (strcmp (non_options[1], "duck") == 0);
1580         ASSERT (strcmp (non_options[2], "-b") == 0);
1581         ASSERT (strcmp (non_options[3], "foo") == 0);
1582         ASSERT (strcmp (non_options[4], "-q") == 0);
1583         ASSERT (strcmp (non_options[5], "johnny") == 0);
1584         ASSERT (strcmp (non_options[6], "bar") == 0);
1585         ASSERT (unrecognized == 0);
1586         ASSERT (optind == 12);
1587       }
1588     }
1589
1590   /* Check that the '-' flag has to come first.  */
1591   for (start = 0; start <= 1; start++)
1592     {
1593       const char *p_value = NULL;
1594       const char *q_value = NULL;
1595       int non_options_count = 0;
1596       const char *non_options[10];
1597       int unrecognized = 0;
1598       int argc = 0;
1599       const char *argv[10];
1600       a_seen = 0;
1601       b_seen = 0;
1602
1603       argv[argc++] = "program";
1604       argv[argc++] = "donald";
1605       argv[argc++] = "-p";
1606       argv[argc++] = "billy";
1607       argv[argc++] = "duck";
1608       argv[argc++] = "-a";
1609       argv[argc++] = "bar";
1610       argv[argc] = NULL;
1611       optind = start;
1612       getopt_long_loop (argc, argv, "abp:q:-", long_options_required,
1613                         &p_value, &q_value,
1614                         &non_options_count, non_options, &unrecognized);
1615       ASSERT (strcmp (argv[0], "program") == 0);
1616       ASSERT (strcmp (argv[1], "-p") == 0);
1617       ASSERT (strcmp (argv[2], "billy") == 0);
1618       ASSERT (strcmp (argv[3], "-a") == 0);
1619       ASSERT (strcmp (argv[4], "donald") == 0);
1620       ASSERT (strcmp (argv[5], "duck") == 0);
1621       ASSERT (strcmp (argv[6], "bar") == 0);
1622       ASSERT (argv[7] == NULL);
1623       ASSERT (a_seen == 1);
1624       ASSERT (b_seen == 0);
1625       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1626       ASSERT (q_value == NULL);
1627       ASSERT (non_options_count == 0);
1628       ASSERT (unrecognized == 0);
1629       ASSERT (optind == 4);
1630     }
1631
1632   /* Check that the '+' flag causes the first non-option to terminate the
1633      loop.  */
1634   for (start = 0; start <= 1; start++)
1635     {
1636       const char *p_value = NULL;
1637       const char *q_value = NULL;
1638       int non_options_count = 0;
1639       const char *non_options[10];
1640       int unrecognized = 0;
1641       int argc = 0;
1642       const char *argv[10];
1643       a_seen = 0;
1644       b_seen = 0;
1645
1646       argv[argc++] = "program";
1647       argv[argc++] = "donald";
1648       argv[argc++] = "-p";
1649       argv[argc++] = "billy";
1650       argv[argc++] = "duck";
1651       argv[argc++] = "-a";
1652       argv[argc++] = "bar";
1653       argv[argc] = NULL;
1654       optind = start;
1655       getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1656                         &p_value, &q_value,
1657                         &non_options_count, non_options, &unrecognized);
1658       ASSERT (strcmp (argv[0], "program") == 0);
1659       ASSERT (strcmp (argv[1], "donald") == 0);
1660       ASSERT (strcmp (argv[2], "-p") == 0);
1661       ASSERT (strcmp (argv[3], "billy") == 0);
1662       ASSERT (strcmp (argv[4], "duck") == 0);
1663       ASSERT (strcmp (argv[5], "-a") == 0);
1664       ASSERT (strcmp (argv[6], "bar") == 0);
1665       ASSERT (argv[7] == NULL);
1666       ASSERT (a_seen == 0);
1667       ASSERT (b_seen == 0);
1668       ASSERT (p_value == NULL);
1669       ASSERT (q_value == NULL);
1670       ASSERT (non_options_count == 0);
1671       ASSERT (unrecognized == 0);
1672       ASSERT (optind == 1);
1673     }
1674   for (start = 0; start <= 1; start++)
1675     {
1676       const char *p_value = NULL;
1677       const char *q_value = NULL;
1678       int non_options_count = 0;
1679       const char *non_options[10];
1680       int unrecognized = 0;
1681       int argc = 0;
1682       const char *argv[10];
1683       a_seen = 0;
1684       b_seen = 0;
1685
1686       argv[argc++] = "program";
1687       argv[argc++] = "-+";
1688       argv[argc] = NULL;
1689       optind = start;
1690       getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1691                         &p_value, &q_value,
1692                         &non_options_count, non_options, &unrecognized);
1693       ASSERT (a_seen == 0);
1694       ASSERT (b_seen == 0);
1695       ASSERT (p_value == NULL);
1696       ASSERT (q_value == NULL);
1697       ASSERT (non_options_count == 0);
1698       ASSERT (unrecognized == '+');
1699       ASSERT (optind == 2);
1700     }
1701
1702   /* Check that '--' ends the argument processing.  */
1703   for (start = 0; start <= 1; start++)
1704     {
1705       const char *p_value = NULL;
1706       const char *q_value = NULL;
1707       int non_options_count = 0;
1708       const char *non_options[10];
1709       int unrecognized = 0;
1710       int argc = 0;
1711       const char *argv[20];
1712       a_seen = 0;
1713       b_seen = 0;
1714
1715       argv[argc++] = "program";
1716       argv[argc++] = "donald";
1717       argv[argc++] = "-p";
1718       argv[argc++] = "billy";
1719       argv[argc++] = "duck";
1720       argv[argc++] = "-a";
1721       argv[argc++] = "--";
1722       argv[argc++] = "-b";
1723       argv[argc++] = "foo";
1724       argv[argc++] = "-q";
1725       argv[argc++] = "johnny";
1726       argv[argc++] = "bar";
1727       argv[argc] = NULL;
1728       optind = start;
1729       getopt_long_loop (argc, argv, "+abp:q:", long_options_required,
1730                         &p_value, &q_value,
1731                         &non_options_count, non_options, &unrecognized);
1732       ASSERT (strcmp (argv[0], "program") == 0);
1733       ASSERT (strcmp (argv[1], "donald") == 0);
1734       ASSERT (strcmp (argv[2], "-p") == 0);
1735       ASSERT (strcmp (argv[3], "billy") == 0);
1736       ASSERT (strcmp (argv[4], "duck") == 0);
1737       ASSERT (strcmp (argv[5], "-a") == 0);
1738       ASSERT (strcmp (argv[6], "--") == 0);
1739       ASSERT (strcmp (argv[7], "-b") == 0);
1740       ASSERT (strcmp (argv[8], "foo") == 0);
1741       ASSERT (strcmp (argv[9], "-q") == 0);
1742       ASSERT (strcmp (argv[10], "johnny") == 0);
1743       ASSERT (strcmp (argv[11], "bar") == 0);
1744       ASSERT (argv[12] == NULL);
1745       ASSERT (a_seen == 0);
1746       ASSERT (b_seen == 0);
1747       ASSERT (p_value == NULL);
1748       ASSERT (q_value == NULL);
1749       ASSERT (non_options_count == 0);
1750       ASSERT (unrecognized == 0);
1751       ASSERT (optind = 1);
1752     }
1753
1754   /* Check that the '+' flag has to come first.  */
1755   for (start = 0; start <= 1; start++)
1756     {
1757       const char *p_value = NULL;
1758       const char *q_value = NULL;
1759       int non_options_count = 0;
1760       const char *non_options[10];
1761       int unrecognized = 0;
1762       int argc = 0;
1763       const char *argv[10];
1764       a_seen = 0;
1765       b_seen = 0;
1766
1767       argv[argc++] = "program";
1768       argv[argc++] = "donald";
1769       argv[argc++] = "-p";
1770       argv[argc++] = "billy";
1771       argv[argc++] = "duck";
1772       argv[argc++] = "-a";
1773       argv[argc++] = "bar";
1774       argv[argc] = NULL;
1775       optind = start;
1776       getopt_long_loop (argc, argv, "abp:q:+", long_options_required,
1777                         &p_value, &q_value,
1778                         &non_options_count, non_options, &unrecognized);
1779       ASSERT (strcmp (argv[0], "program") == 0);
1780       ASSERT (strcmp (argv[1], "-p") == 0);
1781       ASSERT (strcmp (argv[2], "billy") == 0);
1782       ASSERT (strcmp (argv[3], "-a") == 0);
1783       ASSERT (strcmp (argv[4], "donald") == 0);
1784       ASSERT (strcmp (argv[5], "duck") == 0);
1785       ASSERT (strcmp (argv[6], "bar") == 0);
1786       ASSERT (argv[7] == NULL);
1787       ASSERT (a_seen == 1);
1788       ASSERT (b_seen == 0);
1789       ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
1790       ASSERT (q_value == NULL);
1791       ASSERT (non_options_count == 0);
1792       ASSERT (unrecognized == 0);
1793       ASSERT (optind == 4);
1794     }
1795 }
1796
1797 /* Test behavior of getopt_long when POSIXLY_CORRECT is set in the
1798    environment.  Options with optional arguments should not change
1799    behavior just because of an environment variable.
1800    http://lists.gnu.org/archive/html/bug-m4/2006-09/msg00028.html  */
1801 static void
1802 test_getopt_long_posix (void)
1803 {
1804   int start;
1805
1806   /* Check that POSIXLY_CORRECT stops parsing the same as leading '+'.  */
1807   for (start = 0; start <= 1; start++)
1808     {
1809       const char *p_value = NULL;
1810       const char *q_value = NULL;
1811       int non_options_count = 0;
1812       const char *non_options[10];
1813       int unrecognized = 0;
1814       int argc = 0;
1815       const char *argv[10];
1816       a_seen = 0;
1817       b_seen = 0;
1818
1819       argv[argc++] = "program";
1820       argv[argc++] = "donald";
1821       argv[argc++] = "-p";
1822       argv[argc++] = "billy";
1823       argv[argc++] = "duck";
1824       argv[argc++] = "-a";
1825       argv[argc++] = "bar";
1826       argv[argc] = NULL;
1827       optind = start;
1828       getopt_long_loop (argc, argv, "abp:q:", long_options_required,
1829                         &p_value, &q_value,
1830                         &non_options_count, non_options, &unrecognized);
1831       ASSERT (strcmp (argv[0], "program") == 0);
1832       ASSERT (strcmp (argv[1], "donald") == 0);
1833       ASSERT (strcmp (argv[2], "-p") == 0);
1834       ASSERT (strcmp (argv[3], "billy") == 0);
1835       ASSERT (strcmp (argv[4], "duck") == 0);
1836       ASSERT (strcmp (argv[5], "-a") == 0);
1837       ASSERT (strcmp (argv[6], "bar") == 0);
1838       ASSERT (argv[7] == NULL);
1839       ASSERT (a_seen == 0);
1840       ASSERT (b_seen == 0);
1841       ASSERT (p_value == NULL);
1842       ASSERT (q_value == NULL);
1843       ASSERT (non_options_count == 0);
1844       ASSERT (unrecognized == 0);
1845       ASSERT (optind == 1);
1846     }
1847
1848   /* Check that POSIXLY_CORRECT doesn't change optional arguments.  */
1849   for (start = 0; start <= 1; start++)
1850     {
1851       const char *p_value = NULL;
1852       const char *q_value = NULL;
1853       int non_options_count = 0;
1854       const char *non_options[10];
1855       int unrecognized = 0;
1856       int argc = 0;
1857       const char *argv[10];
1858       a_seen = 0;
1859       b_seen = 0;
1860
1861       argv[argc++] = "program";
1862       argv[argc++] = "-p";
1863       argv[argc++] = "billy";
1864       argv[argc] = NULL;
1865       optind = start;
1866       getopt_long_loop (argc, argv, "p::", long_options_required,
1867                         &p_value, &q_value,
1868                         &non_options_count, non_options, &unrecognized);
1869       ASSERT (a_seen == 0);
1870       ASSERT (b_seen == 0);
1871       ASSERT (p_value == NULL);
1872       ASSERT (q_value == NULL);
1873       ASSERT (non_options_count == 0);
1874       ASSERT (unrecognized == 0);
1875       ASSERT (optind == 2);
1876     }
1877
1878   /* Check that leading - still sees options after non-options.  */
1879   for (start = 0; start <= 1; start++)
1880     {
1881       const char *p_value = NULL;
1882       const char *q_value = NULL;
1883       int non_options_count = 0;
1884       const char *non_options[10];
1885       int unrecognized = 0;
1886       int argc = 0;
1887       const char *argv[10];
1888       a_seen = 0;
1889       b_seen = 0;
1890
1891       argv[argc++] = "program";
1892       argv[argc++] = "-a";
1893       argv[argc++] = "billy";
1894       argv[argc++] = "-b";
1895       argv[argc] = NULL;
1896       optind = start;
1897       getopt_long_loop (argc, argv, "-ab", long_options_required,
1898                         &p_value, &q_value,
1899                         &non_options_count, non_options, &unrecognized);
1900       ASSERT (a_seen == 1);
1901       ASSERT (b_seen == 1);
1902       ASSERT (p_value == NULL);
1903       ASSERT (q_value == NULL);
1904       ASSERT (non_options_count == 1);
1905       ASSERT (strcmp (non_options[0], "billy") == 0);
1906       ASSERT (unrecognized == 0);
1907       ASSERT (optind == 4);
1908     }
1909 }
1910
1911 /* Reduce casting, so we can use string literals elsewhere.
1912    getopt_long_only takes an array of char*, but luckily does not
1913    modify those elements, so we can pass const char*.  */
1914 static int
1915 do_getopt_long_only (int argc, const char **argv, const char *shortopts,
1916                      const struct option *longopts, int *longind)
1917 {
1918   return getopt_long_only (argc, (char **) argv, shortopts, longopts, longind);
1919 }
1920
1921 static void
1922 test_getopt_long_only (void)
1923 {
1924   /* Test disambiguation of options.  */
1925   {
1926     int argc = 0;
1927     const char *argv[10];
1928     int option_index;
1929     int c;
1930
1931     argv[argc++] = "program";
1932     argv[argc++] = "-x";
1933     argv[argc] = NULL;
1934     optind = 1;
1935     opterr = 0;
1936     c = do_getopt_long_only (argc, argv, "ab", long_options_required,
1937                              &option_index);
1938     ASSERT (c == '?');
1939     ASSERT (optopt == 0);
1940   }
1941   {
1942     int argc = 0;
1943     const char *argv[10];
1944     int option_index;
1945     int c;
1946
1947     argv[argc++] = "program";
1948     argv[argc++] = "-x";
1949     argv[argc] = NULL;
1950     optind = 1;
1951     opterr = 0;
1952     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1953                              &option_index);
1954     ASSERT (c == 'x');
1955     ASSERT (optopt == 0);
1956   }
1957   {
1958     int argc = 0;
1959     const char *argv[10];
1960     int option_index;
1961     int c;
1962
1963     argv[argc++] = "program";
1964     argv[argc++] = "--x";
1965     argv[argc] = NULL;
1966     optind = 1;
1967     opterr = 0;
1968     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1969                              &option_index);
1970     ASSERT (c == '?');
1971     ASSERT (optopt == 0);
1972   }
1973   {
1974     int argc = 0;
1975     const char *argv[10];
1976     int option_index;
1977     int c;
1978
1979     argv[argc++] = "program";
1980     argv[argc++] = "-b";
1981     argv[argc] = NULL;
1982     optind = 1;
1983     opterr = 0;
1984     b_seen = 0;
1985     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
1986                              &option_index);
1987     ASSERT (c == 'b');
1988     ASSERT (b_seen == 0);
1989   }
1990   {
1991     int argc = 0;
1992     const char *argv[10];
1993     int option_index;
1994     int c;
1995
1996     argv[argc++] = "program";
1997     argv[argc++] = "--b";
1998     argv[argc] = NULL;
1999     optind = 1;
2000     opterr = 0;
2001     b_seen = 0;
2002     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2003                              &option_index);
2004     ASSERT (c == 0);
2005     ASSERT (b_seen == 1);
2006   }
2007   {
2008     int argc = 0;
2009     const char *argv[10];
2010     int option_index;
2011     int c;
2012
2013     argv[argc++] = "program";
2014     argv[argc++] = "-xt";
2015     argv[argc] = NULL;
2016     optind = 1;
2017     opterr = 0;
2018     c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2019                              &option_index);
2020     ASSERT (c == '?');
2021     ASSERT (optopt == 0);
2022   }
2023   {
2024     int argc = 0;
2025     const char *argv[10];
2026     int option_index;
2027     int c;
2028
2029     argv[argc++] = "program";
2030     argv[argc++] = "-xt";
2031     argv[argc] = NULL;
2032     optind = 1;
2033     opterr = 0;
2034     c = do_getopt_long_only (argc, argv, "abx", long_options_required,
2035                              &option_index);
2036     ASSERT (c == '?');
2037     ASSERT (optopt == 0);
2038   }
2039   {
2040     int argc = 0;
2041     const char *argv[10];
2042     int option_index;
2043     int c;
2044
2045     argv[argc++] = "program";
2046     argv[argc++] = "-xtra";
2047     argv[argc] = NULL;
2048     optind = 1;
2049     opterr = 0;
2050     c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2051                              &option_index);
2052     ASSERT (c == 1001);
2053   }
2054   {
2055     int argc = 0;
2056     const char *argv[10];
2057     int option_index;
2058     int c;
2059
2060     argv[argc++] = "program";
2061     argv[argc++] = "-xtreme";
2062     argv[argc] = NULL;
2063     optind = 1;
2064     opterr = 0;
2065     c = do_getopt_long_only (argc, argv, "abx:", long_options_required,
2066                              &option_index);
2067     ASSERT (c == 1002);
2068   }
2069   {
2070     int argc = 0;
2071     const char *argv[10];
2072     int option_index;
2073     int c;
2074
2075     argv[argc++] = "program";
2076     argv[argc++] = "-xtremel";
2077     argv[argc] = NULL;
2078     optind = 1;
2079     opterr = 0;
2080     c = do_getopt_long_only (argc, argv, "ab", long_options_required,
2081                              &option_index);
2082     /* glibc bug http://sources.redhat.com/bugzilla/show_bug.cgi?id=11041 */
2083     /* ASSERT (c == 1003); */
2084     ASSERT (optind == 2);
2085   }
2086   {
2087     int argc = 0;
2088     const char *argv[10];
2089     int option_index;
2090     int c;
2091
2092     argv[argc++] = "program";
2093     argv[argc++] = "-xtremel";
2094     argv[argc] = NULL;
2095     optind = 1;
2096     opterr = 0;
2097     c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2098                              &option_index);
2099     /* glibc bug http://sources.redhat.com/bugzilla/show_bug.cgi?id=11041 */
2100     /* ASSERT (c == 1003); */
2101     ASSERT (optind == 2);
2102     ASSERT (optarg == NULL);
2103   }
2104   {
2105     int argc = 0;
2106     const char *argv[10];
2107     int option_index;
2108     int c;
2109
2110     argv[argc++] = "program";
2111     argv[argc++] = "-xtras";
2112     argv[argc] = NULL;
2113     optind = 1;
2114     opterr = 0;
2115     c = do_getopt_long_only (argc, argv, "abx::", long_options_required,
2116                              &option_index);
2117     ASSERT (c == 'x');
2118     ASSERT (strcmp (optarg, "tras") == 0);
2119   }
2120 }