diff -r 000000000000 -r e4d67989cc36 glib/tsrc/BC/src/misc_test.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/glib/tsrc/BC/src/misc_test.c Tue Feb 02 02:01:42 2010 +0200 @@ -0,0 +1,321 @@ +/* +* 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 +#include +#include "glib.h" +#include + + +#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_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_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; +} \ No newline at end of file