glib/tests/private.c

   1 /* Unit tests for GPrivate and friends
   2  * Copyright (C) 2011 Red Hat, Inc
   3  * Author: Matthias Clasen
   4  *
   5  * This work is provided "as is"; redistribution and modification
   6  * in whole or in part, in any medium, physical or electronic is
   7  * permitted without restriction.
   8  *
   9  * This work is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12  *
  13  * In no event shall the authors or contributors be liable for any
  14  * direct, indirect, incidental, special, exemplary, or consequential
  15  * damages (including, but not limited to, procurement of substitute
  16  * goods or services; loss of use, data, or profits; or business
  17  * interruption) however caused and on any theory of liability, whether
  18  * in contract, strict liability, or tort (including negligence or
  19  * otherwise) arising in any way out of the use of this software, even
  20  * if advised of the possibility of such damage.
  21  */
  22
  23 /* We are testing some deprecated APIs here */
  24 #define GLIB_DISABLE_DEPRECATION_WARNINGS
  25
  26 #include <glib.h>
  27
  28 /* test basics:
  29  * - initial value is NULL
  30  * - set/get work repeatedly
  31  */
  32 static void
  33 test_private1 (void)
  34 {
  35   GPrivate *private1;
  36   gpointer value;
  37
  38   private1 = g_private_new (NULL);
  39
  40   value = g_private_get (private1);
  41   g_assert (value == NULL);
  42
  43   g_private_set (private1, GINT_TO_POINTER(1));
  44   value = g_private_get (private1);
  45   g_assert_cmpint (GPOINTER_TO_INT (value), ==, 1);
  46
  47   g_private_set (private1, GINT_TO_POINTER(2));
  48   value = g_private_get (private1);
  49   g_assert_cmpint (GPOINTER_TO_INT (value), ==, 2);
  50 }
  51
  52 static GPrivate *private2;
  53 static gint private2_destroy_count;
  54
  55 static void
  56 private2_destroy (gpointer data)
  57 {
  58   g_atomic_int_inc (&private2_destroy_count);
  59 }
  60
  61 static gpointer
  62 private2_func (gpointer data)
  63 {
  64   gint value = GPOINTER_TO_INT (data);
  65   gint i;
  66   gint v, v2;
  67
  68   for (i = 0; i < 1000; i++)
  69     {
  70       v = value + (i % 5);
  71       g_private_set (private2, GINT_TO_POINTER(v));
  72       g_usleep (1000);
  73       v2 = GPOINTER_TO_INT(g_private_get (private2));
  74       g_assert_cmpint (v, ==, v2);
  75     }
  76
  77   if (value % 2 == 0)
  78     g_thread_exit (NULL);
  79
  80   return NULL;
  81 }
  82
  83 /* test that
  84  * - threads do not interfere with each other
  85  * - destroy notifies are called for each thread exit
  86  * - destroy notifies are called for g_thread_exit() too
  87  * - destroy notifies are not called on g_private_set()
  88  * - destroy notifies are called on g_private_replace()
  89  */
  90 static void
  91 test_private2 (void)
  92 {
  93   GThread *thread[10];
  94   gint i;
  95
  96   private2 = g_private_new (private2_destroy);
  97
  98   g_private_set (private2, GINT_TO_POINTER(234));
  99   g_private_replace (private2, GINT_TO_POINTER(123));
 100
 101   for (i = 0; i < 10; i++)
 102     thread[i] = g_thread_create (private2_func, GINT_TO_POINTER (i), TRUE, NULL);
 103
 104   for (i = 0; i < 10; i++)
 105     g_thread_join (thread[i]);
 106
 107   g_assert_cmpint (private2_destroy_count, ==, 11);
 108 }
 109
 110 static gboolean private3_freed;
 111
 112 static void
 113 private3_free (gpointer data)
 114 {
 115   g_assert (data == (void*) 0x1234);
 116   private3_freed = TRUE;
 117 }
 118
 119 #ifdef G_OS_WIN32
 120 #include <windows.h>
 121 #include <process.h>
 122
 123 static guint __stdcall
 124 #else
 125 #include <pthread.h>
 126
 127 static gpointer
 128 #endif
 129 private3_func (gpointer data)
 130 {
 131   static GPrivate key = G_PRIVATE_INIT (private3_free);
 132
 133   g_private_set (&key, (void *) 0x1234);
 134
 135   return 0;
 136 }
 137
 138 static void
 139 test_private3 (void)
 140 {
 141   g_assert (!private3_freed);
 142
 143 #ifdef G_OS_WIN32
 144   {
 145     HANDLE thread;
 146     guint ignore;
 147     thread = (HANDLE) _beginthreadex (NULL, 0, private3_func, NULL, 0, &ignore);
 148     WaitForSingleObject (thread, INFINITE);
 149     CloseHandle (thread);
 150   }
 151 #else
 152   {
 153     pthread_t thread;
 154
 155     pthread_create (&thread, NULL, private3_func, NULL);
 156     pthread_join (thread, NULL);
 157   }
 158 #endif
 159   g_assert (private3_freed);
 160 }
 161
 162 /* test basics:
 163  * - static initialization works
 164  * - initial value is NULL
 165  * - get/set works repeatedly
 166  */
 167 static GStaticPrivate sp1 = G_STATIC_PRIVATE_INIT;
 168
 169 static void
 170 test_static_private1 (void)
 171 {
 172   gpointer value;
 173
 174   value = g_static_private_get (&sp1);
 175   g_assert (value == NULL);
 176
 177   g_static_private_set (&sp1, GINT_TO_POINTER(1), NULL);
 178   value = g_static_private_get (&sp1);
 179   g_assert_cmpint (GPOINTER_TO_INT(value), ==, 1);
 180
 181   g_static_private_set (&sp1, GINT_TO_POINTER(2), NULL);
 182   value = g_static_private_get (&sp1);
 183   g_assert_cmpint (GPOINTER_TO_INT(value), ==, 2);
 184
 185   g_static_private_free (&sp1);
 186
 187   value = g_static_private_get (&sp1);
 188   g_assert (value == NULL);
 189 }
 190
 191 static gint sp2_destroy_count;
 192
 193 static void
 194 sp2_destroy (gpointer data)
 195 {
 196   sp2_destroy_count++;
 197 }
 198
 199 static void
 200 sp2_destroy2 (gpointer data)
 201 {
 202   gint value = GPOINTER_TO_INT (data);
 203
 204   g_assert_cmpint (value, ==, 2);
 205 }
 206
 207 /* test that destroy notifies are called as expected
 208  * and on the right values
 209  */
 210 static void
 211 test_static_private2 (void)
 212 {
 213   GStaticPrivate sp2;
 214   gpointer value;
 215
 216   g_static_private_init (&sp2);
 217
 218   value = g_static_private_get (&sp2);
 219   g_assert (value == NULL);
 220
 221   g_static_private_set (&sp2, GINT_TO_POINTER(1), sp2_destroy);
 222   g_assert_cmpint (sp2_destroy_count, ==, 0);
 223   value = g_static_private_get (&sp2);
 224   g_assert_cmpint (GPOINTER_TO_INT(value), ==, 1);
 225
 226   g_static_private_set (&sp2, GINT_TO_POINTER(2), sp2_destroy2);
 227   g_assert_cmpint (sp2_destroy_count, ==, 1);
 228   value = g_static_private_get (&sp2);
 229   g_assert_cmpint (GPOINTER_TO_INT(value), ==, 2);
 230
 231   g_static_private_set (&sp2, GINT_TO_POINTER(3), sp2_destroy);
 232   g_assert_cmpint (sp2_destroy_count, ==, 1);
 233   value = g_static_private_get (&sp2);
 234   g_assert_cmpint (GPOINTER_TO_INT(value), ==, 3);
 235
 236   g_static_private_free (&sp2);
 237
 238   value = g_static_private_get (&sp2);
 239   g_assert (value == NULL);
 240 }
 241
 242 /* test that freeing and reinitializing a static private
 243  * drops previous value
 244  */
 245 static void
 246 test_static_private3 (void)
 247 {
 248   GStaticPrivate sp3;
 249   gpointer value;
 250
 251   g_static_private_init (&sp3);
 252
 253   value = g_static_private_get (&sp3);
 254   g_assert (value == NULL);
 255
 256   g_static_private_set (&sp3, GINT_TO_POINTER(1), NULL);
 257   value = g_static_private_get (&sp3);
 258   g_assert_cmpint (GPOINTER_TO_INT(value), ==, 1);
 259
 260   g_static_private_free (&sp3);
 261   g_static_private_init (&sp3);
 262
 263   value = g_static_private_get (&sp3);
 264   g_assert (value == NULL);
 265
 266   g_static_private_set (&sp3, GINT_TO_POINTER(2), NULL);
 267   value = g_static_private_get (&sp3);
 268   g_assert_cmpint (GPOINTER_TO_INT(value), ==, 2);
 269
 270   g_static_private_free (&sp3);
 271 }
 272
 273 static GStaticPrivate sp4 = G_STATIC_PRIVATE_INIT;
 274
 275 static gpointer
 276 sp4_func (gpointer data)
 277 {
 278   gint value = GPOINTER_TO_INT (data);
 279   gint i;
 280   gint v, v2;
 281
 282   for (i = 0; i < 1000; i++)
 283     {
 284       v = value + (i % 5);
 285       g_static_private_set (&sp4, GINT_TO_POINTER(v), NULL);
 286       g_usleep (1000);
 287       v2 = GPOINTER_TO_INT(g_static_private_get (&sp4));
 288       g_assert_cmpint (v, ==, v2);
 289     }
 290
 291   if (value % 2 == 0)
 292     g_thread_exit (NULL);
 293
 294   return NULL;
 295 }
 296
 297 /* test that threads do not interfere with each other
 298  */
 299 static void
 300 test_static_private4 (void)
 301 {
 302   GThread *thread[10];
 303   gint i;
 304
 305   for (i = 0; i < 10; i++)
 306     thread[i] = g_thread_create (sp4_func, GINT_TO_POINTER (i), TRUE, NULL);
 307
 308   for (i = 0; i < 10; i++)
 309     g_thread_join (thread[i]);
 310
 311   g_static_private_free (&sp4);
 312 }
 313
 314 static GStaticPrivate sp5 = G_STATIC_PRIVATE_INIT;
 315 static GMutex m5;
 316 static GCond c5a;
 317 static GCond c5b;
 318 static gint count5;
 319
 320 static gpointer
 321 sp5_func (gpointer data)
 322 {
 323   gint v = GPOINTER_TO_INT (data);
 324   gpointer value;
 325
 326   value = g_static_private_get (&sp5);
 327   g_assert (value == NULL);
 328
 329   g_static_private_set (&sp5, GINT_TO_POINTER (v), NULL);
 330   value = g_static_private_get (&sp5);
 331   g_assert_cmpint (GPOINTER_TO_INT (value), ==, v);
 332
 333   if (g_test_verbose ())
 334     g_print ("thread %d set sp5\n", v);
 335   g_mutex_lock (&m5);
 336   g_atomic_int_inc (&count5);
 337   g_cond_signal (&c5a);
 338   g_cond_wait (&c5b, &m5);
 339   g_mutex_unlock (&m5);
 340
 341   if (g_test_verbose ())
 342     g_print ("thread %d get sp5\n", v);
 343   value = g_static_private_get (&sp5);
 344   g_assert (value == NULL);
 345
 346   return NULL;
 347 }
 348
 349 static void
 350 test_static_private5 (void)
 351 {
 352   GThread *thread[10];
 353   gint i;
 354
 355   g_atomic_int_set (&count5, 0);
 356
 357   for (i = 0; i < 10; i++)
 358     thread[i] = g_thread_create (sp5_func, GINT_TO_POINTER (i), TRUE, NULL);
 359
 360   g_mutex_lock (&m5);
 361   while (g_atomic_int_get (&count5) < 10)
 362     g_cond_wait (&c5a, &m5);
 363
 364   if (g_test_verbose ())
 365     g_print ("sp5 gets nuked\n");
 366
 367   g_static_private_free (&sp5);
 368
 369   g_cond_broadcast (&c5b);
 370   g_mutex_unlock (&m5);
 371
 372   for (i = 0; i < 10; i++)
 373     g_thread_join (thread[i]);
 374
 375   g_mutex_clear (&m5);
 376   g_cond_clear (&c5a);
 377   g_cond_clear (&c5b);
 378 }
 379
 380 int
 381 main (int argc, char *argv[])
 382 {
 383   g_test_init (&argc, &argv, NULL);
 384
 385   g_test_add_func ("/thread/private1", test_private1);
 386   g_test_add_func ("/thread/private2", test_private2);
 387   g_test_add_func ("/thread/private3", test_private3);
 388   g_test_add_func ("/thread/staticprivate1", test_static_private1);
 389   g_test_add_func ("/thread/staticprivate2", test_static_private2);
 390   g_test_add_func ("/thread/staticprivate3", test_static_private3);
 391   g_test_add_func ("/thread/staticprivate4", test_static_private4);
 392   g_test_add_func ("/thread/staticprivate5", test_static_private5);
 393
 394   return g_test_run ();
 395 }