1 /* GObject - GLib Type, Object, Parameter and Signal Library
2 * Copyright (C) 2001, 2003 Red Hat, Inc.
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library 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. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General
15 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 */
17
18 #undef G_LOG_DOMAIN
19 #define G_LOG_DOMAIN "TestAccumulator"
20
21 #undef G_DISABLE_ASSERT
22 #undef G_DISABLE_CHECKS
23 #undef G_DISABLE_CAST_CHECKS
24
25 #include <string.h>
26
27 #include <glib-object.h>
28
29 #include "testmarshal.h"
30 #include "testcommon.h"
31
32 /* What this test tests is the behavior of signal accumulators
33 * Two accumulators are tested:
34 *
35 * 1: A custom accumulator that appends the returned strings
36 * 2: The standard g_signal_accumulator_true_handled that stops
37 * emission on TRUE returns.
38 */
39
40 /*
41 * TestObject, a parent class for TestObject
42 */
43 #define TEST_TYPE_OBJECT (test_object_get_type ())
44 typedef struct _TestObject TestObject;
45 typedef struct _TestObjectClass TestObjectClass;
46
47 struct _TestObject
48 {
49 GObject parent_instance;
50 };
51 struct _TestObjectClass
52 {
53 GObjectClass parent_class;
54
55 gchar* (*test_signal1) (TestObject *tobject,
56 gint param);
57 gboolean (*test_signal2) (TestObject *tobject,
58 gint param);
59 GVariant* (*test_signal3) (TestObject *tobject,
60 gboolean *weak_ptr);
61 };
62
63 static GType test_object_get_type (void);
64
65 static gboolean
test_signal1_accumulator(GSignalInvocationHint * ihint,GValue * return_accu,const GValue * handler_return,gpointer data)66 test_signal1_accumulator (GSignalInvocationHint *ihint,
67 GValue *return_accu,
68 const GValue *handler_return,
69 gpointer data)
70 {
71 const gchar *accu_string = g_value_get_string (return_accu);
72 const gchar *new_string = g_value_get_string (handler_return);
73 gchar *result_string;
74
75 if (accu_string)
76 result_string = g_strconcat (accu_string, new_string, NULL);
77 else if (new_string)
78 result_string = g_strdup (new_string);
79 else
80 result_string = NULL;
81
82 g_value_set_string_take_ownership (return_accu, result_string);
83
84 return TRUE;
85 }
86
87 static gchar *
test_object_signal1_callback_before(TestObject * tobject,gint param,gpointer data)88 test_object_signal1_callback_before (TestObject *tobject,
89 gint param,
90 gpointer data)
91 {
92 return g_strdup ("<before>");
93 }
94
95 static gchar *
test_object_real_signal1(TestObject * tobject,gint param)96 test_object_real_signal1 (TestObject *tobject,
97 gint param)
98 {
99 return g_strdup ("<default>");
100 }
101
102 static gchar *
test_object_signal1_callback_after(TestObject * tobject,gint param,gpointer data)103 test_object_signal1_callback_after (TestObject *tobject,
104 gint param,
105 gpointer data)
106 {
107 return g_strdup ("<after>");
108 }
109
110 static gboolean
test_object_signal2_callback_before(TestObject * tobject,gint param)111 test_object_signal2_callback_before (TestObject *tobject,
112 gint param)
113 {
114 switch (param)
115 {
116 case 1: return TRUE;
117 case 2: return FALSE;
118 case 3: return FALSE;
119 case 4: return FALSE;
120 }
121
122 g_assert_not_reached ();
123 return FALSE;
124 }
125
126 static gboolean
test_object_real_signal2(TestObject * tobject,gint param)127 test_object_real_signal2 (TestObject *tobject,
128 gint param)
129 {
130 switch (param)
131 {
132 case 1: g_assert_not_reached (); return FALSE;
133 case 2: return TRUE;
134 case 3: return FALSE;
135 case 4: return FALSE;
136 }
137
138 g_assert_not_reached ();
139 return FALSE;
140 }
141
142 static gboolean
test_object_signal2_callback_after(TestObject * tobject,gint param)143 test_object_signal2_callback_after (TestObject *tobject,
144 gint param)
145 {
146 switch (param)
147 {
148 case 1: g_assert_not_reached (); return FALSE;
149 case 2: g_assert_not_reached (); return FALSE;
150 case 3: return TRUE;
151 case 4: return FALSE;
152 }
153
154 g_assert_not_reached ();
155 return FALSE;
156 }
157
158 static gboolean
test_signal3_accumulator(GSignalInvocationHint * ihint,GValue * return_accu,const GValue * handler_return,gpointer data)159 test_signal3_accumulator (GSignalInvocationHint *ihint,
160 GValue *return_accu,
161 const GValue *handler_return,
162 gpointer data)
163 {
164 GVariant *variant;
165
166 variant = g_value_get_variant (handler_return);
167 g_assert (!g_variant_is_floating (variant));
168
169 g_value_set_variant (return_accu, variant);
170
171 return variant == NULL;
172 }
173
174 /* To be notified when the variant is finalised, we construct
175 * it from data with a custom GDestroyNotify.
176 */
177
178 typedef struct {
179 char *mem;
180 gsize n;
181 gboolean *weak_ptr;
182 } VariantData;
183
184 static void
free_data(VariantData * data)185 free_data (VariantData *data)
186 {
187 *(data->weak_ptr) = TRUE;
188 g_free (data->mem);
189 g_slice_free (VariantData, data);
190 }
191
192 static GVariant *
test_object_real_signal3(TestObject * tobject,gboolean * weak_ptr)193 test_object_real_signal3 (TestObject *tobject,
194 gboolean *weak_ptr)
195 {
196 GVariant *variant;
197 VariantData *data;
198
199 variant = g_variant_ref_sink (g_variant_new_uint32 (42));
200 data = g_slice_new (VariantData);
201 data->weak_ptr = weak_ptr;
202 data->n = g_variant_get_size (variant);
203 data->mem = g_malloc (data->n);
204 g_variant_store (variant, data->mem);
205 g_variant_unref (variant);
206
207 variant = g_variant_new_from_data (G_VARIANT_TYPE ("u"),
208 data->mem,
209 data->n,
210 TRUE,
211 (GDestroyNotify) free_data,
212 data);
213 return g_variant_ref_sink (variant);
214 }
215
216 static void
test_object_class_init(TestObjectClass * class)217 test_object_class_init (TestObjectClass *class)
218 {
219 class->test_signal1 = test_object_real_signal1;
220 class->test_signal2 = test_object_real_signal2;
221 class->test_signal3 = test_object_real_signal3;
222
223 g_signal_new ("test-signal1",
224 G_OBJECT_CLASS_TYPE (class),
225 G_SIGNAL_RUN_LAST,
226 G_STRUCT_OFFSET (TestObjectClass, test_signal1),
227 test_signal1_accumulator, NULL,
228 test_marshal_STRING__INT,
229 G_TYPE_STRING, 1, G_TYPE_INT);
230 g_signal_new ("test-signal2",
231 G_OBJECT_CLASS_TYPE (class),
232 G_SIGNAL_RUN_LAST,
233 G_STRUCT_OFFSET (TestObjectClass, test_signal2),
234 g_signal_accumulator_true_handled, NULL,
235 test_marshal_BOOLEAN__INT,
236 G_TYPE_BOOLEAN, 1, G_TYPE_INT);
237 g_signal_new ("test-signal3",
238 G_OBJECT_CLASS_TYPE (class),
239 G_SIGNAL_RUN_LAST,
240 G_STRUCT_OFFSET (TestObjectClass, test_signal3),
241 test_signal3_accumulator, NULL,
242 test_marshal_VARIANT__POINTER,
243 G_TYPE_VARIANT, 1, G_TYPE_POINTER);
244 }
245
DEFINE_TYPE(TestObject,test_object,test_object_class_init,NULL,NULL,G_TYPE_OBJECT)246 static DEFINE_TYPE(TestObject, test_object,
247 test_object_class_init, NULL, NULL,
248 G_TYPE_OBJECT)
249
250 int
251 main (int argc,
252 char *argv[])
253 {
254 TestObject *object;
255 gchar *string_result;
256 gboolean bool_result;
257 gboolean variant_finalised;
258 GVariant *variant_result;
259
260 g_log_set_always_fatal (g_log_set_always_fatal (G_LOG_FATAL_MASK) |
261 G_LOG_LEVEL_WARNING |
262 G_LOG_LEVEL_CRITICAL);
263
264 object = g_object_new (TEST_TYPE_OBJECT, NULL);
265
266 g_signal_connect (object, "test-signal1",
267 G_CALLBACK (test_object_signal1_callback_before), NULL);
268 g_signal_connect_after (object, "test-signal1",
269 G_CALLBACK (test_object_signal1_callback_after), NULL);
270
271 g_signal_emit_by_name (object, "test-signal1", 0, &string_result);
272 g_assert (strcmp (string_result, "<before><default><after>") == 0);
273 g_free (string_result);
274
275 g_signal_connect (object, "test-signal2",
276 G_CALLBACK (test_object_signal2_callback_before), NULL);
277 g_signal_connect_after (object, "test-signal2",
278 G_CALLBACK (test_object_signal2_callback_after), NULL);
279
280 bool_result = FALSE;
281 g_signal_emit_by_name (object, "test-signal2", 1, &bool_result);
282 g_assert (bool_result == TRUE);
283 bool_result = FALSE;
284 g_signal_emit_by_name (object, "test-signal2", 2, &bool_result);
285 g_assert (bool_result == TRUE);
286 bool_result = FALSE;
287 g_signal_emit_by_name (object, "test-signal2", 3, &bool_result);
288 g_assert (bool_result == TRUE);
289 bool_result = TRUE;
290 g_signal_emit_by_name (object, "test-signal2", 4, &bool_result);
291 g_assert (bool_result == FALSE);
292
293 variant_finalised = FALSE;
294 variant_result = NULL;
295 g_signal_emit_by_name (object, "test-signal3", &variant_finalised, &variant_result);
296 g_assert (variant_result != NULL);
297 g_assert (!g_variant_is_floating (variant_result));
298
299 /* Test that variant_result had refcount 1 */
300 g_assert (!variant_finalised);
301 g_variant_unref (variant_result);
302 g_assert (variant_finalised);
303
304 g_object_unref (object);
305
306 return 0;
307 }
308