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;
  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   g_assert (module != NULL);
 202
 203   /* Not loaded until we call ref for the first time */
 204   class = g_type_class_peek (DYNAMIC_OBJECT_TYPE);
 205   g_assert (class == NULL);
 206   g_assert (!loaded);
 207
 208   /* pause newly created threads */
 209   g_mutex_lock (&sync_mutex);
 210
 211   /* create threads */
 212   for (i = 0; i < N_THREADS; i++) {
 213     threads[i] = g_thread_new ("test", ref_unref_thread, (gpointer) DYNAMIC_OBJECT_TYPE);
 214   }
 215
 216   /* execute threads */
 217   g_mutex_unlock (&sync_mutex);
 218
 219   for (i = 0; i < N_THREADS; i++) {
 220     g_thread_join (threads[i]);
 221   }
 222 }
 223
 224 enum
 225 {
 226   PROP_0,
 227   PROP_FOO
 228 };
 229
 230 typedef struct _DynObj DynObj;
 231 typedef struct _DynObjClass DynObjClass;
 232 typedef struct _DynIfaceInterface DynIfaceInterface;
 233
 234 struct _DynObj
 235 {
 236   GObject obj;
 237
 238   gint foo;
 239 };
 240
 241 struct _DynObjClass
 242 {
 243   GObjectClass class;
 244 };
 245
 246 struct _DynIfaceInterface
 247 {
 248   GTypeInterface iface;
 249 };
 250
 251 static void dyn_obj_iface_init (DynIfaceInterface *iface);
 252
 253 G_DEFINE_INTERFACE (DynIface, dyn_iface, G_TYPE_OBJECT)
 254
 255 G_DEFINE_DYNAMIC_TYPE_EXTENDED(DynObj, dyn_obj, G_TYPE_OBJECT, 0,
 256                       G_IMPLEMENT_INTERFACE_DYNAMIC(dyn_iface_get_type (), dyn_obj_iface_init))
 257
 258
 259 static void
 260 dyn_iface_default_init (DynIfaceInterface *iface)
 261 {
 262   g_object_interface_install_property (iface,
 263     g_param_spec_int ("foo", NULL, NULL, 0, 100, 0, G_PARAM_READWRITE));
 264 }
 265
 266 static void
 267 dyn_obj_iface_init (DynIfaceInterface *iface)
 268 {
 269 }
 270
 271 static void
 272 dyn_obj_init (DynObj *obj)
 273 {
 274   obj->foo = 0;
 275 }
 276
 277 static void
 278 set_prop (GObject      *object,
 279           guint         prop_id,
 280           const GValue *value,
 281           GParamSpec   *pspec)
 282 {
 283   DynObj *obj = (DynObj *)object;
 284
 285   switch (prop_id)
 286     {
 287     case PROP_FOO:
 288       obj->foo = g_value_get_int (value);
 289       break;
 290     default:
 291       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 292       break;
 293     }
 294 }
 295
 296 static void
 297 get_prop (GObject    *object,
 298           guint       prop_id,
 299           GValue     *value,
 300           GParamSpec *pspec)
 301 {
 302   DynObj *obj = (DynObj *)object;
 303
 304   switch (prop_id)
 305     {
 306     case PROP_FOO:
 307       g_value_set_int (value, obj->foo);
 308       break;
 309     default:
 310       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 311       break;
 312     }
 313 }
 314
 315 static void
 316 dyn_obj_class_init (DynObjClass *class)
 317 {
 318   GObjectClass *object_class = G_OBJECT_CLASS (class);
 319
 320   object_class->set_property = set_prop;
 321   object_class->get_property = get_prop;
 322
 323   g_object_class_override_property (object_class, PROP_FOO, "foo");
 324 }
 325
 326 static void
 327 dyn_obj_class_finalize (DynObjClass *class)
 328 {
 329 }
 330
 331 static void
 332 mod_register (GTypeModule *module)
 333 {
 334   dyn_obj_register_type (module);
 335 }
 336
 337 static void
 338 test_dynamic_interface_properties (void)
 339 {
 340   GTypeModule *module;
 341   DynObj *obj;
 342
 343   module = test_module_new (mod_register);
 344   g_assert (module != NULL);
 345
 346   obj = g_object_new (dyn_obj_get_type (), "foo", 1, NULL);
 347
 348   g_object_unref (obj);
 349 }
 350
 351 int
 352 main (int   argc,
 353       char *argv[])
 354 {
 355   g_test_init (&argc, &argv, NULL);
 356   g_type_init ();
 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 }