MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/ossrv/glib/tests/thread-test.c
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 /* Portion Copyright © 2008-09 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.*/

     2 #undef G_DISABLE_ASSERT

     3 #undef G_LOG_DOMAIN

     4 

     5 #include <glib.h>

     6 #ifdef __SYMBIAN32__

     7 #include <glib_global.h>

     8 #include "mrt2_glib2_test.h"

     9 #endif /*__SYMBIAN32__*/

    10 

    11 

    12 /* GMutex */

    13 

    14 static GMutex* test_g_mutex_mutex = NULL;

    15 static guint test_g_mutex_int = 0;

    16 static gboolean test_g_mutex_thread_ready;

    17 G_LOCK_DEFINE_STATIC (test_g_mutex);

    18 

    19 static gpointer

    20 test_g_mutex_thread (gpointer data)

    21 {

    22   g_assert (GPOINTER_TO_INT (data) == 42);

    23   g_assert (g_mutex_trylock (test_g_mutex_mutex) == FALSE);

    24   g_assert (G_TRYLOCK (test_g_mutex) == FALSE);

    25   test_g_mutex_thread_ready = TRUE;

    26   g_mutex_lock (test_g_mutex_mutex);

    27   g_assert (test_g_mutex_int == 42);

    28   g_mutex_unlock (test_g_mutex_mutex);

    29 

    30   return GINT_TO_POINTER (41);

    31 }

    32 

    33 static void

    34 test_g_mutex (void)

    35 {

    36   GThread *thread;

    37   test_g_mutex_mutex = g_mutex_new ();

    38 

    39   g_assert (g_mutex_trylock (test_g_mutex_mutex));

    40   g_assert (G_TRYLOCK (test_g_mutex));

    41   test_g_mutex_thread_ready = FALSE;

    42   thread = g_thread_create (test_g_mutex_thread, GINT_TO_POINTER (42),

    43 			    TRUE, NULL);

    44   /* This busy wait is only for testing purposes and not an example of

    45    * good code!*/

    46   while (!test_g_mutex_thread_ready)

    47     g_usleep (G_USEC_PER_SEC / 5);

    48   test_g_mutex_int = 42;

    49   G_UNLOCK (test_g_mutex);

    50   g_mutex_unlock (test_g_mutex_mutex);

    51   g_assert (GPOINTER_TO_INT (g_thread_join (thread)) == 41);

    52   g_mutex_free (test_g_mutex_mutex);

    53 }

    54 

    55 /* GStaticRecMutex */

    56 

    57 static GStaticRecMutex test_g_static_rec_mutex_mutex = G_STATIC_REC_MUTEX_INIT;

    58 static guint test_g_static_rec_mutex_int = 0;

    59 static gboolean test_g_static_rec_mutex_thread_ready;

    60 

    61 static gpointer

    62 test_g_static_rec_mutex_thread (gpointer data)

    63 {

    64   g_assert (GPOINTER_TO_INT (data) == 42);

    65   g_assert (g_static_rec_mutex_trylock (&test_g_static_rec_mutex_mutex) 

    66 	    == FALSE);

    67   test_g_static_rec_mutex_thread_ready = TRUE;

    68   g_static_rec_mutex_lock (&test_g_static_rec_mutex_mutex);

    69   g_static_rec_mutex_lock (&test_g_static_rec_mutex_mutex);

    70   g_assert (test_g_static_rec_mutex_int == 42);

    71   test_g_static_rec_mutex_thread_ready = FALSE;

    72   g_static_rec_mutex_unlock (&test_g_static_rec_mutex_mutex);

    73   g_static_rec_mutex_unlock (&test_g_static_rec_mutex_mutex);

    74 

    75   g_thread_exit (GINT_TO_POINTER (43));

    76   

    77   g_assert_not_reached ();

    78   return NULL;

    79 }

    80 

    81 static void

    82 test_g_static_rec_mutex (void)

    83 {

    84   GThread *thread;

    85 

    86   g_assert (g_static_rec_mutex_trylock (&test_g_static_rec_mutex_mutex));

    87   test_g_static_rec_mutex_thread_ready = FALSE;

    88   thread = g_thread_create (test_g_static_rec_mutex_thread, 

    89 			    GINT_TO_POINTER (42), TRUE, NULL);

    90   /* This busy wait is only for testing purposes and not an example of

    91    * good code!*/

    92   while (!test_g_static_rec_mutex_thread_ready)

    93     g_usleep (G_USEC_PER_SEC / 5);

    94 

    95   g_assert (g_static_rec_mutex_trylock (&test_g_static_rec_mutex_mutex));

    96   test_g_static_rec_mutex_int = 41;

    97   g_static_rec_mutex_unlock (&test_g_static_rec_mutex_mutex);

    98   test_g_static_rec_mutex_int = 42;  

    99   g_static_rec_mutex_unlock (&test_g_static_rec_mutex_mutex);

   100 

   101   /* This busy wait is only for testing purposes and not an example of

   102    * good code!*/

   103   while (test_g_static_rec_mutex_thread_ready)

   104     g_usleep (G_USEC_PER_SEC / 5);

   105 

   106   g_static_rec_mutex_lock (&test_g_static_rec_mutex_mutex);

   107   test_g_static_rec_mutex_int = 0;  

   108   g_static_rec_mutex_unlock (&test_g_static_rec_mutex_mutex);

   109 

   110   g_assert (GPOINTER_TO_INT (g_thread_join (thread)) == 43);

   111 }

   112 

   113 /* GStaticPrivate */

   114 

   115 #define THREADS 10

   116 

   117 static GStaticPrivate test_g_static_private_private1 = G_STATIC_PRIVATE_INIT;

   118 static GStaticPrivate test_g_static_private_private2 = G_STATIC_PRIVATE_INIT;

   119 static GStaticMutex test_g_static_private_mutex = G_STATIC_MUTEX_INIT;

   120 static guint test_g_static_private_counter = 0;

   121 static guint test_g_static_private_ready = 0;

   122 

   123 static gpointer

   124 test_g_static_private_constructor (void)

   125 {

   126   g_static_mutex_lock (&test_g_static_private_mutex);

   127   test_g_static_private_counter++;

   128   g_static_mutex_unlock (&test_g_static_private_mutex);  

   129   return g_new (guint,1);

   130 }

   131 

   132 static void

   133 test_g_static_private_destructor (gpointer data)

   134 {

   135   g_static_mutex_lock (&test_g_static_private_mutex);

   136   test_g_static_private_counter--;

   137   g_static_mutex_unlock (&test_g_static_private_mutex);  

   138   g_free (data);

   139 }

   140 

   141 

   142 static gpointer

   143 test_g_static_private_thread (gpointer data)

   144 {

   145   guint number = GPOINTER_TO_INT (data);

   146   guint i;

   147   guint *private1, *private2;

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

   149     {

   150       number = number * 11 + 1; /* A very simple and bad RNG ;-) */

   151       private1 = g_static_private_get (&test_g_static_private_private1);

   152       if (!private1 || number % 7 > 3)

   153 	{

   154 	  private1 = test_g_static_private_constructor ();

   155 	  g_static_private_set (&test_g_static_private_private1, private1,

   156 				test_g_static_private_destructor);

   157 	}

   158       *private1 = number;

   159       private2 = g_static_private_get (&test_g_static_private_private2);

   160       if (!private2 || number % 13 > 5)

   161 	{

   162 	  private2 = test_g_static_private_constructor ();

   163 	  g_static_private_set (&test_g_static_private_private2, private2,

   164 				test_g_static_private_destructor);

   165 	}

   166       *private2 = number * 2;

   167       g_usleep (G_USEC_PER_SEC / 5);

   168       g_assert (number == *private1);

   169       g_assert (number * 2 == *private2);      

   170     }

   171   g_static_mutex_lock (&test_g_static_private_mutex);

   172   test_g_static_private_ready++;

   173   g_static_mutex_unlock (&test_g_static_private_mutex);  

   174 

   175   /* Busy wait is not nice but that's just a test */

   176   while (test_g_static_private_ready != 0)

   177     g_usleep (G_USEC_PER_SEC / 5);  

   178 

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

   180     {

   181       private2 = g_static_private_get (&test_g_static_private_private2);

   182       number = number * 11 + 1; /* A very simple and bad RNG ;-) */

   183       if (!private2 || number % 13 > 5)

   184 	{

   185 	  private2 = test_g_static_private_constructor ();

   186 	  g_static_private_set (&test_g_static_private_private2, private2,

   187 				test_g_static_private_destructor);

   188 	}      

   189       *private2 = number * 2;

   190       g_usleep (G_USEC_PER_SEC / 5);

   191       g_assert (number * 2 == *private2);      

   192     }

   193 

   194   return GINT_TO_POINTER (GPOINTER_TO_INT (data) * 3);

   195 }

   196 

   197 static void

   198 test_g_static_private (void)

   199 {

   200   GThread *threads[THREADS];

   201   guint i;

   202 

   203   test_g_static_private_ready = 0;

   204 

   205   for (i = 0; i < THREADS; i++)

   206     {

   207       threads[i] = g_thread_create (test_g_static_private_thread, 

   208 				    GINT_TO_POINTER (i), TRUE, NULL);      

   209     }

   210 

   211   /* Busy wait is not nice but that's just a test */

   212   while (test_g_static_private_ready != THREADS)

   213     g_usleep (G_USEC_PER_SEC / 5);

   214 

   215   /* Reuse the static private */

   216   g_static_private_free (&test_g_static_private_private2);

   217   g_static_private_init (&test_g_static_private_private2);

   218   

   219   test_g_static_private_ready = 0;

   220 

   221   for (i = 0; i < THREADS; i++)

   222     g_assert (GPOINTER_TO_INT (g_thread_join (threads[i])) == i * 3);

   223     

   224   g_assert (test_g_static_private_counter == 0); 

   225 }

   226 

   227 /* GStaticRWLock */

   228 

   229 /* -1 = writing; >0 = # of readers */

   230 static gint test_g_static_rw_lock_state = 0; 

   231 G_LOCK_DEFINE (test_g_static_rw_lock_state);

   232 

   233 static gboolean test_g_static_rw_lock_run = TRUE; 

   234 static GStaticRWLock test_g_static_rw_lock_lock = G_STATIC_RW_LOCK_INIT;

   235 

   236 static gpointer

   237 test_g_static_rw_lock_thread (gpointer data)

   238 {

   239   while (test_g_static_rw_lock_run)

   240     {

   241       if (g_random_double() > .2) /* I'm a reader */

   242 	{

   243 	  

   244 	  if (g_random_double() > .2) /* I'll block */

   245 	    g_static_rw_lock_reader_lock (&test_g_static_rw_lock_lock);

   246 	  else /* I'll only try */

   247 	    if (!g_static_rw_lock_reader_trylock (&test_g_static_rw_lock_lock))

   248 	      continue;

   249 	  G_LOCK (test_g_static_rw_lock_state);

   250 	  g_assert (test_g_static_rw_lock_state >= 0);

   251 	  test_g_static_rw_lock_state++;

   252 	  G_UNLOCK (test_g_static_rw_lock_state);

   253 

   254 	  g_usleep (g_random_int_range (20,1000));

   255 

   256 	  G_LOCK (test_g_static_rw_lock_state);

   257 	  test_g_static_rw_lock_state--;

   258 	  G_UNLOCK (test_g_static_rw_lock_state);

   259 

   260 	  g_static_rw_lock_reader_unlock (&test_g_static_rw_lock_lock);

   261 	}

   262       else /* I'm a writer */

   263 	{

   264 	  

   265 	  if (g_random_double() > .2) /* I'll block */ 

   266 	    g_static_rw_lock_writer_lock (&test_g_static_rw_lock_lock);

   267 	  else /* I'll only try */

   268 	    if (!g_static_rw_lock_writer_trylock (&test_g_static_rw_lock_lock))

   269 	      continue;

   270 	  G_LOCK (test_g_static_rw_lock_state);

   271 	  g_assert (test_g_static_rw_lock_state == 0);

   272 	  test_g_static_rw_lock_state = -1;

   273 	  G_UNLOCK (test_g_static_rw_lock_state);

   274 

   275 	  g_usleep (g_random_int_range (20,1000));

   276 

   277 	  G_LOCK (test_g_static_rw_lock_state);

   278 	  test_g_static_rw_lock_state = 0;

   279 	  G_UNLOCK (test_g_static_rw_lock_state);

   280 

   281 	  g_static_rw_lock_writer_unlock (&test_g_static_rw_lock_lock);

   282 	}

   283     }

   284   return NULL;

   285 }

   286 

   287 static void

   288 test_g_static_rw_lock ()

   289 {

   290   GThread *threads[THREADS];

   291   guint i;

   292   for (i = 0; i < THREADS; i++)

   293     {

   294       threads[i] = g_thread_create (test_g_static_rw_lock_thread, 

   295 				    NULL, TRUE, NULL);      

   296     }

   297   g_usleep (G_USEC_PER_SEC * 5);

   298   test_g_static_rw_lock_run = FALSE;

   299   for (i = 0; i < THREADS; i++)

   300     {

   301       g_thread_join (threads[i]);

   302     }

   303   g_assert (test_g_static_rw_lock_state == 0);

   304 }

   305 

   306 #define G_ONCE_SIZE 100

   307 #define G_ONCE_THREADS 10

   308 

   309 G_LOCK_DEFINE (test_g_once);

   310 static guint test_g_once_guint_array[G_ONCE_SIZE];

   311 static GOnce test_g_once_array[G_ONCE_SIZE];

   312 

   313 static gpointer

   314 test_g_once_init_func(gpointer arg)

   315 {

   316   guint *count = arg;

   317   g_usleep (g_random_int_range (20,1000));

   318   (*count)++;

   319   g_usleep (g_random_int_range (20,1000));

   320   return arg;

   321 }

   322 

   323 static gpointer

   324 test_g_once_thread (gpointer ignore)

   325 {

   326   guint i;

   327   G_LOCK (test_g_once);

   328   /* Don't start before all threads are created */

   329   G_UNLOCK (test_g_once);

   330   for (i = 0; i < 1000; i++)

   331     {

   332       guint pos = g_random_int_range (0, G_ONCE_SIZE);

   333       gpointer ret = g_once (test_g_once_array + pos, test_g_once_init_func, 

   334 			     test_g_once_guint_array + pos);

   335       g_assert (ret == test_g_once_guint_array + pos);

   336     }

   337   

   338   /* Make sure, that all counters are touched at least once */

   339   for (i = 0; i < G_ONCE_SIZE; i++)

   340     {

   341       gpointer ret = g_once (test_g_once_array + i, test_g_once_init_func, 

   342 			     test_g_once_guint_array + i);

   343       g_assert (ret == test_g_once_guint_array + i);

   344     }

   345 

   346   return NULL;

   347 }

   348 

   349 static void

   350 test_g_thread_once (void)

   351 {

   352   static GOnce once_init = G_ONCE_INIT;

   353   GThread *threads[G_ONCE_THREADS];

   354   guint i;

   355   for (i = 0; i < G_ONCE_SIZE; i++) 

   356     {

   357       test_g_once_array[i] = once_init;

   358       test_g_once_guint_array[i] = i;

   359     }

   360   G_LOCK (test_g_once);

   361   for (i = 0; i < G_ONCE_THREADS; i++)

   362     {

   363       threads[i] = g_thread_create (test_g_once_thread, GUINT_TO_POINTER(i%2), 

   364 				    TRUE, NULL);

   365     }

   366   G_UNLOCK (test_g_once);

   367   for (i = 0; i < G_ONCE_THREADS; i++)

   368     {

   369       g_thread_join (threads[i]);

   370     }

   371   

   372   for (i = 0; i < G_ONCE_SIZE; i++) 

   373     {

   374       g_assert (test_g_once_guint_array[i] == i + 1);

   375     }

   376 }

   377 

   378 /* run all the tests */

   379 void

   380 run_all_tests()

   381 {

   382   test_g_mutex ();

   383   test_g_static_rec_mutex ();

   384   test_g_static_private ();

   385   test_g_static_rw_lock ();

   386   test_g_thread_once ();

   387 }

   388 

   389 int 

   390 main (int   argc,

   391       char *argv[])

   392 {

   393   #ifdef __SYMBIAN32__

   394   

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

   396   g_set_print_handler(mrtPrintHandler);

   397   #endif /*__SYMBIAN32__*/

   398 	  

   399 

   400   /* Only run the test, if threads are enabled and a default thread

   401      implementation is available */

   402 #if defined(G_THREADS_ENABLED) && ! defined(G_THREADS_IMPL_NONE)

   403   g_thread_init (NULL);

   404   run_all_tests ();

   405 

   406   /* Now we rerun all tests, but this time we fool the system into

   407    * thinking, that the available thread system is not native, but

   408    * userprovided. */

   409 

   410   g_thread_use_default_impl = FALSE;

   411   run_all_tests ();

   412   

   413 #endif

   414 

   415 #ifdef __SYMBIAN32__

   416   testResultXml("thread-test");

   417 #endif /* EMULATOR */

   418   return 0;

   419 }
Symaptic