/* Unit tests for GOptionContext

 * Copyright (C) 2007 Openismus GmbH

 * Authors: Mathias Hasselmann

 * Portions copyright (c) 2009 Nokia Corporation.  All rights reserved.

 * 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>

#ifdef __SYMBIAN32__

#include <glib_global.h>

#include "mrt2_glib2_test.h"

#endif /*__SYMBIAN32__*/

static void

group_captions (void)

{

  gchar *help_variants[] = { "--help", "--help-all", "--help-test" };

  GOptionEntry main_entries[] = {

    { "main-switch", 0,

      G_OPTION_FLAG_NO_ARG,

      G_OPTION_ARG_NONE, NULL,

      "A switch that is in the main group", NULL },

    { NULL }

  };

  GOptionEntry group_entries[] = {

    { "test-switch", 0,

      G_OPTION_FLAG_NO_ARG,

      G_OPTION_ARG_NONE, NULL,

      "A switch that is in the test group", NULL },

    { NULL }

  };

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

      GOptionContext *options;

      GOptionGroup   *group = NULL;

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

        }

      for (j = 0; j < G_N_ELEMENTS (help_variants); ++j)

        {

          GTestTrapFlags trap_flags = 0;

          gchar *args[3];

          args[0] = __FILE__;

          args[1] = help_variants[j];

          args[2] = NULL;

          if (!g_test_verbose ())

            trap_flags |= G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR;

          g_test_message ("test setup: args='%s', main-entries=%d, test-entries=%d",

                          args[1], have_main_entries, have_test_entries);

          if (g_test_trap_fork (0, trap_flags))

            {

              gchar **argv = args;

              gint    argc = 2;

              GError *error = NULL;

              g_setenv ("LANG", "C", TRUE);

              g_option_context_parse (options, &argc, &argv, &error);

              exit(0);

            }

          else

            {

              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;

              g_test_trap_assert_passed ();

              g_test_trap_assert_stderr ("");

              switch (j)

                {

                  case 0:

                    g_assert_cmpstr ("--help", ==, args[1]);

                    expect_main_switch = have_main_entries;

                    expect_test_group  = have_test_entries;

                    break;

                  case 1:

                    g_assert_cmpstr ("--help-all", ==, args[1]);

                    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", ==, args[1]);

                    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;

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;