/* Test of command line argument processing.

   Copyright (C) 2009-2017 Free Software Foundation, Inc.

   This program is free software: you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3 of the License, or

   (at your option) any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

/* Written by Bruno Haible <bruno@clisp.org>, 2009.  */

static int a_seen;

static int b_seen;

static int q_seen;

static const struct option long_options_required[] =

  {

    { "alpha",    no_argument,       NULL, 'a' },

    { "beta",     no_argument,       &b_seen, 1 },

    { "prune",    required_argument, NULL, 'p' },

    { "quetsche", required_argument, &q_seen, 1 },

    { "xtremely-",no_argument,       NULL, 1003 },

    { "xtra",     no_argument,       NULL, 1001 },

    { "xtreme",   no_argument,       NULL, 1002 },

    { "xtremely", no_argument,       NULL, 1003 },

    { NULL,       0,                 NULL, 0 }

  };

static const struct option long_options_optional[] =

  {

    { "alpha",    no_argument,       NULL, 'a' },

    { "beta",     no_argument,       &b_seen, 1 },

    { "prune",    optional_argument, NULL, 'p' },

    { "quetsche", optional_argument, &q_seen, 1 },

    { NULL,       0,                 NULL, 0 }

  };

static void

getopt_long_loop (int argc, const char **argv,

                  const char *options, const struct option *long_options,

                  const char **p_value, const char **q_value,

                  int *non_options_count, const char **non_options,

                  int *unrecognized)

{

  int option_index = -1;

  int c;

  opterr = 0;

  q_seen = 0;

  while ((c = getopt_long (argc, (char **) argv, options, long_options,

                           &option_index))

         != -1)

    {

      switch (c)

        {

        case 0:

          /* An option with a non-NULL flag pointer was processed.  */

          if (q_seen)

            *q_value = optarg;

          break;

        case 'a':

          a_seen++;

          break;

        case 'b':

          b_seen = 1;

          break;

        case 'p':

          *p_value = optarg;

          break;

        case 'q':

          *q_value = optarg;

          break;

        case '\1':

          /* Must only happen with option '-' at the beginning.  */

          ASSERT (options[0] == '-');

          non_options[(*non_options_count)++] = optarg;

          break;

        case ':':

          /* Must only happen with option ':' at the beginning.  */

          ASSERT (options[0] == ':'

                  || ((options[0] == '-' || options[0] == '+')

                      && options[1] == ':'));

          FALLTHROUGH;

        case '?':

          *unrecognized = optopt;

          break;

        default:

          *unrecognized = c;

          break;

        }

    }

}

/* Reduce casting, so we can use string literals elsewhere.

   getopt_long takes an array of char*, but luckily does not modify

   those elements, so we can pass const char*.  */

static int

do_getopt_long (int argc, const char **argv, const char *shortopts,

                const struct option *longopts, int *longind)

{

  return getopt_long (argc, (char **) argv, shortopts, longopts, longind);

}

static void

test_getopt_long (void)

