/*
* Copyright (c) 2006 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:  ?Description
*
*/


#undef G_DISABLE_ASSERT
#undef G_LOG_DOMAIN


#include <stdio.h>
#include <string.h>
#include <glib.h>
#include <fcntl.h>
#include <goption.h>

#ifdef SYMBIAN
#include "mrt2_glib2_test.h"
#endif /*SYMBIAN*/

#define	C2P(c)		((gpointer) ((long) (c)))
#define GINT_TO_POINTER(i)	((gpointer)  (i))
#define GPOINTER_TO_INT(p)	((gint)   (p))
#define TESTPASS	1
#define TESTFAIL	0


//Test for g_strcanon
void tg_strcanon()
{
	gchar string1[]="aabbccdd";
	gchar string2[]="aabbccdd";
	gchar* valid;
	gchar* teststring1;
	gchar* teststring2;
  
 	//Testing for a valid char available in the string
 	//The invalid chars must be replaced
 	valid="cc";
 	teststring1=g_strcanon (string1, valid, 'x');
 	g_assert(!strcmp(teststring1,"xxxxccxx"));

	//Testing for a valid char not-available in the string
	//All the chars must be replaced
	valid="nn";
	teststring2=g_strcanon(string2,valid,'x');
	g_assert(!strcmp(teststring2,"xxxxxxxx"));
}

//Test for g_strcasecmp
void tg_strcasecmp()
{
 	gint strcasecmp_eq,strcasecmp_gr8,strcasecmp_less;
 	//Testing for equal strings,zero must be returned
 	strcasecmp_eq=g_strcasecmp ("abcd123","abcd123");
 	g_assert(strcasecmp_eq==0);

 	//Testing for un-equal strings,left greater,positive value must be returned
 	strcasecmp_gr8=g_strcasecmp ("abcd123","abcd");
 	g_assert(strcasecmp_gr8>0);
 	
 	//Testing for un-equal strings,right greater,negative value must be returned
 	strcasecmp_less=g_strcasecmp ("abcd","abcd123");
 	g_assert(strcasecmp_less<0);
 	
 }
 
 //Test for g_strdown
 void tg_strdown()
 {
 	gchar input[]="ABCDef";
 	gchar* upperToLower=g_strdown(input);
 	g_assert(!strcmp(upperToLower,"abcdef"));	
 }
 
 //Test for g_string_append_c
 void tg_string_append_c()
 {
	GString* obj=(GString*)malloc(sizeof(GString));
	gchar ip[]="abcd";
  	obj->str=ip;
 	obj->len=strlen(ip);
 	obj->allocated_len=10;
 	obj=g_string_append_c(obj,'e');
 	g_assert(!strcmp((obj->str),"abcde"));
 }
 
 //Test for g_string_ascii_down
 void tg_string_ascii_down()
 {
 	GString* obj=(GString*)malloc(sizeof(GString));
 	gchar ip[]="ABc12DeF";
 	obj->str=ip;
 	obj->len=strlen(ip);
 	obj->allocated_len=10;
 	obj=g_string_ascii_down(obj);
 	g_assert(!strcmp((obj->str),"abc12def"));
 }
 
 //Test for g_string_ascii_up
 void tg_string_ascii_up()
 {
 	GString* obj=(GString*)malloc(sizeof(GString));
 	gchar ip[]="ABc12DeF";
 	obj->str=ip;
 	obj->len=strlen(ip);
 	obj->allocated_len=10;
 	obj=g_string_ascii_up(obj);
 	g_assert(!strcmp((obj->str),"ABC12DEF"));
 }
 
 //Test for g_string_down
 void tg_string_down()
 {
 	GString* obj=(GString*)malloc(sizeof(GString));
 	gchar ip[]="ABc12DeF";
 	obj->str=ip;
 	obj->len=strlen(ip);
 	obj->allocated_len=10;
 	obj=g_string_down(obj);
 	g_assert(!strcmp((obj->str),"abc12def"));
 }

 //Test for g_string_hash
 void tg_string_hash()
 {
 	GString* obj=(GString*)malloc(sizeof(GString));
 	guint g_string_hash_result1,g_string_hash_result2;
 	guint g_string_hash_result3,g_string_hash_result4;
 	gchar ip1[]="ABC12";
 	gchar ip2[]="abc12";
 	obj->allocated_len=10;
 	
 	obj->str=ip1;
 	obj->len=strlen(ip1);
 	g_string_hash_result1=g_string_hash(obj);
 	g_string_hash_result2=g_string_hash(obj);
 	g_assert(g_string_hash_result1==g_string_hash_result2);
 	
 	obj->str=ip2;
 	obj->len=strlen(ip2);
 	g_string_hash_result3=g_string_hash(obj);
 	g_string_hash_result4=g_string_hash(obj);
 	g_assert(g_string_hash_result3==g_string_hash_result4);
 	
 	g_assert(g_string_hash_result1 != g_string_hash_result3);
 	
 }
 
 
 //Test for g_string_prepend_c
  void tg_string_prepend_c()
 {
	GString* obj=(GString*)malloc(sizeof(GString));
	gchar ip[]="abcd";
  	obj->str=ip;
 	obj->len=strlen(ip);
 	obj->allocated_len=10;
 	obj=g_string_prepend_c(obj,'e');
 	g_assert(!strcmp((obj->str),"eabcd"));
 }
 
 
 //Test for g_string_up
 void tg_string_up()
 {
 	GString* obj=(GString*)malloc(sizeof(GString));
 	gchar ip[]="ABc12DeF";
 	obj->str=ip;
 	obj->len=strlen(ip);
 	obj->allocated_len=10;
 	obj=g_string_up(obj);
 	g_assert(!strcmp((obj->str),"ABC12DEF"));
 }
 
 
 //Test for g_string_prepend_unichar
 void tg_string_prepend_unichar()
 {
	GString* obj=(GString*)malloc(sizeof(GString));
	gchar ip[]="abcd";
  	obj->str=ip;
 	obj->len=strlen(ip);
 	obj->allocated_len=10;
 	obj=g_string_prepend_unichar(obj,'e');
 	g_assert(!strcmp((obj->str),"eabcd"));
 }
 
 //Test for g_strip_context
 void tg_strip_context()
 {
 	gchar msgid[]="abc|defgh";
 	gchar msgval[]="abc|defgh";
 	const gchar* op;
 	op=g_strip_context(msgid,msgid);
 	g_assert(!strcmp(op,"defgh"));	
 }
 
 //Test for g_strjoin
 void tg_strjoin()
 {
 	gchar sep[]="#&#";
	gchar a[]="abc";
	gchar b[]="def";
 	gchar* op=g_strjoin(sep,a,b,NULL);
 	g_assert(!strcmp(op,"abc#&#def"));
 }
 
 
 //Test for g_strncasecmp
