/* 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);