From 063c43c0d8ed359e1a491c935b6cf659398231be Mon Sep 17 00:00:00 2001 From: Matthias Clasen Date: Fri, 18 Jul 2008 06:25:23 +0000 Subject: [PATCH] Move tests around svn path=/trunk/; revision=7197 --- ChangeLog | 6 + glib/tests/option-context.c | 1539 ++++++++++++++++++++++++++++++++++++++++++ tests/Makefile.am | 1 - tests/option-test.c | 1543 ------------------------------------------- 4 files changed, 1545 insertions(+), 1544 deletions(-) delete mode 100644 tests/option-test.c diff --git a/ChangeLog b/ChangeLog index 4cb30fb..a6ff9db 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,9 @@ +2008-07-18 Matthias Clasen + + * tests/Makefile.am: + * tests/option-test.c: Remove + * glib/tests/option-context.c: Add all GOptionContext tests here. + 2008-07-16 Matthias Clasen Bug 334234 – "printf" format error diff --git a/glib/tests/option-context.c b/glib/tests/option-context.c index c3caad6..f78f8cf 100644 --- a/glib/tests/option-context.c +++ b/glib/tests/option-context.c @@ -23,6 +23,9 @@ #include #include +#include +#include +#include static void group_captions (void) @@ -158,6 +161,1481 @@ group_captions (void) } } +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; + +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; +} + +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 */ +char ** +copy_stringv (char **argv, int argc) +{ + return g_memdup (argv, sizeof (char *) * (argc + 1)); +} + + +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; +} + +void +error_test1 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + g_assert (retval == FALSE); + + /* On failure, values should be reset */ + g_assert (error_test1_int == 0x12345678); + + g_strfreev (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; +} + +void +error_test2 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + retval = g_option_context_parse (context, &argc, &argv, &error); + + g_error_free (error); + g_assert (retval == FALSE); + + g_assert (strcmp (error_test2_string, "foo") == 0); + + g_strfreev (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; +} + +void +error_test3 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + retval = g_option_context_parse (context, &argc, &argv, &error); + + g_error_free (error); + g_assert (retval == FALSE); + + g_assert (!error_test3_boolean); + + g_strfreev (argv); + g_option_context_free (context); +} + +static void +assert_no_error (GError *error) +{ + if (error) + { + fprintf (stderr, "unexpected error: %s, %d, %s\n", g_quark_to_string (error->domain), error->code, error->message); + exit (1); + } +} + +void +arg_test1 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + assert_no_error (error); + g_assert (retval); + + /* Last arg specified is the one that should be stored */ + g_assert (arg_test1_int == 30); + + g_strfreev (argv); + g_option_context_free (context); +} + +void +arg_test2 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +arg_test3 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + + +void +arg_test4 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +arg_test5 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + int argc; + char *old_locale, *current_locale; + const char *locale = "de_DE"; + 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); + + /* 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); + 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); + g_option_context_free (context); +} + +void +arg_test6 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + 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; +} + +void +callback_test1 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + assert_no_error (error); + g_assert (retval); + + g_assert (strcmp (callback_test1_string, "foo.txt") == 0); + + g_free (callback_test1_string); + + g_strfreev (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; +} + +void +callback_test2 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + assert_no_error (error); + g_assert (retval); + + g_assert (callback_test2_int == 2); + + g_strfreev (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; +} + +void +callback_test_optional_1 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +callback_test_optional_2 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +callback_test_optional_3 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + + +void +callback_test_optional_4 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + 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", &argc); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +callback_test_optional_5 (void) +{ + GOptionContext *context; + gboolean dummy; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +callback_test_optional_6 (void) +{ + GOptionContext *context; + gboolean dummy; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +callback_test_optional_7 (void) +{ + GOptionContext *context; + gboolean dummy; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +callback_test_optional_8 (void) +{ + GOptionContext *context; + gboolean dummy; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + 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; +} + +void +callback_remaining_test1 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +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); + 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); +} + +void +ignore_test2 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +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); + 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 +array_test1 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +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); +} + +void +empty_test1 (void) +{ + GOptionContext *context; + GOptionEntry entries [] = + { { NULL } }; + char *prgname; + + g_set_prgname (NULL); + context = g_option_context_new (NULL); + + g_option_context_add_main_entries (context, entries, NULL); + + g_option_context_parse (context, NULL, NULL, NULL); + + prgname = g_get_prgname (); + g_assert (prgname && strcmp (prgname, "") == 0); + + g_option_context_free (context); +} + +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); +} + +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 */ +void +rest_test1 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +/* check that -- works */ +void +rest_test2 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +/* check that -- stripping works */ +void +rest_test2a (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +rest_test2b (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +rest_test2c (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +rest_test2d (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + + +/* check that G_OPTION_REMAINING collects non-option arguments */ +void +rest_test3 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + + +/* check that G_OPTION_REMAINING and -- work together */ +void +rest_test4 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +/* test that G_OPTION_REMAINING works with G_OPTION_ARG_FILENAME_ARRAY */ +void +rest_test5 (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + 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); + g_option_context_free (context); +} + +void +unknown_short_test (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + g_assert (!retval); + + g_strfreev (argv); + g_option_context_free (context); +} + +/* test that lone dashes are treated as non-options */ +void lonely_dash_test (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + int argc; + + g_test_bug ("168008"); + + context = g_option_context_new (NULL); + + /* Now try parsing */ + argv = split_string ("program -", &argc); + + retval = g_option_context_parse (context, &argc, &argv, &error); + assert_no_error (error); + g_assert (retval); + + g_assert (argv[1] && strcmp (argv[1], "-") == 0); + + g_strfreev (argv); + g_option_context_free (context); +} + +void +missing_arg_test (void) +{ + GOptionContext *context; + gboolean retval; + GError *error = NULL; + gchar **argv; + 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); + + retval = g_option_context_parse (context, &argc, &argv, &error); + g_assert (retval == FALSE); + g_clear_error (&error); + + g_strfreev (argv); + + /* Try parsing again */ + argv = split_string ("program --t", &argc); + + retval = g_option_context_parse (context, &argc, &argv, &error); + g_assert (retval == FALSE); + + g_strfreev (argv); + g_option_context_free (context); +} + int main (int argc, char *argv[]) @@ -167,5 +1645,66 @@ main (int argc, g_test_bug_base ("http://bugzilla.gnome.org/"); g_test_add_func ("/group/captions", group_captions); + /* Test that restoration on failure works */ + g_test_add_func ("/restoration/int", error_test1); + g_test_add_func ("/restoration/string", error_test2); + g_test_add_func ("/restoration/boolean", error_test3); + + /* Test that special argument parsing works */ + g_test_add_func ("/arg/repetition/int", arg_test1); + g_test_add_func ("/arg/repetition/string", arg_test2); + g_test_add_func ("/arg/repetition/filename", arg_test3); + g_test_add_func ("/arg/repetition/double", arg_test4); + g_test_add_func ("/arg/repetition/locale", arg_test5); + g_test_add_func ("/arg/repetition/int64", arg_test6); + + /* Test string arrays */ + g_test_add_func ("/arg/array/string", array_test1); + + /* Test callback args */ + g_test_add_func ("/arg/callback/string", callback_test1); + g_test_add_func ("/arg/callback/count", callback_test2); + + /* Test optional arg flag for callback */ + g_test_add_func ("/arg/callback/optional1", callback_test_optional_1); + g_test_add_func ("/arg/callback/optional2", callback_test_optional_2); + g_test_add_func ("/arg/callback/optional3", callback_test_optional_3); + g_test_add_func ("/arg/callback/optional4", callback_test_optional_4); + g_test_add_func ("/arg/callback/optional5", callback_test_optional_5); + g_test_add_func ("/arg/callback/optional6", callback_test_optional_6); + g_test_add_func ("/arg/callback/optional7", callback_test_optional_7); + g_test_add_func ("/arg/callback/optional8", callback_test_optional_8); + + /* Test callback with G_OPTION_REMAINING */ + g_test_add_func ("/arg/remaining/callback", callback_remaining_test1); + + /* Test ignoring options */ + g_test_add_func ("/arg/ignore/long", ignore_test1); + g_test_add_func ("/arg/ignore/short", ignore_test2); + g_test_add_func ("/arg/ignore/arg", ignore_test3); + + g_test_add_func ("/context/add", add_test1); + + /* Test parsing empty args */ + g_test_add_func ("/context/empty1", empty_test1); + g_test_add_func ("/context/empty2", empty_test2); + g_test_add_func ("/context/empty3", empty_test3); + + /* Test handling of rest args */ + g_test_add_func ("/arg/rest/non-option", rest_test1); + g_test_add_func ("/arg/rest/separator1", rest_test2); + g_test_add_func ("/arg/rest/separator2", rest_test2a); + g_test_add_func ("/arg/rest/separator3", rest_test2b); + g_test_add_func ("/arg/rest/separator4", rest_test2c); + g_test_add_func ("/arg/rest/separator5", rest_test2d); + g_test_add_func ("/arg/remaining/non-option", rest_test3); + g_test_add_func ("/arg/remaining/separator", rest_test4); + g_test_add_func ("/arg/remaining/array", rest_test5); + + /* regression tests for individual bugs */ + g_test_add_func ("/bug/unknown-short", unknown_short_test); + g_test_add_func ("/bug/lonely-dash", lonely_dash_test); + g_test_add_func ("/bug/missing-arg", missing_arg_test); + return g_test_run(); } diff --git a/tests/Makefile.am b/tests/Makefile.am index 820bec0..5b81250 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -120,7 +120,6 @@ test_programs = \ module-test \ node-test \ onceinit \ - option-test \ patterntest \ printf-test \ queue-test \ diff --git a/tests/option-test.c b/tests/option-test.c deleted file mode 100644 index 4e07ea0..0000000 --- a/tests/option-test.c +++ /dev/null @@ -1,1543 +0,0 @@ -#include -#include -#include -#include -#include - -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; - -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; -} - -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 */ -char ** -copy_stringv (char **argv, int argc) -{ - return g_memdup (argv, sizeof (char *) * (argc + 1)); -} - - -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; -} - -void -error_test1 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - int argc; - GOptionGroup *main_group; - GOptionEntry entries [] = - { { "test", 0, 0, G_OPTION_ARG_INT, &error_test1_int, NULL, NULL }, - { NULL } }; - - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - g_assert (retval == FALSE); - - /* On failure, values should be reset */ - g_assert (error_test1_int == 0x12345678); - - g_strfreev (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; -} - -void -error_test2 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - int argc; - GOptionGroup *main_group; - GOptionEntry entries [] = - { { "test", 0, 0, G_OPTION_ARG_STRING, &error_test2_string, NULL, NULL }, - { NULL } }; - - 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); - retval = g_option_context_parse (context, &argc, &argv, &error); - - g_error_free (error); - g_assert (retval == FALSE); - - g_assert (strcmp (error_test2_string, "foo") == 0); - - g_strfreev (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; -} - -void -error_test3 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - int argc; - GOptionGroup *main_group; - GOptionEntry entries [] = - { { "test", 0, 0, G_OPTION_ARG_NONE, &error_test3_boolean, NULL, NULL }, - { NULL } }; - - 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); - retval = g_option_context_parse (context, &argc, &argv, &error); - - g_error_free (error); - g_assert (retval == FALSE); - - g_assert (!error_test3_boolean); - - g_strfreev (argv); - g_option_context_free (context); -} - -static void -assert_no_error (GError *error) -{ - if (error) - { - fprintf (stderr, "unexpected error: %s, %d, %s\n", g_quark_to_string (error->domain), error->code, error->message); - exit (1); - } -} - -void -arg_test1 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - assert_no_error (error); - g_assert (retval); - - /* Last arg specified is the one that should be stored */ - g_assert (arg_test1_int == 30); - - g_strfreev (argv); - g_option_context_free (context); -} - -void -arg_test2 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -arg_test3 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - - -void -arg_test4 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -arg_test5 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - int argc; - char *old_locale, *current_locale; - const char *locale = "de_DE"; - 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); - - /* 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); - 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); - g_option_context_free (context); -} - -void -arg_test6 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - 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; -} - -void -callback_test1 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - assert_no_error (error); - g_assert (retval); - - g_assert (strcmp (callback_test1_string, "foo.txt") == 0); - - g_free (callback_test1_string); - - g_strfreev (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; -} - -void -callback_test2 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - assert_no_error (error); - g_assert (retval); - - g_assert (callback_test2_int == 2); - - g_strfreev (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; -} - -void -callback_test_optional_1 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -callback_test_optional_2 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -callback_test_optional_3 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - - -void -callback_test_optional_4 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - 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", &argc); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -callback_test_optional_5 (void) -{ - GOptionContext *context; - gboolean dummy; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -callback_test_optional_6 (void) -{ - GOptionContext *context; - gboolean dummy; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -callback_test_optional_7 (void) -{ - GOptionContext *context; - gboolean dummy; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -callback_test_optional_8 (void) -{ - GOptionContext *context; - gboolean dummy; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - 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; -} - -void -callback_remaining_test1 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -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); - 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); -} - -void -ignore_test2 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -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); - 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 -array_test1 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -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); -} - -void -empty_test1 (void) -{ - GOptionContext *context; - GOptionEntry entries [] = - { { NULL } }; - char *prgname; - - g_set_prgname (NULL); - context = g_option_context_new (NULL); - - g_option_context_add_main_entries (context, entries, NULL); - - g_option_context_parse (context, NULL, NULL, NULL); - - prgname = g_get_prgname (); - g_assert (prgname && strcmp (prgname, "") == 0); - - g_option_context_free (context); -} - -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); -} - -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 */ -void -rest_test1 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -/* check that -- works */ -void -rest_test2 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -/* check that -- stripping works */ -void -rest_test2a (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -rest_test2b (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -rest_test2c (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -rest_test2d (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - - -/* check that G_OPTION_REMAINING collects non-option arguments */ -void -rest_test3 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - - -/* check that G_OPTION_REMAINING and -- work together */ -void -rest_test4 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -/* test that G_OPTION_REMAINING works with G_OPTION_ARG_FILENAME_ARRAY */ -void -rest_test5 (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - 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); - - retval = g_option_context_parse (context, &argc, &argv, &error); - 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); - g_option_context_free (context); -} - -void -unknown_short_test (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - int argc; - GOptionEntry entries [] = { { NULL } }; - - context = g_option_context_new (NULL); - g_option_context_add_main_entries (context, entries, NULL); - - /* Now try parsing */ - argv = split_string ("program -0", &argc); - - retval = g_option_context_parse (context, &argc, &argv, &error); - g_assert (!retval); - - g_strfreev (argv); - g_option_context_free (context); -} - -/* test that lone dashes are treated as non-options */ -void lonely_dash_test (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - int argc; - - context = g_option_context_new (NULL); - - /* Now try parsing */ - argv = split_string ("program -", &argc); - - retval = g_option_context_parse (context, &argc, &argv, &error); - assert_no_error (error); - g_assert (retval); - - g_assert (argv[1] && strcmp (argv[1], "-") == 0); - - g_strfreev (argv); - g_option_context_free (context); -} - -void -missing_arg_test (void) -{ - GOptionContext *context; - gboolean retval; - GError *error = NULL; - gchar **argv; - int argc; - 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); - - /* Now try parsing */ - argv = split_string ("program --test", &argc); - - retval = g_option_context_parse (context, &argc, &argv, &error); - g_assert (retval == FALSE); - g_clear_error (&error); - - g_strfreev (argv); - - /* Try parsing again */ - argv = split_string ("program --t", &argc); - - retval = g_option_context_parse (context, &argc, &argv, &error); - g_assert (retval == FALSE); - - g_strfreev (argv); - g_option_context_free (context); -} - -int -main (int argc, char **argv) -{ - /* Test that restoration on failure works */ - error_test1_int = 0x12345678; - error_test1 (); - error_test2_string = "foo"; - error_test2 (); - error_test3_boolean = FALSE; - error_test3 (); - - /* Test that special argument parsing works */ - arg_test1 (); - arg_test2 (); - arg_test3 (); - arg_test4 (); - arg_test5 (); - arg_test6 (); - - /* Test string arrays */ - array_test1 (); - - /* Test callback args */ - callback_test1 (); - callback_test2 (); - - /* Test optional arg flag for callback */ - callback_test_optional_1 (); - callback_test_optional_2 (); - callback_test_optional_3 (); - callback_test_optional_4 (); - callback_test_optional_5 (); - callback_test_optional_6 (); - callback_test_optional_7 (); - callback_test_optional_8 (); - - /* Test callback with G_OPTION_REMAINING */ - callback_remaining_test1 (); - - /* Test ignoring options */ - ignore_test1 (); - ignore_test2 (); - ignore_test3 (); - - add_test1 (); - - /* Test parsing empty args */ - empty_test1 (); - empty_test2 (); - empty_test3 (); - - /* Test handling of rest args */ - rest_test1 (); - rest_test2 (); - rest_test2a (); - rest_test2b (); - rest_test2c (); - rest_test2d (); - rest_test3 (); - rest_test4 (); - rest_test5 (); - - /* test for bug 166609 */ - unknown_short_test (); - - /* test for bug 168008 */ - lonely_dash_test (); - - /* test for bug 305576 */ - missing_arg_test (); - - return 0; -} -- 2.7.4