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