getopt_long.c

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