{

  int start;

  /* Test disambiguation of options.  */

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "--x";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);

    ASSERT (c == '?');

    ASSERT (optopt == 0);

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "--xt";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);

    ASSERT (c == '?');

    ASSERT (optopt == 0);

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "--xtr";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);

    ASSERT (c == '?');

    ASSERT (optopt == 0);

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "--xtra";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);

    ASSERT (c == 1001);

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "--xtre";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);

    ASSERT (c == '?');

    ASSERT (optopt == 0);

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "--xtrem";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);

    ASSERT (c == '?');

    ASSERT (optopt == 0);

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "--xtreme";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);

    ASSERT (c == 1002);

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "--xtremel";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);

    ASSERT (c == 1003);

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "--xtremely";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "ab", long_options_required, &option_index);

    ASSERT (c == 1003);

  }

  /* Check that -W handles unknown options.  */

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "-W";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);

    ASSERT (c == '?');

    ASSERT (optopt == 'W');

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "-Wunknown";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);

    /* glibc and BSD behave differently here, but for now, we allow

       both behaviors since W support is not frequently used.  */

    if (c == '?')

      {

        ASSERT (optopt == 0);

        ASSERT (optarg == NULL);

      }

    else

      {

        ASSERT (c == 'W');

        ASSERT (strcmp (optarg, "unknown") == 0);

      }

  }

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "-W";

    argv[argc++] = "unknown";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "W;", long_options_required, &option_index);

    /* glibc and BSD behave differently here, but for now, we allow

       both behaviors since W support is not frequently used.  */

    if (c == '?')

      {

        ASSERT (optopt == 0);

        ASSERT (optarg == NULL);

      }

    else

      {

        ASSERT (c == 'W');

        ASSERT (strcmp (optarg, "unknown") == 0);

      }

  }

  /* Test that 'W' does not dump core:

     http://sourceware.org/bugzilla/show_bug.cgi?id=12922  */

  {

    int argc = 0;

    const char *argv[10];

    int option_index;

    int c;

    argv[argc++] = "program";

    argv[argc++] = "-W";

    argv[argc++] = "dummy";

    argv[argc] = NULL;

    optind = 1;

    opterr = 0;

    c = do_getopt_long (argc, argv, "W;", NULL, &option_index);

    ASSERT (c == 'W');

    ASSERT (optind == 2);

  }

  /* Test processing of boolean short options.  */

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-a";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "ab", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 1);

      ASSERT (b_seen == 0);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 2);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-b";

      argv[argc++] = "-a";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "ab", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 1);

      ASSERT (b_seen == 1);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 3);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-ba";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "ab", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 1);

      ASSERT (b_seen == 1);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 2);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-ab";

      argv[argc++] = "-a";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "ab", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 2);

      ASSERT (b_seen == 1);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 3);

    }

  /* Test processing of boolean long options.  */

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "--alpha";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "ab", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 1);

      ASSERT (b_seen == 0);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 2);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "--beta";

      argv[argc++] = "--alpha";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "ab", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 1);

      ASSERT (b_seen == 1);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 3);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "--alpha";

      argv[argc++] = "--beta";

      argv[argc++] = "--alpha";

      argv[argc++] = "--beta";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "ab", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 2);

      ASSERT (b_seen == 1);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 5);

    }

  /* Test processing of boolean long options via -W.  */

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-Walpha";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "abW;", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 1);

      ASSERT (b_seen == 0);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 2);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-W";

      argv[argc++] = "beta";

      argv[argc++] = "-W";

      argv[argc++] = "alpha";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "aW;b", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 1);

      ASSERT (b_seen == 1);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 5);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-Walpha";

      argv[argc++] = "-Wbeta";

      argv[argc++] = "-Walpha";

      argv[argc++] = "-Wbeta";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "W;ab", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 2);

      ASSERT (b_seen == 1);

      ASSERT (p_value == NULL);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 5);

    }

  /* Test processing of short options with arguments.  */

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-pfoo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "p:q:", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 0);

      ASSERT (b_seen == 0);

      ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 2);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-p";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "p:q:", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 0);

      ASSERT (b_seen == 0);

      ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 3);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-ab";

      argv[argc++] = "-q";

      argv[argc++] = "baz";

      argv[argc++] = "-pfoo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "abp:q:", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 1);

      ASSERT (b_seen == 1);

      ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);

      ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 5);

    }

  /* Test processing of long options with arguments.  */

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "--p=foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "p:q:", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 0);

      ASSERT (b_seen == 0);

      ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 2);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "--p";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "p:q:", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 0);

      ASSERT (b_seen == 0);

      ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 3);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-ab";

      argv[argc++] = "--q";

      argv[argc++] = "baz";

      argv[argc++] = "--p=foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "abp:q:", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 1);

      ASSERT (b_seen == 1);

      ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);

      ASSERT (q_value != NULL && strcmp (q_value, "baz") == 0);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 5);

    }

  /* Test processing of long options with arguments via -W.  */

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-Wp=foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "p:q:W;", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 0);

      ASSERT (b_seen == 0);

      ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);

      ASSERT (optind == 2);

    }

  for (start = 0; start <= 1; start++)

    {

      const char *p_value = NULL;

      const char *q_value = NULL;

      int non_options_count = 0;

      const char *non_options[10];

      int unrecognized = 0;

      int argc = 0;

      const char *argv[10];

      a_seen = 0;

      b_seen = 0;

      argv[argc++] = "program";

      argv[argc++] = "-W";

      argv[argc++] = "p";

      argv[argc++] = "foo";

      argv[argc++] = "bar";

      argv[argc] = NULL;

      optind = start;

      getopt_long_loop (argc, argv, "p:W;q:", long_options_required,

                        &p_value, &q_value,

                        &non_options_count, non_options, &unrecognized);

      ASSERT (a_seen == 0);

      ASSERT (b_seen == 0);

      ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);

      ASSERT (q_value == NULL);

      ASSERT (non_options_count == 0);

      ASSERT (unrecognized == 0);