/* Portion Copyright © 2008-09 Nokia Corporation and/or its subsidiary(-ies). All rights reserved. */

#include <glib.h>

#include <string.h>

#ifdef SYMBIAN

#include <glib_global.h>

#include "mrt2_glib2_test.h"

#endif /*SYMBIAN*/

int error_test1_int;

char *error_test2_string;

gboolean error_test3_boolean;

int arg_test1_int;

gchar *arg_test2_string;

gchar *arg_test3_filename;

gchar *callback_test1_string;

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

#ifndef SYMBIAN

  GOptionEntry entries [] =

    { { "test", 0, 0, G_OPTION_ARG_INT, &error_test1_int, NULL, NULL },

      { NULL } };

#else    

  GOptionEntry entries [2];

  entries[0].long_name = "test";

  entries[0].short_name = 0;

  entries[0].flags = 0;

  entries[0].arg = G_OPTION_ARG_INT;

  entries[0].arg_data = (gpointer)&error_test1_int;

  entries[0].description =  NULL;

  entries[0].arg_description = NULL;

  entries[1].long_name = NULL;

  entries[1].short_name = 0;

  entries[1].arg_data = NULL;

  entries[1].description =  NULL;

  entries[1].arg_description = NULL;

#endif

  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;

#ifndef SYMBIAN

  GOptionEntry entries [] =

    { { "test", 0, 0, G_OPTION_ARG_STRING, &error_test2_string, NULL, NULL },

      { NULL } };

#else      

  GOptionEntry entries [2];

  entries[0].long_name = "test";

  entries[0].short_name = 0;

  entries[0].flags = 0;

  entries[0].arg = G_OPTION_ARG_STRING;

  entries[0].arg_data = (gpointer)&error_test2_string;

  entries[0].description =  NULL;

  entries[0].arg_description = NULL;

  entries[1].long_name = NULL;

  entries[1].short_name = 0;

  entries[1].arg_data = NULL;

  entries[1].description =  NULL;

  entries[1].arg_description = NULL;

#endif  

  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;

#ifndef SYMBIAN 

  GOptionEntry entries [] =

    { { "test", 0, 0, G_OPTION_ARG_NONE, &error_test3_boolean, NULL, NULL },

      { NULL } };

#else      

  GOptionEntry entries [2];

  entries[0].long_name = "test";

  entries[0].short_name = 0;

  entries[0].flags = 0;

  entries[0].arg = G_OPTION_ARG_NONE;

  entries[0].arg_data = (gpointer)&error_test3_boolean;

  entries[0].description =  NULL;

  entries[0].arg_description = NULL;

  entries[1].long_name = NULL;

  entries[1].short_name = 0;

  entries[1].arg_data = NULL;

  entries[1].description =  NULL;

  entries[1].arg_description = NULL;

#endif

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

}

void

arg_test1 (void)

{

  GOptionContext *context;

  gboolean retval;

  GError *error = NULL;

  gchar **argv;

  int argc;

#ifndef SYMBIAN 

  GOptionEntry entries [] =

    { { "test", 0, 0, G_OPTION_ARG_INT, &arg_test1_int, NULL, NULL },

      { NULL } };

#else      

  GOptionEntry entries [2];

  entries[0].long_name = "test";

  entries[0].short_name = 0;

  entries[0].flags = 0;

  entries[0].arg = G_OPTION_ARG_INT;

  entries[0].arg_data = (gpointer)&arg_test1_int;

  entries[0].description =  NULL;

  entries[0].arg_description = NULL;

  entries[1].long_name = NULL;

  entries[1].short_name = 0;

  entries[1].arg_data = NULL;

  entries[1].description =  NULL;

  entries[1].arg_description = NULL;

#endif      

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

  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;

#ifndef SYMBIAN  

  GOptionEntry entries [] =

    { { "test", 0, 0, G_OPTION_ARG_STRING, &arg_test2_string, NULL, NULL },

      { NULL } };

#else      

  GOptionEntry entries [2];

  entries[0].long_name = "test";

  entries[0].short_name = 0;

  entries[0].flags = 0;

  entries[0].arg = G_OPTION_ARG_STRING;

  entries[0].arg_data = (gpointer)&arg_test2_string;

  entries[0].description =  NULL;

  entries[0].arg_description = NULL;

  entries[1].long_name = NULL;

  entries[1].short_name = 0;

  entries[1].arg_data = NULL;

  entries[1].description =  NULL;

  entries[1].arg_description = NULL;

#endif      

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

  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;

#ifndef SYMBIAN  

  GOptionEntry entries [] =

    { { "test", 0, 0, G_OPTION_ARG_FILENAME, &arg_test3_filename, NULL, NULL },

      { NULL } };

#else      

  GOptionEntry entries [2];

  entries[0].long_name = "test";

  entries[0].short_name = 0;

  entries[0].flags = 0;

  entries[0].arg = G_OPTION_ARG_FILENAME;

  entries[0].arg_data = (gpointer)&arg_test3_filename;

  entries[0].description =  NULL;

  entries[0].arg_description = NULL;

  entries[1].long_name = NULL;

  entries[1].short_name = 0;

  entries[1].arg_data = NULL;

  entries[1].description =  NULL;

  entries[1].arg_description = NULL;

#endif      

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

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

}

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;

#ifndef SYMBIAN  

  GOptionEntry entries [] =

    { { "test", 0, 0, G_OPTION_ARG_CALLBACK, callback_parse1, NULL, NULL },

      { NULL } };

#else 

  GOptionEntry entries [2];

  entries[0].long_name = "test";

  entries[0].short_name = 0;

  entries[0].flags = 0;

  entries[0].arg = G_OPTION_ARG_CALLBACK;

  entries[0].arg_data = (gpointer)callback_parse1;

  entries[0].description =  NULL;

  entries[0].arg_description = NULL;

  entries[1].long_name = NULL;

  entries[1].short_name = 0;

  entries[1].arg_data = NULL;

  entries[1].description =  NULL;

  entries[1].arg_description = NULL;

#endif

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

  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;

#ifndef SYMBIAN 

  GOptionEntry entries [] =

    { { "test", 0, G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, callback_parse2, NULL, NULL },

      { NULL } };

#else      

  GOptionEntry entries [2];