paramspec-test: Fix leaks in tests
[platform/upstream/glib.git] / tests / gobject / override.c
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  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library 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.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General
17  * Public License along with this library; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21
22 #undef  G_LOG_DOMAIN
23 #define G_LOG_DOMAIN "TestOverride"
24
25 #undef G_DISABLE_ASSERT
26 #undef G_DISABLE_CHECKS
27 #undef G_DISABLE_CAST_CHECKS
28
29 #undef VERBOSE
30
31 #include <string.h>
32
33 #include <glib.h>
34 #include <glib-object.h>
35
36 #include "testcommon.h"
37
38 static guint foo_signal_id = 0;
39 static guint bar_signal_id = 0;
40 static guint baz_signal_id = 0;
41
42 static GType test_i_get_type (void);
43 static GType test_a_get_type (void);
44 static GType test_b_get_type (void);
45 static GType test_c_get_type (void);
46
47 static void  record (const gchar *str);
48
49 #define TEST_TYPE_I (test_i_get_type ())
50
51 typedef struct _TestI TestI;
52 typedef struct _TestIClass TestIClass;
53
54 struct _TestIClass
55 {
56   GTypeInterface base_iface;
57 };
58
59 static void
60 test_i_foo (TestI *self)
61 {
62   record ("TestI::foo");
63 }
64
65 static void
66 test_i_default_init (gpointer g_class)
67 {
68   foo_signal_id = g_signal_newv ("foo",
69                                  TEST_TYPE_I,
70                                  G_SIGNAL_RUN_LAST,
71                                  g_cclosure_new(G_CALLBACK(test_i_foo),
72                                                 NULL, NULL),
73                                  NULL, NULL,
74                                  g_cclosure_marshal_VOID__VOID,
75                                  G_TYPE_NONE, 0, NULL);
76 }
77
78 static DEFINE_IFACE (TestI, test_i, NULL, test_i_default_init)
79
80 #define TEST_TYPE_A (test_a_get_type())
81
82      typedef struct _TestA TestA;
83      typedef struct _TestAClass TestAClass;
84
85 struct _TestA {
86   GObject parent;
87 };
88 struct _TestAClass {
89   GObjectClass parent_class;
90
91   void (* bar) (TestA *self);
92 };
93
94 static void
95 test_a_foo (TestI *self)
96 {
97   GValue args[1] = { G_VALUE_INIT };
98
99   record ("TestA::foo");
100
101   g_value_init (&args[0], TEST_TYPE_A);
102   g_value_set_object (&args[0], self);
103
104   g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
105   g_signal_chain_from_overridden (args, NULL);
106
107   g_value_unset (&args[0]);
108 }
109
110 static void
111 test_a_bar (TestA *self)
112 {
113   record ("TestA::bar");
114 }
115
116 static gchar *
117 test_a_baz (TestA    *self,
118             GObject  *object,
119             gpointer  pointer)
120 {
121   record ("TestA::baz");
122
123   g_assert (object == G_OBJECT (self));
124   g_assert (GPOINTER_TO_INT (pointer) == 23);
125
126   return g_strdup ("TestA::baz");
127 }
128
129 static void
130 test_a_class_init (TestAClass *class)
131 {
132   class->bar = test_a_bar;
133
134   bar_signal_id = g_signal_new ("bar",
135                                 TEST_TYPE_A,
136                                 G_SIGNAL_RUN_LAST,
137                                 G_STRUCT_OFFSET (TestAClass, bar),
138                                 NULL, NULL,
139                                 g_cclosure_marshal_VOID__VOID,
140                                 G_TYPE_NONE, 0, NULL);
141
142   baz_signal_id = g_signal_new_class_handler ("baz",
143                                               TEST_TYPE_A,
144                                               G_SIGNAL_RUN_LAST,
145                                               G_CALLBACK (test_a_baz),
146                                               NULL, NULL,
147                                               g_cclosure_marshal_STRING__OBJECT_POINTER,
148                                               G_TYPE_STRING, 2,
149                                               G_TYPE_OBJECT,
150                                               G_TYPE_POINTER);
151 }
152
153 static void
154 test_a_interface_init (TestIClass *iface)
155 {
156   g_signal_override_class_closure (foo_signal_id,
157                                    TEST_TYPE_A,
158                                    g_cclosure_new (G_CALLBACK (test_a_foo),
159                                                    NULL, NULL));
160 }
161
162 static DEFINE_TYPE_FULL (TestA, test_a,
163                          test_a_class_init, NULL, NULL,
164                          G_TYPE_OBJECT,
165                          INTERFACE (test_a_interface_init, TEST_TYPE_I))
166      
167 #define TEST_TYPE_B (test_b_get_type())
168
169 typedef struct _TestB TestB;
170 typedef struct _TestBClass TestBClass;
171
172 struct _TestB {
173   TestA parent;
174 };
175 struct _TestBClass {
176   TestAClass parent_class;
177 };
178
179 static void
180 test_b_foo (TestI *self)
181 {
182   GValue args[1] = { G_VALUE_INIT };
183
184   record ("TestB::foo");
185
186   g_value_init (&args[0], TEST_TYPE_A);
187   g_value_set_object (&args[0], self);
188
189   g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
190   g_signal_chain_from_overridden (args, NULL);
191
192   g_value_unset (&args[0]);
193 }
194
195 static void
196 test_b_bar (TestA *self)
197 {
198   GValue args[1] = { G_VALUE_INIT };
199
200   record ("TestB::bar");
201
202   g_value_init (&args[0], TEST_TYPE_A);
203   g_value_set_object (&args[0], self);
204
205   g_assert (g_signal_get_invocation_hint (self)->signal_id == bar_signal_id);
206   g_signal_chain_from_overridden (args, NULL);
207
208   g_value_unset (&args[0]);
209 }
210
211 static gchar *
212 test_b_baz (TestA    *self,
213             GObject  *object,
214             gpointer  pointer)
215 {
216   gchar *retval = NULL;
217
218   record ("TestB::baz");
219
220   g_assert (object == G_OBJECT (self));
221   g_assert (GPOINTER_TO_INT (pointer) == 23);
222
223   g_signal_chain_from_overridden_handler (self, object, pointer, &retval);
224
225   if (retval)
226     {
227       gchar *tmp = g_strconcat (retval , ",TestB::baz", NULL);
228       g_free (retval);
229       retval = tmp;
230     }
231
232   return retval;
233 }
234
235 static void
236 test_b_class_init (TestBClass *class)
237 {
238   g_signal_override_class_closure (foo_signal_id,
239                                    TEST_TYPE_B,
240                                    g_cclosure_new (G_CALLBACK (test_b_foo),
241                                                    NULL, NULL));
242   g_signal_override_class_closure (bar_signal_id,
243                                    TEST_TYPE_B,
244                                    g_cclosure_new (G_CALLBACK (test_b_bar),
245                                                    NULL, NULL));
246   g_signal_override_class_handler ("baz",
247                                    TEST_TYPE_B,
248                                    G_CALLBACK (test_b_baz));
249 }
250
251 static DEFINE_TYPE (TestB, test_b,
252                     test_b_class_init, NULL, NULL,
253                     TEST_TYPE_A)
254
255 #define TEST_TYPE_C (test_c_get_type())
256
257 typedef struct _TestC TestC;
258 typedef struct _TestCClass TestCClass;
259
260 struct _TestC {
261   TestB parent;
262 };
263 struct _TestCClass {
264   TestBClass parent_class;
265 };
266
267 static void
268 test_c_foo (TestI *self)
269 {
270   GValue args[1] = { G_VALUE_INIT };
271
272   record ("TestC::foo");
273
274   g_value_init (&args[0], TEST_TYPE_A);
275   g_value_set_object (&args[0], self);
276
277   g_assert (g_signal_get_invocation_hint (self)->signal_id == foo_signal_id);
278   g_signal_chain_from_overridden (args, NULL);
279
280   g_value_unset (&args[0]);
281 }
282
283 static void
284 test_c_bar (TestA *self)
285 {
286   GValue args[1] = { G_VALUE_INIT };
287
288   record ("TestC::bar");
289
290   g_value_init (&args[0], TEST_TYPE_A);
291   g_value_set_object (&args[0], self);
292
293   g_assert (g_signal_get_invocation_hint (self)->signal_id == 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 (object == G_OBJECT (self));
309   g_assert (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 gboolean failed = FALSE;
346      
347 static void
348 record (const gchar *str)
349 {
350   if (test_string->len)
351     g_string_append_c (test_string, ',');
352   g_string_append (test_string, str);
353 }
354      
355 static void
356 test (GType        type,
357       const gchar *signal,
358       const gchar *expected,
359       const gchar *expected_retval)
360 {
361   GObject *self = g_object_new (type, NULL);
362
363   test_string = g_string_new (NULL);
364
365   if (strcmp (signal, "baz"))
366     {
367       g_signal_emit_by_name (self, signal);
368     }
369   else
370     {
371       gchar *ret;
372
373       g_signal_emit_by_name (self, signal, self, GINT_TO_POINTER (23), &ret);
374
375       if (strcmp (ret, expected_retval) != 0)
376         failed = TRUE;
377
378       g_free (ret);
379     }
380
381 #ifndef VERBOSE
382   if (strcmp (test_string->str, expected) != 0)
383 #endif
384     {
385       g_printerr ("*** emitting %s on a %s instance\n"
386                   "    Expecting: %s\n"
387                   "    Got: %s\n",
388                   signal, g_type_name (type),
389                   expected,
390                   test_string->str);
391       
392       if (strcmp (test_string->str, expected) != 0)
393         failed = TRUE;
394     }
395
396   g_string_free (test_string, TRUE);
397   g_object_unref (self);
398 }
399      
400 int
401 main (int argc, char **argv)
402 {
403   g_log_set_always_fatal (g_log_set_always_fatal (G_LOG_FATAL_MASK) |
404                           G_LOG_LEVEL_WARNING |
405                           G_LOG_LEVEL_CRITICAL);
406
407   test (TEST_TYPE_A, "foo", "TestA::foo,TestI::foo", NULL);
408   test (TEST_TYPE_A, "bar", "TestA::bar", NULL);
409   test (TEST_TYPE_A, "baz", "TestA::baz", "TestA::baz");
410
411   test (TEST_TYPE_B, "foo", "TestB::foo,TestA::foo,TestI::foo", NULL);
412   test (TEST_TYPE_B, "bar", "TestB::bar,TestA::bar", NULL);
413   test (TEST_TYPE_B, "baz", "TestB::baz,TestA::baz", "TestA::baz,TestB::baz");
414
415   test (TEST_TYPE_C, "foo", "TestC::foo,TestB::foo,TestA::foo,TestI::foo", NULL);
416   test (TEST_TYPE_C, "bar", "TestC::bar,TestB::bar,TestA::bar", NULL);
417   test (TEST_TYPE_C, "baz", "TestC::baz,TestB::baz,TestA::baz", "TestA::baz,TestB::baz,TestC::baz");
418
419   return failed ? 1 : 0;
420 }