Symaptic: os/ossrv/glib/tsrc/BC/tests/refcount/signals-multithread.c@260cb5ec6c19

     1 /* Portion Copyright © 2008-09 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.*/

     6 #include <unistd.h>

     7 #include <glib.h>

     8 #include <glib-object.h>

    10 #ifdef SYMBIAN

    11 #include "glib_global.h"

    12 #include "mrt2_glib2_test.h"

    13 #define MULTITHREAD

    14 //#define TEST_STOP_EMISSION

    15 //#define VERBOSE

    16 #define LOOP 3

    17 int TESTNUM;

    18 int notifynum;

    19 int handlernum;

    20 gulong  hookid;

    21 GValue gv ;

    22 GSignalQuery gq;

    23 guint gi;

    24 #endif /*SYMBIAN*/

    27 #define G_TYPE_TEST               (g_test_get_type ())

    28 #define G_TEST(test)              (G_TYPE_CHECK_INSTANCE_CAST ((test), G_TYPE_TEST, GTest))

    29 #define G_IS_TEST(test)           (G_TYPE_CHECK_INSTANCE_TYPE ((test), G_TYPE_TEST))

    30 #define G_TEST_CLASS(tclass)      (G_TYPE_CHECK_CLASS_CAST ((tclass), G_TYPE_TEST, GTestClass))

    31 #define G_IS_TEST_CLASS(tclass)   (G_TYPE_CHECK_CLASS_TYPE ((tclass), G_TYPE_TEST))

    32 #define G_TEST_GET_CLASS(test)    (G_TYPE_INSTANCE_GET_CLASS ((test), G_TYPE_TEST, GTestClass))

    34 static GRand *grand;

    36 typedef struct _GTest GTest;

    37 typedef struct _GTestClass GTestClass;

    39 struct _GTest

    40 {

    41   GObject object;

    43   gint value;

    44 };

    46 struct _GTestClass

    47 {

    48   GObjectClass parent_class;

    50   void (*test_signal1) (GTest * test, gint an_int);

    51   void (*test_signal2) (GTest * test, gint an_int);

    52 };

    54 static GType g_test_get_type (void);

    55 static volatile gboolean stopping;

    57 /* Element signals and args */

    58 enum

    59 {

    60   TEST_SIGNAL1,

    61   TEST_SIGNAL2,

    62   /* add more above */

    63   LAST_SIGNAL

    64 };

    66 enum

    67 {

    68   ARG_0,

    69   ARG_TEST_PROP

    70 };

    72 static void g_test_class_init (GTestClass * klass);

    73 static void g_test_init (GTest * test);

    74 static void g_test_dispose (GObject * object);

    76 static void signal2_handler (GTest * test, gint anint);

    78 static void g_test_set_property (GObject * object, guint prop_id,

    79     const GValue * value, GParamSpec * pspec);

    80 static void g_test_get_property (GObject * object, guint prop_id,

    81     GValue * value, GParamSpec * pspec);

    83 static GObjectClass *parent_class = NULL;

    85 static guint g_test_signals[LAST_SIGNAL] = { 0 };

    87 static GType

    88 g_test_get_type (void)

    89 {

    90   static GType test_type = 0;

    92   if (!test_type) {

    93     static const GTypeInfo test_info = {

    94       sizeof (GTestClass),

    95       NULL,

    96       NULL,

    97       (GClassInitFunc) g_test_class_init,

    98       NULL,

    99       NULL,

   100       sizeof (GTest),

   101       0,

   102       (GInstanceInitFunc) g_test_init,

   103       NULL

   104     };

   106     grand = g_rand_new();

   108     test_type = g_type_register_static (G_TYPE_OBJECT, "GTest",

   109         &test_info, 0);

   110   }

   111   return test_type;

   112 }

   114 static void

   115 g_test_class_init (GTestClass * klass)

   116 {

   117   GObjectClass *gobject_class;

   119   gobject_class = (GObjectClass *) klass;

   121   parent_class = g_type_class_ref (G_TYPE_OBJECT);

   122 #ifndef SYMBIAN

   123   if (!g_thread_supported ())

   124     g_thread_init (NULL);

   125 #else

   127 #ifdef MULTITHREAD

   128   if (!g_thread_supported ())

   129     g_thread_init (NULL);

   130 #endif /*MULTITHREAD*/

   132 #endif /*SYMBAIN*/

   134   gobject_class->dispose = g_test_dispose;

   135   gobject_class->set_property = g_test_set_property;

   136   gobject_class->get_property = g_test_get_property;

   138   g_test_signals[TEST_SIGNAL1] =

   139       g_signal_new ("test-signal1", G_TYPE_FROM_CLASS (klass),

   140       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GTestClass, test_signal1), NULL,

   141       NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);

   142   g_test_signals[TEST_SIGNAL2] =

   143       g_signal_new ("test-signal2", G_TYPE_FROM_CLASS (klass),

   144       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GTestClass, test_signal2), NULL,

   145       NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);

   147   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TEST_PROP,

   148       g_param_spec_int ("test-prop", "Test Prop", "Test property",

   149           0, 1, 0, G_PARAM_READWRITE));

   151   klass->test_signal2 = signal2_handler;

   152 }

   154 static void

   155 g_test_init (GTest * test)

   156 {

   157   #ifndef SYMBIAN

   158   g_print ("init %p\n", test);

   159   #else

   161   #ifdef VERBOSE

   162   g_print ("init %p\n", test);

   163   #endif

   165   #endif /*SYMBIAN*/

   167   test->value = 0;

   168 }

   170 static void

   171 g_test_dispose (GObject * object)

   172 {

   173   GTest *test;

   175   test = G_TEST (object);

   177   g_print ("dispose %p!\n", object);

   179   G_OBJECT_CLASS (parent_class)->dispose (object);

   180 }

   182 static void

   183 g_test_set_property (GObject * object, guint prop_id,

   184     const GValue * value, GParamSpec * pspec)

   185 {

   186   GTest *test;

   188   test = G_TEST (object);

   190   switch (prop_id) {

   191     case ARG_TEST_PROP:

   192       test->value = g_value_get_int (value);

   193       break;

   194     default:

   195       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   196       break;

   197   }

   198 }

   200 static void

   201 g_test_get_property (GObject * object, guint prop_id,

   202     GValue * value, GParamSpec * pspec)

   203 {

   204   GTest *test;

   206   test = G_TEST (object);

   208   switch (prop_id) {

   209     case ARG_TEST_PROP:

   210       g_value_set_int (value, test->value);

   211       break;

   212     default:

   213       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   214       break;

   215   }

   216 }

   218 static void

   219 g_test_do_signal1 (GTest * test)

   220 {

   221   g_signal_emit (G_OBJECT (test), g_test_signals[TEST_SIGNAL1], 0, 0);

   222 }

   224 static void

   225 signal2_handler (GTest * test, gint anint)

   226 {

   227 	#ifdef VERBOSE

   228 	g_print ("Function: signal2_handler called\n");

   229 	#endif

   231 	handlernum++;

   232 }

   234 static void

   235 g_test_do_signal2 (GTest * test)

   236 {

   237   g_signal_emit (G_OBJECT (test), g_test_signals[TEST_SIGNAL2], 0, 0);

   238 }

   240 static void

   241 g_test_do_prop (GTest * test)

   242 {

   243   test->value = g_rand_int (grand);

   244   g_object_notify (G_OBJECT (test), "test-prop");

   245 }

   247 static gpointer

   248 run_thread (GTest * test)

   249 {

   250   gint i = 1;

   252 #ifndef SYMBIAN

   253   while (!stopping)

   254    {

   255     if (TESTNUM == 1)

   256       g_test_do_signal1 (test);

   257     if (TESTNUM == 2)

   258       g_test_do_signal2 (test);

   259     if (TESTNUM == 3)

   260       g_test_do_prop (test);

   261     if ((i++ % 10000) == 0) {

   262       g_print (".");

   263      g_thread_yield();  /*force context switch */

   264     }

   265    }

   266 #else

   268 #ifdef MULTITHREAD

   269   while (!stopping)

   270    {

   271     if (TESTNUM == 1)

   272       g_test_do_signal1 (test);

   273     if (TESTNUM == 2)

   274       g_test_do_signal2 (test);

   275     if (TESTNUM == 3)

   276       g_test_do_prop (test);

   277     if ((i++ % 10/*000*/) == 0)

   278     {

   279     #ifdef VERBOSE

   280       g_print (".");

   281     #endif  /*VERBOSE*/

   282      g_thread_yield(); /* force context switch */

   283     }

   284    }

   285 #else

   286   for(i=0;i <= LOOP;i++)

   287   {

   288     if (TESTNUM == 1)

   289       g_test_do_signal1 (test);

   290     if (TESTNUM == 2)

   291       g_test_do_signal2 (test);

   292     if (TESTNUM == 3)

   293       g_test_do_prop (test);

   295     #ifdef 	VERBOSE

   296     g_print(".");

   297     #endif

   298   }

   299 #endif /*MULTITHREAD*/

   301 #endif /*SYMBIAN*/

   303   return NULL;

   304 }

   309 static void

   310 notify (GObject *object, GParamSpec *spec, gpointer user_data)

   311 {

   312   gint value;

   314   notifynum++;

   315 	#ifdef VERBOSE

   316 	g_print ("Function: notify called\n");

   317 	#endif

   319   g_object_get (object, "test-prop", &value, NULL);

   320   //g_print ("+ %d", value);

   321 }

   323 #ifdef SYMBIAN

   324 void hook_function()

   325 {

   326 	#ifdef VERBOSE

   327 	g_print ("Function: hook_function called\n");

   328 	#endif

   329 	handlernum++;

   330 }

   331 #endif

   333 int

   334 main (int argc, char **argv)

   335 {

   336   gint i;

   337   GTest *test1, *test2;

   338   GArray *test_threads;

   339   const gint n_threads = 1;

   341   #ifdef SYMBIAN

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

   343   g_set_print_handler(mrtPrintHandler);

   344   #endif /*SYMBIAN*/

   346   g_thread_init (NULL);

   348   #ifndef SYMBIAN

   349   g_print ("START: %s\n", argv[0]);

   350   #else

   352   #ifdef VERBOSE

   353   g_print ("START: %s\n", argv[0]);

   354   #endif

   356   #endif /*SYMBIAN*/

   357   g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | g_log_set_always_fatal (G_LOG_FATAL_MASK));

   358   g_type_init ();

   360   test1 = g_object_new (G_TYPE_TEST, NULL);

   361   test2 = g_object_new (G_TYPE_TEST, NULL);

   363   g_signal_connect (test1, "notify::test-prop", G_CALLBACK (notify), NULL);

   364   g_signal_connect (test1, "test-signal1", G_CALLBACK (notify), NULL);

   365   g_signal_connect (test1, "test-signal2", G_CALLBACK (notify), NULL);

   370 #ifndef SYMBIAN

   371   test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));

   373   stopping = FALSE;

   375   for (i = 0; i < n_threads; i++) {

   376     GThread *thread;

   378     thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);

   379     g_array_append_val (test_threads, thread);

   381     thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);

   382     g_array_append_val (test_threads, thread);

   383   }

   384   g_usleep (500000);

   386   stopping = TRUE;

   388   g_print ("\nstopping\n");

   390   /* join all threads */

   391   for (i = 0; i < 2 * n_threads; i++) {

   392     GThread *thread;

   394     thread = g_array_index (test_threads, GThread *, i);

   395     g_thread_join (thread);

   396   }

   398   g_print ("stopped:%d\n",TESTNUM);

   399 #else

   401 #ifdef MULTITHREAD

   403   test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));

   404   stopping = FALSE;

   405   TESTNUM=1;

   406   notifynum=0;

   407   handlernum=0;

   408   for (i = 0; i < n_threads; i++)

   409   {

   410     GThread *thread;

   412     thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);

   413     g_array_append_val (test_threads, thread);

   415     thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);

   416     g_array_append_val (test_threads, thread);

   417   }

   418   g_usleep (500000);

   420   stopping = TRUE;

   422   #ifdef VERBOSE

   423   g_print ("\nstopping\n");

   424   #endif

   425   /* join all threads */

   426   for (i = 0; i < 2 * n_threads; i++)

   427   {

   428     GThread *thread;

   430     thread = g_array_index (test_threads, GThread *, i);

   431     g_thread_join (thread);

   432   }

   434   g_assert(notifynum != 0);

   435   g_assert(handlernum == 0);

   437   g_array_free (test_threads, TRUE);

   439   #ifdef VERBOSE

   440   g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM);

   441   #endif

   445   test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));

   446   stopping = FALSE;

   447   TESTNUM=2;

   448   notifynum=0;

   449   handlernum=0;

   451   for (i = 0; i < n_threads; i++)

   452   {

   453     GThread *thread;

   455     thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);

   456     g_array_append_val (test_threads, thread);

   458     thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);

   459     g_array_append_val (test_threads, thread);

   460   }

   461   g_usleep (500000);

   463   stopping = TRUE;

   465   #ifdef VERBOSE

   466   g_print ("\nstopping\n");

   467   #endif

   468   /* join all threads */

   469   for (i = 0; i < 2 * n_threads; i++)

   470   {

   471     GThread *thread;

   473     thread = g_array_index (test_threads, GThread *, i);

   474     g_thread_join (thread);

   475   }

   477   g_assert(notifynum != 0);

   478   g_assert(handlernum != 0);

   480   g_array_free (test_threads, TRUE);

   482   #ifdef VERBOSE

   483   g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM);

   484   #endif

   487   test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));

   488   stopping = FALSE;

   489   TESTNUM=3;

   490   notifynum=0;

   491   handlernum=0;

   493   for (i = 0; i < n_threads; i++)

   494   {

   495     GThread *thread;

   497     thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);

   498     g_array_append_val (test_threads, thread);

   500     thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);

   501     g_array_append_val (test_threads, thread);

   502   }

   503   g_usleep (5000000);

   505   stopping = TRUE;

   507   #ifdef VERBOSE

   508   g_print ("\nstopping\n");

   509   #endif

   510   /* join all threads */

   511   for (i = 0; i < 2 * n_threads; i++)

   512   {

   513     GThread *thread;

   515     thread = g_array_index (test_threads, GThread *, i);

   516     g_thread_join (thread);

   517   }

   519   g_assert(notifynum != 0);

   520   g_assert(handlernum == 0);

   522   g_array_free (test_threads, TRUE);

   524   #ifdef VERBOSE

   525   g_print ("Signals.c: completed for TESTNUM = %d\n",TESTNUM);

   526   #endif

   528 #else	/* ! MULTITHREAD*/

   531 TESTNUM=1;

   532 #ifdef VERBOSE

   533 g_print ("\nStarting with TESTNUM=%d\n",TESTNUM);

   534 #endif

   536 notifynum=0;

   537 handlernum=0;

   538 run_thread(test1);

   539 g_assert(notifynum == LOOP +1);

   540 g_assert(handlernum ==0);

   542 notifynum=0;

   543 handlernum=0;

   544 run_thread(test2);

   545 g_assert(notifynum == 0);

   546 g_assert(handlernum == 0);

   548 TESTNUM=2;

   549 #ifdef VERBOSE

   550 g_print ("\nStarting with TESTNUM=%d\n",TESTNUM);

   551 #endif

   553 notifynum=0;

   554 handlernum=0;

   555 run_thread(test1);

   556 g_assert(notifynum == LOOP+1);

   557 g_assert(handlernum == LOOP+1);

   559 notifynum=0;

   560 handlernum=0;

   561 run_thread(test2);

   562 g_assert(notifynum == 0);

   563 g_assert(handlernum == LOOP+1);

   565 TESTNUM=3;

   566 #ifdef VERBOSE

   567 g_print ("\nStarting with TESTNUM=%d\n",TESTNUM);

   568 #endif

   570 notifynum=0;

   571 handlernum=0;

   572 run_thread(test1);

   573 g_assert(notifynum == LOOP +1);

   574 g_assert(handlernum ==0);

   576 notifynum=0;

   577 handlernum=0;

   578 run_thread(test2);

   579 g_assert(notifynum == 0);

   580 g_assert(handlernum == 0);

   582 g_assert(g_signal_has_handler_pending(G_OBJECT(test1),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==TRUE);

   583 g_assert(g_signal_has_handler_pending(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,TRUE)==FALSE);

   585 g_assert(g_signal_handler_is_connected(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST))==TRUE);

   586 g_assert(g_signal_handler_is_connected(G_OBJECT(test2),g_signal_lookup("test-signal2",G_TYPE_TEST))==FALSE);

   588 handlernum=g_signal_lookup("test-signal1",G_TYPE_TEST);

   589 #ifdef VERBOSE

   590 g_print("Signal id: %d\n",handlernum);

   591 #endif

   593 g_signal_connect (test2, "test-signal1", G_CALLBACK (notify), NULL);

   595 hookid=g_signal_add_emission_hook(handlernum,NULL,(GSignalEmissionHook) hook_function,NULL,NULL);

   597 #ifdef VERBOSE

   598 g_print("Hookid: %d\n",hookid);

   599 #endif

   600 /********************/

   602 #ifdef TEST_STOP_EMISSION

   603 /*

   604 notifynum=0;

   605 handlernum=0;

   606 g_print("The following call stops signal emission\n");

   607 g_signal_stop_emission(G_OBJECT(test1),g_signal_lookup("test-signal1",G_TYPE_TEST),0);

   609 g_print("The following call should abort and it is normal\n");

   610 run_thread(test1);

   611 printf("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum);

   613 */

   614 notifynum=0;

   615 handlernum=0;

   616 g_signal_stop_emission_by_name(G_OBJECT(test1),"test-signal1");

   617 //run_thread(test1);

   618 g_print("Notifynum: %d and Handlernum: %d\n",notifynum,handlernum);

   621 #endif /*TEST_STOP_EMISSION*/

   623 /*******************/

   626 handlernum=0;

   627 g_signal_emit(G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0);

   628 g_signal_emit(G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0);

   629 g_assert(handlernum==2);

   632 g_signal_remove_emission_hook(g_signal_lookup("test-signal1",G_TYPE_TEST),hookid);

   634 #ifdef VERBOSE

   635 g_print("Emitting signal again after removing emission hook\n");

   636 #endif

   638 handlernum=0;

   639 g_signal_emit (G_OBJECT (test1), g_test_signals[TEST_SIGNAL1], 0, 0);

   640 g_signal_emit (G_OBJECT (test2), g_test_signals[TEST_SIGNAL1], 0, 0);

   641 g_assert(handlernum==0);

   643 g_assert (strcmp ("test-signal1", g_signal_name (g_signal_lookup("test-signal1",G_TYPE_TEST))) == 0);

   644 g_assert (strcmp ("test-signal2", g_signal_name (g_signal_lookup("test-signal2",G_TYPE_TEST))) == 0);

   647 memset(&gv,0,sizeof(gv));

   648 g_value_init(&gv,G_TYPE_OBJECT);

   649 g_value_set_object(&gv,test1);

   651 gi=0;

   652 g_signal_list_ids(G_OBJECT_TYPE(test1),&gi);

   653 g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gi);

   655 notifynum=0;

   656 g_signal_emitv (&gv, g_test_signals[TEST_SIGNAL1], 0, &gv);

   657 g_assert(notifynum==1);

   659 g_signal_query(g_signal_lookup("test-signal1",G_TYPE_TEST),&gq);

   660 g_assert(strcmp("test-signal1",gq.signal_name)==0);

   661 g_assert(g_signal_lookup("test-signal1",G_TYPE_TEST)==gq.signal_id);

   664 g_assert(g_signal_handler_find(G_OBJECT(test1), G_SIGNAL_RUN_LAST,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,NULL,NULL)==2);

   667 notifynum=g_signal_handlers_block_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL);

   668 handlernum=g_signal_handlers_unblock_matched(G_OBJECT(test1),G_SIGNAL_MATCH_FUNC,g_signal_lookup("test-signal2",G_TYPE_TEST),NULL,NULL,(gpointer)G_CALLBACK(notify),NULL);

   669 g_assert(notifynum==handlernum);

   671 #endif /*MULTITHREAD*/

   673 #ifdef VERBOSE

   674 g_printf ("\nsignals.c: Completed all tests\n");

   675 #endif

   677 #endif /*SYMBIAN*/

   681   #if SYMBIAN

   682   testResultXml("signals-multithread");

   683   #endif /* EMULATOR */

   685   return 0;

   686 }

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--