diff -r acd3cd4aaceb -r 2efc27d87e1c glib/tsrc/glib_nonstif/src/tthread.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/glib/tsrc/glib_nonstif/src/tthread.c Wed Sep 01 12:36:54 2010 +0100 @@ -0,0 +1,237 @@ +/* +* Copyright (c) 2009 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: +* +*/ +#undef G_DISABLE_ASSERT +#undef G_LOG_DOMAIN + +#include +#include + +#ifdef __SYMBIAN32__ +#include +#include "mrt2_glib2_test.h" +#endif /*__SYMBIAN32__*/ + +#define THREADS 10 + +/* GStaticRecMutex */ + +GStaticRecMutex test_g_static_rec_mutex_mutex; +static guint test_g_static_rec_mutex_int = 0; +static gboolean test_g_static_rec_mutex_thread_ready; + +static gpointer +test_g_static_rec_mutex_thread (gpointer data) +{ + g_assert (GPOINTER_TO_INT (data) == 42); + g_assert (g_static_rec_mutex_trylock (&test_g_static_rec_mutex_mutex) + == FALSE); + test_g_static_rec_mutex_thread_ready = TRUE; + + //Testing g_static_rec_mutex_lock_full + g_static_rec_mutex_lock_full (&test_g_static_rec_mutex_mutex, 10); + + g_assert (test_g_static_rec_mutex_int == 42); + test_g_static_rec_mutex_thread_ready = FALSE; + + //Testing g_static_rec_mutex_unlock_full for lock_full + g_static_rec_mutex_unlock_full (&test_g_static_rec_mutex_mutex); + + g_thread_exit (GINT_TO_POINTER (43)); + + g_assert_not_reached (); + return NULL; +} + +static void +test_g_static_rec_mutex (void) +{ + GThread *thread; + + //Test for g_static_rec_mutex_init + g_static_rec_mutex_init(&test_g_static_rec_mutex_mutex); + + g_assert (g_static_rec_mutex_trylock (&test_g_static_rec_mutex_mutex)); + test_g_static_rec_mutex_thread_ready = FALSE; + thread = g_thread_create (test_g_static_rec_mutex_thread, + GINT_TO_POINTER (42), TRUE, NULL); + /* This busy wait is only for testing purposes and not an example of + * good code!*/ + while (!test_g_static_rec_mutex_thread_ready) + g_usleep (G_USEC_PER_SEC / 5); + + g_assert (g_static_rec_mutex_trylock (&test_g_static_rec_mutex_mutex)); + test_g_static_rec_mutex_int = 41; + g_static_rec_mutex_unlock (&test_g_static_rec_mutex_mutex); + test_g_static_rec_mutex_int = 42; + g_static_rec_mutex_unlock (&test_g_static_rec_mutex_mutex); + + /* This busy wait is only for testing purposes and not an example of + * good code!*/ + while (test_g_static_rec_mutex_thread_ready) + g_usleep (G_USEC_PER_SEC / 5); + + g_static_rec_mutex_lock (&test_g_static_rec_mutex_mutex); + test_g_static_rec_mutex_int = 0; + + //Testing g_static_rec_mutex_unlock_full with normal single lock + g_static_rec_mutex_unlock_full (&test_g_static_rec_mutex_mutex); + + g_assert (GPOINTER_TO_INT (g_thread_join (thread)) == 43); + g_static_rec_mutex_free (&test_g_static_rec_mutex_mutex); +} + + +/* GStaticRWLock */ + +/* -1 = writing; >0 = # of readers */ +static gint test_g_static_rw_lock_state = 0; +G_LOCK_DEFINE (test_g_static_rw_lock_state); + +static gboolean test_g_static_rw_lock_run = TRUE; +GStaticRWLock test_g_static_rw_lock_lock;// = G_STATIC_RW_LOCK_INIT; + +static gpointer +test_g_static_rw_lock_thread (gpointer data) +{ + while (test_g_static_rw_lock_run) + { + if (g_random_double() > .2) /* I'm a reader */ + { + + if (g_random_double() > .2) /* I'll block */ + g_static_rw_lock_reader_lock (&test_g_static_rw_lock_lock); + else /* I'll only try */ + if (!g_static_rw_lock_reader_trylock (&test_g_static_rw_lock_lock)) + continue; + G_LOCK (test_g_static_rw_lock_state); + g_assert (test_g_static_rw_lock_state >= 0); + test_g_static_rw_lock_state++; + G_UNLOCK (test_g_static_rw_lock_state); + + g_usleep (g_random_int_range (20,1000)); + + G_LOCK (test_g_static_rw_lock_state); + test_g_static_rw_lock_state--; + G_UNLOCK (test_g_static_rw_lock_state); + + g_static_rw_lock_reader_unlock (&test_g_static_rw_lock_lock); + } + else /* I'm a writer */ + { + + if (g_random_double() > .2) /* I'll block */ + g_static_rw_lock_writer_lock (&test_g_static_rw_lock_lock); + else /* I'll only try */ + if (!g_static_rw_lock_writer_trylock (&test_g_static_rw_lock_lock)) + continue; + G_LOCK (test_g_static_rw_lock_state); + g_assert (test_g_static_rw_lock_state == 0); + test_g_static_rw_lock_state = -1; + G_UNLOCK (test_g_static_rw_lock_state); + + g_usleep (g_random_int_range (20,1000)); + + G_LOCK (test_g_static_rw_lock_state); + test_g_static_rw_lock_state = 0; + G_UNLOCK (test_g_static_rw_lock_state); + + g_static_rw_lock_writer_unlock (&test_g_static_rw_lock_lock); + } + } + return NULL; +} + +static void +test_g_static_rw_lock () +{ + GThread *threads[THREADS]; + guint i; + + g_static_rw_lock_init(&test_g_static_rw_lock_lock); + + for (i = 0; i < THREADS; i++) + { + threads[i] = g_thread_create (test_g_static_rw_lock_thread, + NULL, TRUE, NULL); + } + g_usleep (G_USEC_PER_SEC * 5); + test_g_static_rw_lock_run = FALSE; + for (i = 0; i < THREADS; i++) + { + g_thread_join (threads[i]); + } + g_assert (test_g_static_rw_lock_state == 0); + g_static_rw_lock_free(&test_g_static_rw_lock_lock); +} + +void test_g_thread_error_quark() +{ + GQuark c = g_thread_error_quark(); + g_assert(c == 1); +} + + +static void test_g_thread_set_priority (void) +{ + GThread *thread; + thread = g_thread_self(); + g_thread_set_priority (thread, G_THREAD_PRIORITY_HIGH); + g_assert((thread->priority) == G_THREAD_PRIORITY_HIGH); +} + + +/* run all the tests */ +void +run_all_thread_tests() +{ + test_g_static_rec_mutex (); + test_g_static_rw_lock (); + test_g_thread_error_quark(); + test_g_thread_set_priority(); +} + +int +main (int argc, + char *argv[]) +{ + #ifdef __SYMBIAN32__ + + 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); + g_set_print_handler(mrtPrintHandler); + #endif /*__SYMBIAN32__*/ + + + /* Only run the test, if threads are enabled and a default thread + implementation is available */ +#if defined(G_THREADS_ENABLED) && ! defined(G_THREADS_IMPL_NONE) + g_thread_init (NULL); + run_all_thread_tests (); + + /* Now we rerun all tests, but this time we fool the system into + * thinking, that the available thread system is not native, but + * userprovided. */ + + g_thread_use_default_impl = FALSE; + run_all_thread_tests (); + +#endif + +#ifdef __SYMBIAN32__ + testResultXml("tthread"); +#endif /* EMULATOR */ + return 0; +}