getopt_long.cpp

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