luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-12-28 00:16:15 +01:00
Code Issues Packages Projects Releases Wiki Activity
555fc57a1c
glib/glib/tests/option-context.c
Nirbheek Chauhan e0e4968dca Merge branch 'allow_NULL_argument_to_parse_strv' into 'master' 
GOption: Allow NULL arguments to parse_strv

Closes #873

See merge request GNOME/glib!1064
2019-08-27 13:17:39 +00:00

2679 lines
72 KiB
C
Raw Blame History

/* Unit tests for GOptionContext
* Copyright (C) 2007 Openismus GmbH
* Authors: Mathias Hasselmann
*
* This work is provided "as is"; redistribution and modification
* in whole or in part, in any medium, physical or electronic is
* permitted without restriction.
*
* This work 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.
*
* In no event shall the authors or contributors be liable for any
* direct, indirect, incidental, special, exemplary, or consequential
* damages (including, but not limited to, procurement of substitute
* goods or services; loss of use, data, or profits; or business
* interruption) however caused and on any theory of liability, whether
* in contract, strict liability, or tort (including negligence or
* otherwise) arising in any way out of the use of this software, even
* if advised of the possibility of such damage.
*/
#include <glib.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <locale.h>
static GOptionEntry main_entries[] = {
{ "main-switch", 0, 0,
G_OPTION_ARG_NONE, NULL,
"A switch that is in the main group", NULL },
{ NULL }
};
static GOptionEntry group_entries[] = {
{ "test-switch", 0, 0,
G_OPTION_ARG_NONE, NULL,
"A switch that is in the test group", NULL },
{ NULL }
};
static GOptionContext *
make_options (int test_number)
{
GOptionContext *options;
GOptionGroup *group = NULL;
gboolean have_main_entries = (0 != (test_number & 1));
gboolean have_test_entries = (0 != (test_number & 2));
options = g_option_context_new (NULL);
if (have_main_entries)
g_option_context_add_main_entries (options, main_entries, NULL);
if (have_test_entries)
{
group = g_option_group_new ("test", "Test Options",
"Show all test options",
NULL, NULL);
g_option_context_add_group (options, group);
g_option_group_add_entries (group, group_entries);
}
return options;
}
static void
print_help (GOptionContext *options, gchar **argv)
{
gint argc = 3;
GError *error = NULL;
g_option_context_parse (options, &argc, &argv, &error);
g_option_context_free (options);
exit(0);
}
static void
test_group_captions_help (gconstpointer test_number)
{
GOptionContext *options;
gchar *argv[] = { __FILE__, "--help", NULL };
options = make_options (GPOINTER_TO_INT (test_number));
print_help (options, argv);
}
static void
test_group_captions_help_all (gconstpointer test_number)
{
GOptionContext *options;
gchar *argv[] = { __FILE__, "--help-all", NULL };
options = make_options (GPOINTER_TO_INT (test_number));
print_help (options, argv);
}
static void
test_group_captions_help_test (gconstpointer test_number)
{
GOptionContext *options;
gchar *argv[] = { __FILE__, "--help-test", NULL };
options = make_options (GPOINTER_TO_INT (test_number));
print_help (options, argv);
}
static void
test_group_captions (void)
{
const gchar *test_name_base[] = { "help", "help-all", "help-test" };
gchar *test_name;
gint i, j;
g_test_bug ("504142");
for (i = 0; i < 4; ++i)
{
gboolean have_main_entries = (0 != (i & 1));
gboolean have_test_entries = (0 != (i & 2));
for (j = 0; j < G_N_ELEMENTS (test_name_base); ++j)
{
GTestSubprocessFlags trap_flags = 0;
gboolean expect_main_description = FALSE;
gboolean expect_main_switch = FALSE;
gboolean expect_test_description = FALSE;
gboolean expect_test_switch = FALSE;
gboolean expect_test_group = FALSE;
if (g_test_verbose ())
trap_flags |= G_TEST_SUBPROCESS_INHERIT_STDOUT | G_TEST_SUBPROCESS_INHERIT_STDERR;
test_name = g_strdup_printf ("/option/group/captions/subprocess/%s-%d",
test_name_base[j], i);
g_test_trap_subprocess (test_name, 0, trap_flags);
g_free (test_name);
g_test_trap_assert_passed ();
g_test_trap_assert_stderr ("");
switch (j)
{
case 0:
g_assert_cmpstr ("help", ==, test_name_base[j]);
expect_main_switch = have_main_entries;
expect_test_group = have_test_entries;
break;
case 1:
g_assert_cmpstr ("help-all", ==, test_name_base[j]);
expect_main_switch = have_main_entries;
expect_test_switch = have_test_entries;
expect_test_group = have_test_entries;
break;
case 2:
g_assert_cmpstr ("help-test", ==, test_name_base[j]);
expect_test_switch = have_test_entries;
break;
default:
g_assert_not_reached ();
break;
}
expect_main_description |= expect_main_switch;
expect_test_description |= expect_test_switch;
if (expect_main_description)
g_test_trap_assert_stdout ("*Application Options*");
else
g_test_trap_assert_stdout_unmatched ("*Application Options*");
if (expect_main_switch)
g_test_trap_assert_stdout ("*--main-switch*");
else
g_test_trap_assert_stdout_unmatched ("*--main-switch*");
if (expect_test_description)
g_test_trap_assert_stdout ("*Test Options*");
else
g_test_trap_assert_stdout_unmatched ("*Test Options*");
if (expect_test_switch)
g_test_trap_assert_stdout ("*--test-switch*");
else
g_test_trap_assert_stdout_unmatched ("*--test-switch*");
if (expect_test_group)
g_test_trap_assert_stdout ("*--help-test*");
else
g_test_trap_assert_stdout_unmatched ("*--help-test*");
}
}
}
int error_test1_int;
char *error_test2_string;
gboolean error_test3_boolean;
int arg_test1_int;
gchar *arg_test2_string;
gchar *arg_test3_filename;
gdouble arg_test4_double;
gdouble arg_test5_double;
gint64 arg_test6_int64;
gint64 arg_test6_int64_2;
gchar *callback_test1_string;
int callback_test2_int;
gchar *callback_test_optional_string;
gboolean callback_test_optional_boolean;
gchar **array_test1_array;
gboolean ignore_test1_boolean;
gboolean ignore_test2_boolean;
gchar *ignore_test3_string;
static gchar **
split_string (const char *str, int *argc)
{
gchar **argv;
int len;
argv = g_strsplit (str, " ", 0);
for (len = 0; argv[len] != NULL; len++);
if (argc)
*argc = len;
return argv;
}
static gchar *
join_stringv (int argc, char **argv)
{
int i;
GString *str;
str = g_string_new (NULL);
for (i = 0; i < argc; i++)
{
g_string_append (str, argv[i]);
if (i < argc - 1)
g_string_append_c (str, ' ');
}
return g_string_free (str, FALSE);
}
/* Performs a shallow copy */
static char **
copy_stringv (char **argv, int argc)
{
return g_memdup (argv, sizeof (char *) * (argc + 1));
}
static void
check_identical_stringv (gchar **before, gchar **after)
{
guint i;
/* Not only is it the same string... */
for (i = 0; before[i] != NULL; i++)
g_assert_cmpstr (before[i], ==, after[i]);
/* ... it is actually the same pointer */
for (i = 0; before[i] != NULL; i++)
g_assert (before[i] == after[i]);
g_assert (after[i] == NULL);
}
static gboolean
error_test1_pre_parse (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
g_assert (error_test1_int == 0x12345678);
return TRUE;
}
static gboolean
error_test1_post_parse (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
g_assert (error_test1_int == 20);
/* Set an error in the post hook */
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, " ");
return FALSE;
}
static void
error_test1 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionGroup *main_group;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_INT, &error_test1_int, NULL, NULL },
{ NULL } };
error_test1_int = 0x12345678;
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Set pre and post parse hooks */
main_group = g_option_context_get_main_group (context);
g_option_group_set_parse_hooks (main_group,
error_test1_pre_parse, error_test1_post_parse);
/* Now try parsing */
argv = split_string ("program --test 20", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == FALSE);
g_assert (error != NULL);
/* An error occurred, so argv has not been changed */
check_identical_stringv (argv_copy, argv);
g_clear_error (&error);
/* On failure, values should be reset */
g_assert (error_test1_int == 0x12345678);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static gboolean
error_test2_pre_parse (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
g_assert (strcmp (error_test2_string, "foo") == 0);
return TRUE;
}
static gboolean
error_test2_post_parse (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
g_assert (strcmp (error_test2_string, "bar") == 0);
/* Set an error in the post hook */
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, " ");
return FALSE;
}
static void
error_test2 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionGroup *main_group;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_STRING, &error_test2_string, NULL, NULL },
{ NULL } };
error_test2_string = "foo";
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Set pre and post parse hooks */
main_group = g_option_context_get_main_group (context);
g_option_group_set_parse_hooks (main_group,
error_test2_pre_parse, error_test2_post_parse);
/* Now try parsing */
argv = split_string ("program --test bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == FALSE);
g_assert (error != NULL);
check_identical_stringv (argv_copy, argv);
g_clear_error (&error);
g_assert (strcmp (error_test2_string, "foo") == 0);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static gboolean
error_test3_pre_parse (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
g_assert (!error_test3_boolean);
return TRUE;
}
static gboolean
error_test3_post_parse (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
g_assert (error_test3_boolean);
/* Set an error in the post hook */
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, " ");
return FALSE;
}
static void
error_test3 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionGroup *main_group;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_NONE, &error_test3_boolean, NULL, NULL },
{ NULL } };
error_test3_boolean = FALSE;
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Set pre and post parse hooks */
main_group = g_option_context_get_main_group (context);
g_option_group_set_parse_hooks (main_group,
error_test3_pre_parse, error_test3_post_parse);
/* Now try parsing */
argv = split_string ("program --test", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == FALSE);
g_assert (error != NULL);
check_identical_stringv (argv_copy, argv);
g_clear_error (&error);
g_assert (!error_test3_boolean);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
arg_test1 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test 20 --test 30", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Last arg specified is the one that should be stored */
g_assert (arg_test1_int == 30);
/* We free all of the strings in a copy of argv, because now argv is a
* subset - some have been removed in-place
*/
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
arg_test2 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_STRING, &arg_test2_string, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test foo --test bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Last arg specified is the one that should be stored */
g_assert (strcmp (arg_test2_string, "bar") == 0);
g_free (arg_test2_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
arg_test3 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_FILENAME, &arg_test3_filename, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test foo.txt", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Last arg specified is the one that should be stored */
g_assert (strcmp (arg_test3_filename, "foo.txt") == 0);
g_free (arg_test3_filename);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
arg_test4 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv_copy;
gchar **argv;
int argc;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_DOUBLE, &arg_test4_double, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test 20.0 --test 30.03", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Last arg specified is the one that should be stored */
g_assert (arg_test4_double == 30.03);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
arg_test5 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
char *old_locale, *current_locale;
const char *locale = "de_DE.UTF-8";
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_DOUBLE, &arg_test5_double, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test 20,0 --test 30,03", &argc);
argv_copy = copy_stringv (argv, argc);
/* set it to some locale that uses commas instead of decimal points */
old_locale = g_strdup (setlocale (LC_NUMERIC, locale));
current_locale = setlocale (LC_NUMERIC, NULL);
if (strcmp (current_locale, locale) != 0)
{
fprintf (stderr, "Cannot set locale to %s, skipping\n", locale);
goto cleanup;
}
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Last arg specified is the one that should be stored */
g_assert (arg_test5_double == 30.03);
cleanup:
setlocale (LC_NUMERIC, old_locale);
g_free (old_locale);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
arg_test6 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_INT64, &arg_test6_int64, NULL, NULL },
{ "test2", 0, 0, G_OPTION_ARG_INT64, &arg_test6_int64_2, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test 4294967297 --test 4294967296 --test2 0xfffffffff", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Last arg specified is the one that should be stored */
g_assert (arg_test6_int64 == G_GINT64_CONSTANT(4294967296));
g_assert (arg_test6_int64_2 == G_GINT64_CONSTANT(0xfffffffff));
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static gboolean
callback_parse1 (const gchar *option_name, const gchar *value,
gpointer data, GError **error)
{
callback_test1_string = g_strdup (value);
return TRUE;
}
static void
callback_test1 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_CALLBACK, callback_parse1, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test foo.txt", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (strcmp (callback_test1_string, "foo.txt") == 0);
g_free (callback_test1_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static gboolean
callback_parse2 (const gchar *option_name, const gchar *value,
gpointer data, GError **error)
{
callback_test2_int++;
return TRUE;
}
static void
callback_test2 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, callback_parse2, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test --test", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (callback_test2_int == 2);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static gboolean
callback_parse_optional (const gchar *option_name, const gchar *value,
gpointer data, GError **error)
{
callback_test_optional_boolean = TRUE;
if (value)
callback_test_optional_string = g_strdup (value);
else
callback_test_optional_string = NULL;
return TRUE;
}
static void
callback_test_optional_1 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 0, G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
callback_parse_optional, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test foo.txt", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (strcmp (callback_test_optional_string, "foo.txt") == 0);
g_assert (callback_test_optional_boolean);
g_free (callback_test_optional_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
callback_test_optional_2 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 0, G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
callback_parse_optional, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (callback_test_optional_string == NULL);
g_assert (callback_test_optional_boolean);
g_free (callback_test_optional_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
callback_test_optional_3 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv_copy;
gchar **argv;
int argc;
GOptionEntry entries [] =
{ { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
callback_parse_optional, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program -t foo.txt", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (strcmp (callback_test_optional_string, "foo.txt") == 0);
g_assert (callback_test_optional_boolean);
g_free (callback_test_optional_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
callback_test_optional_4 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
callback_parse_optional, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program -t", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (callback_test_optional_string == NULL);
g_assert (callback_test_optional_boolean);
g_free (callback_test_optional_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
callback_test_optional_5 (void)
{
GOptionContext *context;
gboolean dummy;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "dummy", 'd', 0, G_OPTION_ARG_NONE, &dummy, NULL },
{ "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
callback_parse_optional, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test --dummy", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (callback_test_optional_string == NULL);
g_assert (callback_test_optional_boolean);
g_free (callback_test_optional_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
callback_test_optional_6 (void)
{
GOptionContext *context;
gboolean dummy;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "dummy", 'd', 0, G_OPTION_ARG_NONE, &dummy, NULL },
{ "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
callback_parse_optional, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program -t -d", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (callback_test_optional_string == NULL);
g_assert (callback_test_optional_boolean);
g_free (callback_test_optional_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
callback_test_optional_7 (void)
{
GOptionContext *context;
gboolean dummy;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "dummy", 'd', 0, G_OPTION_ARG_NONE, &dummy, NULL },
{ "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
callback_parse_optional, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program -td", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (callback_test_optional_string == NULL);
g_assert (callback_test_optional_boolean);
g_free (callback_test_optional_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
callback_test_optional_8 (void)
{
GOptionContext *context;
gboolean dummy;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "dummy", 'd', 0, G_OPTION_ARG_NONE, &dummy, NULL },
{ "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK,
callback_parse_optional, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program -dt foo.txt", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (callback_test_optional_string);
g_assert (callback_test_optional_boolean);
g_free (callback_test_optional_string);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static GPtrArray *callback_remaining_args;
static gboolean
callback_remaining_test1_callback (const gchar *option_name, const gchar *value,
gpointer data, GError **error)
{
g_ptr_array_add (callback_remaining_args, g_strdup (value));
return TRUE;
}
static void
callback_remaining_test1 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_CALLBACK, callback_remaining_test1_callback, NULL, NULL },
{ NULL } };
callback_remaining_args = g_ptr_array_new ();
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program foo.txt blah.txt", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (callback_remaining_args->len == 2);
g_assert (strcmp (callback_remaining_args->pdata[0], "foo.txt") == 0);
g_assert (strcmp (callback_remaining_args->pdata[1], "blah.txt") == 0);
g_ptr_array_foreach (callback_remaining_args, (GFunc) g_free, NULL);
g_ptr_array_free (callback_remaining_args, TRUE);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static gboolean
callback_error (const gchar *option_name, const gchar *value,
gpointer data, GError **error)
{
g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "42");
return FALSE;
}
static void
callback_returns_false (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "error", 0, 0, G_OPTION_ARG_CALLBACK, callback_error, NULL, NULL },
{ "error-no-arg", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, callback_error, NULL, NULL },
{ "error-optional-arg", 0, G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, callback_error, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --error value", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE);
g_assert (retval == FALSE);
check_identical_stringv (argv_copy, argv);
g_option_context_free (context);
g_clear_error (&error);
g_strfreev (argv_copy);
g_free (argv);
/* And again, this time with a no-arg variant */
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
argv = split_string ("program --error-no-arg", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE);
g_assert (retval == FALSE);
check_identical_stringv (argv_copy, argv);
g_option_context_free (context);
g_clear_error (&error);
g_strfreev (argv_copy);
g_free (argv);
/* And again, this time with an optional arg variant, with argument */
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
argv = split_string ("program --error-optional-arg value", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE);
g_assert (retval == FALSE);
check_identical_stringv (argv_copy, argv);
g_option_context_free (context);
g_clear_error (&error);
g_strfreev (argv_copy);
g_free (argv);
/* And again, this time with an optional arg variant, without argument */
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
argv = split_string ("program --error-optional-arg", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE);
g_assert (retval == FALSE);
check_identical_stringv (argv_copy, argv);
g_option_context_free (context);
g_clear_error (&error);
g_strfreev (argv_copy);
g_free (argv);
}
static void
ignore_test1 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv, **argv_copy;
int argc;
gchar *arg;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test --hello", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
arg = join_stringv (argc, argv);
g_assert (strcmp (arg, "program --hello") == 0);
g_free (arg);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
ignore_test2 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
gchar *arg;
GOptionEntry entries [] =
{ { "test", 't', 0, G_OPTION_ARG_NONE, &ignore_test2_boolean, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program -test", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
arg = join_stringv (argc, argv);
g_assert (strcmp (arg, "program -es") == 0);
g_free (arg);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
ignore_test3 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv, **argv_copy;
int argc;
gchar *arg;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_STRING, &ignore_test3_string, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test foo --hello", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
arg = join_stringv (argc, argv);
g_assert (strcmp (arg, "program --hello") == 0);
g_assert (strcmp (ignore_test3_string, "foo") == 0);
g_free (ignore_test3_string);
g_free (arg);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
void
static array_test1 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] =
{ { "test", 0, 0, G_OPTION_ARG_STRING_ARRAY, &array_test1_array, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test foo --test bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (strcmp (array_test1_array[0], "foo") == 0);
g_assert (strcmp (array_test1_array[1], "bar") == 0);
g_assert (array_test1_array[2] == NULL);
g_strfreev (array_test1_array);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
add_test1 (void)
{
GOptionContext *context;
GOptionEntry entries1 [] =
{ { "test1", 0, 0, G_OPTION_ARG_STRING_ARRAY, NULL, NULL, NULL },
{ NULL } };
GOptionEntry entries2 [] =
{ { "test2", 0, 0, G_OPTION_ARG_STRING_ARRAY, NULL, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries1, NULL);
g_option_context_add_main_entries (context, entries2, NULL);
g_option_context_free (context);
}
static void
empty_test2 (void)
{
GOptionContext *context;
context = g_option_context_new (NULL);
g_option_context_parse (context, NULL, NULL, NULL);
g_option_context_free (context);
}
static void
empty_test3 (void)
{
GOptionContext *context;
gint argc;
gchar **argv;
argc = 0;
argv = NULL;
context = g_option_context_new (NULL);
g_option_context_parse (context, &argc, &argv, NULL);
g_option_context_free (context);
}
/* check that non-option arguments are left in argv by default */
static void
rest_test1 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = {
{ "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program foo --test bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (ignore_test1_boolean);
g_assert (strcmp (argv[0], "program") == 0);
g_assert (strcmp (argv[1], "foo") == 0);
g_assert (strcmp (argv[2], "bar") == 0);
g_assert (argv[3] == NULL);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
/* check that -- works */
static void
rest_test2 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = {
{ "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program foo --test -- -bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (ignore_test1_boolean);
g_assert (strcmp (argv[0], "program") == 0);
g_assert (strcmp (argv[1], "foo") == 0);
g_assert (strcmp (argv[2], "--") == 0);
g_assert (strcmp (argv[3], "-bar") == 0);
g_assert (argv[4] == NULL);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
/* check that -- stripping works */
static void
rest_test2a (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = {
{ "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program foo --test -- bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (ignore_test1_boolean);
g_assert (strcmp (argv[0], "program") == 0);
g_assert (strcmp (argv[1], "foo") == 0);
g_assert (strcmp (argv[2], "bar") == 0);
g_assert (argv[3] == NULL);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
rest_test2b (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = {
{ "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program foo --test -bar --", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (ignore_test1_boolean);
g_assert (strcmp (argv[0], "program") == 0);
g_assert (strcmp (argv[1], "foo") == 0);
g_assert (strcmp (argv[2], "-bar") == 0);
g_assert (argv[3] == NULL);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
rest_test2c (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = {
{ "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test foo -- bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (ignore_test1_boolean);
g_assert (strcmp (argv[0], "program") == 0);
g_assert (strcmp (argv[1], "foo") == 0);
g_assert (strcmp (argv[2], "bar") == 0);
g_assert (argv[3] == NULL);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
rest_test2d (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = {
{ "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test -- -bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (ignore_test1_boolean);
g_assert (strcmp (argv[0], "program") == 0);
g_assert (strcmp (argv[1], "--") == 0);
g_assert (strcmp (argv[2], "-bar") == 0);
g_assert (argv[3] == NULL);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
/* check that G_OPTION_REMAINING collects non-option arguments */
static void
rest_test3 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = {
{ "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &array_test1_array, NULL, NULL },
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program foo --test bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (ignore_test1_boolean);
g_assert (strcmp (array_test1_array[0], "foo") == 0);
g_assert (strcmp (array_test1_array[1], "bar") == 0);
g_assert (array_test1_array[2] == NULL);
g_strfreev (array_test1_array);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
/* check that G_OPTION_REMAINING and -- work together */
static void
rest_test4 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = {
{ "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &array_test1_array, NULL, NULL },
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program foo --test -- -bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (ignore_test1_boolean);
g_assert (strcmp (array_test1_array[0], "foo") == 0);
g_assert (strcmp (array_test1_array[1], "-bar") == 0);
g_assert (array_test1_array[2] == NULL);
g_strfreev (array_test1_array);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
/* test that G_OPTION_REMAINING works with G_OPTION_ARG_FILENAME_ARRAY */
static void
rest_test5 (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = {
{ "test", 0, 0, G_OPTION_ARG_NONE, &ignore_test1_boolean, NULL, NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &array_test1_array, NULL, NULL },
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program foo --test bar", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
/* Check array */
g_assert (ignore_test1_boolean);
g_assert (strcmp (array_test1_array[0], "foo") == 0);
g_assert (strcmp (array_test1_array[1], "bar") == 0);
g_assert (array_test1_array[2] == NULL);
g_strfreev (array_test1_array);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
unknown_short_test (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
GOptionEntry entries [] = { { NULL } };
g_test_bug ("166609");
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program -0", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (!retval);
g_assert (error != NULL);
g_clear_error (&error);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
/* test that lone dashes are treated as non-options */
static void
lonely_dash_test (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
g_test_bug ("168008");
context = g_option_context_new (NULL);
/* Now try parsing */
argv = split_string ("program -", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert (argv[1] && strcmp (argv[1], "-") == 0);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
/* test that three dashes are treated as non-options */
static void
triple_dash_test (void)
{
GOptionContext *context;
GOptionGroup *group;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
gint arg1, arg2;
GOptionEntry entries [] =
{ { "foo", 0, 0, G_OPTION_ARG_INT, &arg1, NULL, NULL},
{ NULL }
};
GOptionEntry group_entries [] =
{ { "test", 0, 0, G_OPTION_ARG_INT, &arg2, NULL, NULL},
{ NULL }
};
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
group = g_option_group_new ("group", "Group description", "Group help", NULL, NULL);
g_option_group_add_entries (group, group_entries);
g_option_context_add_group (context, group);
/* Now try parsing */
argv = split_string ("program ---test 42", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_error (error, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION);
g_assert (retval == FALSE);
g_option_context_free (context);
g_clear_error (&error);
g_strfreev (argv_copy);
g_free (argv);
}
static void
missing_arg_test (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
gchar *arg = NULL;
GOptionEntry entries [] =
{ { "test", 't', 0, G_OPTION_ARG_STRING, &arg, NULL, NULL },
{ NULL } };
g_test_bug ("305576");
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == FALSE);
g_assert (error != NULL);
/* An error occurred, so argv has not been changed */
check_identical_stringv (argv_copy, argv);
g_clear_error (&error);
g_strfreev (argv_copy);
g_free (argv);
/* Try parsing again */
argv = split_string ("program -t", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == FALSE);
g_assert (error != NULL);
/* An error occurred, so argv has not been changed */
check_identical_stringv (argv_copy, argv);
g_clear_error (&error);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
/* Checking g_option_context_parse_strv on NULL args */
context = g_option_context_new (NULL);
g_assert_true (g_option_context_parse_strv (context, NULL, NULL));
g_option_context_free (context);
}
static gchar *test_arg;
static gboolean cb (const gchar *option_name,
const gchar *value,
gpointer data,
GError **error)
{
test_arg = g_strdup (value);
return TRUE;
}
static void
dash_arg_test (void)
{
GOptionContext *context;
gboolean retval;
GError *error = NULL;
gchar **argv;
gchar **argv_copy;
int argc;
gboolean argb = FALSE;
GOptionEntry entries [] =
{ { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_CALLBACK, cb, NULL, NULL },
{ "three", '3', 0, G_OPTION_ARG_NONE, &argb, NULL, NULL },
{ NULL } };
g_test_bug ("577638");
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
/* Now try parsing */
argv = split_string ("program --test=-3", &argc);
argv_copy = copy_stringv (argv, argc);
test_arg = NULL;
error = NULL;
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval);
g_assert_no_error (error);
g_assert_cmpstr (test_arg, ==, "-3");
g_strfreev (argv_copy);
g_free (argv);
g_free (test_arg);
test_arg = NULL;
/* Try parsing again */
argv = split_string ("program --test -3", &argc);
argv_copy = copy_stringv (argv, argc);
error = NULL;
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert_cmpstr (test_arg, ==, NULL);
g_option_context_free (context);
g_strfreev (argv_copy);
g_free (argv);
}
static void
test_basic (void)
{
GOptionContext *context;
gchar *arg = NULL;
GOptionEntry entries [] =
{ { "test", 't', 0, G_OPTION_ARG_STRING, &arg, NULL, NULL },
{ NULL } };
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_assert (g_option_context_get_help_enabled (context));
g_assert (!g_option_context_get_ignore_unknown_options (context));
g_assert_cmpstr (g_option_context_get_summary (context), ==, NULL);
g_assert_cmpstr (g_option_context_get_description (context), ==, NULL);
g_option_context_set_help_enabled (context, FALSE);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_set_summary (context, "summary");
g_option_context_set_description(context, "description");
g_assert (!g_option_context_get_help_enabled (context));
g_assert (g_option_context_get_ignore_unknown_options (context));
g_assert_cmpstr (g_option_context_get_summary (context), ==, "summary");
g_assert_cmpstr (g_option_context_get_description (context), ==, "description");
g_option_context_free (context);
}
typedef struct {
gboolean parameter_seen;
gboolean summary_seen;
gboolean description_seen;
gboolean destroyed;
} TranslateData;
static const gchar *
translate_func (const gchar *str,
gpointer data)
{
TranslateData *d = data;
if (strcmp (str, "parameter") == 0)
d->parameter_seen = TRUE;
else if (strcmp (str, "summary") == 0)
d->summary_seen = TRUE;
else if (strcmp (str, "description") == 0)
d->description_seen = TRUE;
return str;
}
static void
destroy_notify (gpointer data)
{
TranslateData *d = data;
d->destroyed = TRUE;
}
static void
test_translate (void)
{
GOptionContext *context;
gchar *arg = NULL;
GOptionEntry entries [] =
{ { "test", 't', 0, G_OPTION_ARG_STRING, &arg, NULL, NULL },
{ NULL } };
TranslateData data = { 0, };
gchar *str;
context = g_option_context_new ("parameter");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_summary (context, "summary");
g_option_context_set_description (context, "description");
g_option_context_set_translate_func (context, translate_func, &data, destroy_notify);
str = g_option_context_get_help (context, FALSE, NULL);
g_free (str);
g_option_context_free (context);
g_assert (data.parameter_seen);
g_assert (data.summary_seen);
g_assert (data.description_seen);
g_assert (data.destroyed);
}
static void
test_help (void)
{
GOptionContext *context;
GOptionGroup *group;
gchar *str;
gchar *arg = NULL;
gchar **sarr = NULL;
GOptionEntry entries[] = {
{ "test", 't', 0, G_OPTION_ARG_STRING, &arg, "Test tests", "Argument to use in test" },
{ "test2", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, NULL, "Tests also", NULL },
{ "frob", 0, 0, G_OPTION_ARG_NONE, NULL, "Main frob", NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &sarr, "Rest goes here", "REST" },
{ NULL }
};
GOptionEntry group_entries[] = {
{ "test", 't', 0, G_OPTION_ARG_STRING, &arg, "Group test", "Group test arg" },
{ "frob", 0, G_OPTION_FLAG_NOALIAS, G_OPTION_ARG_NONE, NULL, "Group frob", NULL },
{ NULL }
};
context = g_option_context_new ("blabla");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_summary (context, "Summary");
g_option_context_set_description (context, "Description");
group = g_option_group_new ("group1", "Group1-description", "Group1-help", NULL, NULL);
g_option_group_add_entries (group, group_entries);
g_option_context_add_group (context, group);
str = g_option_context_get_help (context, FALSE, NULL);
g_assert (strstr (str, "blabla") != NULL);
g_assert (strstr (str, "Test tests") != NULL);
g_assert (strstr (str, "Argument to use in test") != NULL);
g_assert (strstr (str, "Tests also") == NULL);
g_assert (strstr (str, "REST") != NULL);
g_assert (strstr (str, "Summary") != NULL);
g_assert (strstr (str, "Description") != NULL);
g_assert (strstr (str, "--help") != NULL);
g_assert (strstr (str, "--help-all") != NULL);
g_assert (strstr (str, "--help-group1") != NULL);
g_assert (strstr (str, "Group1-description") != NULL);
g_assert (strstr (str, "Group1-help") != NULL);
g_assert (strstr (str, "Group test arg") != NULL);
g_assert (strstr (str, "Group frob") != NULL);
g_assert (strstr (str, "Main frob") != NULL);
g_assert (strstr (str, "--frob") != NULL);
g_assert (strstr (str, "--group1-test") != NULL);
g_assert (strstr (str, "--group1-frob") == NULL);
g_free (str);
g_option_context_free (context);
}
static void
test_help_no_options (void)
{
GOptionContext *context;
gchar **sarr = NULL;
GOptionEntry entries[] = {
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &sarr, "Rest goes here", "REST" },
{ NULL }
};
gchar *str;
context = g_option_context_new ("blabla");
g_option_context_add_main_entries (context, entries, NULL);
str = g_option_context_get_help (context, FALSE, NULL);
g_assert (strstr (str, "blabla") != NULL);
g_assert (strstr (str, "REST") != NULL);
g_assert (strstr (str, "Help Options") != NULL);
g_assert (strstr (str, "Application Options") == NULL);
g_free (str);
g_option_context_free (context);
}
static void
test_help_no_help_options (void)
{
GOptionContext *context;
GOptionGroup *group;
gchar *str;
gchar *arg = NULL;
gchar **sarr = NULL;
GOptionEntry entries[] = {
{ "test", 't', 0, G_OPTION_ARG_STRING, &arg, "Test tests", "Argument to use in test" },
{ "test2", 0, G_OPTION_FLAG_HIDDEN, G_OPTION_ARG_NONE, NULL, "Tests also", NULL },
{ "frob", 0, 0, G_OPTION_ARG_NONE, NULL, "Main frob", NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &sarr, "Rest goes here", "REST" },
{ NULL }
};
GOptionEntry group_entries[] = {
{ "test", 't', 0, G_OPTION_ARG_STRING, &arg, "Group test", "Group test arg" },
{ "frob", 0, G_OPTION_FLAG_NOALIAS, G_OPTION_ARG_NONE, NULL, "Group frob", NULL },
{ NULL }
};
g_test_bug ("697652");
context = g_option_context_new ("blabla");
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_summary (context, "Summary");
g_option_context_set_description (context, "Description");
g_option_context_set_help_enabled (context, FALSE);
group = g_option_group_new ("group1", "Group1-description", "Group1-help", NULL, NULL);
g_option_group_add_entries (group, group_entries);
g_option_context_add_group (context, group);
str = g_option_context_get_help (context, FALSE, NULL);
g_assert (strstr (str, "blabla") != NULL);
g_assert (strstr (str, "Test tests") != NULL);
g_assert (strstr (str, "Argument to use in test") != NULL);
g_assert (strstr (str, "Tests also") == NULL);
g_assert (strstr (str, "REST") != NULL);
g_assert (strstr (str, "Summary") != NULL);
g_assert (strstr (str, "Description") != NULL);
g_assert (strstr (str, "Help Options") == NULL);
g_assert (strstr (str, "--help") == NULL);
g_assert (strstr (str, "--help-all") == NULL);
g_assert (strstr (str, "--help-group1") == NULL);
g_assert (strstr (str, "Group1-description") != NULL);
g_assert (strstr (str, "Group1-help") == NULL);
g_assert (strstr (str, "Group test arg") != NULL);
g_assert (strstr (str, "Group frob") != NULL);
g_assert (strstr (str, "Main frob") != NULL);
g_assert (strstr (str, "--frob") != NULL);
g_assert (strstr (str, "--group1-test") != NULL);
g_assert (strstr (str, "--group1-frob") == NULL);
g_free (str);
g_option_context_free (context);
}
static void
set_bool (gpointer data)
{
gboolean *b = data;
*b = TRUE;
}
static void
test_main_group (void)
{
GOptionContext *context;
GOptionGroup *group;
gboolean b = FALSE;
context = g_option_context_new (NULL);
g_assert (g_option_context_get_main_group (context) == NULL);
group = g_option_group_new ("name", "description", "hlep", &b, set_bool);
g_option_context_add_group (context, group);
group = g_option_group_new ("name2", "description", "hlep", NULL, NULL);
g_option_context_add_group (context, group);
g_assert (g_option_context_get_main_group (context) == NULL);
group = g_option_group_new ("name", "description", "hlep", NULL, NULL);
g_option_context_set_main_group (context, group);
g_assert (g_option_context_get_main_group (context) == group);
g_option_context_free (context);
g_assert (b);
}
static gboolean error_func_called = FALSE;
static void
error_func (GOptionContext *context,
GOptionGroup *group,
gpointer data,
GError **error)
{
g_assert_cmpint (GPOINTER_TO_INT(data), ==, 1234);
error_func_called = TRUE;
}
static void
test_error_hook (void)
{
GOptionContext *context;
gchar *arg = NULL;
GOptionEntry entries [] =
{ { "test", 't', 0, G_OPTION_ARG_STRING, &arg, NULL, NULL },
{ NULL } };
GOptionGroup *group;
gchar **argv;
gchar **argv_copy;
gint argc;
gboolean retval;
GError *error = NULL;
context = g_option_context_new (NULL);
group = g_option_group_new ("name", "description", "hlep", GINT_TO_POINTER(1234), NULL);
g_option_group_add_entries (group, entries);
g_option_context_set_main_group (context, group);
g_option_group_set_error_hook (g_option_context_get_main_group (context),
error_func);
argv = split_string ("program --test", &argc);
argv_copy = copy_stringv (argv, argc);
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert (retval == FALSE);
g_assert (error != NULL);
/* An error occurred, so argv has not been changed */
check_identical_stringv (argv_copy, argv);
g_clear_error (&error);
g_assert (error_func_called);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
test_group_parse (void)
{
GOptionContext *context;
GOptionGroup *group;
gchar *arg1 = NULL;
gchar *arg2 = NULL;
gchar *arg3 = NULL;
gchar *arg4 = NULL;
gchar *arg5 = NULL;
GOptionEntry entries[] = {
{ "test", 't', 0, G_OPTION_ARG_STRING, &arg1, NULL, NULL },
{ "faz", 'f', 0, G_OPTION_ARG_STRING, &arg2, NULL, NULL },
{ NULL }
};
GOptionEntry group_entries[] = {
{ "test", 0, 0, G_OPTION_ARG_STRING, &arg3, NULL, NULL },
{ "frob", 'f', 0, G_OPTION_ARG_STRING, &arg4, NULL, NULL },
{ "faz", 'z', 0, G_OPTION_ARG_STRING, &arg5, NULL, NULL },
{ NULL }
};
gchar **argv, **orig_argv;
gint argc;
GError *error = NULL;
gboolean retval;
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
group = g_option_group_new ("group", "A group", "help for group", NULL, NULL);
g_option_group_add_entries (group, group_entries);
g_option_context_add_group (context, group);
argv = split_string ("program --test arg1 -f arg2 --group-test arg3 --frob arg4 -z arg5", &argc);
orig_argv = g_memdup (argv, (argc + 1) * sizeof (char *));
retval = g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (retval);
g_assert_cmpstr (arg1, ==, "arg1");
g_assert_cmpstr (arg2, ==, "arg2");
g_assert_cmpstr (arg3, ==, "arg3");
g_assert_cmpstr (arg4, ==, "arg4");
g_assert_cmpstr (arg5, ==, "arg5");
g_free (arg1);
g_free (arg2);
g_free (arg3);
g_free (arg4);
g_free (arg5);
g_free (argv);
g_strfreev (orig_argv);
g_option_context_free (context);
}
static gint
option_context_parse_command_line (GOptionContext *context,
const gchar *command_line)
{
gchar **argv;
guint argv_len, argv_new_len;
gboolean success;
argv = split_string (command_line, NULL);
argv_len = g_strv_length (argv);
success = g_option_context_parse_strv (context, &argv, NULL);
argv_new_len = g_strv_length (argv);
g_strfreev (argv);
return success ? argv_len - argv_new_len : -1;
}
static void
test_strict_posix (void)
{
GOptionContext *context;
gboolean foo;
gboolean bar;
GOptionEntry entries[] = {
{ "foo", 'f', 0, G_OPTION_ARG_NONE, &foo, NULL, NULL },
{ "bar", 'b', 0, G_OPTION_ARG_NONE, &bar, NULL, NULL },
{ NULL }
};
gint n_parsed;
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
foo = bar = FALSE;
g_option_context_set_strict_posix (context, FALSE);
n_parsed = option_context_parse_command_line (context, "program --foo command --bar");
g_assert_cmpint (n_parsed, ==, 2);
g_assert (foo == TRUE);
g_assert (bar == TRUE);
foo = bar = FALSE;
g_option_context_set_strict_posix (context, TRUE);
n_parsed = option_context_parse_command_line (context, "program --foo command --bar");
g_assert_cmpint (n_parsed, ==, 1);
g_assert (foo == TRUE);
g_assert (bar == FALSE);
foo = bar = FALSE;
g_option_context_set_strict_posix (context, TRUE);
n_parsed = option_context_parse_command_line (context, "program --foo --bar command");
g_assert_cmpint (n_parsed, ==, 2);
g_assert (foo == TRUE);
g_assert (bar == TRUE);
foo = bar = FALSE;
g_option_context_set_strict_posix (context, TRUE);
n_parsed = option_context_parse_command_line (context, "program command --foo --bar");
g_assert_cmpint (n_parsed, ==, 0);
g_assert (foo == FALSE);
g_assert (bar == FALSE);
g_option_context_free (context);
}
static void
flag_reverse_string (void)
{
GOptionContext *context;
gchar *arg = NULL;
GOptionEntry entries [] =
{ { "test", 't', G_OPTION_FLAG_REVERSE, G_OPTION_ARG_STRING, &arg, NULL, NULL },
{ NULL } };
gchar **argv;
gint argc;
gboolean retval;
GError *error = NULL;
if (!g_test_undefined ())
return;
context = g_option_context_new (NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*ignoring reverse flag*");
g_option_context_add_main_entries (context, entries, NULL);
g_test_assert_expected_messages ();
argv = split_string ("program --test bla", &argc);
retval = g_option_context_parse_strv (context, &argv, &error);
g_assert (retval == TRUE);
g_assert_no_error (error);
g_strfreev (argv);
g_option_context_free (context);
g_free (arg);
}
static void
flag_optional_int (void)
{
GOptionContext *context;
gint arg = 0;
GOptionEntry entries [] =
{ { "test", 't', G_OPTION_FLAG_OPTIONAL_ARG, G_OPTION_ARG_INT, &arg, NULL, NULL },
{ NULL } };
gchar **argv;
gint argc;
gboolean retval;
GError *error = NULL;
if (!g_test_undefined ())
return;
context = g_option_context_new (NULL);
g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_WARNING,
"*ignoring no-arg, optional-arg or filename flags*");
g_option_context_add_main_entries (context, entries, NULL);
g_test_assert_expected_messages ();
argv = split_string ("program --test 5", &argc);
retval = g_option_context_parse_strv (context, &argv, &error);
g_assert (retval == TRUE);
g_assert_no_error (error);
g_strfreev (argv);
g_option_context_free (context);
}
static void
short_remaining (void)
{
gboolean ignore = FALSE;
gboolean remaining = FALSE;
gint number = 0;
gchar* text = NULL;
gchar** files = NULL;
GError* error = NULL;
GOptionEntry entries[] =
{
{ "ignore", 'i', 0, G_OPTION_ARG_NONE, &ignore, NULL, NULL },
{ "remaining", 'r', 0, G_OPTION_ARG_NONE, &remaining, NULL, NULL },
{ "number", 'n', 0, G_OPTION_ARG_INT, &number, NULL, NULL },
{ "text", 't', 0, G_OPTION_ARG_STRING, &text, NULL, NULL },
{ G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &files, NULL, NULL },
{ NULL }
};
GOptionContext* context;
gchar **argv, **argv_copy;
gint argc;
g_test_bug ("729563");
argv = split_string ("program -ri -n 4 -t hello file1 file2", &argc);
argv_copy = copy_stringv (argv, argc);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, TRUE);
g_option_context_parse (context, &argc, &argv, &error);
g_assert_no_error (error);
g_assert (ignore);
g_assert (remaining);
g_assert_cmpint (number, ==, 4);
g_assert_cmpstr (text, ==, "hello");
g_assert_cmpstr (files[0], ==, "file1");
g_assert_cmpstr (files[1], ==, "file2");
g_assert (files[2] == NULL);
g_free (text);
g_strfreev (files);
g_strfreev (argv_copy);
g_free (argv);
g_option_context_free (context);
}
static void
double_free (void)
{
gchar* text = NULL;
GOptionEntry entries[] =
{
{ "known", 0, 0, G_OPTION_ARG_STRING, &text, NULL, NULL },
{ NULL }
};
GOptionContext* context;
gchar **argv;
gint argc;
GError *error = NULL;
g_test_bug ("646926");
argv = split_string ("program --known=foo --known=bar --unknown=baz", &argc);
context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, entries, NULL);
g_option_context_set_ignore_unknown_options (context, FALSE);
g_option_context_parse (context, &argc, &argv, &error);
g_assert_error (error, G_OPTION_ERROR, G_OPTION_ERROR_UNKNOWN_OPTION);
g_assert_null (text);
g_option_context_free (context);
g_clear_error (&error);
g_strfreev (argv);
}
int
main (int argc,
char *argv[])
{
int i;
gchar *test_name;
g_setenv ("LC_ALL", "C", TRUE);
g_test_init (&argc, &argv, NULL);
g_test_bug_base ("http://bugzilla.gnome.org/");
g_test_add_func ("/option/help/options", test_help);
g_test_add_func ("/option/help/no-options", test_help_no_options);
g_test_add_func ("/option/help/no-help-options", test_help_no_help_options);
g_test_add_func ("/option/basic", test_basic);
g_test_add_func ("/option/translate", test_translate);
g_test_add_func ("/option/group/captions", test_group_captions);
for (i = 0; i < 4; i++)
{
test_name = g_strdup_printf ("/option/group/captions/subprocess/help-%d", i);
g_test_add_data_func (test_name, GINT_TO_POINTER (i),
test_group_captions_help);
g_free (test_name);
test_name = g_strdup_printf ("/option/group/captions/subprocess/help-all-%d", i);
g_test_add_data_func (test_name, GINT_TO_POINTER (i),
test_group_captions_help_all);
g_free (test_name);
test_name = g_strdup_printf ("/option/group/captions/subprocess/help-test-%d", i);
g_test_add_data_func (test_name, GINT_TO_POINTER (i),
test_group_captions_help_test);
g_free (test_name);
}
g_test_add_func ("/option/group/main", test_main_group);
g_test_add_func ("/option/group/error-hook", test_error_hook);
g_test_add_func ("/option/group/parse", test_group_parse);
g_test_add_func ("/option/strict-posix", test_strict_posix);
/* Test that restoration on failure works */
g_test_add_func ("/option/restoration/int", error_test1);
g_test_add_func ("/option/restoration/string", error_test2);
g_test_add_func ("/option/restoration/boolean", error_test3);
/* Test that special argument parsing works */
g_test_add_func ("/option/arg/repetition/int", arg_test1);
g_test_add_func ("/option/arg/repetition/string", arg_test2);
g_test_add_func ("/option/arg/repetition/filename", arg_test3);
g_test_add_func ("/option/arg/repetition/double", arg_test4);
g_test_add_func ("/option/arg/repetition/locale", arg_test5);
g_test_add_func ("/option/arg/repetition/int64", arg_test6);
/* Test string arrays */
g_test_add_func ("/option/arg/array/string", array_test1);
/* Test callback args */
g_test_add_func ("/option/arg/callback/string", callback_test1);
g_test_add_func ("/option/arg/callback/count", callback_test2);
/* Test optional arg flag for callback */
g_test_add_func ("/option/arg/callback/optional1", callback_test_optional_1);
g_test_add_func ("/option/arg/callback/optional2", callback_test_optional_2);
g_test_add_func ("/option/arg/callback/optional3", callback_test_optional_3);
g_test_add_func ("/option/arg/callback/optional4", callback_test_optional_4);
g_test_add_func ("/option/arg/callback/optional5", callback_test_optional_5);
g_test_add_func ("/option/arg/callback/optional6", callback_test_optional_6);
g_test_add_func ("/option/arg/callback/optional7", callback_test_optional_7);
g_test_add_func ("/option/arg/callback/optional8", callback_test_optional_8);
/* Test callback with G_OPTION_REMAINING */
g_test_add_func ("/option/arg/remaining/callback", callback_remaining_test1);
/* Test callbacks which return FALSE */
g_test_add_func ("/option/arg/remaining/callback-false", callback_returns_false);
/* Test ignoring options */
g_test_add_func ("/option/arg/ignore/long", ignore_test1);
g_test_add_func ("/option/arg/ignore/short", ignore_test2);
g_test_add_func ("/option/arg/ignore/arg", ignore_test3);
g_test_add_func ("/option/context/add", add_test1);
/* Test parsing empty args */
/* Note there used to be an empty1 here, but it effectively moved
* to option-argv0.c.
*/
g_test_add_func ("/option/context/empty2", empty_test2);
g_test_add_func ("/option/context/empty3", empty_test3);
/* Test handling of rest args */
g_test_add_func ("/option/arg/rest/non-option", rest_test1);
g_test_add_func ("/option/arg/rest/separator1", rest_test2);
g_test_add_func ("/option/arg/rest/separator2", rest_test2a);
g_test_add_func ("/option/arg/rest/separator3", rest_test2b);
g_test_add_func ("/option/arg/rest/separator4", rest_test2c);
g_test_add_func ("/option/arg/rest/separator5", rest_test2d);
g_test_add_func ("/option/arg/remaining/non-option", rest_test3);
g_test_add_func ("/option/arg/remaining/separator", rest_test4);
g_test_add_func ("/option/arg/remaining/array", rest_test5);
/* Test some invalid flag combinations */
g_test_add_func ("/option/arg/reverse-string", flag_reverse_string);
g_test_add_func ("/option/arg/optional-int", flag_optional_int);
/* regression tests for individual bugs */
g_test_add_func ("/option/bug/unknown-short", unknown_short_test);
g_test_add_func ("/option/bug/lonely-dash", lonely_dash_test);
g_test_add_func ("/option/bug/triple-dash", triple_dash_test);
g_test_add_func ("/option/bug/missing-arg", missing_arg_test);
g_test_add_func ("/option/bug/dash-arg", dash_arg_test);
g_test_add_func ("/option/bug/short-remaining", short_remaining);
g_test_add_func ("/option/bug/double-free", double_free);
return g_test_run();
}
Reference in New Issue View Git Blame Copy Permalink