/* Test of command line argument processing.
- Copyright (C) 2009 Free Software Foundation, Inc.
+ Copyright (C) 2009, 2010 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
#include <stdbool.h>
+/* The glibc/gnulib implementation of getopt supports setting optind =
+ 0, but not all other implementations do. This matters for getopt.
+ But for getopt_long, we require GNU compatibility. */
+#if defined __GETOPT_PREFIX || (__GLIBC__ >= 2)
+# define OPTIND_MIN 0
+#elif HAVE_DECL_OPTRESET
+# define OPTIND_MIN (optreset = 1)
+#else
+# define OPTIND_MIN 1
+#endif
+
static void
getopt_loop (int argc, const char **argv,
const char *options,
int *a_seen, int *b_seen,
const char **p_value, const char **q_value,
int *non_options_count, const char **non_options,
- int *unrecognized)
+ int *unrecognized, bool *message_issued)
{
int c;
+ int pos = ftell (stderr);
- opterr = 0;
while ((c = getopt (argc, (char **) argv, options)) != -1)
{
switch (c)
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] == ':'));
+ /* fall through */
case '?':
*unrecognized = optopt;
break;
break;
}
}
+
+ *message_issued = pos < ftell (stderr);
}
static void
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "ab",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 1);
ASSERT (b_seen == 0);
ASSERT (p_value == NULL);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 2);
+ ASSERT (!output);
}
for (start = OPTIND_MIN; start <= 1; start++)
{
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "ab",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 1);
ASSERT (b_seen == 1);
ASSERT (p_value == NULL);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 3);
+ ASSERT (!output);
}
for (start = OPTIND_MIN; start <= 1; start++)
{
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "ab",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 1);
ASSERT (b_seen == 1);
ASSERT (p_value == NULL);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 2);
+ ASSERT (!output);
}
for (start = OPTIND_MIN; start <= 1; start++)
{
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "ab",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 2);
ASSERT (b_seen == 1);
ASSERT (p_value == NULL);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 3);
+ ASSERT (!output);
}
/* Test processing of options with arguments. */
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "p:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 0);
ASSERT (b_seen == 0);
ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 2);
+ ASSERT (!output);
}
for (start = OPTIND_MIN; start <= 1; start++)
{
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "p:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 0);
ASSERT (b_seen == 0);
ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 3);
+ ASSERT (!output);
}
for (start = OPTIND_MIN; start <= 1; start++)
{
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "abp:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 1);
ASSERT (b_seen == 1);
ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 5);
+ ASSERT (!output);
}
#if GNULIB_GETOPT_GNU
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "p::q::",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 0);
ASSERT (b_seen == 0);
ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 2);
+ ASSERT (!output);
}
for (start = OPTIND_MIN; start <= 1; start++)
{
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "p::q::",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 0);
ASSERT (b_seen == 0);
ASSERT (p_value == NULL);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 2);
+ ASSERT (!output);
}
for (start = OPTIND_MIN; start <= 1; start++)
{
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "abp::q::",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 1);
ASSERT (b_seen == 0);
ASSERT (p_value == NULL);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 3);
+ ASSERT (!output);
}
#endif
- /* Check that invalid options are recognized. */
+ /* Check that invalid options are recognized; and that both opterr
+ and leading ':' can silence output. */
for (start = OPTIND_MIN; start <= 1; start++)
{
int a_seen = 0;
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 42;
getopt_loop (argc, argv, "abp:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 1);
ASSERT (b_seen == 0);
ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 'x');
ASSERT (optind == 5);
+ ASSERT (output);
+ }
+ for (start = OPTIND_MIN; start <= 1; start++)
+ {
+ int a_seen = 0;
+ int b_seen = 0;
+ const char *p_value = NULL;
+ const char *q_value = NULL;
+ int non_options_count = 0;
+ const char *non_options[10];
+ int unrecognized = 0;
+ bool output;
+ int argc = 0;
+ const char *argv[10];
+
+ argv[argc++] = "program";
+ argv[argc++] = "-p";
+ argv[argc++] = "foo";
+ argv[argc++] = "-x";
+ argv[argc++] = "-a";
+ argv[argc++] = "bar";
+ argv[argc] = NULL;
+ optind = start;
+ opterr = 0;
+ getopt_loop (argc, argv, "abp:q:",
+ &a_seen, &b_seen, &p_value, &q_value,
+ &non_options_count, non_options, &unrecognized, &output);
+ ASSERT (a_seen == 1);
+ ASSERT (b_seen == 0);
+ ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
+ ASSERT (q_value == NULL);
+ ASSERT (non_options_count == 0);
+ ASSERT (unrecognized == 'x');
+ ASSERT (optind == 5);
+ ASSERT (!output);
+ }
+ for (start = OPTIND_MIN; start <= 1; start++)
+ {
+ int a_seen = 0;
+ int b_seen = 0;
+ const char *p_value = NULL;
+ const char *q_value = NULL;
+ int non_options_count = 0;
+ const char *non_options[10];
+ int unrecognized = 0;
+ bool output;
+ int argc = 0;
+ const char *argv[10];
+
+ argv[argc++] = "program";
+ argv[argc++] = "-p";
+ argv[argc++] = "foo";
+ argv[argc++] = "-x";
+ argv[argc++] = "-a";
+ argv[argc++] = "bar";
+ argv[argc] = NULL;
+ optind = start;
+ opterr = 1;
+ getopt_loop (argc, argv, ":abp:q:",
+ &a_seen, &b_seen, &p_value, &q_value,
+ &non_options_count, non_options, &unrecognized, &output);
+ ASSERT (a_seen == 1);
+ ASSERT (b_seen == 0);
+ ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
+ ASSERT (q_value == NULL);
+ ASSERT (non_options_count == 0);
+ ASSERT (unrecognized == 'x');
+ ASSERT (optind == 5);
+ ASSERT (!output);
+ }
+ for (start = OPTIND_MIN; start <= 1; start++)
+ {
+ int a_seen = 0;
+ int b_seen = 0;
+ const char *p_value = NULL;
+ const char *q_value = NULL;
+ int non_options_count = 0;
+ const char *non_options[10];
+ int unrecognized = 0;
+ bool output;
+ int argc = 0;
+ const char *argv[10];
+
+ argv[argc++] = "program";
+ argv[argc++] = "-p";
+ argv[argc++] = "foo";
+ argv[argc++] = "-:";
+ argv[argc++] = "-a";
+ argv[argc++] = "bar";
+ argv[argc] = NULL;
+ optind = start;
+ opterr = 42;
+ getopt_loop (argc, argv, "abp:q:",
+ &a_seen, &b_seen, &p_value, &q_value,
+ &non_options_count, non_options, &unrecognized, &output);
+ ASSERT (a_seen == 1);
+ ASSERT (b_seen == 0);
+ ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
+ ASSERT (q_value == NULL);
+ ASSERT (non_options_count == 0);
+ ASSERT (unrecognized == ':');
+ ASSERT (optind == 5);
+ ASSERT (output);
+ }
+ for (start = OPTIND_MIN; start <= 1; start++)
+ {
+ int a_seen = 0;
+ int b_seen = 0;
+ const char *p_value = NULL;
+ const char *q_value = NULL;
+ int non_options_count = 0;
+ const char *non_options[10];
+ int unrecognized = 0;
+ bool output;
+ int argc = 0;
+ const char *argv[10];
+
+ argv[argc++] = "program";
+ argv[argc++] = "-p";
+ argv[argc++] = "foo";
+ argv[argc++] = "-:";
+ argv[argc++] = "-a";
+ argv[argc++] = "bar";
+ argv[argc] = NULL;
+ optind = start;
+ opterr = 0;
+ getopt_loop (argc, argv, "abp:q:",
+ &a_seen, &b_seen, &p_value, &q_value,
+ &non_options_count, non_options, &unrecognized, &output);
+ ASSERT (a_seen == 1);
+ ASSERT (b_seen == 0);
+ ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
+ ASSERT (q_value == NULL);
+ ASSERT (non_options_count == 0);
+ ASSERT (unrecognized == ':');
+ ASSERT (optind == 5);
+ ASSERT (!output);
+ }
+ for (start = OPTIND_MIN; start <= 1; start++)
+ {
+ int a_seen = 0;
+ int b_seen = 0;
+ const char *p_value = NULL;
+ const char *q_value = NULL;
+ int non_options_count = 0;
+ const char *non_options[10];
+ int unrecognized = 0;
+ bool output;
+ int argc = 0;
+ const char *argv[10];
+
+ argv[argc++] = "program";
+ argv[argc++] = "-p";
+ argv[argc++] = "foo";
+ argv[argc++] = "-:";
+ argv[argc++] = "-a";
+ argv[argc++] = "bar";
+ argv[argc] = NULL;
+ optind = start;
+ opterr = 1;
+ getopt_loop (argc, argv, ":abp:q:",
+ &a_seen, &b_seen, &p_value, &q_value,
+ &non_options_count, non_options, &unrecognized, &output);
+ ASSERT (a_seen == 1);
+ ASSERT (b_seen == 0);
+ ASSERT (p_value != NULL && strcmp (p_value, "foo") == 0);
+ ASSERT (q_value == NULL);
+ ASSERT (non_options_count == 0);
+ ASSERT (unrecognized == ':');
+ ASSERT (optind == 5);
+ ASSERT (!output);
+ }
+
+ /* Check for missing argument behavior. */
+ for (start = OPTIND_MIN; start <= 1; start++)
+ {
+ int a_seen = 0;
+ int b_seen = 0;
+ const char *p_value = NULL;
+ const char *q_value = NULL;
+ int non_options_count = 0;
+ const char *non_options[10];
+ int unrecognized = 0;
+ bool output;
+ int argc = 0;
+ const char *argv[10];
+
+ argv[argc++] = "program";
+ argv[argc++] = "-ap";
+ argv[argc] = NULL;
+ optind = start;
+ opterr = 1;
+ getopt_loop (argc, argv, "abp:q:",
+ &a_seen, &b_seen, &p_value, &q_value,
+ &non_options_count, non_options, &unrecognized, &output);
+ ASSERT (a_seen == 1);
+ ASSERT (b_seen == 0);
+ ASSERT (p_value == NULL);
+ ASSERT (q_value == NULL);
+ ASSERT (non_options_count == 0);
+ ASSERT (unrecognized == 'p');
+ ASSERT (optind == 2);
+ ASSERT (output);
+ }
+ for (start = OPTIND_MIN; start <= 1; start++)
+ {
+ int a_seen = 0;
+ int b_seen = 0;
+ const char *p_value = NULL;
+ const char *q_value = NULL;
+ int non_options_count = 0;
+ const char *non_options[10];
+ int unrecognized = 0;
+ bool output;
+ int argc = 0;
+ const char *argv[10];
+
+ argv[argc++] = "program";
+ argv[argc++] = "-ap";
+ argv[argc] = NULL;
+ optind = start;
+ opterr = 0;
+ getopt_loop (argc, argv, "abp:q:",
+ &a_seen, &b_seen, &p_value, &q_value,
+ &non_options_count, non_options, &unrecognized, &output);
+ ASSERT (a_seen == 1);
+ ASSERT (b_seen == 0);
+ ASSERT (p_value == NULL);
+ ASSERT (q_value == NULL);
+ ASSERT (non_options_count == 0);
+ ASSERT (unrecognized == 'p');
+ ASSERT (optind == 2);
+ ASSERT (!output);
+ }
+ for (start = OPTIND_MIN; start <= 1; start++)
+ {
+ int a_seen = 0;
+ int b_seen = 0;
+ const char *p_value = NULL;
+ const char *q_value = NULL;
+ int non_options_count = 0;
+ const char *non_options[10];
+ int unrecognized = 0;
+ bool output;
+ int argc = 0;
+ const char *argv[10];
+
+ argv[argc++] = "program";
+ argv[argc++] = "-ap";
+ argv[argc] = NULL;
+ optind = start;
+ opterr = 1;
+ getopt_loop (argc, argv, ":abp:q:",
+ &a_seen, &b_seen, &p_value, &q_value,
+ &non_options_count, non_options, &unrecognized, &output);
+ ASSERT (a_seen == 1);
+ ASSERT (b_seen == 0);
+ ASSERT (p_value == NULL);
+ ASSERT (q_value == NULL);
+ ASSERT (non_options_count == 0);
+ ASSERT (unrecognized == 'p');
+ ASSERT (optind == 2);
+ ASSERT (!output);
}
/* Check that by default, non-options arguments are moved to the end. */
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "abp:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
if (posixly)
{
ASSERT (strcmp (argv[0], "program") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 1);
+ ASSERT (!output);
}
else
{
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 4);
+ ASSERT (!output);
}
}
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[20];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "abp:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
if (posixly)
{
ASSERT (strcmp (argv[0], "program") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 1);
+ ASSERT (!output);
}
else
{
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 5);
+ ASSERT (!output);
}
}
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "-abp:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (strcmp (argv[0], "program") == 0);
ASSERT (strcmp (argv[1], "donald") == 0);
ASSERT (strcmp (argv[2], "-p") == 0);
ASSERT (strcmp (non_options[2], "bar") == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 7);
+ ASSERT (!output);
}
/* Check that '--' ends the argument processing. */
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[20];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "-abp:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (strcmp (argv[0], "program") == 0);
ASSERT (strcmp (argv[1], "donald") == 0);
ASSERT (strcmp (argv[2], "-p") == 0);
ASSERT (b_seen == 0);
ASSERT (p_value != NULL && strcmp (p_value, "billy") == 0);
ASSERT (q_value == NULL);
+ ASSERT (!output);
if (non_options_count == 2)
{
/* glibc behaviour. */
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "abp:q:-",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
if (posixly)
{
ASSERT (strcmp (argv[0], "program") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 1);
+ ASSERT (!output);
}
else
{
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 4);
+ ASSERT (!output);
}
}
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "+abp:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (strcmp (argv[0], "program") == 0);
ASSERT (strcmp (argv[1], "donald") == 0);
ASSERT (strcmp (argv[2], "-p") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 1);
+ ASSERT (!output);
}
for (start = OPTIND_MIN; start <= 1; start++)
{
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "-+";
argv[argc] = NULL;
optind = start;
+ /* Suppress output, since glibc is inconsistent on whether this
+ prints a message:
+ http://sources.redhat.com/bugzilla/show_bug.cgi?id=11039 */
+ opterr = 0;
getopt_loop (argc, argv, "+abp:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (a_seen == 0);
ASSERT (b_seen == 0);
ASSERT (p_value == NULL);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == '+');
ASSERT (optind == 2);
+ ASSERT (!output);
}
/* Check that '--' ends the argument processing. */
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[20];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "+abp:q:",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
ASSERT (strcmp (argv[0], "program") == 0);
ASSERT (strcmp (argv[1], "donald") == 0);
ASSERT (strcmp (argv[2], "-p") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind = 1);
+ ASSERT (!output);
}
/* Check that the '+' flag has to come first. */
int non_options_count = 0;
const char *non_options[10];
int unrecognized = 0;
+ bool output;
int argc = 0;
const char *argv[10];
argv[argc++] = "bar";
argv[argc] = NULL;
optind = start;
+ opterr = 1;
getopt_loop (argc, argv, "abp:q:+",
&a_seen, &b_seen, &p_value, &q_value,
- &non_options_count, non_options, &unrecognized);
+ &non_options_count, non_options, &unrecognized, &output);
if (posixly)
{
ASSERT (strcmp (argv[0], "program") == 0);
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 1);
+ ASSERT (!output);
}
else
{
ASSERT (non_options_count == 0);
ASSERT (unrecognized == 0);
ASSERT (optind == 4);
+ ASSERT (!output);
}
}
+
+ /* No tests of "-:..." or "+:...", due to glibc bug:
+ http://sources.redhat.com/bugzilla/show_bug.cgi?id=11039 */
}