1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #undef G_DISABLE_ASSERT

    22 #undef G_LOG_DOMAIN

    23 

    24 #include <stdio.h>

    25 #include <string.h>

    26 #include "glib.h"

    27 #include <stdlib.h>

    28 

    29 

    30 #ifdef __SYMBIAN32__

    31 #include "mrt2_glib2_test.h"

    32 #endif /*__SYMBIAN32__*/

    33 

    34 

    35 

    36 gboolean res;

    37 

    38 void g_unichar_digit_value_test()

    39 {

    40 	gunichar str='a';

    41 	gunichar dig='7';

    42 	   int i;

    43     i=g_unichar_digit_value(str);

    44     if(i!=-1)

    45 	{

    46 		g_printf("g_unichar_digit_value failed,str ='a' \n");

    47 		g_assert(FALSE && "g_unichar_digit_value failed str ='a'\n");

    48 	}

    49     

    50     i=g_unichar_digit_value(dig);

    51     if(i!=7 || i==-1)

    52 	{

    53 		g_print("g_unichar_digit_value failed,str ='7' \n");

    54 		g_assert(FALSE && "g_unichar_digit_value failed str ='7'\n");

    55 	}

    56  

    57 }

    58 

    59 void g_unichar_isalnum_test()

    60 {

    61 	gunichar str='8';

    62    	res=g_unichar_isalnum(str);

    63     if(res!=TRUE)

    64 	{

    65 		g_print("g_unichar_isalnum failed,str ='8' \n");

    66 		g_assert(FALSE && "g_unichar_isalnum failed\n");

    67 	}

    68  

    69 }

    70 

    71 void g_unichar_iscntrl_test()

    72 {

    73 	gunichar str ='\n';

    74 	res=g_unichar_iscntrl(str);

    75 	if(res!=TRUE)

    76 	{

    77 		g_print("g_unichar_iscntrl failed,str ='\n' \n");

    78 		g_assert(FALSE && "g_unichar_iscntrl failed\n");

    79 	}

    80 	//g_assert(res==TRUE);

    81 	str='a';

    82 	res=g_unichar_iscntrl(str);

    83 	if(res==TRUE)

    84 	{

    85 		g_print("g_unichar_iscntrl failed , str ='a'\n");

    86 		g_assert(FALSE && "g_unichar_iscntrl failed\n");

    87 	}

    88 	//g_assert(g_unichar_iscntrl(str)==FALSE);

    89 }

    90 

    91 

    92 

    93 void g_unichar_isdigit_test()

    94 {

    95 	gunichar str ='6';

    96 	res=g_unichar_isdigit(str);

    97 	if(res!=TRUE)

    98 	{

    99 		g_print("g_unichar_isdigit failed,str ='\n' \n");

   100 		g_assert(FALSE && "g_unichar_isdigit failed\n");

   101 	}

   102 	//g_assert(res==TRUE);

   103 	str='a';

   104 	res=g_unichar_isdigit(str);

   105 	if(res==TRUE)

   106 	{

   107 		g_print("g_unichar_iscntrl failed , str ='a'\n");

   108 		g_assert(FALSE && "g_unichar_iscntrl failed\n");

   109 	}

   110 	//g_assert(g_unichar_iscntrl(str)==FALSE);

   111 }

   112 

   113 

   114 void g_unichar_islower_test()

   115 {

   116 	gunichar str ='a';

   117 	res=g_unichar_islower(str);

   118 	if(res!=TRUE)

   119 	{

   120 		g_print("g_unichar_islower failed,str ='\n' \n");

   121 		g_assert(FALSE && "g_unichar_islower failed\n");

   122 	}

   123 	//g_assert(res==TRUE);

   124 	str='A';

   125 	res=g_unichar_islower(str);

   126 	if(res==TRUE)

   127 	{

   128 		g_print("g_unichar_islower failed , str ='a'\n");

   129 		g_assert(FALSE && "g_unichar_islower failed\n");

   130 	}

   131 }

   132 

   133 void g_unichar_ispunct_test()

   134 {

   135 	gunichar str ='!';

   136 	res=g_unichar_ispunct(str);

   137 	if(res!=TRUE)

   138 	{

   139 		g_print("g_unichar_ispunct failed,str ='\n' \n");

   140 		g_assert(FALSE && "g_unichar_ispunct failed\n");

   141 	}

   142 	//g_assert(res==TRUE);

   143 	str='A';

   144 	res=g_unichar_ispunct(str);

   145 	if(res==TRUE)

   146 	{

   147 		g_print("g_unichar_ispunct failed , str ='a'\n");

   148 		g_assert(FALSE && "g_unichar_ispunct failed\n");

   149 	}

   150 }

   151 

   152 

   153 void g_unichar_isupper_test()

   154 {

   155 	gunichar str ='A';

   156 	res=g_unichar_isupper(str);

   157 	if(res!=TRUE)

   158 	{

   159 		g_print("g_unichar_isupper failed '\n' \n");

   160 		g_assert(FALSE && "g_unichar_isupper failed\n");

   161 	}

   162 	//g_assert(res==TRUE);

   163 	str='a';

   164 	res=g_unichar_isupper(str);

   165 	if(res==TRUE)

   166 	{

   167 		g_print("g_unichar_isupper failed \n");

   168 		g_assert(FALSE && "g_unichar_isupper failed\n");

   169 	}

   170 }

   171 

   172 void g_unichar_isxdigit_test()

   173 {

   174 	gunichar str ='e';

   175 	res=g_unichar_isxdigit(str);

   176 	if(res!=TRUE)

   177 	{

   178 		g_print("g_unichar_isxdigit failed '\n' \n");

   179 		g_assert(FALSE && "g_unichar_isxdigit failed\n");

   180 	}

   181 	//g_assert(res==TRUE);

   182 	str='k';

   183 	res=g_unichar_isxdigit(str);

   184 	if(res==TRUE)

   185 	{

   186 		g_print("g_unichar_isxdigit failed \n");

   187 		g_assert(FALSE && "g_unichar_isxdigit failed\n");

   188 	}

   189 }

   190 

   191 void g_unichar_xdigit_value_test()

   192 {

   193 	int i;

   194 	gunichar str ='e';

   195     i=g_unichar_xdigit_value(str);

   196 	if(i!=14 || i==-1)

   197 	{

   198 		g_print("g_unichar_xdigit_value failed  \n");

   199 		g_assert(FALSE && "g_unichar_xdigit_value failed\n");

   200 	}

   201 	

   202 	str='4';

   203 	i=g_unichar_xdigit_value(str);

   204 	if(i!=4 || i==-1)

   205 	{

   206 		g_print("g_unichar_xdigit_value failed  \n");

   207 		g_assert(FALSE && "g_unichar_xdigit_value failed\n");

   208 	}

   209 	

   210 	

   211 	//g_assert(res==TRUE);

   212 	str='k';

   213 	i=g_unichar_xdigit_value(str);

   214 	if(i!=-1)

   215 	{

   216 		g_print("g_unichar_xdigit_value failed \n");

   217 		g_assert(FALSE && "g_unichar_xdigit_value failed\n");

   218 	}

   219 }

   220 

   221 

   222 void g_unichar_isgraph_test()

   223 {

   224 	gunichar str ='e';

   225     res=g_unichar_isgraph(str);

   226 	if(res!=TRUE)

   227 	{

   228 		g_print("g_unichar_isgraph failed '\n' \n");

   229 		g_assert(FALSE && "g_unichar_isgraph failed\n");

   230 	}

   231 	//g_assert(res==TRUE);

   232 	str=' ';

   233 	res=g_unichar_isgraph(str);

   234 	if(res==TRUE)

   235 	{

   236 		g_print("g_unichar_isgraph failed \n");

   237 		g_assert(FALSE && "g_unichar_isgraph failed\n");

   238 	}

   239 }

   240 

   241 void g_unichar_isspace_test()

   242 {

   243 	gunichar str ='\t';

   244     res=g_unichar_isspace(str);

   245 	if(res!=TRUE)

   246 	{

   247 		g_print("g_unichar_isspace failed '\n' \n");

   248 		g_assert(FALSE && "g_unichar_isspace failed\n");

   249 	}

   250 	//g_assert(res==TRUE);

   251 	str='5';

   252 	res=g_unichar_isspace(str);

   253 	if(res==TRUE)

   254 	{

   255 		g_print("g_unichar_isspace failed \n");

   256 		g_assert(FALSE && "g_unichar_isspace failed\n");

   257 	}

   258 }

   259 

   260 void g_unichar_isprint_test()

   261 {

   262 	gunichar str1=' ';

   263 	gboolean res1;

   264 	gunichar str2='a';

   265 	res=g_unichar_isprint(str1);

   266 	res1=g_unichar_isprint(str2);

   267 	if(res!=TRUE || res1!=TRUE)

   268 	{

   269 		g_print("g_unichar_isprint failed\n");

   270 		g_assert(FALSE && "g_unichar_isprint failed\n");

   271 	}

   272 	str1='\t';

   273 	res=g_unichar_isprint(str1);

   274 	if (res==TRUE)

   275 	{

   276 	    g_print("g_unichar_isprint failed\n");

   277 		g_assert(FALSE && "g_unichar_isprint failed\n");

   278 		

   279 	}

   280 

   281 }

   282 

   283 

   284 int main (int   argc,

   285       char *argv[])

   286 {

   287 	#ifdef __SYMBIAN32__

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

   289 	#endif /*__SYMBIAN32__*/

   290 	

   291 	g_unichar_digit_value_test();

   292 	g_unichar_isalnum_test();

   293 	g_unichar_iscntrl_test();

   294 	g_unichar_islower_test();

   295 	g_unichar_isupper_test();

   296 	g_unichar_isxdigit_test();	

   297 	g_unichar_xdigit_value_test();

   298 	g_unichar_isgraph_test();

   299 	g_unichar_ispunct_test();

   300 	g_unichar_isspace_test();

   301 	g_unichar_isdigit_test();

   302 	g_unichar_isprint_test();

   303 

   304 

   305 	#ifdef __SYMBIAN32__

   306   	testResultXml("unichar_test");

   307   	#endif /* EMULATOR */

   308 	

   309 	return 0;

   310 }