gobject/tests/dynamictests.c

   1 /* GLib testing framework examples and tests
   2  * Copyright (C) 2008 Imendio AB
   3  * Authors: Tim Janik
   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 #include <glib.h>
  23 #include <glib-object.h>
  24
  25 /* This test tests the macros for defining dynamic types.
  26  */
  27
  28 static GMutex *sync_mutex = NULL;
  29 static gboolean loaded = FALSE;
  30
  31 /* MODULE */
  32 typedef struct _TestModule      TestModule;
  33 typedef struct _TestModuleClass TestModuleClass;
  34
  35 #define TEST_TYPE_MODULE              (test_module_get_type ())
  36 #define TEST_MODULE(module)           (G_TYPE_CHECK_INSTANCE_CAST ((module), TEST_TYPE_MODULE, TestModule))
  37 #define TEST_MODULE_CLASS(class)      (G_TYPE_CHECK_CLASS_CAST ((class), TEST_TYPE_MODULE, TestModuleClass))
  38 #define TEST_IS_MODULE(module)        (G_TYPE_CHECK_INSTANCE_TYPE ((module), TEST_TYPE_MODULE))
  39 #define TEST_IS_MODULE_CLASS(class)   (G_TYPE_CHECK_CLASS_TYPE ((class), TEST_TYPE_MODULE))
  40 #define TEST_MODULE_GET_CLASS(module) (G_TYPE_INSTANCE_GET_CLASS ((module), TEST_TYPE_MODULE, TestModuleClass))
  41 typedef void (*TestModuleRegisterFunc) (GTypeModule *module);
  42
  43 struct _TestModule
  44 {
  45   GTypeModule parent_instance;
  46
  47   TestModuleRegisterFunc register_func;
  48 };
  49
  50 struct _TestModuleClass
  51 {
  52   GTypeModuleClass parent_class;
  53 };
  54
  55 static GType test_module_get_type (void);
  56
  57 static gboolean
  58 test_module_load (GTypeModule *module)
  59 {
  60   TestModule *test_module = TEST_MODULE (module);
  61
  62   test_module->register_func (module);
  63
  64   return TRUE;
  65 }
  66
  67 static void
  68 test_module_unload (GTypeModule *module)
  69 {
  70 }
  71
  72 static void
  73 test_module_class_init (TestModuleClass *class)
  74 {
  75   GTypeModuleClass *module_class = G_TYPE_MODULE_CLASS (class);
  76
  77   module_class->load = test_module_load;
  78   module_class->unload = test_module_unload;
  79 }
  80
  81 static GType test_module_get_type (void)
  82 {
  83   static GType object_type = 0;
  84
  85   if (!object_type) {
  86     static const GTypeInfo object_info =
  87       {
  88         sizeof (TestModuleClass),
  89         (GBaseInitFunc) NULL,
  90         (GBaseFinalizeFunc) NULL,
  91         (GClassInitFunc) test_module_class_init,
  92         (GClassFinalizeFunc) NULL,
  93         NULL,
  94         sizeof (TestModule),
  95         0,
  96         (GInstanceInitFunc)NULL
  97       };
  98     object_type = g_type_register_static (G_TYPE_TYPE_MODULE, "TestModule", &object_info, 0);
  99   }
 100   return object_type;
 101 }
 102
 103
 104 GTypeModule *
 105 test_module_new (TestModuleRegisterFunc register_func)
 106 {
 107   TestModule *test_module = g_object_new (TEST_TYPE_MODULE, NULL);
 108   GTypeModule *module = G_TYPE_MODULE (test_module);
 109
 110   test_module->register_func = register_func;
 111
 112   /* Register the types initially */
 113   g_type_module_use (module);
 114   g_type_module_unuse (module);
 115
 116   return G_TYPE_MODULE (module);
 117 }
 118
 119
 120
 121 #define DYNAMIC_OBJECT_TYPE (dynamic_object_get_type ())
 122
 123 typedef GObject DynamicObject;
 124 typedef struct _DynamicObjectClass DynamicObjectClass;
 125
 126 struct _DynamicObjectClass
 127 {
 128   GObjectClass parent_class;
 129   guint val;
 130 };
 131
 132 G_DEFINE_DYNAMIC_TYPE(DynamicObject, dynamic_object, G_TYPE_OBJECT);
 133
 134 static void
 135 dynamic_object_class_init (DynamicObjectClass *class)
 136 {
 137   class->val = 42;
 138   g_assert (loaded == FALSE);
 139   loaded = TRUE;
 140 }
 141
 142 static void
 143 dynamic_object_class_finalize (DynamicObjectClass *class)
 144 {
 145   g_assert (loaded == TRUE);
 146   loaded = FALSE;
 147 }
 148
 149 static void
 150 dynamic_object_init (DynamicObject *dynamic_object)
 151 {
 152 }
 153
 154
 155 static void
 156 module_register (GTypeModule *module)
 157 {
 158   dynamic_object_register_type (module);
 159 }
 160
 161 #define N_THREADS 100
 162 #define N_REFS 10000
 163
 164 static gpointer
 165 ref_unref_thread (gpointer data)
 166 {
 167   gint i;
 168   /* first, syncronize with other threads,
 169    */
 170   if (g_test_verbose())
 171     g_print ("WAITING!\n");
 172   g_mutex_lock (sync_mutex);
 173   g_mutex_unlock (sync_mutex);
 174   if (g_test_verbose ())
 175     g_print ("STARTING\n");
 176
 177   /* ref/unref the klass 10000000 times */
 178   for (i = N_REFS; i; i--) {
 179     if (g_test_verbose ())
 180       if (i % 10)
 181         g_print ("%d\n", i);
 182     g_type_class_unref (g_type_class_ref ((GType) data));
 183   }
 184
 185   if (g_test_verbose())
 186     g_print ("DONE !\n");
 187
 188   return NULL;
 189 }
 190
 191 static void
 192 test_multithreaded_dynamic_type_init (void)
 193 {
 194   GTypeModule *module;
 195   DynamicObjectClass *class;
 196   /* Create N_THREADS threads that are going to just ref/unref a class */
 197   GThread *threads[N_THREADS];
 198   guint i;
 199
 200   module = test_module_new (module_register);
 201   /* Not loaded until we call ref for the first time */
 202   class = g_type_class_peek (DYNAMIC_OBJECT_TYPE);
 203   g_assert (class == NULL);
 204   g_assert (!loaded);
 205
 206   /* pause newly created threads */
 207   g_mutex_lock (sync_mutex);
 208
 209   /* create threads */
 210   for (i = 0; i < N_THREADS; i++) {
 211     threads[i] = g_thread_create (ref_unref_thread, (gpointer) DYNAMIC_OBJECT_TYPE, TRUE, NULL);
 212   }
 213
 214   /* execute threads */
 215   g_mutex_unlock (sync_mutex);
 216
 217   for (i = 0; i < N_THREADS; i++) {
 218     g_thread_join (threads[i]);
 219   }
 220 }
 221
 222 enum
 223 {
 224   PROP_0,
 225   PROP_FOO
 226 };
 227
 228 typedef struct _DynObj DynObj;
 229 typedef struct _DynObjClass DynObjClass;
 230 typedef struct _DynIfaceInterface DynIfaceInterface;
 231
 232 struct _DynObj
 233 {
 234   GObject obj;
 235
 236   gint foo;
 237 };
 238
 239 struct _DynObjClass
 240 {
 241   GObjectClass class;
 242 };
 243
 244 struct _DynIfaceInterface
 245 {
 246   GTypeInterface iface;
 247 };
 248
 249 static void dyn_obj_iface_init (DynIfaceInterface *iface);
 250
 251 G_DEFINE_INTERFACE (DynIface, dyn_iface, G_TYPE_OBJECT)
 252
 253 G_DEFINE_DYNAMIC_TYPE_EXTENDED(DynObj, dyn_obj, G_TYPE_OBJECT, 0,
 254                       G_IMPLEMENT_INTERFACE_DYNAMIC(dyn_iface_get_type (), dyn_obj_iface_init))
 255
 256
 257 static void
 258 dyn_iface_default_init (DynIfaceInterface *iface)
 259 {
 260   g_object_interface_install_property (iface,
 261     g_param_spec_int ("foo", NULL, NULL, 0, 100, 0, G_PARAM_READWRITE));
 262 }
 263
 264 static void
 265 dyn_obj_iface_init (DynIfaceInterface *iface)
 266 {
 267 }
 268
 269 static void
 270 dyn_obj_init (DynObj *obj)
 271 {
 272   obj->foo = 0;
 273 }
 274
 275 static void
 276 set_prop (GObject      *object,
 277           guint         prop_id,
 278           const GValue *value,
 279           GParamSpec   *pspec)
 280 {
 281   DynObj *obj = (DynObj *)object;
 282
 283   switch (prop_id)
 284     {
 285     case PROP_FOO:
 286       obj->foo = g_value_get_int (value);
 287       break;
 288     default:
 289       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 290       break;
 291     }
 292 }
 293
 294 static void
 295 get_prop (GObject    *object,
 296           guint       prop_id,
 297           GValue     *value,
 298           GParamSpec *pspec)
 299 {
 300   DynObj *obj = (DynObj *)object;
 301
 302   switch (prop_id)
 303     {
 304     case PROP_FOO:
 305       g_value_set_int (value, obj->foo);
 306       break;
 307     default:
 308       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 309       break;
 310     }
 311 }
 312
 313 static void
 314 dyn_obj_class_init (DynObjClass *class)
 315 {
 316   GObjectClass *object_class = G_OBJECT_CLASS (class);
 317
 318   object_class->set_property = set_prop;
 319   object_class->get_property = get_prop;
 320
 321   g_object_class_override_property (object_class, PROP_FOO, "foo");
 322 }
 323
 324 static void
 325 dyn_obj_class_finalize (DynObjClass *class)
 326 {
 327 }
 328
 329 static void
 330 mod_register (GTypeModule *module)
 331 {
 332   dyn_obj_register_type (module);
 333 }
 334
 335 static void
 336 test_dynamic_interface_properties (void)
 337 {
 338   GTypeModule *module;
 339   DynObj *obj;
 340
 341   module = test_module_new (mod_register);
 342
 343   obj = g_object_new (dyn_obj_get_type (), "foo", 1, NULL);
 344
 345   g_object_unref (obj);
 346 }
 347
 348 int
 349 main (int   argc,
 350       char *argv[])
 351 {
 352   g_thread_init (NULL);
 353   g_test_init (&argc, &argv, NULL);
 354   g_type_init ();
 355
 356   sync_mutex = g_mutex_new();
 357
 358   g_test_add_func ("/GObject/threaded-dynamic-ref-unref-init", test_multithreaded_dynamic_type_init);
 359   g_test_add_func ("/GObject/dynamic-interface-properties", test_dynamic_interface_properties);
 360
 361   return g_test_run();
 362 }