void tg_strncasecmp()
{
 	gint strncasecmp_eq,strncasecmp_gr8,strncasecmp_less;
 	//Testing for equal strings,zero must be returned
 	strncasecmp_eq=g_strncasecmp ("abcd123","abcd123",10);
 	g_assert(strncasecmp_eq==0);

 	//Testing for un-equal strings,left greater,positive value must be returned
 	strncasecmp_gr8=g_strncasecmp ("abcd123","abcd",4);
 	g_assert(strncasecmp_gr8==0);
 	
 	//Testing for un-equal strings,right greater,negative value must be returned
 	strncasecmp_less=g_strncasecmp ("abcd","abcd123",6);
 	g_assert(strncasecmp_less<0);
 	
 }
 
 
 //Test for g_strnfill
 void tg_strnfill()
 {
 	gchar fill='x';
	gsize size=10;
	gchar* strnfill_buf_null;
	gchar* strnfill_buf=g_strnfill(size,fill);
 	g_assert(!strcmp(strnfill_buf,"xxxxxxxxxx"));
 
 	size=0;
	strnfill_buf_null=g_strnfill(size,fill);
 	g_assert(!strcmp(strnfill_buf_null,""));
 
 }
 
 //Test for g_strreverse
 void tg_strreverse()
 {
 	gchar ip[]="abCdeF123";
	gchar* strreverse_op=g_strreverse(ip);
 	g_assert(!strcmp(strreverse_op,"321FedCba"));
 
 }
 
 
 //Test for g_strup
 void tg_strup()
 {
 	gchar ip[]="Abc12deF";
 	gchar* strup=g_strup(ip);
 	g_assert(!strcmp(strup,"ABC12DEF"));
 }
 
 
 //Test for g_pattern_match_string
 void tg_pattern_match_string()
 {
 	gchar pattern_str[]="abcdefghijklmnopqrstuvwxyz";
 	gchar match_str_pos[]="abcdefghijklmnopqrstuvwxyz"; //Proper a-z
 	gchar match_str_neg[]="abcdefghjiklmnopqrstuvwxyz";	//i and j interchanged
 	
 	GPatternSpec* spec=g_pattern_spec_new(pattern_str);
 	g_assert(g_pattern_match_string(spec,match_str_pos));
 	g_assert(!g_pattern_match_string(spec,match_str_neg));
 	
 }

 //Called by g_printf_string_upper_bound for a va-list
 void test_arg_string_upper_bound(gchar* fmt,...)
 {
 	va_list ap;
	va_start(ap,fmt);
	g_assert(g_printf_string_upper_bound(fmt,ap)==27);
	va_end(ap);
 }
 //Test for g_printf_string_upper_bound
 void tg_printf_string_upper_bound()
 {
 	test_arg_string_upper_bound("%d\n%s\t%f",9999999,"Abcd#%@",999.999999);
 }


 //Test for g_sprintf
 void tg_sprintf()
 {
 	gchar sprintf_converted[100];
 	gint sprintf_return_val=g_sprintf(sprintf_converted,"%d%s%f",9999999,"Abcd#%@",999.999999);
 	g_assert(sprintf_return_val==24);
 }



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*/
 	
 	tg_strcanon();
	tg_strcasecmp();
	tg_strdown();
	tg_string_append_c();
	tg_string_ascii_down();
	tg_string_ascii_up();
	tg_string_down();
	tg_string_hash();
	tg_string_prepend_c();
	tg_string_prepend_unichar();
	tg_string_up();
	tg_strip_context();
	tg_strjoin();
	tg_strncasecmp();
	tg_strnfill();
	tg_strreverse();
	tg_strup();
	tg_pattern_match_string();
	tg_printf_string_upper_bound();
	tg_sprintf();
	
	#ifdef SYMBIAN
  testResultXml("tgstring");
#endif /* EMULATOR */
 	return 0;
}