1 /* GObject - GLib Type, Object, Parameter and Signal Library
2 * override.c: Closure override test program
3 * Copyright (C) 2001, James Henstridge
4 * Copyright (C) 2003, Red Hat, Inc.
5 *
6 * SPDX-License-Identifier: LGPL-2.1-or-later
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General
19 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include <glib.h>
23 #include <glib-object.h>
24
25 #include "testcommon.h"
26
27 static guint foo_signal_id = 0;
28 static guint bar_signal_id = 0;
29 static guint baz_signal_id = 0;
30
31 static GType test_i_get_type (void);
32 static GType test_a_get_type (void);
33 static GType test_b_get_type (void);
34 static GType test_c_get_type (void);
35
36 static void record (const gchar *str);
37
38 #define TEST_TYPE_I (test_i_get_type ())
39
40 typedef struct _TestI TestI;
41 typedef struct _TestIClass TestIClass;
42
43 struct _TestIClass
44 {
45 GTypeInterface base_iface;
46 };
47
48 static void
49 test_i_foo (TestI *self)
50 {
51 record ("TestI::foo");
52 }
53
54 static void
55 test_i_default_init (gpointer g_class)
56 {
57 foo_signal_id = g_signal_newv ("foo",
58 TEST_TYPE_I,
59 G_SIGNAL_RUN_LAST,
60 g_cclosure_new(G_CALLBACK(test_i_foo),
61 NULL, NULL),
62 NULL, NULL,
63 g_cclosure_marshal_VOID__VOID,
64 G_TYPE_NONE, 0, NULL);
65 }
66
67 static DEFINE_IFACE (TestI, test_i, NULL, test_i_default_init)
68
69 #define TEST_TYPE_A (test_a_get_type())
70
71 typedef struct _TestA TestA;
72 typedef struct _TestAClass TestAClass;
73
74 struct _TestA {
75 GObject parent;
76 };
77 struct _TestAClass {
78 GObjectClass parent_class;
79
80 void (* bar) (TestA *self);
81 };
82
83 static void
84 test_a_foo (TestI *self)
85 {
86 GValue args[1] = { G_VALUE_INIT };
87
88 record ("TestA::foo");
89
90 g_value_init (&args[0], TEST_TYPE_A);
91 g_value_set_object (&args[0], self);
92
93 g_assert_cmpint (g_signal_get_invocation_hint (self)->signal_id,
94 ==,
95 foo_signal_id);
96 g_signal_chain_from_overridden (args, NULL);
97
98 g_value_unset (&args[0]);
99 }
100
101 static void
102 test_a_bar (TestA *self)
103 {
104 record ("TestA::bar");
105 }
106
107 static gchar *
108 test_a_baz (TestA *self,
109 GObject *object,
110 gpointer pointer)
111 {
112 record ("TestA::baz");
113
114 g_assert_true (object == G_OBJECT (self));
115 g_assert_cmpint (GPOINTER_TO_INT (pointer), ==, 23);
116
117 return g_strdup ("TestA::baz");
118 }
119
120 static void
121 test_a_class_init (TestAClass *class)
122 {
123 class->bar = test_a_bar;
124
125 bar_signal_id = g_signal_new ("bar",
126 TEST_TYPE_A,
127 G_SIGNAL_RUN_LAST,
128 G_STRUCT_OFFSET (TestAClass, bar),
129 NULL, NULL,
130 g_cclosure_marshal_VOID__VOID,
131 G_TYPE_NONE, 0, NULL);
132
133 baz_signal_id =
134 g_signal_new_class_handler ("baz",
135 TEST_TYPE_A,
136 G_SIGNAL_RUN_LAST,
137 G_CALLBACK (test_a_baz),
138 NULL, NULL,
139 g_cclosure_marshal_STRING__OBJECT_POINTER,
140 G_TYPE_STRING, 2,
141 G_TYPE_OBJECT,
142 G_TYPE_POINTER);
143 }
144
145 static void
146 test_a_interface_init (TestIClass *iface)
147 {
148 g_signal_override_class_closure (foo_signal_id,
149 TEST_TYPE_A,
150 g_cclosure_new (G_CALLBACK (test_a_foo),
151 NULL, NULL));
152 }
153
154 static DEFINE_TYPE_FULL (TestA, test_a,
155 test_a_class_init, NULL, NULL,
156 G_TYPE_OBJECT,
157 INTERFACE (test_a_interface_init, TEST_TYPE_I))
158
159 #define TEST_TYPE_B (test_b_get_type())
160
161 typedef struct _TestB TestB;
162 typedef struct _TestBClass TestBClass;
163
164 struct _TestB {
165 TestA parent;
166 };
167 struct _TestBClass {
168 TestAClass parent_class;
169 };
170
171 static void
172 test_b_foo (TestI *self)
173 {
174 GValue args[1] = { G_VALUE_INIT };
175
176 record ("TestB::foo");
177
178 g_value_init (&args[0], TEST_TYPE_A);
179 g_value_set_object (&args[0], self);
180
181 g_assert_cmpint (g_signal_get_invocation_hint (self)->signal_id,
182 ==,
183 foo_signal_id);
184 g_signal_chain_from_overridden (args, NULL);
185
186 g_value_unset (&args[0]);
187 }
188
189 static void
190 test_b_bar (TestA *self)
191 {
192 GValue args[1] = { G_VALUE_INIT };
193
194 record ("TestB::bar");
195
196 g_value_init (&args[0], TEST_TYPE_A);
197 g_value_set_object (&args[0], self);
198
199 g_assert_cmpint (g_signal_get_invocation_hint (self)->signal_id,
200 ==,
201 bar_signal_id);
202 g_signal_chain_from_overridden (args, NULL);
203
204 g_value_unset (&args[0]);
205 }
206
207 static gchar *
208 test_b_baz (TestA *self,
209 GObject *object,
210 gpointer pointer)
211 {
212 gchar *retval = NULL;
213
214 record ("TestB::baz");
215
216 g_assert_true (object == G_OBJECT (self));
217 g_assert_cmpint (GPOINTER_TO_INT (pointer), ==, 23);
218
219 g_signal_chain_from_overridden_handler (self, object, pointer, &retval);
220
221 if (retval)
222 {
223 gchar *tmp = g_strconcat (retval , ",TestB::baz", NULL);
224 g_free (retval);
225 retval = tmp;
226 }
227
228 return retval;
229 }
230
231 static void
232 test_b_class_init (TestBClass *class)
233 {
234 g_signal_override_class_closure (foo_signal_id,
235 TEST_TYPE_B,
236 g_cclosure_new (G_CALLBACK (test_b_foo),
237 NULL, NULL));
238 g_signal_override_class_closure (bar_signal_id,
239 TEST_TYPE_B,
240 g_cclosure_new (G_CALLBACK (test_b_bar),
241 NULL, NULL));
242 g_signal_override_class_handler ("baz",
243 TEST_TYPE_B,
244 G_CALLBACK (test_b_baz));
245 }
246
247 static DEFINE_TYPE (TestB, test_b,
248 test_b_class_init, NULL, NULL,
249 TEST_TYPE_A)
250
251 #define TEST_TYPE_C (test_c_get_type())
252
253 typedef struct _TestC TestC;
254 typedef struct _TestCClass TestCClass;
255
256 struct _TestC {
257 TestB parent;
258 };
259 struct _TestCClass {
260 TestBClass parent_class;
261 };
262
263 static void
264 test_c_foo (TestI *self)
265 {
266 GValue args[1] = { G_VALUE_INIT };
267
268 record ("TestC::foo");
269
270 g_value_init (&args[0], TEST_TYPE_A);
271 g_value_set_object (&args[0], self);
272
273 g_assert_cmpint (g_signal_get_invocation_hint (self)->signal_id,
274 ==,
275 foo_signal_id);
276 g_signal_chain_from_overridden (args, NULL);
277
278 g_value_unset (&args[0]);
279 }
280
281 static void
282 test_c_bar (TestA *self)
283 {
284 GValue args[1] = { G_VALUE_INIT };
285
286 record ("TestC::bar");
287
288 g_value_init (&args[0], TEST_TYPE_A);
289 g_value_set_object (&args[0], self);
290
291 g_assert_cmpint (g_signal_get_invocation_hint (self)->signal_id,
292 ==,
293 bar_signal_id);
294 g_signal_chain_from_overridden (args, NULL);
295
296 g_value_unset (&args[0]);
297 }
298
299 static gchar *
300 test_c_baz (TestA *self,
301 GObject *object,
302 gpointer pointer)
303 {
304 gchar *retval = NULL;
305
306 record ("TestC::baz");
307
308 g_assert_true (object == G_OBJECT (self));
309 g_assert_cmpint (GPOINTER_TO_INT (pointer), ==, 23);
310
311 g_signal_chain_from_overridden_handler (self, object, pointer, &retval);
312
313 if (retval)
314 {
315 gchar *tmp = g_strconcat (retval , ",TestC::baz", NULL);
316 g_free (retval);
317 retval = tmp;
318 }
319
320 return retval;
321 }
322
323 static void
324 test_c_class_init (TestBClass *class)
325 {
326 g_signal_override_class_closure (foo_signal_id,
327 TEST_TYPE_C,
328 g_cclosure_new (G_CALLBACK (test_c_foo),
329 NULL, NULL));
330 g_signal_override_class_closure (bar_signal_id,
331 TEST_TYPE_C,
332 g_cclosure_new (G_CALLBACK (test_c_bar),
333 NULL, NULL));
334 g_signal_override_class_handler ("baz",
335 TEST_TYPE_C,
336 G_CALLBACK (test_c_baz));
337 }
338
339
340 static DEFINE_TYPE (TestC, test_c,
341 test_c_class_init, NULL, NULL,
342 TEST_TYPE_B)
343
344 static GString *test_string = NULL;
345
346 static void
347 record (const gchar *str)
348 {
349 if (test_string->len)
350 g_string_append_c (test_string, ',');
351 g_string_append (test_string, str);
352 }
353
354 static void
355 test (GType type,
356 const gchar *signal,
357 const gchar *expected,
358 const gchar *expected_retval)
359 {
360 GObject *self = g_object_new (type, NULL);
361
362 test_string = g_string_new (NULL);
363
364 if (strcmp (signal, "baz"))
365 {
366 g_signal_emit_by_name (self, signal);
367 }
368 else
369 {
370 gchar *ret;
371
372 g_signal_emit_by_name (self, signal, self, GINT_TO_POINTER (23), &ret);
373 g_assert_cmpstr (ret, ==, expected_retval);
374
375 g_free (ret);
376 }
377
378 g_test_message ("*** emitting %s on a %s instance\n"
379 " Expecting: %s\n"
380 " Got: %s",
381 signal, g_type_name (type),
382 expected,
383 test_string->str);
384
385 g_assert_cmpstr (test_string->str, ==, expected);
386
387 g_string_free (test_string, TRUE);
388 g_object_unref (self);
389 }
390
391 static void
392 test_override (void)
393 {
394 test (TEST_TYPE_A, "foo", "TestA::foo,TestI::foo", NULL);
395 test (TEST_TYPE_A, "bar", "TestA::bar", NULL);
396 test (TEST_TYPE_A, "baz", "TestA::baz", "TestA::baz");
397
398 test (TEST_TYPE_B, "foo", "TestB::foo,TestA::foo,TestI::foo", NULL);
399 test (TEST_TYPE_B, "bar", "TestB::bar,TestA::bar", NULL);
400 test (TEST_TYPE_B, "baz", "TestB::baz,TestA::baz", "TestA::baz,TestB::baz");
401
402 test (TEST_TYPE_C, "foo", "TestC::foo,TestB::foo,TestA::foo,TestI::foo", NULL);
403 test (TEST_TYPE_C, "bar", "TestC::bar,TestB::bar,TestA::bar", NULL);
404 test (TEST_TYPE_C, "baz", "TestC::baz,TestB::baz,TestA::baz", "TestA::baz,TestB::baz,TestC::baz");
405 }
406
407 int
408 main (int argc,
409 char **argv)
410 {
411 g_log_set_always_fatal (g_log_set_always_fatal (G_LOG_FATAL_MASK) |
412 G_LOG_LEVEL_WARNING |
413 G_LOG_LEVEL_CRITICAL);
414
415 g_test_init (&argc, &argv, NULL);
416
417 g_test_add_func ("/gobject/override", test_override);
418
419 return g_test_run ();
420 }