/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 *

 * Description:

 *

 */

 #undef G_DISABLE_ASSERT

 #undef G_LOG_DOMAIN

 #include <stdio.h>

 #include <string.h>

 #include "glib.h"

 #include <stdlib.h>

 #include <glib/gprintf.h>

 #ifdef SYMBIAN

 #include "mrt2_glib2_test.h"

 #endif /*SYMBIAN*/

 void array_test()

 {

 	GArray *garray;

 	gint i;

 	int a = 1;

 	int b[3] = 

 	{

 		4,5,6

 	};

 	garray = g_array_new (FALSE,FALSE,sizeof(gint));

 	g_array_append_val(garray,a);

 	g_array_append_val(garray,a);

 	g_array_append_val(garray,a);

 	g_array_insert_vals(garray,0,b,3);

     g_assert (g_array_index (garray, gint, 0) == 4);

     g_assert (g_array_index (garray, gint, 1) == 5);

     g_assert (g_array_index (garray, gint, 2) == 6);

 	g_array_free(garray,TRUE);

 }

 void g_ascii_strdown_test()

 {

 	gchar str[] = "ABCd";

 	gchar *str1;

 	str1 = g_ascii_strdown(str,4);

 	g_assert(str1[0] == 'a');

 	g_assert(str1[1] == 'b');

 	g_assert(str1[2] == 'c');

 	g_assert(str1[3] == 'd');	

 }

 void g_ascii_strup_test()

 {

 	gchar str[] = "ABCd";

 	gchar *str1;

 	str1 = g_ascii_strup(str,4);

 	g_assert(str1[0] == 'A');

 	g_assert(str1[1] == 'B');

 	g_assert(str1[2] == 'C');

 	g_assert(str1[3] == 'D');	

 }

 void g_fprintf_test()

 {

 	FILE *fp;

 	char *teststring = "testing";

 	int retVal;

 	fp = fopen("c:\\test.txt","w");

 	if(fp)

 	{

 		g_assert(g_fprintf(fp,"%s",teststring) == strlen(teststring));

 		fclose(fp);

 	}

 }

 void g_application_name_test()

 {

 	gchar *app_name = "Test App";

 	g_set_application_name(app_name);

 	g_assert(!strcmp(g_get_application_name(),app_name));

 }

 void g_listenv_test()

 {

 	gchar **e = NULL;

 	int i;

 	e = g_listenv();

 	g_assert(e!=NULL);

 	g_strfreev(e);

 }

 void g_direct_equal_test()

 {

 	int *i,a=1,*j;

 	i = &a;

 	j=i;

 	g_assert(g_direct_equal(i,j));

 	j++;

 	g_assert(!g_direct_equal(i,j));

 }

 void g_direct_hash_test()

 {

 	int *i,a=1,j;

 	int hash_value;

 	i = &a;	

 	j = (gint)i;

 	g_assert(g_direct_hash(i) == j);

 }

 void g_bit_nth_lsf_test()

 {

 	gulong mask = 15;

 	// 15 is 00000000 ........ 1111. Therefore the position of first 1 should be 0

 	g_assert(g_bit_nth_lsf(mask,-1) == 0);

 }

 void g_bit_nth_msf_test()

 {

 	gulong mask = 15;

 	// 15 is 00000000 ........ 1111. Therefore the position of last 1 should be 3

 	g_assert(g_bit_nth_msf(mask,-1) == 3);

 }

 void g_basename_test()

 {

 	const gchar *filename;

 	filename = g_basename("c:\\test\\test.txt");

 	g_assert(!strcmp(filename,"test.txt"));

 }

 void function()

 {

 	return;

 }

 void g_atexit_test()

 {

 	g_atexit(function);

 }

 void g_bit_storage_test()

 {

 	g_assert(g_bit_storage(8) == 4);

 }

 void g_filename_display_basename_test()

 {

 	g_assert(!strcmp(g_filename_display_basename("c:/test/test.txt"),"test.txt"));

 }

 void g_find_program_in_path_test()

 {

 	char *program_name = g_find_program_in_path("misc_test.exe");

 }

 void g_atomic_test()

 {

 	int i = 5;

 	int j;

 	char *p,*q;

 	j = g_atomic_int_get(&i);

 	g_assert(j == i);

 	p = g_malloc(1);

 	q = g_atomic_pointer_get(&p);

 	g_assert(p == q);

 	g_free(p);

 }

 void g_error_test()

 {

 	GError err,*err_copy = NULL;

 	err.domain = 1;

 	err.code = 5;

 	err.message = "test";

 	err_copy = g_error_copy(&err);

 	g_assert(err_copy->code == 5 && err_copy->code == 5 && !strcmp(err_copy->message,"test"));

 	g_error_free(err_copy);

 	err_copy = NULL;

 	err_copy = g_error_new_literal(err.domain,err.code,"test is %s");

 	g_assert(err_copy->code == 5 && err_copy->code == 5 && !strcmp(err_copy->message,"test is %s"));

 	g_error_free(err_copy);

 	err_copy = NULL;

 }

 static guint

 my_hash (gconstpointer key)

 {

   return (guint) *((const gint*) key);

 }

 static gboolean

 my_hash_equal (gconstpointer a,

 	       gconstpointer b)

 {

   return *((const gint*) a) == *((const gint*) b);

 }

 static gboolean find_first     (gpointer key, 

 				gpointer value, 

 				gpointer user_data)

 {

   gint *v = value; 

   gint *test = user_data;

   return (*v == *test);

 }

 gboolean func(gpointer key,gpointer value,gpointer user_data)

 {

 	gint *key1 = (int *)key;

 	gint *value1 = (int *)value;

 	gint *user_data1 = (int *)user_data;

 	if(*key1 == *user_data1 && *value1 == *user_data1)

 		return TRUE;

 	else

 		return FALSE;

 }

 void hash_test()

 {

 	GHashTable *hash_table;

 	gint i;

 	gint value = 4;

 	gint *pvalue; 

 	int array[10];

 	int count = 0;

 	hash_table = g_hash_table_new (my_hash, my_hash_equal);

 	for (i = 0; i < 10; i++)

 	{

 	  array[i] = i;

 	  g_hash_table_insert (hash_table, &array[i], &array[i]);

 	}

 	g_assert(g_hash_table_steal(hash_table,&value));

 	pvalue = g_hash_table_find (hash_table, find_first, &value);

 	//checks if g_hash_table_steal worked or not

 	g_assert(pvalue == NULL);

 	value = 5;

 	pvalue = g_hash_table_find (hash_table, find_first, &value);

 	count = g_hash_table_foreach_steal(hash_table,func,&value);

 	pvalue = g_hash_table_find (hash_table, find_first, &value);

 	g_assert(count == 1 && pvalue == NULL);

 }

 void check_version_test()

 {

     const char *x = glib_check_version(2,8,3);

 	g_assert(x == NULL);

 }

 int main (int   argc,

       char *argv[])

 {

 	#ifdef SYMBIAN

 	g_log_set_handler (NULL,  G_LOG_FLAG_FATAL| G_LOG_FLAG_RECURSION | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING | G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_INFO | G_LOG_LEVEL_DEBUG, &mrtLogHandler, NULL);

 	#endif /*SYMBIAN*/

 	array_test();

 	g_ascii_strup_test();

 	g_ascii_strdown_test();

 	g_fprintf_test();

 	g_application_name_test();

 	g_listenv_test();

 	g_direct_equal_test();

 	g_direct_hash_test();

 	g_bit_nth_lsf_test();

 	g_bit_nth_msf_test();

 	g_basename_test();

 	g_atexit_test();

 	g_bit_storage_test();

 	g_filename_display_basename_test();

 	g_find_program_in_path_test();

 	g_atomic_test();

 	g_error_test();

 	hash_test();

 	check_version_test();

 	#ifdef SYMBIAN

   	testResultXml("misc_test");

   	#endif /* EMULATOR */

 	return 0;

 }