tests/refcount/signals.c

   1 #include <unistd.h>
   2 #include <glib.h>
   3 #include <glib-object.h>
   4
   5 #define G_TYPE_TEST                (my_test_get_type ())
   6 #define MY_TEST(test)              (G_TYPE_CHECK_INSTANCE_CAST ((test), G_TYPE_TEST, GTest))
   7 #define MY_IS_TEST(test)           (G_TYPE_CHECK_INSTANCE_TYPE ((test), G_TYPE_TEST))
   8 #define MY_TEST_CLASS(tclass)      (G_TYPE_CHECK_CLASS_CAST ((tclass), G_TYPE_TEST, GTestClass))
   9 #define MY_IS_TEST_CLASS(tclass)   (G_TYPE_CHECK_CLASS_TYPE ((tclass), G_TYPE_TEST))
  10 #define MY_TEST_GET_CLASS(test)    (G_TYPE_INSTANCE_GET_CLASS ((test), G_TYPE_TEST, GTestClass))
  11
  12 static GRand *rand;
  13
  14 typedef struct _GTest GTest;
  15 typedef struct _GTestClass GTestClass;
  16
  17 struct _GTest
  18 {
  19   GObject object;
  20
  21   gint value;
  22 };
  23
  24 struct _GTestClass
  25 {
  26   GObjectClass parent_class;
  27
  28   void (*test_signal1) (GTest * test, gint an_int);
  29   void (*test_signal2) (GTest * test, gint an_int);
  30 };
  31
  32 static GType my_test_get_type (void);
  33 static volatile gboolean stopping;
  34
  35 /* Element signals and args */
  36 enum
  37 {
  38   TEST_SIGNAL1,
  39   TEST_SIGNAL2,
  40   /* add more above */
  41   LAST_SIGNAL
  42 };
  43
  44 enum
  45 {
  46   ARG_0,
  47   ARG_TEST_PROP
  48 };
  49
  50 static void my_test_class_init (GTestClass * klass);
  51 static void my_test_init (GTest * test);
  52 static void my_test_dispose (GObject * object);
  53
  54 static void signal2_handler (GTest * test, gint anint);
  55
  56 static void my_test_set_property (GObject * object, guint prop_id,
  57     const GValue * value, GParamSpec * pspec);
  58 static void my_test_get_property (GObject * object, guint prop_id,
  59     GValue * value, GParamSpec * pspec);
  60
  61 static GObjectClass *parent_class = NULL;
  62
  63 static guint my_test_signals[LAST_SIGNAL] = { 0 };
  64
  65 static GType
  66 my_test_get_type (void)
  67 {
  68   static GType test_type = 0;
  69
  70   if (!test_type) {
  71     const GTypeInfo test_info = {
  72       sizeof (GTestClass),
  73       NULL,
  74       NULL,
  75       (GClassInitFunc) my_test_class_init,
  76       NULL,
  77       NULL,
  78       sizeof (GTest),
  79       0,
  80       (GInstanceInitFunc) my_test_init,
  81       NULL
  82     };
  83
  84     rand = g_rand_new();
  85
  86     test_type = g_type_register_static (G_TYPE_OBJECT, "GTest",
  87         &test_info, 0);
  88   }
  89   return test_type;
  90 }
  91
  92 static void
  93 my_test_class_init (GTestClass * klass)
  94 {
  95   GObjectClass *gobject_class;
  96
  97   gobject_class = (GObjectClass *) klass;
  98
  99   parent_class = g_type_class_ref (G_TYPE_OBJECT);
 100
 101   gobject_class->dispose = my_test_dispose;
 102   gobject_class->set_property = my_test_set_property;
 103   gobject_class->get_property = my_test_get_property;
 104
 105   my_test_signals[TEST_SIGNAL1] =
 106       g_signal_new ("test-signal1", G_TYPE_FROM_CLASS (klass),
 107       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GTestClass, test_signal1), NULL,
 108       NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
 109   my_test_signals[TEST_SIGNAL2] =
 110       g_signal_new ("test-signal2", G_TYPE_FROM_CLASS (klass),
 111       G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GTestClass, test_signal2), NULL,
 112       NULL, g_cclosure_marshal_VOID__INT, G_TYPE_NONE, 1, G_TYPE_INT);
 113
 114   g_object_class_install_property (G_OBJECT_CLASS (klass), ARG_TEST_PROP,
 115       g_param_spec_int ("test-prop", "Test Prop", "Test property",
 116           0, 1, 0, G_PARAM_READWRITE));
 117
 118   klass->test_signal2 = signal2_handler;
 119 }
 120
 121 static void
 122 my_test_init (GTest * test)
 123 {
 124   g_print ("init %p\n", test);
 125
 126   test->value = 0;
 127 }
 128
 129 static void
 130 my_test_dispose (GObject * object)
 131 {
 132   GTest *test;
 133
 134   test = MY_TEST (object);
 135
 136   g_print ("dispose %p!\n", test);
 137
 138   G_OBJECT_CLASS (parent_class)->dispose (object);
 139 }
 140
 141 static void
 142 my_test_set_property (GObject * object, guint prop_id,
 143                       const GValue * value, GParamSpec * pspec)
 144 {
 145   GTest *test;
 146
 147   test = MY_TEST (object);
 148
 149   switch (prop_id) {
 150     case ARG_TEST_PROP:
 151       test->value = g_value_get_int (value);
 152       break;
 153     default:
 154       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 155       break;
 156   }
 157 }
 158
 159 static void
 160 my_test_get_property (GObject * object, guint prop_id,
 161                       GValue * value, GParamSpec * pspec)
 162 {
 163   GTest *test;
 164
 165   test = MY_TEST (object);
 166
 167   switch (prop_id) {
 168     case ARG_TEST_PROP:
 169       g_value_set_int (value, test->value);
 170       break;
 171     default:
 172       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 173       break;
 174   }
 175 }
 176
 177 static void
 178 my_test_do_signal1 (GTest * test)
 179 {
 180   g_signal_emit (G_OBJECT (test), my_test_signals[TEST_SIGNAL1], 0, 0);
 181 }
 182
 183 static void
 184 signal2_handler (GTest * test, gint anint)
 185 {
 186 }
 187
 188 static void
 189 my_test_do_signal2 (GTest * test)
 190 {
 191   g_signal_emit (G_OBJECT (test), my_test_signals[TEST_SIGNAL2], 0, 0);
 192 }
 193
 194 static void
 195 my_test_do_prop (GTest * test)
 196 {
 197   test->value = g_rand_int (rand);
 198   g_object_notify (G_OBJECT (test), "test-prop");
 199 }
 200
 201 static gpointer
 202 run_thread (GTest * test)
 203 {
 204   gint i = 1;
 205
 206   while (!stopping) {
 207     if (TESTNUM == 1)
 208       my_test_do_signal1 (test);
 209     if (TESTNUM == 2)
 210       my_test_do_signal2 (test);
 211     if (TESTNUM == 3)
 212       my_test_do_prop (test);
 213     if ((i++ % 10000) == 0) {
 214       g_print (".");
 215       g_thread_yield(); /* force context switch */
 216     }
 217   }
 218
 219   return NULL;
 220 }
 221
 222 static void
 223 notify (GObject *object, GParamSpec *spec, gpointer user_data)
 224 {
 225   gint value;
 226
 227   g_object_get (object, "test-prop", &value, NULL);
 228   /*g_print ("+ %d", value);*/
 229 }
 230
 231 int
 232 main (int argc, char **argv)
 233 {
 234   gint i;
 235   GTest *test1, *test2;
 236   GArray *test_threads;
 237   const gint n_threads = 1;
 238
 239   g_print ("START: %s\n", argv[0]);
 240   g_log_set_always_fatal (G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | g_log_set_always_fatal (G_LOG_FATAL_MASK));
 241   g_type_init ();
 242
 243   test1 = g_object_new (G_TYPE_TEST, NULL);
 244   test2 = g_object_new (G_TYPE_TEST, NULL);
 245
 246   g_signal_connect (test1, "notify::test-prop", G_CALLBACK (notify), NULL);
 247   g_signal_connect (test1, "test-signal1", G_CALLBACK (notify), NULL);
 248   g_signal_connect (test1, "test-signal2", G_CALLBACK (notify), NULL);
 249
 250   test_threads = g_array_new (FALSE, FALSE, sizeof (GThread *));
 251
 252   stopping = FALSE;
 253
 254   for (i = 0; i < n_threads; i++) {
 255     GThread *thread;
 256
 257     thread = g_thread_create ((GThreadFunc) run_thread, test1, TRUE, NULL);
 258     g_array_append_val (test_threads, thread);
 259
 260     thread = g_thread_create ((GThreadFunc) run_thread, test2, TRUE, NULL);
 261     g_array_append_val (test_threads, thread);
 262   }
 263   g_usleep (5000000);
 264
 265   stopping = TRUE;
 266
 267   g_print ("\nstopping\n");
 268
 269   /* join all threads */
 270   for (i = 0; i < 2 * n_threads; i++) {
 271     GThread *thread;
 272
 273     thread = g_array_index (test_threads, GThread *, i);
 274     g_thread_join (thread);
 275   }
 276
 277   g_print ("stopped\n");
 278
 279   return 0;
 280 }