/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include <glib.h>

#include <locale.h>

#include <string.h>

#include <stdlib.h>

#include <stdio.h>

#ifdef SYMBIAN

#include "mrt2_glib2_test.h"

#endif /*SYMBIAN*/

static GKeyFile *

load_data (const gchar   *data, 

	   GKeyFileFlags  flags)

{

  GKeyFile *keyfile;

  GError *error = NULL;

  keyfile = g_key_file_new ();

  g_key_file_load_from_data (keyfile, data, -1, flags, &error);

  if (error)

    {

      g_print ("Could not load data: %s\n", error->message);

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

  return keyfile;

}

static void

check_error (GError **error,

	     GQuark   domain,

	     gint     code)

{

  if (*error == NULL)

    {

      g_print ("Missing an error\n");

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

  if ((*error)->domain != domain)

    {

      g_print ("Wrong error domain: got %s, expected %s\n",

	       g_quark_to_string ((*error)->domain),

	       g_quark_to_string (domain));      

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */ 	  

      exit (1);

    }

  if ((*error)->code != code)

    {

      g_print ("Wrong error code: got %d, expected %d\n",

	       (*error)->code, code);

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

  g_error_free (*error);

  *error = NULL;

}

static void 

check_no_error (GError **error)

{

  if (*error != NULL)

    {

      g_print ("Unexpected error: (%s, %d) %s\n",

	       g_quark_to_string ((*error)->domain),

	       (*error)->code, (*error)->message);	        

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

}

static void

check_string_value (GKeyFile    *keyfile,

		    const gchar *group,

		    const gchar *key,

		    const gchar *expected) 

{

  GError *error = NULL;

  gchar *value;

  value = g_key_file_get_string (keyfile, group, key, &error);

  check_no_error (&error);

  g_assert (value != NULL);

  if (strcmp (value, expected) != 0)

    {

      g_print ("Group %s key %s: "

	       "expected string value '%s', actual value '%s'\n",

	       group, key, expected, value); 

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

  g_free (value);

}

static void

check_locale_string_value (GKeyFile    *keyfile,

			   const gchar *group,

			   const gchar *key,

			   const gchar *locale,

			   const gchar *expected) 

{

  GError *error = NULL;

  gchar *value;

  value = g_key_file_get_locale_string (keyfile, group, key, locale, &error);

  check_no_error (&error);

  g_assert (value != NULL);

  if (strcmp (value, expected) != 0)

    {

      g_print ("Group %s key %s locale %s: "

	       "expected string value '%s', actual value '%s'\n",

	       group, key, locale, expected, value);  

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

  g_free (value);

}

static void

check_string_list_value (GKeyFile    *keyfile,

			 const gchar *group,

			 const gchar *key,

			 ...)

{

  gint i;

  gchar *v, **value;

  va_list args;

  gsize len;

  GError *error = NULL;

  value = g_key_file_get_string_list (keyfile, group, key, &len, &error);

  check_no_error (&error);

  g_assert (value != NULL);

  va_start (args, key);

  i = 0;

  v = va_arg (args, gchar*);

  while (v)

    {

      if (value[i] == NULL)

	{

	  g_print ("Group %s key %s: list too short (%d)\n", 

		   group, key, i);      

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

	  exit (1);

	}

      if (strcmp (v, value[i]) != 0)

	{

	  g_print ("Group %s key %s: mismatch at %d, expected %s, got %s\n", 

		   group, key, i, v, value[i]);      

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

	  exit (1);

	}

      i++;

      v = va_arg (args, gchar*);

    }

  va_end (args);

  g_strfreev (value);

}

static void

check_integer_list_value (GKeyFile    *keyfile,

			  const gchar *group,

			  const gchar *key,

			  ...)

{

  gint i;

  gint v, *value;

  va_list args;

  gsize len;

  GError *error = NULL;

  value = g_key_file_get_integer_list (keyfile, group, key, &len, &error);

  check_no_error (&error);

  g_assert (value != NULL);

  va_start (args, key);

  i = 0;

  v = va_arg (args, gint);

  while (v != -100)

    {

      if (i == len)

	{

	  g_print ("Group %s key %s: list too short (%d)\n", 

		   group, key, i);      

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

	  exit (1);

	}

      if (value[i] != v)

	{

	  g_print ("Group %s key %s: mismatch at %d, expected %d, got %d\n", 

		   group, key, i, v, value[i]);      

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

	  exit (1);

	}

      i++;

      v = va_arg (args, gint);

    }

  va_end (args);

  g_free (value);

}

static void

check_boolean_list_value (GKeyFile    *keyfile,

			  const gchar *group,

			  const gchar *key,

			  ...)

{

  gint i;

  gboolean v, *value;

  va_list args;

  gsize len;

  GError *error = NULL;

  value = g_key_file_get_boolean_list (keyfile, group, key, &len, &error);

  check_no_error (&error);

  g_assert (value != NULL);

  va_start (args, key);

  i = 0;

  v = va_arg (args, gboolean);

  while (v != -100)

    {

      if (i == len)

	{

	  g_print ("Group %s key %s: list too short (%d)\n", 

		   group, key, i);      

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

	  exit (1);

	}

      if (value[i] != v)

	{

	  g_print ("Group %s key %s: mismatch at %d, expected %d, got %d\n", 

		   group, key, i, v, value[i]);      

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

	  exit (1);

	}

      i++;

      v = va_arg (args, gboolean);

    }

  va_end (args);

  g_free (value);

}

static void

check_boolean_value (GKeyFile    *keyfile,

		     const gchar *group,

		     const gchar *key,

		     gboolean     expected) 

{

  GError *error = NULL;

  gboolean value;

  value = g_key_file_get_boolean (keyfile, group, key, &error);

  check_no_error (&error);

  if (value != expected)

    {

      g_print ("Group %s key %s: "

	       "expected boolean value '%s', actual value '%s'\n",

	       group, key, 

	       expected ? "true" : "false", 

	       value ? "true" : "false");      

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

}

static void

check_integer_value (GKeyFile    *keyfile,

		     const gchar *group,

		     const gchar *key,

		     gint         expected) 

{

  GError *error = NULL;

  gint value;

  value = g_key_file_get_integer (keyfile, group, key, &error);

  check_no_error (&error);

  if (value != expected)

    {

      g_print ("Group %s key %s: "

	       "expected integer value %d, actual value %d\n",

	       group, key, expected, value);      

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

}

static void

check_name (const gchar *what,

	    const gchar *value,

	    const gchar *expected,

	    gint         position)

{

  if (!value || strcmp (expected, value) != 0)

    {

      g_print ("Wrong %s returned: got '%s' at %d, expected '%s'\n",

	       what, value, position, expected);

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

}

static void

check_length (const gchar *what,

	      gint         n_items,

	      gint         length,

	      gint         expected)

{

  if (n_items != length || length != expected)

    {

      g_print ("Wrong number of %s returned: got %d items, length %d, expected %d\n",

	       what, n_items, length, expected);

      g_assert(FALSE && "keyfile-test failed");

      #ifdef SYMBIAN

  	  testResultXml("keyfile-test");

  	  #endif /* EMULATOR */

      exit (1);

    }

}

/* check that both \n and \r\n are accepted as line ends,

 * and that stray \r are passed through

 */

static void

test_line_ends (void)

{

  GKeyFile *keyfile;

  const gchar *data = 

    "[group1]\n"

    "key1=value1\n"

    "key2=value2\r\n"

    "[group2]\r\n"

    "key3=value3\r\r\n"

    "key4=value4\n";

  keyfile = load_data (data, 0);

  check_string_value (keyfile, "group1", "key1", "value1");

  check_string_value (keyfile, "group1", "key2", "value2");

  check_string_value (keyfile, "group2", "key3", "value3\r");

  check_string_value (keyfile, "group2", "key4", "value4");

  g_key_file_free (keyfile);

}

/* check handling of whitespace 

 */

static void

test_whitespace (void)

{

  GKeyFile *keyfile;

  const gchar *data = 

    "[group1]\n"

    "key1 = value1\n"

    "key2\t=\tvalue2\n"

    " [ group2 ] \n"

    "key3  =  value3  \n"

    "key4  =  value \t4\n"

    "  key5  =  value5\n";

  keyfile = load_data (data, 0);

  check_string_value (keyfile, "group1", "key1", "value1");

  check_string_value (keyfile, "group1", "key2", "value2");

  check_string_value (keyfile, " group2 ", "key3", "value3  ");

  check_string_value (keyfile, " group2 ", "key4", "value \t4");

  check_string_value (keyfile, " group2 ", "key5", "value5");

  g_key_file_free (keyfile);

}

/* check handling of comments

 */

static void

test_comments (void)

{

  GKeyFile *keyfile;

  gchar **names;

  gsize len;

  GError *error = NULL;

  gchar *comment;

  const gchar *data = 

    "# top comment\n"

    "# top comment, continued\n"

    "[group1]\n"

    "key1 = value1\n"