Branch data Line data Source code
1 : : #include <glib-object.h>
2 : : #include "marshalers.h"
3 : :
4 : : #define g_assert_cmpflags(type,n1, cmp, n2) G_STMT_START { \
5 : : type __n1 = (n1), __n2 = (n2); \
6 : : if (__n1 cmp __n2) ; else \
7 : : g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
8 : : #n1 " " #cmp " " #n2, __n1, #cmp, __n2, 'i'); \
9 : : } G_STMT_END
10 : : #define g_assert_cmpenum(type,n1, cmp, n2) G_STMT_START { \
11 : : type __n1 = (n1), __n2 = (n2); \
12 : : if (__n1 cmp __n2) ; else \
13 : : g_assertion_message_cmpint (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
14 : : #n1 " " #cmp " " #n2, __n1, #cmp, __n2, 'i'); \
15 : : } G_STMT_END
16 : :
17 : : typedef enum {
18 : : TEST_ENUM_NEGATIVE = -30,
19 : : TEST_ENUM_NONE = 0,
20 : : TEST_ENUM_FOO = 1,
21 : : TEST_ENUM_BAR = 2
22 : : } TestEnum;
23 : :
24 : : typedef enum {
25 : : TEST_UNSIGNED_ENUM_FOO = 1,
26 : : TEST_UNSIGNED_ENUM_BAR = 42
27 : : /* Don't test 0x80000000 for now- nothing appears to do this in
28 : : * practice, and it triggers GValue/GEnum bugs on ppc64.
29 : : */
30 : : } TestUnsignedEnum;
31 : :
32 : : static void
33 : 1 : custom_marshal_VOID__INVOCATIONHINT (GClosure *closure,
34 : : GValue *return_value G_GNUC_UNUSED,
35 : : guint n_param_values,
36 : : const GValue *param_values,
37 : : gpointer invocation_hint,
38 : : gpointer marshal_data)
39 : : {
40 : : typedef void (*GMarshalFunc_VOID__INVOCATIONHINT) (gpointer data1,
41 : : gpointer invocation_hint,
42 : : gpointer data2);
43 : : GMarshalFunc_VOID__INVOCATIONHINT callback;
44 : 1 : GCClosure *cc = (GCClosure*) closure;
45 : : gpointer data1, data2;
46 : :
47 : 1 : g_return_if_fail (n_param_values == 2);
48 : :
49 : 1 : if (G_CCLOSURE_SWAP_DATA (closure))
50 : : {
51 : 0 : data1 = closure->data;
52 : 0 : data2 = g_value_peek_pointer (param_values + 0);
53 : : }
54 : : else
55 : : {
56 : 1 : data1 = g_value_peek_pointer (param_values + 0);
57 : 1 : data2 = closure->data;
58 : : }
59 : 1 : callback = (GMarshalFunc_VOID__INVOCATIONHINT) (marshal_data ? marshal_data : cc->callback);
60 : :
61 : 1 : callback (data1,
62 : : invocation_hint,
63 : : data2);
64 : : }
65 : :
66 : : static GType
67 : 2 : test_enum_get_type (void)
68 : : {
69 : : static GType static_g_define_type_id = 0;
70 : :
71 : 2 : if (g_once_init_enter_pointer (&static_g_define_type_id))
72 : : {
73 : : static const GEnumValue values[] = {
74 : : { TEST_ENUM_NEGATIVE, "TEST_ENUM_NEGATIVE", "negative" },
75 : : { TEST_ENUM_NONE, "TEST_ENUM_NONE", "none" },
76 : : { TEST_ENUM_FOO, "TEST_ENUM_FOO", "foo" },
77 : : { TEST_ENUM_BAR, "TEST_ENUM_BAR", "bar" },
78 : : { 0, NULL, NULL }
79 : : };
80 : : GType g_define_type_id =
81 : 1 : g_enum_register_static (g_intern_static_string ("TestEnum"), values);
82 : 1 : g_once_init_leave_pointer (&static_g_define_type_id, g_define_type_id);
83 : : }
84 : :
85 : 2 : return static_g_define_type_id;
86 : : }
87 : :
88 : : static GType
89 : 2 : test_unsigned_enum_get_type (void)
90 : : {
91 : : static GType static_g_define_type_id = 0;
92 : :
93 : 2 : if (g_once_init_enter_pointer (&static_g_define_type_id))
94 : : {
95 : : static const GEnumValue values[] = {
96 : : { TEST_UNSIGNED_ENUM_FOO, "TEST_UNSIGNED_ENUM_FOO", "foo" },
97 : : { TEST_UNSIGNED_ENUM_BAR, "TEST_UNSIGNED_ENUM_BAR", "bar" },
98 : : { 0, NULL, NULL }
99 : : };
100 : : GType g_define_type_id =
101 : 1 : g_enum_register_static (g_intern_static_string ("TestUnsignedEnum"), values);
102 : 1 : g_once_init_leave_pointer (&static_g_define_type_id, g_define_type_id);
103 : : }
104 : :
105 : 2 : return static_g_define_type_id;
106 : : }
107 : :
108 : : typedef enum {
109 : : MY_ENUM_VALUE = 1,
110 : : } MyEnum;
111 : :
112 : : static const GEnumValue my_enum_values[] =
113 : : {
114 : : { MY_ENUM_VALUE, "the first value", "one" },
115 : : { 0, NULL, NULL }
116 : : };
117 : :
118 : : typedef enum {
119 : : MY_FLAGS_FIRST_BIT = (1 << 0),
120 : : MY_FLAGS_THIRD_BIT = (1 << 2),
121 : : MY_FLAGS_LAST_BIT = (1u << 31)
122 : : } G_GNUC_FLAG_ENUM MyFlags;
123 : :
124 : : static const GFlagsValue my_flag_values[] =
125 : : {
126 : : { MY_FLAGS_FIRST_BIT, "the first bit", "first-bit" },
127 : : { MY_FLAGS_THIRD_BIT, "the third bit", "third-bit" },
128 : : { MY_FLAGS_LAST_BIT, "the last bit", "last-bit" },
129 : : { 0, NULL, NULL }
130 : : };
131 : :
132 : : static GType enum_type;
133 : : static GType flags_type;
134 : :
135 : : static guint simple_id;
136 : : static guint simple2_id;
137 : :
138 : : typedef struct {
139 : : GTypeInterface g_iface;
140 : : } FooInterface;
141 : :
142 : : GType foo_get_type (void);
143 : :
144 : 3 : G_DEFINE_INTERFACE (Foo, foo, G_TYPE_OBJECT)
145 : :
146 : : static void
147 : 1 : foo_default_init (FooInterface *iface)
148 : : {
149 : 1 : }
150 : :
151 : : typedef struct {
152 : : GObject parent;
153 : : } Baa;
154 : :
155 : : typedef struct {
156 : : GObjectClass parent_class;
157 : : } BaaClass;
158 : :
159 : : static void
160 : 1 : baa_init_foo (FooInterface *iface)
161 : : {
162 : 1 : }
163 : :
164 : : GType baa_get_type (void);
165 : :
166 : 3 : G_DEFINE_TYPE_WITH_CODE (Baa, baa, G_TYPE_OBJECT,
167 : : G_IMPLEMENT_INTERFACE (foo_get_type (), baa_init_foo))
168 : :
169 : : static void
170 : 1 : baa_init (Baa *baa)
171 : : {
172 : 1 : }
173 : :
174 : : static void
175 : 1 : baa_class_init (BaaClass *class)
176 : : {
177 : 1 : }
178 : :
179 : : typedef struct _Test Test;
180 : : typedef struct _TestClass TestClass;
181 : :
182 : : struct _Test
183 : : {
184 : : GObject parent_instance;
185 : : };
186 : :
187 : : static void all_types_handler (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, MyEnum e, MyFlags f, float fl, double db, char *str, GParamSpec *param, GBytes *bytes, gpointer ptr, Test *obj, GVariant *var, gint64 i64, guint64 ui64);
188 : : static gboolean accumulator_sum (GSignalInvocationHint *ihint, GValue *return_accu, const GValue *handler_return, gpointer data);
189 : : static gboolean accumulator_concat_string (GSignalInvocationHint *ihint, GValue *return_accu, const GValue *handler_return, gpointer data);
190 : : static gchar * accumulator_class (Test *test);
191 : :
192 : : struct _TestClass
193 : : {
194 : : GObjectClass parent_class;
195 : :
196 : : void (* variant_changed) (Test *, GVariant *);
197 : : void (* all_types) (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, MyEnum e, MyFlags f, float fl, double db, char *str, GParamSpec *param, GBytes *bytes, gpointer ptr, Test *obj, GVariant *var, gint64 i64, guint64 ui64);
198 : : void (* all_types_null) (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, MyEnum e, MyFlags f, float fl, double db, char *str, GParamSpec *param, GBytes *bytes, gpointer ptr, Test *obj, GVariant *var, gint64 i64, guint64 ui64);
199 : : gchar * (*accumulator_class) (Test *test);
200 : : };
201 : :
202 : : static GType test_get_type (void);
203 : 67 : G_DEFINE_TYPE (Test, test, G_TYPE_OBJECT)
204 : :
205 : : static void
206 : 33 : test_init (Test *test)
207 : : {
208 : 33 : }
209 : :
210 : : static void
211 : 1 : test_class_init (TestClass *klass)
212 : : {
213 : : guint s;
214 : :
215 : 1 : enum_type = g_enum_register_static ("MyEnum", my_enum_values);
216 : 1 : flags_type = g_flags_register_static ("MyFlag", my_flag_values);
217 : :
218 : 1 : klass->all_types = all_types_handler;
219 : 1 : klass->accumulator_class = accumulator_class;
220 : :
221 : 1 : simple_id = g_signal_new ("simple",
222 : : G_TYPE_FROM_CLASS (klass),
223 : : G_SIGNAL_RUN_LAST,
224 : : 0,
225 : : NULL, NULL,
226 : : NULL,
227 : : G_TYPE_NONE,
228 : : 0);
229 : 1 : g_signal_new ("simple-detailed",
230 : : G_TYPE_FROM_CLASS (klass),
231 : : G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
232 : : 0,
233 : : NULL, NULL,
234 : : NULL,
235 : : G_TYPE_NONE,
236 : : 0);
237 : : /* Deliberately install this one in non-canonical form to check that’s handled correctly: */
238 : 1 : simple2_id = g_signal_new ("simple_2",
239 : : G_TYPE_FROM_CLASS (klass),
240 : : G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
241 : : 0,
242 : : NULL, NULL,
243 : : NULL,
244 : : G_TYPE_NONE,
245 : : 0);
246 : 1 : g_signal_new ("simple-accumulator",
247 : : G_TYPE_FROM_CLASS (klass),
248 : : G_SIGNAL_RUN_LAST,
249 : : 0,
250 : : accumulator_sum, NULL,
251 : : NULL,
252 : : G_TYPE_INT,
253 : : 0);
254 : 1 : g_signal_new ("accumulator-class-first",
255 : : G_TYPE_FROM_CLASS (klass),
256 : : G_SIGNAL_RUN_FIRST,
257 : : G_STRUCT_OFFSET (TestClass, accumulator_class),
258 : : accumulator_concat_string, NULL,
259 : : NULL,
260 : : G_TYPE_STRING,
261 : : 0);
262 : 1 : g_signal_new ("accumulator-class-last",
263 : : G_TYPE_FROM_CLASS (klass),
264 : : G_SIGNAL_RUN_LAST,
265 : : G_STRUCT_OFFSET (TestClass, accumulator_class),
266 : : accumulator_concat_string, NULL,
267 : : NULL,
268 : : G_TYPE_STRING,
269 : : 0);
270 : 1 : g_signal_new ("accumulator-class-cleanup",
271 : : G_TYPE_FROM_CLASS (klass),
272 : : G_SIGNAL_RUN_CLEANUP,
273 : : G_STRUCT_OFFSET (TestClass, accumulator_class),
274 : : accumulator_concat_string, NULL,
275 : : NULL,
276 : : G_TYPE_STRING,
277 : : 0);
278 : 1 : g_signal_new ("accumulator-class-first-last",
279 : : G_TYPE_FROM_CLASS (klass),
280 : : G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST,
281 : : G_STRUCT_OFFSET (TestClass, accumulator_class),
282 : : accumulator_concat_string, NULL,
283 : : NULL,
284 : : G_TYPE_STRING,
285 : : 0);
286 : 1 : g_signal_new ("accumulator-class-first-last-cleanup",
287 : : G_TYPE_FROM_CLASS (klass),
288 : : G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST | G_SIGNAL_RUN_CLEANUP,
289 : : G_STRUCT_OFFSET (TestClass, accumulator_class),
290 : : accumulator_concat_string, NULL,
291 : : NULL,
292 : : G_TYPE_STRING,
293 : : 0);
294 : 1 : g_signal_new ("accumulator-class-last-cleanup",
295 : : G_TYPE_FROM_CLASS (klass),
296 : : G_SIGNAL_RUN_LAST | G_SIGNAL_RUN_CLEANUP,
297 : : G_STRUCT_OFFSET (TestClass, accumulator_class),
298 : : accumulator_concat_string, NULL,
299 : : NULL,
300 : : G_TYPE_STRING,
301 : : 0);
302 : 1 : g_signal_new ("generic-marshaller-1",
303 : : G_TYPE_FROM_CLASS (klass),
304 : : G_SIGNAL_RUN_LAST,
305 : : 0,
306 : : NULL, NULL,
307 : : NULL,
308 : : G_TYPE_NONE,
309 : : 7,
310 : : G_TYPE_CHAR, G_TYPE_UCHAR, G_TYPE_INT, G_TYPE_LONG, G_TYPE_POINTER, G_TYPE_DOUBLE, G_TYPE_FLOAT);
311 : 1 : g_signal_new ("generic-marshaller-2",
312 : : G_TYPE_FROM_CLASS (klass),
313 : : G_SIGNAL_RUN_LAST,
314 : : 0,
315 : : NULL, NULL,
316 : : NULL,
317 : : G_TYPE_NONE,
318 : : 5,
319 : : G_TYPE_INT, test_enum_get_type(), G_TYPE_INT, test_unsigned_enum_get_type (), G_TYPE_INT);
320 : 1 : g_signal_new ("generic-marshaller-enum-return-signed",
321 : : G_TYPE_FROM_CLASS (klass),
322 : : G_SIGNAL_RUN_LAST,
323 : : 0,
324 : : NULL, NULL,
325 : : NULL,
326 : : test_enum_get_type(),
327 : : 0);
328 : 1 : g_signal_new ("generic-marshaller-enum-return-unsigned",
329 : : G_TYPE_FROM_CLASS (klass),
330 : : G_SIGNAL_RUN_LAST,
331 : : 0,
332 : : NULL, NULL,
333 : : NULL,
334 : : test_unsigned_enum_get_type(),
335 : : 0);
336 : 1 : g_signal_new ("generic-marshaller-int-return",
337 : : G_TYPE_FROM_CLASS (klass),
338 : : G_SIGNAL_RUN_LAST,
339 : : 0,
340 : : NULL, NULL,
341 : : NULL,
342 : : G_TYPE_INT,
343 : : 0);
344 : 1 : s = g_signal_new ("va-marshaller-int-return",
345 : : G_TYPE_FROM_CLASS (klass),
346 : : G_SIGNAL_RUN_LAST,
347 : : 0,
348 : : NULL, NULL,
349 : : test_INT__VOID,
350 : : G_TYPE_INT,
351 : : 0);
352 : 1 : g_signal_set_va_marshaller (s, G_TYPE_FROM_CLASS (klass),
353 : : test_INT__VOIDv);
354 : 1 : g_signal_new ("generic-marshaller-uint-return",
355 : : G_TYPE_FROM_CLASS (klass),
356 : : G_SIGNAL_RUN_LAST,
357 : : 0,
358 : : NULL, NULL,
359 : : NULL,
360 : : G_TYPE_UINT,
361 : : 0);
362 : 1 : g_signal_new ("generic-marshaller-interface-return",
363 : : G_TYPE_FROM_CLASS (klass),
364 : : G_SIGNAL_RUN_LAST,
365 : : 0,
366 : : NULL, NULL,
367 : : NULL,
368 : : foo_get_type (),
369 : : 0);
370 : 1 : s = g_signal_new ("va-marshaller-uint-return",
371 : : G_TYPE_FROM_CLASS (klass),
372 : : G_SIGNAL_RUN_LAST,
373 : : 0,
374 : : NULL, NULL,
375 : : test_INT__VOID,
376 : : G_TYPE_UINT,
377 : : 0);
378 : 1 : g_signal_set_va_marshaller (s, G_TYPE_FROM_CLASS (klass),
379 : : test_UINT__VOIDv);
380 : 1 : g_signal_new ("custom-marshaller",
381 : : G_TYPE_FROM_CLASS (klass),
382 : : G_SIGNAL_RUN_LAST,
383 : : 0,
384 : : NULL, NULL,
385 : : custom_marshal_VOID__INVOCATIONHINT,
386 : : G_TYPE_NONE,
387 : : 1,
388 : : G_TYPE_POINTER);
389 : 1 : g_signal_new ("variant-changed-no-slot",
390 : : G_TYPE_FROM_CLASS (klass),
391 : : G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,
392 : : 0,
393 : : NULL, NULL,
394 : : g_cclosure_marshal_VOID__VARIANT,
395 : : G_TYPE_NONE,
396 : : 1,
397 : : G_TYPE_VARIANT);
398 : 1 : g_signal_new ("variant-changed",
399 : : G_TYPE_FROM_CLASS (klass),
400 : : G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,
401 : : G_STRUCT_OFFSET (TestClass, variant_changed),
402 : : NULL, NULL,
403 : : g_cclosure_marshal_VOID__VARIANT,
404 : : G_TYPE_NONE,
405 : : 1,
406 : : G_TYPE_VARIANT);
407 : 1 : g_signal_new ("all-types",
408 : : G_TYPE_FROM_CLASS (klass),
409 : : G_SIGNAL_RUN_LAST,
410 : : G_STRUCT_OFFSET (TestClass, all_types),
411 : : NULL, NULL,
412 : : test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
413 : : G_TYPE_NONE,
414 : : 19,
415 : : G_TYPE_INT,
416 : : G_TYPE_BOOLEAN,
417 : : G_TYPE_CHAR,
418 : : G_TYPE_UCHAR,
419 : : G_TYPE_UINT,
420 : : G_TYPE_LONG,
421 : : G_TYPE_ULONG,
422 : : enum_type,
423 : : flags_type,
424 : : G_TYPE_FLOAT,
425 : : G_TYPE_DOUBLE,
426 : : G_TYPE_STRING,
427 : 1 : G_TYPE_PARAM_LONG,
428 : : G_TYPE_BYTES,
429 : : G_TYPE_POINTER,
430 : : test_get_type (),
431 : : G_TYPE_VARIANT,
432 : : G_TYPE_INT64,
433 : : G_TYPE_UINT64);
434 : 1 : s = g_signal_new ("all-types-va",
435 : : G_TYPE_FROM_CLASS (klass),
436 : : G_SIGNAL_RUN_LAST,
437 : : G_STRUCT_OFFSET (TestClass, all_types),
438 : : NULL, NULL,
439 : : test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
440 : : G_TYPE_NONE,
441 : : 19,
442 : : G_TYPE_INT,
443 : : G_TYPE_BOOLEAN,
444 : : G_TYPE_CHAR,
445 : : G_TYPE_UCHAR,
446 : : G_TYPE_UINT,
447 : : G_TYPE_LONG,
448 : : G_TYPE_ULONG,
449 : : enum_type,
450 : : flags_type,
451 : : G_TYPE_FLOAT,
452 : : G_TYPE_DOUBLE,
453 : : G_TYPE_STRING,
454 : 1 : G_TYPE_PARAM_LONG,
455 : : G_TYPE_BYTES,
456 : : G_TYPE_POINTER,
457 : : test_get_type (),
458 : : G_TYPE_VARIANT,
459 : : G_TYPE_INT64,
460 : : G_TYPE_UINT64);
461 : 1 : g_signal_set_va_marshaller (s, G_TYPE_FROM_CLASS (klass),
462 : : test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64v);
463 : :
464 : 1 : g_signal_new ("all-types-generic",
465 : : G_TYPE_FROM_CLASS (klass),
466 : : G_SIGNAL_RUN_LAST,
467 : : G_STRUCT_OFFSET (TestClass, all_types),
468 : : NULL, NULL,
469 : : NULL,
470 : : G_TYPE_NONE,
471 : : 19,
472 : : G_TYPE_INT,
473 : : G_TYPE_BOOLEAN,
474 : : G_TYPE_CHAR,
475 : : G_TYPE_UCHAR,
476 : : G_TYPE_UINT,
477 : : G_TYPE_LONG,
478 : : G_TYPE_ULONG,
479 : : enum_type,
480 : : flags_type,
481 : : G_TYPE_FLOAT,
482 : : G_TYPE_DOUBLE,
483 : : G_TYPE_STRING,
484 : 1 : G_TYPE_PARAM_LONG,
485 : : G_TYPE_BYTES,
486 : : G_TYPE_POINTER,
487 : : test_get_type (),
488 : : G_TYPE_VARIANT,
489 : : G_TYPE_INT64,
490 : : G_TYPE_UINT64);
491 : 1 : g_signal_new ("all-types-null",
492 : : G_TYPE_FROM_CLASS (klass),
493 : : G_SIGNAL_RUN_LAST,
494 : : G_STRUCT_OFFSET (TestClass, all_types_null),
495 : : NULL, NULL,
496 : : test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
497 : : G_TYPE_NONE,
498 : : 19,
499 : : G_TYPE_INT,
500 : : G_TYPE_BOOLEAN,
501 : : G_TYPE_CHAR,
502 : : G_TYPE_UCHAR,
503 : : G_TYPE_UINT,
504 : : G_TYPE_LONG,
505 : : G_TYPE_ULONG,
506 : : enum_type,
507 : : flags_type,
508 : : G_TYPE_FLOAT,
509 : : G_TYPE_DOUBLE,
510 : : G_TYPE_STRING,
511 : 1 : G_TYPE_PARAM_LONG,
512 : : G_TYPE_BYTES,
513 : : G_TYPE_POINTER,
514 : : test_get_type (),
515 : : G_TYPE_VARIANT,
516 : : G_TYPE_INT64,
517 : : G_TYPE_UINT64);
518 : 1 : g_signal_new ("all-types-empty",
519 : : G_TYPE_FROM_CLASS (klass),
520 : : G_SIGNAL_RUN_LAST,
521 : : 0,
522 : : NULL, NULL,
523 : : test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
524 : : G_TYPE_NONE,
525 : : 19,
526 : : G_TYPE_INT,
527 : : G_TYPE_BOOLEAN,
528 : : G_TYPE_CHAR,
529 : : G_TYPE_UCHAR,
530 : : G_TYPE_UINT,
531 : : G_TYPE_LONG,
532 : : G_TYPE_ULONG,
533 : : enum_type,
534 : : flags_type,
535 : : G_TYPE_FLOAT,
536 : : G_TYPE_DOUBLE,
537 : : G_TYPE_STRING,
538 : 1 : G_TYPE_PARAM_LONG,
539 : : G_TYPE_BYTES,
540 : : G_TYPE_POINTER,
541 : : test_get_type (),
542 : : G_TYPE_VARIANT,
543 : : G_TYPE_INT64,
544 : : G_TYPE_UINT64);
545 : 1 : }
546 : :
547 : : typedef struct _Test Test2;
548 : : typedef struct _TestClass Test2Class;
549 : :
550 : : static GType test2_get_type (void);
551 : 3 : G_DEFINE_TYPE (Test2, test2, G_TYPE_OBJECT)
552 : :
553 : : static void
554 : 1 : test2_init (Test2 *test)
555 : : {
556 : 1 : }
557 : :
558 : : static void
559 : 1 : test2_class_init (Test2Class *klass)
560 : : {
561 : 1 : }
562 : :
563 : : static void
564 : 1 : test_variant_signal (void)
565 : : {
566 : : Test *test;
567 : : GVariant *v;
568 : :
569 : : /* Tests that the signal emission consumes the variant,
570 : : * even if there are no handlers connected.
571 : : */
572 : :
573 : 1 : test = g_object_new (test_get_type (), NULL);
574 : :
575 : 1 : v = g_variant_new_boolean (TRUE);
576 : 1 : g_variant_ref (v);
577 : 1 : g_assert_true (g_variant_is_floating (v));
578 : 1 : g_signal_emit_by_name (test, "variant-changed-no-slot", v);
579 : 1 : g_assert_false (g_variant_is_floating (v));
580 : 1 : g_variant_unref (v);
581 : :
582 : 1 : v = g_variant_new_boolean (TRUE);
583 : 1 : g_variant_ref (v);
584 : 1 : g_assert_true (g_variant_is_floating (v));
585 : 1 : g_signal_emit_by_name (test, "variant-changed", v);
586 : 1 : g_assert_false (g_variant_is_floating (v));
587 : 1 : g_variant_unref (v);
588 : :
589 : 1 : g_object_unref (test);
590 : 1 : }
591 : :
592 : : static void
593 : 1 : on_generic_marshaller_1 (Test *obj,
594 : : gint8 v_schar,
595 : : guint8 v_uchar,
596 : : gint v_int,
597 : : glong v_long,
598 : : gpointer v_pointer,
599 : : gdouble v_double,
600 : : gfloat v_float,
601 : : gpointer user_data)
602 : : {
603 : 1 : g_assert_cmpint (v_schar, ==, 42);
604 : 1 : g_assert_cmpint (v_uchar, ==, 43);
605 : 1 : g_assert_cmpint (v_int, ==, 4096);
606 : 1 : g_assert_cmpint (v_long, ==, 8192);
607 : 1 : g_assert_null (v_pointer);
608 : 1 : g_assert_cmpfloat (v_double, >, 0.0);
609 : 1 : g_assert_cmpfloat (v_double, <, 1.0);
610 : 1 : g_assert_cmpfloat (v_float, >, 5.0);
611 : 1 : g_assert_cmpfloat (v_float, <, 6.0);
612 : 1 : }
613 : :
614 : : static void
615 : 1 : test_generic_marshaller_signal_1 (void)
616 : : {
617 : : Test *test;
618 : 1 : test = g_object_new (test_get_type (), NULL);
619 : :
620 : 1 : g_signal_connect (test, "generic-marshaller-1", G_CALLBACK (on_generic_marshaller_1), NULL);
621 : :
622 : 1 : g_signal_emit_by_name (test, "generic-marshaller-1", 42, 43, 4096, 8192, NULL, 0.5, 5.5);
623 : :
624 : 1 : g_object_unref (test);
625 : 1 : }
626 : :
627 : : static void
628 : 1 : on_generic_marshaller_2 (Test *obj,
629 : : gint v_int1,
630 : : TestEnum v_enum,
631 : : gint v_int2,
632 : : TestUnsignedEnum v_uenum,
633 : : gint v_int3)
634 : : {
635 : 1 : g_assert_cmpint (v_int1, ==, 42);
636 : 1 : g_assert_cmpint (v_enum, ==, TEST_ENUM_BAR);
637 : 1 : g_assert_cmpint (v_int2, ==, 43);
638 : 1 : g_assert_cmpint (v_uenum, ==, TEST_UNSIGNED_ENUM_BAR);
639 : 1 : g_assert_cmpint (v_int3, ==, 44);
640 : 1 : }
641 : :
642 : : static void
643 : 1 : test_generic_marshaller_signal_2 (void)
644 : : {
645 : : Test *test;
646 : 1 : test = g_object_new (test_get_type (), NULL);
647 : :
648 : 1 : g_signal_connect (test, "generic-marshaller-2", G_CALLBACK (on_generic_marshaller_2), NULL);
649 : :
650 : 1 : g_signal_emit_by_name (test, "generic-marshaller-2", 42, TEST_ENUM_BAR, 43, TEST_UNSIGNED_ENUM_BAR, 44);
651 : :
652 : 1 : g_object_unref (test);
653 : 1 : }
654 : :
655 : : static TestEnum
656 : 1 : on_generic_marshaller_enum_return_signed_1 (Test *obj)
657 : : {
658 : 1 : return TEST_ENUM_NEGATIVE;
659 : : }
660 : :
661 : : static TestEnum
662 : 1 : on_generic_marshaller_enum_return_signed_2 (Test *obj)
663 : : {
664 : 1 : return TEST_ENUM_BAR;
665 : : }
666 : :
667 : : static void
668 : 1 : test_generic_marshaller_signal_enum_return_signed (void)
669 : : {
670 : : Test *test;
671 : : guint id;
672 : 1 : TestEnum retval = 0;
673 : :
674 : 1 : test = g_object_new (test_get_type (), NULL);
675 : :
676 : : /* Test return value NEGATIVE */
677 : 1 : id = g_signal_connect (test,
678 : : "generic-marshaller-enum-return-signed",
679 : : G_CALLBACK (on_generic_marshaller_enum_return_signed_1),
680 : : NULL);
681 : 1 : g_signal_emit_by_name (test, "generic-marshaller-enum-return-signed", &retval);
682 : 1 : g_assert_cmpint (retval, ==, TEST_ENUM_NEGATIVE);
683 : 1 : g_signal_handler_disconnect (test, id);
684 : :
685 : : /* Test return value BAR */
686 : 1 : retval = 0;
687 : 1 : id = g_signal_connect (test,
688 : : "generic-marshaller-enum-return-signed",
689 : : G_CALLBACK (on_generic_marshaller_enum_return_signed_2),
690 : : NULL);
691 : 1 : g_signal_emit_by_name (test, "generic-marshaller-enum-return-signed", &retval);
692 : 1 : g_assert_cmpint (retval, ==, TEST_ENUM_BAR);
693 : 1 : g_signal_handler_disconnect (test, id);
694 : :
695 : 1 : g_object_unref (test);
696 : 1 : }
697 : :
698 : : static TestUnsignedEnum
699 : 1 : on_generic_marshaller_enum_return_unsigned_1 (Test *obj)
700 : : {
701 : 1 : return TEST_UNSIGNED_ENUM_FOO;
702 : : }
703 : :
704 : : static TestUnsignedEnum
705 : 1 : on_generic_marshaller_enum_return_unsigned_2 (Test *obj)
706 : : {
707 : 1 : return TEST_UNSIGNED_ENUM_BAR;
708 : : }
709 : :
710 : : static void
711 : 1 : test_generic_marshaller_signal_enum_return_unsigned (void)
712 : : {
713 : : Test *test;
714 : : guint id;
715 : 1 : TestUnsignedEnum retval = 0;
716 : :
717 : 1 : test = g_object_new (test_get_type (), NULL);
718 : :
719 : : /* Test return value FOO */
720 : 1 : id = g_signal_connect (test,
721 : : "generic-marshaller-enum-return-unsigned",
722 : : G_CALLBACK (on_generic_marshaller_enum_return_unsigned_1),
723 : : NULL);
724 : 1 : g_signal_emit_by_name (test, "generic-marshaller-enum-return-unsigned", &retval);
725 : 1 : g_assert_cmpint (retval, ==, TEST_UNSIGNED_ENUM_FOO);
726 : 1 : g_signal_handler_disconnect (test, id);
727 : :
728 : : /* Test return value BAR */
729 : 1 : retval = 0;
730 : 1 : id = g_signal_connect (test,
731 : : "generic-marshaller-enum-return-unsigned",
732 : : G_CALLBACK (on_generic_marshaller_enum_return_unsigned_2),
733 : : NULL);
734 : 1 : g_signal_emit_by_name (test, "generic-marshaller-enum-return-unsigned", &retval);
735 : 1 : g_assert_cmpint (retval, ==, TEST_UNSIGNED_ENUM_BAR);
736 : 1 : g_signal_handler_disconnect (test, id);
737 : :
738 : 1 : g_object_unref (test);
739 : 1 : }
740 : :
741 : : /**********************/
742 : :
743 : : static gint
744 : 4 : on_generic_marshaller_int_return_signed_1 (Test *obj)
745 : : {
746 : 4 : return -30;
747 : : }
748 : :
749 : : static gint
750 : 3 : on_generic_marshaller_int_return_signed_2 (Test *obj)
751 : : {
752 : 3 : return 2;
753 : : }
754 : :
755 : : static void
756 : 1 : test_generic_marshaller_signal_int_return (void)
757 : : {
758 : : Test *test;
759 : : guint id;
760 : 1 : gint retval = 0;
761 : :
762 : 1 : test = g_object_new (test_get_type (), NULL);
763 : :
764 : : /* Test return value -30 */
765 : 1 : id = g_signal_connect (test,
766 : : "generic-marshaller-int-return",
767 : : G_CALLBACK (on_generic_marshaller_int_return_signed_1),
768 : : NULL);
769 : 1 : g_signal_emit_by_name (test, "generic-marshaller-int-return", &retval);
770 : 1 : g_assert_cmpint (retval, ==, -30);
771 : 1 : g_signal_handler_disconnect (test, id);
772 : :
773 : : /* Test return value positive */
774 : 1 : retval = 0;
775 : 1 : id = g_signal_connect (test,
776 : : "generic-marshaller-int-return",
777 : : G_CALLBACK (on_generic_marshaller_int_return_signed_2),
778 : : NULL);
779 : 1 : g_signal_emit_by_name (test, "generic-marshaller-int-return", &retval);
780 : 1 : g_assert_cmpint (retval, ==, 2);
781 : 1 : g_signal_handler_disconnect (test, id);
782 : :
783 : : /* Same test for va marshaller */
784 : :
785 : : /* Test return value -30 */
786 : 1 : id = g_signal_connect (test,
787 : : "va-marshaller-int-return",
788 : : G_CALLBACK (on_generic_marshaller_int_return_signed_1),
789 : : NULL);
790 : 1 : g_signal_emit_by_name (test, "va-marshaller-int-return", &retval);
791 : 1 : g_assert_cmpint (retval, ==, -30);
792 : 1 : g_signal_handler_disconnect (test, id);
793 : :
794 : : /* Test return value positive */
795 : 1 : retval = 0;
796 : 1 : id = g_signal_connect (test,
797 : : "va-marshaller-int-return",
798 : : G_CALLBACK (on_generic_marshaller_int_return_signed_2),
799 : : NULL);
800 : 1 : g_signal_emit_by_name (test, "va-marshaller-int-return", &retval);
801 : 1 : g_assert_cmpint (retval, ==, 2);
802 : 1 : g_signal_handler_disconnect (test, id);
803 : :
804 : 1 : g_object_unref (test);
805 : 1 : }
806 : :
807 : : static guint
808 : 2 : on_generic_marshaller_uint_return_1 (Test *obj)
809 : : {
810 : 2 : return 1;
811 : : }
812 : :
813 : : static guint
814 : 2 : on_generic_marshaller_uint_return_2 (Test *obj)
815 : : {
816 : 2 : return G_MAXUINT;
817 : : }
818 : :
819 : : static void
820 : 1 : test_generic_marshaller_signal_uint_return (void)
821 : : {
822 : : Test *test;
823 : : guint id;
824 : 1 : guint retval = 0;
825 : :
826 : 1 : test = g_object_new (test_get_type (), NULL);
827 : :
828 : 1 : id = g_signal_connect (test,
829 : : "generic-marshaller-uint-return",
830 : : G_CALLBACK (on_generic_marshaller_uint_return_1),
831 : : NULL);
832 : 1 : g_signal_emit_by_name (test, "generic-marshaller-uint-return", &retval);
833 : 1 : g_assert_cmpint (retval, ==, 1);
834 : 1 : g_signal_handler_disconnect (test, id);
835 : :
836 : 1 : retval = 0;
837 : 1 : id = g_signal_connect (test,
838 : : "generic-marshaller-uint-return",
839 : : G_CALLBACK (on_generic_marshaller_uint_return_2),
840 : : NULL);
841 : 1 : g_signal_emit_by_name (test, "generic-marshaller-uint-return", &retval);
842 : 1 : g_assert_cmpint (retval, ==, G_MAXUINT);
843 : 1 : g_signal_handler_disconnect (test, id);
844 : :
845 : : /* Same test for va marshaller */
846 : :
847 : 1 : id = g_signal_connect (test,
848 : : "va-marshaller-uint-return",
849 : : G_CALLBACK (on_generic_marshaller_uint_return_1),
850 : : NULL);
851 : 1 : g_signal_emit_by_name (test, "va-marshaller-uint-return", &retval);
852 : 1 : g_assert_cmpint (retval, ==, 1);
853 : 1 : g_signal_handler_disconnect (test, id);
854 : :
855 : 1 : retval = 0;
856 : 1 : id = g_signal_connect (test,
857 : : "va-marshaller-uint-return",
858 : : G_CALLBACK (on_generic_marshaller_uint_return_2),
859 : : NULL);
860 : 1 : g_signal_emit_by_name (test, "va-marshaller-uint-return", &retval);
861 : 1 : g_assert_cmpint (retval, ==, G_MAXUINT);
862 : 1 : g_signal_handler_disconnect (test, id);
863 : :
864 : 1 : g_object_unref (test);
865 : 1 : }
866 : :
867 : : static gpointer
868 : 1 : on_generic_marshaller_interface_return (Test *test)
869 : : {
870 : 1 : return g_object_new (baa_get_type (), NULL);
871 : : }
872 : :
873 : : static void
874 : 1 : test_generic_marshaller_signal_interface_return (void)
875 : : {
876 : : Test *test;
877 : : guint id;
878 : : gpointer retval;
879 : :
880 : 1 : test = g_object_new (test_get_type (), NULL);
881 : :
882 : : /* Test return value -30 */
883 : 1 : id = g_signal_connect (test,
884 : : "generic-marshaller-interface-return",
885 : : G_CALLBACK (on_generic_marshaller_interface_return),
886 : : NULL);
887 : 1 : g_signal_emit_by_name (test, "generic-marshaller-interface-return", &retval);
888 : 1 : g_assert_true (g_type_check_instance_is_a ((GTypeInstance*)retval, foo_get_type ()));
889 : 1 : g_object_unref (retval);
890 : :
891 : 1 : g_signal_handler_disconnect (test, id);
892 : :
893 : 1 : g_object_unref (test);
894 : 1 : }
895 : :
896 : : static const GSignalInvocationHint dont_use_this = { 0, };
897 : :
898 : : static void
899 : 1 : custom_marshaller_callback (Test *test,
900 : : GSignalInvocationHint *hint,
901 : : gpointer unused)
902 : : {
903 : : GSignalInvocationHint *ihint;
904 : :
905 : 1 : g_assert_true (hint != &dont_use_this);
906 : :
907 : 1 : ihint = g_signal_get_invocation_hint (test);
908 : :
909 : 1 : g_assert_cmpuint (hint->signal_id, ==, ihint->signal_id);
910 : 1 : g_assert_cmpuint (hint->detail , ==, ihint->detail);
911 : 1 : g_assert_cmpflags (GSignalFlags, hint->run_type, ==, ihint->run_type);
912 : 1 : }
913 : :
914 : : static void
915 : 1 : test_custom_marshaller (void)
916 : : {
917 : : Test *test;
918 : :
919 : 1 : test = g_object_new (test_get_type (), NULL);
920 : :
921 : 1 : g_signal_connect (test,
922 : : "custom-marshaller",
923 : : G_CALLBACK (custom_marshaller_callback),
924 : : NULL);
925 : :
926 : 1 : g_signal_emit_by_name (test, "custom-marshaller", &dont_use_this);
927 : :
928 : 1 : g_object_unref (test);
929 : 1 : }
930 : :
931 : : static int all_type_handlers_count = 0;
932 : :
933 : : static void
934 : 26 : all_types_handler (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, MyEnum e, MyFlags f, float fl, double db, char *str, GParamSpec *param, GBytes *bytes, gpointer ptr, Test *obj, GVariant *var, gint64 i64, guint64 ui64)
935 : : {
936 : 26 : all_type_handlers_count++;
937 : :
938 : 26 : g_assert_cmpint (i, ==, 42);
939 : 26 : g_assert_cmpint (b, ==, TRUE);
940 : 26 : g_assert_cmpint (c, ==, 17);
941 : 26 : g_assert_cmpuint (uc, ==, 140);
942 : 26 : g_assert_cmpuint (ui, ==, G_MAXUINT - 42);
943 : 26 : g_assert_cmpint (l, ==, -1117);
944 : 26 : g_assert_cmpuint (ul, ==, G_MAXULONG - 999);
945 : 26 : g_assert_cmpenum (MyEnum, e, ==, MY_ENUM_VALUE);
946 : 26 : g_assert_cmpflags (MyFlags, f, ==, MY_FLAGS_FIRST_BIT | MY_FLAGS_THIRD_BIT | MY_FLAGS_LAST_BIT);
947 : 26 : g_assert_cmpfloat (fl, ==, 0.25);
948 : 26 : g_assert_cmpfloat (db, ==, 1.5);
949 : 26 : g_assert_cmpstr (str, ==, "Test");
950 : 26 : g_assert_cmpstr (g_param_spec_get_nick (param), ==, "nick");
951 : 26 : g_assert_cmpstr (g_bytes_get_data (bytes, NULL), ==, "Blah");
952 : 26 : g_assert_true (ptr == &enum_type);
953 : 26 : g_assert_cmpuint (g_variant_get_uint16 (var), == , 99);
954 : 26 : g_assert_cmpint (i64, ==, G_MAXINT64 - 1234);
955 : 26 : g_assert_cmpuint (ui64, ==, G_MAXUINT64 - 123456);
956 : 26 : }
957 : :
958 : : static void
959 : 16 : all_types_handler_cb (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, MyEnum e, guint f, float fl, double db, char *str, GParamSpec *param, GBytes *bytes, gpointer ptr, Test *obj, GVariant *var, gint64 i64, guint64 ui64, gpointer user_data)
960 : : {
961 : 16 : g_assert_true (user_data == &flags_type);
962 : 16 : all_types_handler (test, i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, obj, var, i64, ui64);
963 : 16 : }
964 : :
965 : : static void
966 : 1 : test_all_types (void)
967 : : {
968 : : Test *test;
969 : :
970 : 1 : int i = 42;
971 : 1 : gboolean b = TRUE;
972 : 1 : char c = 17;
973 : 1 : guchar uc = 140;
974 : 1 : guint ui = G_MAXUINT - 42;
975 : 1 : glong l = -1117;
976 : 1 : gulong ul = G_MAXULONG - 999;
977 : 1 : MyEnum e = MY_ENUM_VALUE;
978 : 1 : MyFlags f = MY_FLAGS_FIRST_BIT | MY_FLAGS_THIRD_BIT | MY_FLAGS_LAST_BIT;
979 : 1 : float fl = 0.25;
980 : 1 : double db = 1.5;
981 : 1 : char *str = "Test";
982 : 1 : GParamSpec *param = g_param_spec_long ("param", "nick", "blurb", 0, 10, 4, 0);
983 : 1 : GBytes *bytes = g_bytes_new_static ("Blah", 5);
984 : 1 : gpointer ptr = &enum_type;
985 : 1 : GVariant *var = g_variant_new_uint16 (99);
986 : : gint64 i64;
987 : : guint64 ui64;
988 : 1 : g_variant_ref_sink (var);
989 : 1 : i64 = G_MAXINT64 - 1234;
990 : 1 : ui64 = G_MAXUINT64 - 123456;
991 : :
992 : 1 : test = g_object_new (test_get_type (), NULL);
993 : :
994 : 1 : all_type_handlers_count = 0;
995 : :
996 : 1 : g_signal_emit_by_name (test, "all-types",
997 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
998 : 1 : g_signal_emit_by_name (test, "all-types-va",
999 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1000 : 1 : g_signal_emit_by_name (test, "all-types-generic",
1001 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1002 : 1 : g_signal_emit_by_name (test, "all-types-empty",
1003 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1004 : 1 : g_signal_emit_by_name (test, "all-types-null",
1005 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1006 : :
1007 : 1 : g_assert_cmpint (all_type_handlers_count, ==, 3);
1008 : :
1009 : 1 : all_type_handlers_count = 0;
1010 : :
1011 : 1 : g_signal_connect (test, "all-types", G_CALLBACK (all_types_handler_cb), &flags_type);
1012 : 1 : g_signal_connect (test, "all-types-va", G_CALLBACK (all_types_handler_cb), &flags_type);
1013 : 1 : g_signal_connect (test, "all-types-generic", G_CALLBACK (all_types_handler_cb), &flags_type);
1014 : 1 : g_signal_connect (test, "all-types-empty", G_CALLBACK (all_types_handler_cb), &flags_type);
1015 : 1 : g_signal_connect (test, "all-types-null", G_CALLBACK (all_types_handler_cb), &flags_type);
1016 : :
1017 : 1 : g_signal_emit_by_name (test, "all-types",
1018 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1019 : 1 : g_signal_emit_by_name (test, "all-types-va",
1020 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1021 : 1 : g_signal_emit_by_name (test, "all-types-generic",
1022 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1023 : 1 : g_signal_emit_by_name (test, "all-types-empty",
1024 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1025 : 1 : g_signal_emit_by_name (test, "all-types-null",
1026 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1027 : :
1028 : 1 : g_assert_cmpint (all_type_handlers_count, ==, 3 + 5);
1029 : :
1030 : 1 : all_type_handlers_count = 0;
1031 : :
1032 : 1 : g_signal_connect (test, "all-types", G_CALLBACK (all_types_handler_cb), &flags_type);
1033 : 1 : g_signal_connect (test, "all-types-va", G_CALLBACK (all_types_handler_cb), &flags_type);
1034 : 1 : g_signal_connect (test, "all-types-generic", G_CALLBACK (all_types_handler_cb), &flags_type);
1035 : 1 : g_signal_connect (test, "all-types-empty", G_CALLBACK (all_types_handler_cb), &flags_type);
1036 : 1 : g_signal_connect (test, "all-types-null", G_CALLBACK (all_types_handler_cb), &flags_type);
1037 : :
1038 : 1 : g_signal_emit_by_name (test, "all-types",
1039 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1040 : 1 : g_signal_emit_by_name (test, "all-types-va",
1041 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1042 : 1 : g_signal_emit_by_name (test, "all-types-generic",
1043 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1044 : 1 : g_signal_emit_by_name (test, "all-types-empty",
1045 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1046 : 1 : g_signal_emit_by_name (test, "all-types-null",
1047 : : i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1048 : :
1049 : 1 : g_assert_cmpint (all_type_handlers_count, ==, 3 + 5 + 5);
1050 : :
1051 : 1 : g_object_unref (test);
1052 : 1 : g_param_spec_unref (param);
1053 : 1 : g_bytes_unref (bytes);
1054 : 1 : g_variant_unref (var);
1055 : 1 : }
1056 : :
1057 : : static void
1058 : 1 : test_connect (void)
1059 : : {
1060 : : GObject *test;
1061 : : gint retval;
1062 : :
1063 : 1 : test = g_object_new (test_get_type (), NULL);
1064 : :
1065 : 1 : g_object_connect (test,
1066 : : "signal::generic-marshaller-int-return",
1067 : : G_CALLBACK (on_generic_marshaller_int_return_signed_1),
1068 : : NULL,
1069 : : "object-signal::va-marshaller-int-return",
1070 : : G_CALLBACK (on_generic_marshaller_int_return_signed_2),
1071 : : NULL,
1072 : : NULL);
1073 : 1 : g_signal_emit_by_name (test, "generic-marshaller-int-return", &retval);
1074 : 1 : g_assert_cmpint (retval, ==, -30);
1075 : 1 : g_signal_emit_by_name (test, "va-marshaller-int-return", &retval);
1076 : 1 : g_assert_cmpint (retval, ==, 2);
1077 : :
1078 : 1 : g_object_disconnect (test,
1079 : : "any-signal",
1080 : : G_CALLBACK (on_generic_marshaller_int_return_signed_1),
1081 : : NULL,
1082 : : "any-signal::va-marshaller-int-return",
1083 : : G_CALLBACK (on_generic_marshaller_int_return_signed_2),
1084 : : NULL,
1085 : : NULL);
1086 : :
1087 : 1 : g_object_unref (test);
1088 : 1 : }
1089 : :
1090 : : static void
1091 : 1 : test_is_connected (void)
1092 : : {
1093 : : GObject *test;
1094 : : gulong handler_id;
1095 : :
1096 : 1 : test = g_object_new (test_get_type (), NULL);
1097 : :
1098 : 1 : handler_id = g_signal_connect (test, "generic-marshaller-int-return",
1099 : : G_CALLBACK (test_is_connected),
1100 : : NULL);
1101 : :
1102 : 1 : g_assert_true (g_signal_handler_is_connected (test, handler_id));
1103 : :
1104 : 1 : g_signal_handler_disconnect (test, handler_id);
1105 : :
1106 : 1 : g_assert_false (g_signal_handler_is_connected (test, handler_id));
1107 : :
1108 : 1 : g_assert_false (g_signal_handler_is_connected (test, 0));
1109 : 1 : g_assert_false (g_signal_handler_is_connected (test, handler_id + 1));
1110 : :
1111 : 1 : g_object_unref (test);
1112 : 1 : }
1113 : :
1114 : : static void
1115 : 1 : simple_handler1 (GObject *sender,
1116 : : GObject *target)
1117 : : {
1118 : 1 : g_object_unref (target);
1119 : 1 : }
1120 : :
1121 : : static void
1122 : 1 : simple_handler2 (GObject *sender,
1123 : : GObject *target)
1124 : : {
1125 : 1 : g_object_unref (target);
1126 : 1 : }
1127 : :
1128 : : static void
1129 : 1 : test_destroy_target_object (void)
1130 : : {
1131 : : Test *sender, *target1, *target2;
1132 : :
1133 : 1 : sender = g_object_new (test_get_type (), NULL);
1134 : 1 : target1 = g_object_new (test_get_type (), NULL);
1135 : 1 : target2 = g_object_new (test_get_type (), NULL);
1136 : 1 : g_signal_connect_object (sender, "simple", G_CALLBACK (simple_handler1),
1137 : : target1, G_CONNECT_DEFAULT);
1138 : 1 : g_signal_connect_object (sender, "simple", G_CALLBACK (simple_handler2),
1139 : : target2, G_CONNECT_DEFAULT);
1140 : 1 : g_signal_emit_by_name (sender, "simple");
1141 : 1 : g_object_unref (sender);
1142 : 1 : }
1143 : :
1144 : : static gboolean
1145 : 26 : hook_func (GSignalInvocationHint *ihint,
1146 : : guint n_params,
1147 : : const GValue *params,
1148 : : gpointer data)
1149 : : {
1150 : 26 : gint *count = data;
1151 : :
1152 : 26 : (*count)++;
1153 : :
1154 : 26 : return TRUE;
1155 : : }
1156 : :
1157 : : static gboolean
1158 : 11 : hook_func_removal (GSignalInvocationHint *ihint,
1159 : : guint n_params,
1160 : : const GValue *params,
1161 : : gpointer data)
1162 : : {
1163 : 11 : gint *count = data;
1164 : :
1165 : 11 : (*count)++;
1166 : :
1167 : 11 : return FALSE;
1168 : : }
1169 : :
1170 : : static void
1171 : 1 : simple_handler_remove_hook (GObject *sender,
1172 : : gpointer data)
1173 : : {
1174 : 1 : gulong *hook = data;
1175 : :
1176 : 1 : g_signal_remove_emission_hook (simple_id, *hook);
1177 : 1 : }
1178 : :
1179 : : static void
1180 : 1 : test_emission_hook (void)
1181 : : {
1182 : : GObject *test1, *test2;
1183 : 1 : gint count = 0;
1184 : : gulong hook;
1185 : : gulong connection_id;
1186 : :
1187 : 1 : test1 = g_object_new (test_get_type (), NULL);
1188 : 1 : test2 = g_object_new (test_get_type (), NULL);
1189 : :
1190 : 1 : hook = g_signal_add_emission_hook (simple_id, 0, hook_func, &count, NULL);
1191 : 1 : g_assert_cmpint (count, ==, 0);
1192 : 1 : g_signal_emit_by_name (test1, "simple");
1193 : 1 : g_assert_cmpint (count, ==, 1);
1194 : 1 : g_signal_emit_by_name (test2, "simple");
1195 : 1 : g_assert_cmpint (count, ==, 2);
1196 : 1 : g_signal_remove_emission_hook (simple_id, hook);
1197 : 1 : g_signal_emit_by_name (test1, "simple");
1198 : 1 : g_assert_cmpint (count, ==, 2);
1199 : :
1200 : 1 : count = 0;
1201 : 1 : hook = g_signal_add_emission_hook (simple_id, 0, hook_func_removal, &count, NULL);
1202 : 1 : g_assert_cmpint (count, ==, 0);
1203 : 1 : g_signal_emit_by_name (test1, "simple");
1204 : 1 : g_assert_cmpint (count, ==, 1);
1205 : 1 : g_signal_emit_by_name (test2, "simple");
1206 : 1 : g_assert_cmpint (count, ==, 1);
1207 : :
1208 : 1 : g_test_expect_message ("GLib-GObject", G_LOG_LEVEL_CRITICAL,
1209 : : "*simple* had no hook * to remove");
1210 : 1 : g_signal_remove_emission_hook (simple_id, hook);
1211 : 1 : g_test_assert_expected_messages ();
1212 : :
1213 : 1 : count = 0;
1214 : 1 : hook = g_signal_add_emission_hook (simple_id, 0, hook_func, &count, NULL);
1215 : 1 : connection_id = g_signal_connect (test1, "simple",
1216 : : G_CALLBACK (simple_handler_remove_hook), &hook);
1217 : 1 : g_assert_cmpint (count, ==, 0);
1218 : 1 : g_signal_emit_by_name (test1, "simple");
1219 : 1 : g_assert_cmpint (count, ==, 1);
1220 : 1 : g_signal_emit_by_name (test2, "simple");
1221 : 1 : g_assert_cmpint (count, ==, 1);
1222 : :
1223 : 1 : g_test_expect_message ("GLib-GObject", G_LOG_LEVEL_CRITICAL,
1224 : : "*simple* had no hook * to remove");
1225 : 1 : g_signal_remove_emission_hook (simple_id, hook);
1226 : 1 : g_test_assert_expected_messages ();
1227 : :
1228 : 1 : g_clear_signal_handler (&connection_id, test1);
1229 : :
1230 : : gulong hooks[10];
1231 : 1 : count = 0;
1232 : :
1233 : 11 : for (size_t i = 0; i < G_N_ELEMENTS (hooks); ++i)
1234 : 10 : hooks[i] = g_signal_add_emission_hook (simple_id, 0, hook_func, &count, NULL);
1235 : :
1236 : 1 : g_assert_cmpint (count, ==, 0);
1237 : 1 : g_signal_emit_by_name (test1, "simple");
1238 : 1 : g_assert_cmpint (count, ==, 10);
1239 : 1 : g_signal_emit_by_name (test2, "simple");
1240 : 1 : g_assert_cmpint (count, ==, 20);
1241 : :
1242 : 11 : for (size_t i = 0; i < G_N_ELEMENTS (hooks); ++i)
1243 : 10 : g_signal_remove_emission_hook (simple_id, hooks[i]);
1244 : :
1245 : 1 : g_signal_emit_by_name (test1, "simple");
1246 : 1 : g_assert_cmpint (count, ==, 20);
1247 : :
1248 : 1 : count = 0;
1249 : :
1250 : 11 : for (size_t i = 0; i < G_N_ELEMENTS (hooks); ++i)
1251 : 10 : hooks[i] = g_signal_add_emission_hook (simple_id, 0, hook_func_removal, &count, NULL);
1252 : :
1253 : 1 : g_assert_cmpint (count, ==, 0);
1254 : 1 : g_signal_emit_by_name (test1, "simple");
1255 : 1 : g_assert_cmpint (count, ==, 10);
1256 : 1 : g_signal_emit_by_name (test2, "simple");
1257 : 1 : g_assert_cmpint (count, ==, 10);
1258 : :
1259 : 11 : for (size_t i = 0; i < G_N_ELEMENTS (hooks); ++i)
1260 : : {
1261 : 10 : g_test_expect_message ("GLib-GObject", G_LOG_LEVEL_CRITICAL,
1262 : : "*simple* had no hook * to remove");
1263 : 10 : g_signal_remove_emission_hook (simple_id, hooks[i]);
1264 : 10 : g_test_assert_expected_messages ();
1265 : : }
1266 : :
1267 : 1 : g_object_unref (test1);
1268 : 1 : g_object_unref (test2);
1269 : 1 : }
1270 : :
1271 : : static void
1272 : 1 : simple_cb (gpointer instance, gpointer data)
1273 : : {
1274 : : GSignalInvocationHint *ihint;
1275 : :
1276 : 1 : ihint = g_signal_get_invocation_hint (instance);
1277 : :
1278 : 1 : g_assert_cmpstr (g_signal_name (ihint->signal_id), ==, "simple");
1279 : :
1280 : 1 : g_signal_emit_by_name (instance, "simple-2");
1281 : 1 : }
1282 : :
1283 : : static void
1284 : 1 : simple2_cb (gpointer instance, gpointer data)
1285 : : {
1286 : : GSignalInvocationHint *ihint;
1287 : :
1288 : 1 : ihint = g_signal_get_invocation_hint (instance);
1289 : :
1290 : 1 : g_assert_cmpstr (g_signal_name (ihint->signal_id), ==, "simple-2");
1291 : 1 : }
1292 : :
1293 : : static void
1294 : 1 : test_invocation_hint (void)
1295 : : {
1296 : : GObject *test;
1297 : :
1298 : 1 : test = g_object_new (test_get_type (), NULL);
1299 : :
1300 : 1 : g_signal_connect (test, "simple", G_CALLBACK (simple_cb), NULL);
1301 : 1 : g_signal_connect (test, "simple-2", G_CALLBACK (simple2_cb), NULL);
1302 : 1 : g_signal_emit_by_name (test, "simple");
1303 : :
1304 : 1 : g_object_unref (test);
1305 : 1 : }
1306 : :
1307 : : static gboolean
1308 : 3 : accumulator_sum (GSignalInvocationHint *ihint,
1309 : : GValue *return_accu,
1310 : : const GValue *handler_return,
1311 : : gpointer data)
1312 : : {
1313 : 3 : gint acc = g_value_get_int (return_accu);
1314 : 3 : gint ret = g_value_get_int (handler_return);
1315 : :
1316 : 3 : g_assert_cmpint (ret, >, 0);
1317 : :
1318 : 3 : if (ihint->run_type & G_SIGNAL_ACCUMULATOR_FIRST_RUN)
1319 : : {
1320 : 1 : g_assert_cmpint (acc, ==, 0);
1321 : 1 : g_assert_cmpint (ret, ==, 1);
1322 : 1 : g_assert_true (ihint->run_type & G_SIGNAL_RUN_FIRST);
1323 : 1 : g_assert_false (ihint->run_type & G_SIGNAL_RUN_LAST);
1324 : : }
1325 : 2 : else if (ihint->run_type & G_SIGNAL_RUN_FIRST)
1326 : : {
1327 : : /* Only the first signal handler was called so far */
1328 : 1 : g_assert_cmpint (acc, ==, 1);
1329 : 1 : g_assert_cmpint (ret, ==, 2);
1330 : 1 : g_assert_false (ihint->run_type & G_SIGNAL_RUN_LAST);
1331 : : }
1332 : 1 : else if (ihint->run_type & G_SIGNAL_RUN_LAST)
1333 : : {
1334 : : /* Only the first two signal handler were called so far */
1335 : 1 : g_assert_cmpint (acc, ==, 3);
1336 : 1 : g_assert_cmpint (ret, ==, 3);
1337 : 1 : g_assert_false (ihint->run_type & G_SIGNAL_RUN_FIRST);
1338 : : }
1339 : : else
1340 : : {
1341 : : g_assert_not_reached ();
1342 : : }
1343 : :
1344 : 3 : g_value_set_int (return_accu, acc + ret);
1345 : :
1346 : : /* Continue with the other signal handlers as long as the sum is < 6,
1347 : : * i.e. don't run simple_accumulator_4_cb() */
1348 : 3 : return acc + ret < 6;
1349 : : }
1350 : :
1351 : : static gint
1352 : 1 : simple_accumulator_1_cb (gpointer instance, gpointer data)
1353 : : {
1354 : 1 : return 1;
1355 : : }
1356 : :
1357 : : static gint
1358 : 1 : simple_accumulator_2_cb (gpointer instance, gpointer data)
1359 : : {
1360 : 1 : return 2;
1361 : : }
1362 : :
1363 : : static gint
1364 : 1 : simple_accumulator_3_cb (gpointer instance, gpointer data)
1365 : : {
1366 : 1 : return 3;
1367 : : }
1368 : :
1369 : : static gint
1370 : 0 : simple_accumulator_4_cb (gpointer instance, gpointer data)
1371 : : {
1372 : 0 : return 4;
1373 : : }
1374 : :
1375 : : static void
1376 : 1 : test_accumulator (void)
1377 : : {
1378 : : GObject *test;
1379 : 1 : gint ret = -1;
1380 : :
1381 : 1 : test = g_object_new (test_get_type (), NULL);
1382 : :
1383 : : /* Connect in reverse order to make sure that LAST signal handlers are
1384 : : * called after FIRST signal handlers but signal handlers in each "group"
1385 : : * are called in the order they were registered */
1386 : 1 : g_signal_connect_after (test, "simple-accumulator", G_CALLBACK (simple_accumulator_3_cb), NULL);
1387 : 1 : g_signal_connect_after (test, "simple-accumulator", G_CALLBACK (simple_accumulator_4_cb), NULL);
1388 : 1 : g_signal_connect (test, "simple-accumulator", G_CALLBACK (simple_accumulator_1_cb), NULL);
1389 : 1 : g_signal_connect (test, "simple-accumulator", G_CALLBACK (simple_accumulator_2_cb), NULL);
1390 : 1 : g_signal_emit_by_name (test, "simple-accumulator", &ret);
1391 : :
1392 : : /* simple_accumulator_4_cb() is not run because accumulator is 6 */
1393 : 1 : g_assert_cmpint (ret, ==, 6);
1394 : :
1395 : 1 : g_object_unref (test);
1396 : 1 : }
1397 : :
1398 : : static gboolean
1399 : 22 : accumulator_concat_string (GSignalInvocationHint *ihint, GValue *return_accu, const GValue *handler_return, gpointer data)
1400 : : {
1401 : 22 : const gchar *acc = g_value_get_string (return_accu);
1402 : 22 : const gchar *ret = g_value_get_string (handler_return);
1403 : :
1404 : 22 : g_assert_nonnull (ret);
1405 : :
1406 : 22 : if (acc == NULL)
1407 : 6 : g_value_set_string (return_accu, ret);
1408 : : else
1409 : 16 : g_value_take_string (return_accu, g_strconcat (acc, ret, NULL));
1410 : :
1411 : 22 : return TRUE;
1412 : : }
1413 : :
1414 : : static gchar *
1415 : 6 : accumulator_class_before_cb (gpointer instance, gpointer data)
1416 : : {
1417 : 6 : return g_strdup ("before");
1418 : : }
1419 : :
1420 : : static gchar *
1421 : 6 : accumulator_class_after_cb (gpointer instance, gpointer data)
1422 : : {
1423 : 6 : return g_strdup ("after");
1424 : : }
1425 : :
1426 : : static gchar *
1427 : 10 : accumulator_class (Test *test)
1428 : : {
1429 : 10 : return g_strdup ("class");
1430 : : }
1431 : :
1432 : : static void
1433 : 1 : test_accumulator_class (void)
1434 : : {
1435 : : const struct {
1436 : : const gchar *signal_name;
1437 : : const gchar *return_string;
1438 : 1 : } tests[] = {
1439 : : {"accumulator-class-first", "classbeforeafter"},
1440 : : {"accumulator-class-last", "beforeclassafter"},
1441 : : {"accumulator-class-cleanup", "beforeafterclass"},
1442 : : {"accumulator-class-first-last", "classbeforeclassafter"},
1443 : : {"accumulator-class-first-last-cleanup", "classbeforeclassafterclass"},
1444 : : {"accumulator-class-last-cleanup", "beforeclassafterclass"},
1445 : : };
1446 : : gsize i;
1447 : :
1448 : 7 : for (i = 0; i < G_N_ELEMENTS (tests); i++)
1449 : : {
1450 : : GObject *test;
1451 : 6 : gchar *ret = NULL;
1452 : :
1453 : 6 : g_test_message ("Signal: %s", tests[i].signal_name);
1454 : :
1455 : 6 : test = g_object_new (test_get_type (), NULL);
1456 : :
1457 : 6 : g_signal_connect (test, tests[i].signal_name, G_CALLBACK (accumulator_class_before_cb), NULL);
1458 : 6 : g_signal_connect_after (test, tests[i].signal_name, G_CALLBACK (accumulator_class_after_cb), NULL);
1459 : 6 : g_signal_emit_by_name (test, tests[i].signal_name, &ret);
1460 : :
1461 : 6 : g_assert_cmpstr (ret, ==, tests[i].return_string);
1462 : 6 : g_free (ret);
1463 : :
1464 : 6 : g_object_unref (test);
1465 : : }
1466 : 1 : }
1467 : :
1468 : : static gboolean
1469 : 27 : in_set (const gchar *s,
1470 : : const gchar *set[])
1471 : : {
1472 : : gint i;
1473 : :
1474 : 378 : for (i = 0; set[i]; i++)
1475 : : {
1476 : 378 : if (g_strcmp0 (s, set[i]) == 0)
1477 : 27 : return TRUE;
1478 : : }
1479 : :
1480 : 0 : return FALSE;
1481 : : }
1482 : :
1483 : : static void
1484 : 1 : test_introspection (void)
1485 : : {
1486 : : guint *ids;
1487 : : guint n_ids;
1488 : : const gchar *name;
1489 : : guint i;
1490 : 1 : const gchar *names[] = {
1491 : : "simple",
1492 : : "simple-detailed",
1493 : : "simple-2",
1494 : : "simple-accumulator",
1495 : : "accumulator-class-first",
1496 : : "accumulator-class-last",
1497 : : "accumulator-class-cleanup",
1498 : : "accumulator-class-first-last",
1499 : : "accumulator-class-first-last-cleanup",
1500 : : "accumulator-class-last-cleanup",
1501 : : "generic-marshaller-1",
1502 : : "generic-marshaller-2",
1503 : : "generic-marshaller-enum-return-signed",
1504 : : "generic-marshaller-enum-return-unsigned",
1505 : : "generic-marshaller-int-return",
1506 : : "va-marshaller-int-return",
1507 : : "generic-marshaller-uint-return",
1508 : : "generic-marshaller-interface-return",
1509 : : "va-marshaller-uint-return",
1510 : : "variant-changed-no-slot",
1511 : : "variant-changed",
1512 : : "all-types",
1513 : : "all-types-va",
1514 : : "all-types-generic",
1515 : : "all-types-null",
1516 : : "all-types-empty",
1517 : : "custom-marshaller",
1518 : : NULL
1519 : : };
1520 : : GSignalQuery query;
1521 : :
1522 : 1 : ids = g_signal_list_ids (test_get_type (), &n_ids);
1523 : 1 : g_assert_cmpuint (n_ids, ==, g_strv_length ((gchar**)names));
1524 : :
1525 : 28 : for (i = 0; i < n_ids; i++)
1526 : : {
1527 : 27 : name = g_signal_name (ids[i]);
1528 : 27 : g_assert_true (in_set (name, names));
1529 : : }
1530 : :
1531 : 1 : g_signal_query (simple_id, &query);
1532 : 1 : g_assert_cmpuint (query.signal_id, ==, simple_id);
1533 : 1 : g_assert_cmpstr (query.signal_name, ==, "simple");
1534 : 1 : g_assert_true (query.itype == test_get_type ());
1535 : 1 : g_assert_cmpint (query.signal_flags, ==, G_SIGNAL_RUN_LAST);
1536 : 1 : g_assert_cmpuint (query.return_type, ==, G_TYPE_NONE);
1537 : 1 : g_assert_cmpuint (query.n_params, ==, 0);
1538 : :
1539 : 1 : g_free (ids);
1540 : 1 : }
1541 : :
1542 : : static void
1543 : 7 : test_handler (gpointer instance, gpointer data)
1544 : : {
1545 : 7 : gint *count = data;
1546 : :
1547 : 7 : (*count)++;
1548 : 7 : }
1549 : :
1550 : : static void
1551 : 1 : test_block_handler (void)
1552 : : {
1553 : : GObject *test1, *test2;
1554 : 1 : gint count1 = 0;
1555 : 1 : gint count2 = 0;
1556 : : gulong handler1, handler;
1557 : :
1558 : 1 : test1 = g_object_new (test_get_type (), NULL);
1559 : 1 : test2 = g_object_new (test_get_type (), NULL);
1560 : :
1561 : 1 : handler1 = g_signal_connect (test1, "simple", G_CALLBACK (test_handler), &count1);
1562 : 1 : g_signal_connect (test2, "simple", G_CALLBACK (test_handler), &count2);
1563 : :
1564 : 1 : handler = g_signal_handler_find (test1, G_SIGNAL_MATCH_ID, simple_id, 0, NULL, NULL, NULL);
1565 : :
1566 : 1 : g_assert_true (handler == handler1);
1567 : :
1568 : 1 : g_assert_cmpint (count1, ==, 0);
1569 : 1 : g_assert_cmpint (count2, ==, 0);
1570 : :
1571 : 1 : g_signal_emit_by_name (test1, "simple");
1572 : 1 : g_signal_emit_by_name (test2, "simple");
1573 : :
1574 : 1 : g_assert_cmpint (count1, ==, 1);
1575 : 1 : g_assert_cmpint (count2, ==, 1);
1576 : :
1577 : 1 : g_signal_handler_block (test1, handler1);
1578 : :
1579 : 1 : g_signal_emit_by_name (test1, "simple");
1580 : 1 : g_signal_emit_by_name (test2, "simple");
1581 : :
1582 : 1 : g_assert_cmpint (count1, ==, 1);
1583 : 1 : g_assert_cmpint (count2, ==, 2);
1584 : :
1585 : 1 : g_signal_handler_unblock (test1, handler1);
1586 : :
1587 : 1 : g_signal_emit_by_name (test1, "simple");
1588 : 1 : g_signal_emit_by_name (test2, "simple");
1589 : :
1590 : 1 : g_assert_cmpint (count1, ==, 2);
1591 : 1 : g_assert_cmpint (count2, ==, 3);
1592 : :
1593 : 1 : g_assert_cmpuint (g_signal_handlers_block_matched (test1, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, test_block_handler, NULL), ==, 0);
1594 : 1 : g_assert_cmpuint (g_signal_handlers_block_matched (test2, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, test_handler, NULL), ==, 1);
1595 : :
1596 : 1 : g_signal_emit_by_name (test1, "simple");
1597 : 1 : g_signal_emit_by_name (test2, "simple");
1598 : :
1599 : 1 : g_assert_cmpint (count1, ==, 3);
1600 : 1 : g_assert_cmpint (count2, ==, 3);
1601 : :
1602 : 1 : g_signal_handlers_unblock_matched (test2, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, test_handler, NULL);
1603 : :
1604 : : /* Test match by signal ID. */
1605 : 1 : g_assert_cmpuint (g_signal_handlers_block_matched (test1, G_SIGNAL_MATCH_ID, simple_id, 0, NULL, NULL, NULL), ==, 1);
1606 : :
1607 : 1 : g_signal_emit_by_name (test1, "simple");
1608 : 1 : g_signal_emit_by_name (test2, "simple");
1609 : :
1610 : 1 : g_assert_cmpint (count1, ==, 3);
1611 : 1 : g_assert_cmpint (count2, ==, 4);
1612 : :
1613 : 1 : g_assert_cmpuint (g_signal_handlers_unblock_matched (test1, G_SIGNAL_MATCH_ID, simple_id, 0, NULL, NULL, NULL), ==, 1);
1614 : :
1615 : : /* Match types are conjunctive */
1616 : 1 : g_assert_cmpuint (g_signal_handlers_block_matched (test1, G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, test_handler, "will not match"), ==, 0);
1617 : 1 : g_assert_cmpuint (g_signal_handlers_block_matched (test1, G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, test_handler, &count1), ==, 1);
1618 : 1 : g_assert_cmpuint (g_signal_handlers_unblock_matched (test1, G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, 0, 0, NULL, test_handler, &count1), ==, 1);
1619 : :
1620 : : /* Test g_signal_handlers_disconnect_matched for G_SIGNAL_MATCH_ID match */
1621 : 1 : g_assert_cmpuint (g_signal_handlers_disconnect_matched (test1,
1622 : : G_SIGNAL_MATCH_ID,
1623 : : simple_id, 0,
1624 : : NULL, NULL, NULL),
1625 : : ==,
1626 : : 1);
1627 : 1 : g_assert_cmpuint (g_signal_handler_find (test1,
1628 : : G_SIGNAL_MATCH_ID,
1629 : : simple_id, 0,
1630 : : NULL, NULL, NULL),
1631 : : ==,
1632 : : 0);
1633 : :
1634 : 1 : g_object_unref (test1);
1635 : 1 : g_object_unref (test2);
1636 : 1 : }
1637 : :
1638 : : static void
1639 : 1 : stop_emission (gpointer instance, gpointer data)
1640 : : {
1641 : 1 : g_signal_stop_emission (instance, simple_id, 0);
1642 : 1 : }
1643 : :
1644 : : static void
1645 : 1 : stop_emission_by_name (gpointer instance, gpointer data)
1646 : : {
1647 : 1 : g_signal_stop_emission_by_name (instance, "simple");
1648 : 1 : }
1649 : :
1650 : : static void
1651 : 0 : dont_reach (gpointer instance, gpointer data)
1652 : : {
1653 : : g_assert_not_reached ();
1654 : : }
1655 : :
1656 : : static void
1657 : 1 : test_stop_emission (void)
1658 : : {
1659 : : GObject *test1;
1660 : : gulong handler;
1661 : :
1662 : 1 : test1 = g_object_new (test_get_type (), NULL);
1663 : 1 : handler = g_signal_connect (test1, "simple", G_CALLBACK (stop_emission), NULL);
1664 : 1 : g_signal_connect_after (test1, "simple", G_CALLBACK (dont_reach), NULL);
1665 : :
1666 : 1 : g_signal_emit_by_name (test1, "simple");
1667 : :
1668 : 1 : g_signal_handler_disconnect (test1, handler);
1669 : 1 : g_signal_connect (test1, "simple", G_CALLBACK (stop_emission_by_name), NULL);
1670 : :
1671 : 1 : g_signal_emit_by_name (test1, "simple");
1672 : :
1673 : 1 : g_object_unref (test1);
1674 : 1 : }
1675 : :
1676 : : static void
1677 : 1 : test_signal_disconnect_wrong_object (void)
1678 : : {
1679 : : Test *object, *object2;
1680 : : Test2 *object3;
1681 : : guint signal_id;
1682 : :
1683 : 1 : object = g_object_new (test_get_type (), NULL);
1684 : 1 : object2 = g_object_new (test_get_type (), NULL);
1685 : 1 : object3 = g_object_new (test2_get_type (), NULL);
1686 : :
1687 : 1 : signal_id = g_signal_connect (object,
1688 : : "simple",
1689 : : G_CALLBACK (simple_handler1),
1690 : : NULL);
1691 : :
1692 : 1 : g_assert_true (g_signal_handler_is_connected (object, signal_id));
1693 : :
1694 : : /* disconnect from the wrong object (same type), should warn */
1695 : 1 : g_test_expect_message ("GLib-GObject", G_LOG_LEVEL_CRITICAL,
1696 : : "*: instance '*' has no handler with id '*'");
1697 : 1 : g_signal_handler_disconnect (object2, signal_id);
1698 : 1 : g_test_assert_expected_messages ();
1699 : :
1700 : : /* and from an object of the wrong type */
1701 : 1 : g_test_expect_message ("GLib-GObject", G_LOG_LEVEL_CRITICAL,
1702 : : "*: instance '*' has no handler with id '*'");
1703 : 1 : g_signal_handler_disconnect (object3, signal_id);
1704 : 1 : g_test_assert_expected_messages ();
1705 : :
1706 : : /* it's still connected */
1707 : 1 : g_assert_true (g_signal_handler_is_connected (object, signal_id));
1708 : :
1709 : 1 : g_object_unref (object);
1710 : 1 : g_object_unref (object2);
1711 : 1 : g_object_unref (object3);
1712 : 1 : }
1713 : :
1714 : : static void
1715 : 1 : test_clear_signal_handler (void)
1716 : : {
1717 : : GObject *test_obj;
1718 : : gulong handler;
1719 : :
1720 : 1 : test_obj = g_object_new (test_get_type (), NULL);
1721 : :
1722 : 1 : handler = g_signal_connect (test_obj, "simple", G_CALLBACK (dont_reach), NULL);
1723 : 1 : g_assert_cmpuint (handler, >, 0);
1724 : :
1725 : 1 : g_clear_signal_handler (&handler, test_obj);
1726 : 1 : g_assert_cmpuint (handler, ==, 0);
1727 : :
1728 : 1 : g_signal_emit_by_name (test_obj, "simple");
1729 : :
1730 : 1 : g_clear_signal_handler (&handler, test_obj);
1731 : :
1732 : 1 : if (g_test_undefined ())
1733 : : {
1734 : 1 : handler = (gulong) g_random_int_range (0x01, 0xFF);
1735 : 1 : g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
1736 : : "*instance '* has no handler with id *'");
1737 : 1 : g_clear_signal_handler (&handler, test_obj);
1738 : 1 : g_assert_cmpuint (handler, ==, 0);
1739 : 1 : g_test_assert_expected_messages ();
1740 : : }
1741 : :
1742 : 1 : g_object_unref (test_obj);
1743 : 1 : }
1744 : :
1745 : : static void
1746 : 1 : test_lookup (void)
1747 : : {
1748 : : GTypeClass *test_class;
1749 : : guint signal_id, saved_signal_id;
1750 : :
1751 : 1 : g_test_summary ("Test that g_signal_lookup() works with a variety of inputs.");
1752 : :
1753 : 1 : test_class = g_type_class_ref (test_get_type ());
1754 : :
1755 : 1 : signal_id = g_signal_lookup ("all-types", test_get_type ());
1756 : 1 : g_assert_cmpint (signal_id, !=, 0);
1757 : :
1758 : 1 : saved_signal_id = signal_id;
1759 : :
1760 : : /* Try with a non-canonical name. */
1761 : 1 : signal_id = g_signal_lookup ("all_types", test_get_type ());
1762 : 1 : g_assert_cmpint (signal_id, ==, saved_signal_id);
1763 : :
1764 : : /* Looking up a non-existent signal should return nothing. */
1765 : 1 : g_assert_cmpint (g_signal_lookup ("nope", test_get_type ()), ==, 0);
1766 : :
1767 : 1 : g_type_class_unref (test_class);
1768 : 1 : }
1769 : :
1770 : : static void
1771 : 1 : test_lookup_invalid (void)
1772 : : {
1773 : 1 : g_test_summary ("Test that g_signal_lookup() emits a warning if looking up an invalid signal name.");
1774 : :
1775 : 1 : if (g_test_subprocess ())
1776 : : {
1777 : : GTypeClass *test_class;
1778 : : guint signal_id;
1779 : :
1780 : 0 : test_class = g_type_class_ref (test_get_type ());
1781 : :
1782 : 0 : signal_id = g_signal_lookup ("", test_get_type ());
1783 : 0 : g_assert_cmpint (signal_id, ==, 0);
1784 : :
1785 : 0 : g_type_class_unref (test_class);
1786 : 0 : return;
1787 : : }
1788 : :
1789 : 1 : g_test_trap_subprocess (NULL, 0, G_TEST_SUBPROCESS_DEFAULT);
1790 : 1 : g_test_trap_assert_failed ();
1791 : 1 : g_test_trap_assert_stderr ("*CRITICAL*unable to look up invalid signal name*");
1792 : : }
1793 : :
1794 : : static void
1795 : 1 : test_parse_name (void)
1796 : : {
1797 : : GTypeClass *test_class;
1798 : : guint signal_id, saved_signal_id;
1799 : : gboolean retval;
1800 : : GQuark detail, saved_detail;
1801 : :
1802 : 1 : g_test_summary ("Test that g_signal_parse_name() works with a variety of inputs.");
1803 : :
1804 : 1 : test_class = g_type_class_ref (test_get_type ());
1805 : :
1806 : : /* Simple test. */
1807 : 1 : retval = g_signal_parse_name ("simple-detailed", test_get_type (), &signal_id, &detail, TRUE);
1808 : 1 : g_assert_true (retval);
1809 : 1 : g_assert_cmpint (signal_id, !=, 0);
1810 : 1 : g_assert_cmpint (detail, ==, 0);
1811 : :
1812 : 1 : saved_signal_id = signal_id;
1813 : :
1814 : : /* Simple test with detail. */
1815 : 1 : retval = g_signal_parse_name ("simple-detailed::a-detail", test_get_type (), &signal_id, &detail, TRUE);
1816 : 1 : g_assert_true (retval);
1817 : 1 : g_assert_cmpint (signal_id, ==, saved_signal_id);
1818 : 1 : g_assert_cmpint (detail, !=, 0);
1819 : :
1820 : 1 : saved_detail = detail;
1821 : :
1822 : : /* Simple test with the same detail again. */
1823 : 1 : retval = g_signal_parse_name ("simple-detailed::a-detail", test_get_type (), &signal_id, &detail, FALSE);
1824 : 1 : g_assert_true (retval);
1825 : 1 : g_assert_cmpint (signal_id, ==, saved_signal_id);
1826 : 1 : g_assert_cmpint (detail, ==, saved_detail);
1827 : :
1828 : : /* Simple test with a new detail. */
1829 : 1 : retval = g_signal_parse_name ("simple-detailed::another-detail", test_get_type (), &signal_id, &detail, FALSE);
1830 : 1 : g_assert_true (retval);
1831 : 1 : g_assert_cmpint (signal_id, ==, saved_signal_id);
1832 : 1 : g_assert_cmpint (detail, ==, 0); /* we didn’t force the quark */
1833 : :
1834 : : /* Canonicalisation shouldn’t affect the results. */
1835 : 1 : retval = g_signal_parse_name ("simple_detailed::a-detail", test_get_type (), &signal_id, &detail, FALSE);
1836 : 1 : g_assert_true (retval);
1837 : 1 : g_assert_cmpint (signal_id, ==, saved_signal_id);
1838 : 1 : g_assert_cmpint (detail, ==, saved_detail);
1839 : :
1840 : : /* Details don’t have to look like property names. */
1841 : 1 : retval = g_signal_parse_name ("simple-detailed::hello::world", test_get_type (), &signal_id, &detail, TRUE);
1842 : 1 : g_assert_true (retval);
1843 : 1 : g_assert_cmpint (signal_id, ==, saved_signal_id);
1844 : 1 : g_assert_cmpint (detail, !=, 0);
1845 : :
1846 : : /* Trying to parse a detail for a signal which isn’t %G_SIGNAL_DETAILED should fail. */
1847 : 1 : retval = g_signal_parse_name ("all-types::a-detail", test_get_type (), &signal_id, &detail, FALSE);
1848 : 1 : g_assert_false (retval);
1849 : :
1850 : 1 : g_type_class_unref (test_class);
1851 : 1 : }
1852 : :
1853 : : static void
1854 : 1 : test_parse_name_invalid (void)
1855 : : {
1856 : : GTypeClass *test_class;
1857 : : gsize i;
1858 : : guint signal_id;
1859 : : GQuark detail;
1860 : 1 : const gchar *vectors[] =
1861 : : {
1862 : : "",
1863 : : "7zip",
1864 : : "invalid:signal",
1865 : : "simple-detailed::",
1866 : : "simple-detailed:",
1867 : : ":",
1868 : : "::",
1869 : : ":valid-detail",
1870 : : "::valid-detail",
1871 : : };
1872 : :
1873 : 1 : g_test_summary ("Test that g_signal_parse_name() ignores a variety of invalid inputs.");
1874 : :
1875 : 1 : test_class = g_type_class_ref (test_get_type ());
1876 : :
1877 : 10 : for (i = 0; i < G_N_ELEMENTS (vectors); i++)
1878 : : {
1879 : 9 : g_test_message ("Parser input: %s", vectors[i]);
1880 : 9 : g_assert_false (g_signal_parse_name (vectors[i], test_get_type (), &signal_id, &detail, TRUE));
1881 : : }
1882 : :
1883 : 1 : g_type_class_unref (test_class);
1884 : 1 : }
1885 : :
1886 : : static void
1887 : 3 : test_signals_invalid_name (gconstpointer test_data)
1888 : : {
1889 : 3 : const gchar *signal_name = test_data;
1890 : :
1891 : 3 : g_test_summary ("Check that g_signal_new() rejects invalid signal names.");
1892 : :
1893 : 3 : if (g_test_subprocess ())
1894 : : {
1895 : 0 : g_signal_new (signal_name,
1896 : : test_get_type (),
1897 : : G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
1898 : : 0,
1899 : : NULL, NULL,
1900 : : NULL,
1901 : : G_TYPE_NONE,
1902 : : 0);
1903 : 0 : return;
1904 : : }
1905 : :
1906 : 3 : g_test_trap_subprocess (NULL, 0, G_TEST_SUBPROCESS_DEFAULT);
1907 : 3 : g_test_trap_assert_failed ();
1908 : 3 : g_test_trap_assert_stderr ("*CRITICAL*g_signal_is_valid_name (signal_name)*");
1909 : : }
1910 : :
1911 : : static void
1912 : 1 : test_signal_is_valid_name (void)
1913 : : {
1914 : 1 : const gchar *valid_names[] =
1915 : : {
1916 : : "signal",
1917 : : "i",
1918 : : "multiple-segments",
1919 : : "segment0-SEGMENT1",
1920 : : "using_underscores",
1921 : : };
1922 : 1 : const gchar *invalid_names[] =
1923 : : {
1924 : : "",
1925 : : "7zip",
1926 : : "my_int:hello",
1927 : : };
1928 : : gsize i;
1929 : :
1930 : 6 : for (i = 0; i < G_N_ELEMENTS (valid_names); i++)
1931 : 5 : g_assert_true (g_signal_is_valid_name (valid_names[i]));
1932 : :
1933 : 4 : for (i = 0; i < G_N_ELEMENTS (invalid_names); i++)
1934 : 3 : g_assert_false (g_signal_is_valid_name (invalid_names[i]));
1935 : 1 : }
1936 : :
1937 : : static void
1938 : 1 : test_emitv (void)
1939 : : {
1940 : : GArray *values;
1941 : : GObject *test;
1942 : 1 : GValue return_value = G_VALUE_INIT;
1943 : 1 : gint count = 0;
1944 : : guint signal_id;
1945 : : gulong hook;
1946 : : gulong id;
1947 : :
1948 : 1 : test = g_object_new (test_get_type (), NULL);
1949 : :
1950 : 1 : values = g_array_new (TRUE, TRUE, sizeof (GValue));
1951 : 1 : g_array_set_clear_func (values, (GDestroyNotify) g_value_unset);
1952 : :
1953 : 1 : g_array_set_size (values, 1);
1954 : 1 : g_value_init (&g_array_index (values, GValue, 0), G_TYPE_OBJECT);
1955 : 1 : g_value_set_object (&g_array_index (values, GValue, 0), test);
1956 : 1 : hook = g_signal_add_emission_hook (simple_id, 0, hook_func, &count, NULL);
1957 : 1 : g_assert_cmpint (count, ==, 0);
1958 : 1 : g_signal_emitv ((GValue *) values->data, simple_id, 0, NULL);
1959 : 1 : g_assert_cmpint (count, ==, 1);
1960 : 1 : g_signal_remove_emission_hook (simple_id, hook);
1961 : :
1962 : 1 : g_array_set_size (values, 20);
1963 : 1 : g_value_init (&g_array_index (values, GValue, 1), G_TYPE_INT);
1964 : 1 : g_value_set_int (&g_array_index (values, GValue, 1), 42);
1965 : :
1966 : 1 : g_value_init (&g_array_index (values, GValue, 2), G_TYPE_BOOLEAN);
1967 : 1 : g_value_set_boolean (&g_array_index (values, GValue, 2), TRUE);
1968 : :
1969 : 1 : g_value_init (&g_array_index (values, GValue, 3), G_TYPE_CHAR);
1970 : 1 : g_value_set_schar (&g_array_index (values, GValue, 3), 17);
1971 : :
1972 : 1 : g_value_init (&g_array_index (values, GValue, 4), G_TYPE_UCHAR);
1973 : 1 : g_value_set_uchar (&g_array_index (values, GValue, 4), 140);
1974 : :
1975 : 1 : g_value_init (&g_array_index (values, GValue, 5), G_TYPE_UINT);
1976 : 1 : g_value_set_uint (&g_array_index (values, GValue, 5), G_MAXUINT - 42);
1977 : :
1978 : 1 : g_value_init (&g_array_index (values, GValue, 6), G_TYPE_LONG);
1979 : 1 : g_value_set_long (&g_array_index (values, GValue, 6), -1117);
1980 : :
1981 : 1 : g_value_init (&g_array_index (values, GValue, 7), G_TYPE_ULONG);
1982 : 1 : g_value_set_ulong (&g_array_index (values, GValue, 7), G_MAXULONG - 999);
1983 : :
1984 : 1 : g_value_init (&g_array_index (values, GValue, 8), enum_type);
1985 : 1 : g_value_set_enum (&g_array_index (values, GValue, 8), MY_ENUM_VALUE);
1986 : :
1987 : 1 : g_value_init (&g_array_index (values, GValue, 9), flags_type);
1988 : 1 : g_value_set_flags (&g_array_index (values, GValue, 9),
1989 : : MY_FLAGS_FIRST_BIT | MY_FLAGS_THIRD_BIT | MY_FLAGS_LAST_BIT);
1990 : :
1991 : 1 : g_value_init (&g_array_index (values, GValue, 10), G_TYPE_FLOAT);
1992 : 1 : g_value_set_float (&g_array_index (values, GValue, 10), 0.25);
1993 : :
1994 : 1 : g_value_init (&g_array_index (values, GValue, 11), G_TYPE_DOUBLE);
1995 : 1 : g_value_set_double (&g_array_index (values, GValue, 11), 1.5);
1996 : :
1997 : 1 : g_value_init (&g_array_index (values, GValue, 12), G_TYPE_STRING);
1998 : 1 : g_value_set_string (&g_array_index (values, GValue, 12), "Test");
1999 : :
2000 : 1 : g_value_init (&g_array_index (values, GValue, 13), G_TYPE_PARAM_LONG);
2001 : 1 : g_value_take_param (&g_array_index (values, GValue, 13),
2002 : : g_param_spec_long ("param", "nick", "blurb", 0, 10, 4, 0));
2003 : :
2004 : 1 : g_value_init (&g_array_index (values, GValue, 14), G_TYPE_BYTES);
2005 : 1 : g_value_take_boxed (&g_array_index (values, GValue, 14),
2006 : 1 : g_bytes_new_static ("Blah", 5));
2007 : :
2008 : 1 : g_value_init (&g_array_index (values, GValue, 15), G_TYPE_POINTER);
2009 : 1 : g_value_set_pointer (&g_array_index (values, GValue, 15), &enum_type);
2010 : :
2011 : 1 : g_value_init (&g_array_index (values, GValue, 16), test_get_type ());
2012 : 1 : g_value_set_object (&g_array_index (values, GValue, 16), test);
2013 : :
2014 : 1 : g_value_init (&g_array_index (values, GValue, 17), G_TYPE_VARIANT);
2015 : 1 : g_value_take_variant (&g_array_index (values, GValue, 17),
2016 : : g_variant_ref_sink (g_variant_new_uint16 (99)));
2017 : :
2018 : 1 : g_value_init (&g_array_index (values, GValue, 18), G_TYPE_INT64);
2019 : 1 : g_value_set_int64 (&g_array_index (values, GValue, 18), G_MAXINT64 - 1234);
2020 : :
2021 : 1 : g_value_init (&g_array_index (values, GValue, 19), G_TYPE_UINT64);
2022 : 1 : g_value_set_uint64 (&g_array_index (values, GValue, 19), G_MAXUINT64 - 123456);
2023 : :
2024 : 1 : id = g_signal_connect (test, "all-types", G_CALLBACK (all_types_handler_cb), &flags_type);
2025 : 1 : signal_id = g_signal_lookup ("all-types", test_get_type ());
2026 : 1 : g_assert_cmpuint (signal_id, >, 0);
2027 : :
2028 : 1 : count = 0;
2029 : 1 : hook = g_signal_add_emission_hook (signal_id, 0, hook_func, &count, NULL);
2030 : 1 : g_assert_cmpint (count, ==, 0);
2031 : 1 : g_signal_emitv ((GValue *) values->data, signal_id, 0, NULL);
2032 : 1 : g_assert_cmpint (count, ==, 1);
2033 : 1 : g_signal_remove_emission_hook (signal_id, hook);
2034 : 1 : g_clear_signal_handler (&id, test);
2035 : :
2036 : :
2037 : 1 : signal_id = g_signal_lookup ("generic-marshaller-int-return", test_get_type ());
2038 : 1 : g_assert_cmpuint (signal_id, >, 0);
2039 : 1 : g_array_set_size (values, 1);
2040 : :
2041 : 1 : id = g_signal_connect (test,
2042 : : "generic-marshaller-int-return",
2043 : : G_CALLBACK (on_generic_marshaller_int_return_signed_1),
2044 : : NULL);
2045 : :
2046 : 1 : count = 0;
2047 : 1 : hook = g_signal_add_emission_hook (signal_id, 0, hook_func, &count, NULL);
2048 : 1 : g_assert_cmpint (count, ==, 0);
2049 : 1 : g_value_init (&return_value, G_TYPE_INT);
2050 : 1 : g_signal_emitv ((GValue *) values->data, signal_id, 0, &return_value);
2051 : 1 : g_assert_cmpint (count, ==, 1);
2052 : 1 : g_assert_cmpint (g_value_get_int (&return_value), ==, -30);
2053 : 1 : g_signal_remove_emission_hook (signal_id, hook);
2054 : 1 : g_clear_signal_handler (&id, test);
2055 : :
2056 : : #ifdef G_ENABLE_DEBUG
2057 : 1 : g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2058 : : "*return*value*generic-marshaller-int-return*NULL*");
2059 : 1 : g_signal_emitv ((GValue *) values->data, signal_id, 0, NULL);
2060 : 1 : g_test_assert_expected_messages ();
2061 : :
2062 : 1 : g_value_unset (&return_value);
2063 : 1 : g_value_init (&return_value, G_TYPE_FLOAT);
2064 : 1 : g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
2065 : : "*return*value*generic-marshaller-int-return*gfloat*");
2066 : 1 : g_signal_emitv ((GValue *) values->data, signal_id, 0, &return_value);
2067 : 1 : g_test_assert_expected_messages ();
2068 : : #endif
2069 : :
2070 : 1 : g_object_unref (test);
2071 : 1 : g_array_unref (values);
2072 : 1 : }
2073 : :
2074 : : typedef struct
2075 : : {
2076 : : GWeakRef wr;
2077 : : gulong handler;
2078 : : } TestWeakRefDisconnect;
2079 : :
2080 : : static void
2081 : 1 : weak_ref_disconnect_notify (gpointer data,
2082 : : GObject *where_object_was)
2083 : : {
2084 : 1 : TestWeakRefDisconnect *state = data;
2085 : 1 : g_assert_null (g_weak_ref_get (&state->wr));
2086 : 1 : state->handler = 0;
2087 : 1 : }
2088 : :
2089 : : static void
2090 : 1 : test_weak_ref_disconnect (void)
2091 : : {
2092 : : TestWeakRefDisconnect state;
2093 : : GObject *test;
2094 : :
2095 : 1 : test = g_object_new (test_get_type (), NULL);
2096 : 1 : g_weak_ref_init (&state.wr, test);
2097 : 1 : state.handler = g_signal_connect_data (test,
2098 : : "simple",
2099 : : G_CALLBACK (dont_reach),
2100 : : &state,
2101 : : (GClosureNotify) weak_ref_disconnect_notify,
2102 : : 0);
2103 : 1 : g_assert_cmpuint (state.handler, >, 0);
2104 : :
2105 : 1 : g_object_unref (test);
2106 : :
2107 : 1 : g_assert_cmpuint (state.handler, ==, 0);
2108 : 1 : g_assert_null (g_weak_ref_get (&state.wr));
2109 : 1 : g_weak_ref_clear (&state.wr);
2110 : 1 : }
2111 : :
2112 : : /* --- */
2113 : :
2114 : : int
2115 : 1 : main (int argc,
2116 : : char *argv[])
2117 : : {
2118 : 1 : g_test_init (&argc, &argv, NULL);
2119 : :
2120 : 1 : g_test_add_func ("/gobject/signals/all-types", test_all_types);
2121 : 1 : g_test_add_func ("/gobject/signals/variant", test_variant_signal);
2122 : 1 : g_test_add_func ("/gobject/signals/destroy-target-object", test_destroy_target_object);
2123 : 1 : g_test_add_func ("/gobject/signals/generic-marshaller-1", test_generic_marshaller_signal_1);
2124 : 1 : g_test_add_func ("/gobject/signals/generic-marshaller-2", test_generic_marshaller_signal_2);
2125 : 1 : g_test_add_func ("/gobject/signals/generic-marshaller-enum-return-signed", test_generic_marshaller_signal_enum_return_signed);
2126 : 1 : g_test_add_func ("/gobject/signals/generic-marshaller-enum-return-unsigned", test_generic_marshaller_signal_enum_return_unsigned);
2127 : 1 : g_test_add_func ("/gobject/signals/generic-marshaller-int-return", test_generic_marshaller_signal_int_return);
2128 : 1 : g_test_add_func ("/gobject/signals/generic-marshaller-uint-return", test_generic_marshaller_signal_uint_return);
2129 : 1 : g_test_add_func ("/gobject/signals/generic-marshaller-interface-return", test_generic_marshaller_signal_interface_return);
2130 : 1 : g_test_add_func ("/gobject/signals/custom-marshaller", test_custom_marshaller);
2131 : 1 : g_test_add_func ("/gobject/signals/connect", test_connect);
2132 : 1 : g_test_add_func ("/gobject/signals/is-connected", test_is_connected);
2133 : 1 : g_test_add_func ("/gobject/signals/emission-hook", test_emission_hook);
2134 : 1 : g_test_add_func ("/gobject/signals/emitv", test_emitv);
2135 : 1 : g_test_add_func ("/gobject/signals/accumulator", test_accumulator);
2136 : 1 : g_test_add_func ("/gobject/signals/accumulator-class", test_accumulator_class);
2137 : 1 : g_test_add_func ("/gobject/signals/introspection", test_introspection);
2138 : 1 : g_test_add_func ("/gobject/signals/block-handler", test_block_handler);
2139 : 1 : g_test_add_func ("/gobject/signals/stop-emission", test_stop_emission);
2140 : 1 : g_test_add_func ("/gobject/signals/invocation-hint", test_invocation_hint);
2141 : 1 : g_test_add_func ("/gobject/signals/test-disconnection-wrong-object", test_signal_disconnect_wrong_object);
2142 : 1 : g_test_add_func ("/gobject/signals/clear-signal-handler", test_clear_signal_handler);
2143 : 1 : g_test_add_func ("/gobject/signals/lookup", test_lookup);
2144 : 1 : g_test_add_func ("/gobject/signals/lookup/invalid", test_lookup_invalid);
2145 : 1 : g_test_add_func ("/gobject/signals/parse-name", test_parse_name);
2146 : 1 : g_test_add_func ("/gobject/signals/parse-name/invalid", test_parse_name_invalid);
2147 : 1 : g_test_add_data_func ("/gobject/signals/invalid-name/colon", "my_int:hello", test_signals_invalid_name);
2148 : 1 : g_test_add_data_func ("/gobject/signals/invalid-name/first-char", "7zip", test_signals_invalid_name);
2149 : 1 : g_test_add_data_func ("/gobject/signals/invalid-name/empty", "", test_signals_invalid_name);
2150 : 1 : g_test_add_func ("/gobject/signals/is-valid-name", test_signal_is_valid_name);
2151 : 1 : g_test_add_func ("/gobject/signals/weak-ref-disconnect", test_weak_ref_disconnect);
2152 : :
2153 : 1 : return g_test_run ();
2154 : : }
|
