1 /*

     2 * Portions copyright (c) 2009 Nokia Corporation.  All rights reserved.

     3 */

     4 #include <unistd.h>

     5 #include <glib.h>

     6 #include <glib-object.h>

     7 #ifdef __SYMBIAN32__

     8 #include <glib_global.h>

     9 #include "mrt2_glib2_test.h"

    10 #endif /*__SYMBIAN32__*/

    11 

    12 #ifdef __SYMBIAN32__

    13 int TESTNUM;

    14 #endif//__SYMBIAN32__

    15 

    16 #define G_TYPE_TEST                (my_test_get_type ())

    17 #define MY_TEST(test)              (G_TYPE_CHECK_INSTANCE_CAST ((test), G_TYPE_TEST, GTest))

    18 #define MY_IS_TEST(test)           (G_TYPE_CHECK_INSTANCE_TYPE ((test), G_TYPE_TEST))

    19 #define MY_TEST_CLASS(tclass)      (G_TYPE_CHECK_CLASS_CAST ((tclass), G_TYPE_TEST, GTestClass))

    20 #define MY_IS_TEST_CLASS(tclass)   (G_TYPE_CHECK_CLASS_TYPE ((tclass), G_TYPE_TEST))

    21 #define MY_TEST_GET_CLASS(test)    (G_TYPE_INSTANCE_GET_CLASS ((test), G_TYPE_TEST, GTestClass))

    22 

    23 static GRand *rand;

    24 

    25 typedef struct _GTest GTest;

    26 typedef struct _GTestClass GTestClass;

    27 

    28 struct _GTest

    29 {

    30   GObject object;

    31 

    32   gint value;

    33 };

    34 

    35 struct _GTestClass

    36 {

    37   GObjectClass parent_class;

    38 

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

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

    41 };

    42 

    43 static GType my_test_get_type (void);

    44 static volatile gboolean stopping;

    45 

    46 /* Element signals and args */

    47 enum

    48 {

    49   TEST_SIGNAL1,

    50   TEST_SIGNAL2,

    51   /* add more above */

    52   LAST_SIGNAL

    53 };

    54 

    55 enum

    56 {

    57   ARG_0,

    58   ARG_TEST_PROP

    59 };

    60 

    61 static void my_test_class_init (GTestClass * klass);

    62 static void my_test_init (GTest * test);

    63 static void my_test_dispose (GObject * object);

    64 

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

    66 

    67 static void my_test_set_property (GObject * object, guint prop_id,

    68     const GValue * value, GParamSpec * pspec);

    69 static void my_test_get_property (GObject * object, guint prop_id,

    70     GValue * value, GParamSpec * pspec);

    71 

    72 static GObjectClass *parent_class = NULL;

    73 

    74 static guint my_test_signals[LAST_SIGNAL] = { 0 };

    75 

    76 static GType

    77 my_test_get_type (void)

    78 {

    79   static GType test_type = 0;

    80 

    81   if (!test_type) {

    82     static const GTypeInfo test_info = {

    83       sizeof (GTestClass),

    84       NULL,

    85       NULL,

    86       (GClassInitFunc) my_test_class_init,

    87       NULL,

    88       NULL,

    89       sizeof (GTest),

    90       0,

    91       (GInstanceInitFunc) my_test_init,

    92       NULL

    93     };

    94 

    95     rand = g_rand_new();

    96 

    97     test_type = g_type_register_static (G_TYPE_OBJECT, "GTest",

    98         &test_info, 0);

    99   }

   100   return test_type;

   101 }

   102 

   103 static void

   104 my_test_class_init (GTestClass * klass)

   105 {

   106   GObjectClass *gobject_class;

   107 

   108   gobject_class = (GObjectClass *) klass;

   109 

   110   parent_class = g_type_class_ref (G_TYPE_OBJECT);

   111 

   112   if (!g_thread_supported ())

   113     g_thread_init (NULL);

   114 

   115   gobject_class->dispose = my_test_dispose;

   116   gobject_class->set_property = my_test_set_property;

   117   gobject_class->get_property = my_test_get_property;

   118 

   119   my_test_signals[TEST_SIGNAL1] =

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

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

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

   123   my_test_signals[TEST_SIGNAL2] =

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

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

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

   127 

   128   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TEST_PROP,

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

   130           0, 1, 0, G_PARAM_READWRITE));

   131 

   132   klass->test_signal2 = signal2_handler;

   133 }

   134 

   135 static void

   136 my_test_init (GTest * test)

   137 {

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

   139 

   140   test->value = 0;

   141 }

   142 

   143 static void

   144 my_test_dispose (GObject * object)

   145 {

   146   GTest *test;

   147 

   148   test = MY_TEST (object);

   149 

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

   151 

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

   153 }

   154 

   155 static void

   156 my_test_set_property (GObject * object, guint prop_id,

   157                       const GValue * value, GParamSpec * pspec)

   158 {

   159   GTest *test;

   160 

   161   test = MY_TEST (object);

   162 

   163   switch (prop_id) {

   164     case ARG_TEST_PROP:

   165       test->value = g_value_get_int (value);

   166       break;

   167     default:

   168       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   169       break;

   170   }

   171 }

   172 

   173 static void

   174 my_test_get_property (GObject * object, guint prop_id,

   175                       GValue * value, GParamSpec * pspec)

   176 {

   177   GTest *test;

   178 

   179   test = MY_TEST (object);

   180 

   181   switch (prop_id) {

   182     case ARG_TEST_PROP:

   183       g_value_set_int (value, test->value);

   184       break;

   185     default:

   186       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);

   187       break;

   188   }

   189 }

   190 

   191 static void

   192 my_test_do_signal1 (GTest * test)

   193 {

   194   g_signal_emit (G_OBJECT (test), my_test_signals[TEST_SIGNAL1], 0, 0);

   195 }

   196 

   197 static void

   198 signal2_handler (GTest * test, gint anint)

   199 {

   200 }

   201 

   202 static void

   203 my_test_do_signal2 (GTest * test)

   204 {

   205   g_signal_emit (G_OBJECT (test), my_test_signals[TEST_SIGNAL2], 0, 0);

   206 }

   207 

   208 static void

   209 my_test_do_prop (GTest * test)

   210 {

   211   test->value = g_rand_int (rand);

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

   213 }

   214 

   215 static gpointer

   216 run_thread (GTest * test)

   217 {

   218   gint i = 1;

   219 

   220   while (!stopping) {

   221     if (TESTNUM == 1)

   222       my_test_do_signal1 (test);

   223     if (TESTNUM == 2)

   224       my_test_do_signal2 (test);

   225     if (TESTNUM == 3)

   226       my_test_do_prop (test);

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

   228       g_print (".");

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

   230     }

   231   }

   232 

   233   return NULL;

   234 }

   235 

   236 static void

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

   238 {

   239   gint value;

   240 

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

   242   /*g_print ("+ %d", value);*/

   243 }

   244 

   245 int

   246 main (int argc, char **argv)

   247 {

   248   gint i;

   249   GTest *test1, *test2;

   250   GArray *test_threads;

   251   const gint n_threads = 1;

   252     #ifdef __SYMBIAN32__

   253  

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

   255   g_set_print_handler(mrtPrintHandler);

   256   #endif /*__SYMBIAN32__*/

   257 

   258   g_thread_init (NULL);

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

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

   261   g_type_init ();

   262 

   263   test1 = g_object_new (G_TYPE_TEST, NULL);

   264   test2 = g_object_new (G_TYPE_TEST, NULL);

   265 

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

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

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

   269 

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

   271 

   272   stopping = FALSE;

   273 

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

   275     GThread *thread;

   276 

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

   278     g_array_append_val (test_threads, thread);

   279 

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

   281     g_array_append_val (test_threads, thread);

   282   }

   283   g_usleep (5000000);

   284 

   285   stopping = TRUE;

   286 

   287   g_print ("\nstopping\n");

   288 

   289   /* join all threads */

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

   291     GThread *thread;

   292 

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

   294     g_thread_join (thread);

   295   }

   296 

   297   g_print ("stopped\n");

   298 #ifdef __SYMBIAN32__

   299   testResultXml("signals");

   300 #endif /* EMULATOR */

   301 

   302   return 0;

   303 }