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_cmpnum (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_cmpnum (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, \
14 #n1 " " #cmp " " #n2, __n1, #cmp, __n2, 'i'); \
15 } G_STMT_END
16
17typedef enum {
18 TEST_ENUM_NEGATIVE = -30,
19 TEST_ENUM_NONE = 0,
20 TEST_ENUM_FOO = 1,
21 TEST_ENUM_BAR = 2
22} TestEnum;
23
24typedef 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
32static void
33custom_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 GCClosure *cc = (GCClosure*) closure;
45 gpointer data1, data2;
46
47 g_return_if_fail (n_param_values == 2);
48
49 if (G_CCLOSURE_SWAP_DATA (closure))
50 {
51 data1 = closure->data;
52 data2 = g_value_peek_pointer (value: param_values + 0);
53 }
54 else
55 {
56 data1 = g_value_peek_pointer (value: param_values + 0);
57 data2 = closure->data;
58 }
59 callback = (GMarshalFunc_VOID__INVOCATIONHINT) (marshal_data ? marshal_data : cc->callback);
60
61 callback (data1,
62 invocation_hint,
63 data2);
64}
65
66static GType
67test_enum_get_type (void)
68{
69 static gsize static_g_define_type_id = 0;
70
71 if (g_once_init_enter (&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 g_enum_register_static (name: g_intern_static_string (string: "TestEnum"), const_static_values: values);
82 g_once_init_leave (&static_g_define_type_id, g_define_type_id);
83 }
84
85 return static_g_define_type_id;
86}
87
88static GType
89test_unsigned_enum_get_type (void)
90{
91 static gsize static_g_define_type_id = 0;
92
93 if (g_once_init_enter (&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 g_enum_register_static (name: g_intern_static_string (string: "TestUnsignedEnum"), const_static_values: values);
102 g_once_init_leave (&static_g_define_type_id, g_define_type_id);
103 }
104
105 return static_g_define_type_id;
106}
107
108typedef enum {
109 MY_ENUM_VALUE = 1,
110} MyEnum;
111
112static const GEnumValue my_enum_values[] =
113{
114 { MY_ENUM_VALUE, "the first value", "one" },
115 { 0, NULL, NULL }
116};
117
118typedef enum {
119 MY_FLAGS_FIRST_BIT = (1 << 0),
120 MY_FLAGS_THIRD_BIT = (1 << 2),
121 MY_FLAGS_LAST_BIT = (1 << 31)
122} MyFlags;
123
124static 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
132static GType enum_type;
133static GType flags_type;
134
135static guint simple_id;
136static guint simple2_id;
137
138typedef struct {
139 GTypeInterface g_iface;
140} FooInterface;
141
142GType foo_get_type (void);
143
144G_DEFINE_INTERFACE (Foo, foo, G_TYPE_OBJECT)
145
146static void
147foo_default_init (FooInterface *iface)
148{
149}
150
151typedef struct {
152 GObject parent;
153} Baa;
154
155typedef struct {
156 GObjectClass parent_class;
157} BaaClass;
158
159static void
160baa_init_foo (FooInterface *iface)
161{
162}
163
164GType baa_get_type (void);
165
166G_DEFINE_TYPE_WITH_CODE (Baa, baa, G_TYPE_OBJECT,
167 G_IMPLEMENT_INTERFACE (foo_get_type (), baa_init_foo))
168
169static void
170baa_init (Baa *baa)
171{
172}
173
174static void
175baa_class_init (BaaClass *class)
176{
177}
178
179typedef struct _Test Test;
180typedef struct _TestClass TestClass;
181
182struct _Test
183{
184 GObject parent_instance;
185};
186
187static 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);
188static gboolean accumulator_sum (GSignalInvocationHint *ihint, GValue *return_accu, const GValue *handler_return, gpointer data);
189static gboolean accumulator_concat_string (GSignalInvocationHint *ihint, GValue *return_accu, const GValue *handler_return, gpointer data);
190static gchar * accumulator_class (Test *test);
191
192struct _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
202static GType test_get_type (void);
203G_DEFINE_TYPE (Test, test, G_TYPE_OBJECT)
204
205static void
206test_init (Test *test)
207{
208}
209
210static void
211test_class_init (TestClass *klass)
212{
213 guint s;
214
215 enum_type = g_enum_register_static (name: "MyEnum", const_static_values: my_enum_values);
216 flags_type = g_flags_register_static (name: "MyFlag", const_static_values: my_flag_values);
217
218 klass->all_types = all_types_handler;
219 klass->accumulator_class = accumulator_class;
220
221 simple_id = g_signal_new (signal_name: "simple",
222 G_TYPE_FROM_CLASS (klass),
223 signal_flags: G_SIGNAL_RUN_LAST,
224 class_offset: 0,
225 NULL, NULL,
226 NULL,
227 G_TYPE_NONE,
228 n_params: 0);
229 g_signal_new (signal_name: "simple-detailed",
230 G_TYPE_FROM_CLASS (klass),
231 signal_flags: G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
232 class_offset: 0,
233 NULL, NULL,
234 NULL,
235 G_TYPE_NONE,
236 n_params: 0);
237 /* Deliberately install this one in non-canonical form to check that’s handled correctly: */
238 simple2_id = g_signal_new (signal_name: "simple_2",
239 G_TYPE_FROM_CLASS (klass),
240 signal_flags: G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
241 class_offset: 0,
242 NULL, NULL,
243 NULL,
244 G_TYPE_NONE,
245 n_params: 0);
246 g_signal_new (signal_name: "simple-accumulator",
247 G_TYPE_FROM_CLASS (klass),
248 signal_flags: G_SIGNAL_RUN_LAST,
249 class_offset: 0,
250 accumulator: accumulator_sum, NULL,
251 NULL,
252 G_TYPE_INT,
253 n_params: 0);
254 g_signal_new (signal_name: "accumulator-class-first",
255 G_TYPE_FROM_CLASS (klass),
256 signal_flags: G_SIGNAL_RUN_FIRST,
257 G_STRUCT_OFFSET (TestClass, accumulator_class),
258 accumulator: accumulator_concat_string, NULL,
259 NULL,
260 G_TYPE_STRING,
261 n_params: 0);
262 g_signal_new (signal_name: "accumulator-class-last",
263 G_TYPE_FROM_CLASS (klass),
264 signal_flags: G_SIGNAL_RUN_LAST,
265 G_STRUCT_OFFSET (TestClass, accumulator_class),
266 accumulator: accumulator_concat_string, NULL,
267 NULL,
268 G_TYPE_STRING,
269 n_params: 0);
270 g_signal_new (signal_name: "accumulator-class-cleanup",
271 G_TYPE_FROM_CLASS (klass),
272 signal_flags: G_SIGNAL_RUN_CLEANUP,
273 G_STRUCT_OFFSET (TestClass, accumulator_class),
274 accumulator: accumulator_concat_string, NULL,
275 NULL,
276 G_TYPE_STRING,
277 n_params: 0);
278 g_signal_new (signal_name: "accumulator-class-first-last",
279 G_TYPE_FROM_CLASS (klass),
280 signal_flags: G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST,
281 G_STRUCT_OFFSET (TestClass, accumulator_class),
282 accumulator: accumulator_concat_string, NULL,
283 NULL,
284 G_TYPE_STRING,
285 n_params: 0);
286 g_signal_new (signal_name: "accumulator-class-first-last-cleanup",
287 G_TYPE_FROM_CLASS (klass),
288 signal_flags: G_SIGNAL_RUN_FIRST | G_SIGNAL_RUN_LAST | G_SIGNAL_RUN_CLEANUP,
289 G_STRUCT_OFFSET (TestClass, accumulator_class),
290 accumulator: accumulator_concat_string, NULL,
291 NULL,
292 G_TYPE_STRING,
293 n_params: 0);
294 g_signal_new (signal_name: "accumulator-class-last-cleanup",
295 G_TYPE_FROM_CLASS (klass),
296 signal_flags: G_SIGNAL_RUN_LAST | G_SIGNAL_RUN_CLEANUP,
297 G_STRUCT_OFFSET (TestClass, accumulator_class),
298 accumulator: accumulator_concat_string, NULL,
299 NULL,
300 G_TYPE_STRING,
301 n_params: 0);
302 g_signal_new (signal_name: "generic-marshaller-1",
303 G_TYPE_FROM_CLASS (klass),
304 signal_flags: G_SIGNAL_RUN_LAST,
305 class_offset: 0,
306 NULL, NULL,
307 NULL,
308 G_TYPE_NONE,
309 n_params: 7,
310 G_TYPE_CHAR, G_TYPE_UCHAR, G_TYPE_INT, G_TYPE_LONG, G_TYPE_POINTER, G_TYPE_DOUBLE, G_TYPE_FLOAT);
311 g_signal_new (signal_name: "generic-marshaller-2",
312 G_TYPE_FROM_CLASS (klass),
313 signal_flags: G_SIGNAL_RUN_LAST,
314 class_offset: 0,
315 NULL, NULL,
316 NULL,
317 G_TYPE_NONE,
318 n_params: 5,
319 G_TYPE_INT, test_enum_get_type(), G_TYPE_INT, test_unsigned_enum_get_type (), G_TYPE_INT);
320 g_signal_new (signal_name: "generic-marshaller-enum-return-signed",
321 G_TYPE_FROM_CLASS (klass),
322 signal_flags: G_SIGNAL_RUN_LAST,
323 class_offset: 0,
324 NULL, NULL,
325 NULL,
326 return_type: test_enum_get_type(),
327 n_params: 0);
328 g_signal_new (signal_name: "generic-marshaller-enum-return-unsigned",
329 G_TYPE_FROM_CLASS (klass),
330 signal_flags: G_SIGNAL_RUN_LAST,
331 class_offset: 0,
332 NULL, NULL,
333 NULL,
334 return_type: test_unsigned_enum_get_type(),
335 n_params: 0);
336 g_signal_new (signal_name: "generic-marshaller-int-return",
337 G_TYPE_FROM_CLASS (klass),
338 signal_flags: G_SIGNAL_RUN_LAST,
339 class_offset: 0,
340 NULL, NULL,
341 NULL,
342 G_TYPE_INT,
343 n_params: 0);
344 s = g_signal_new (signal_name: "va-marshaller-int-return",
345 G_TYPE_FROM_CLASS (klass),
346 signal_flags: G_SIGNAL_RUN_LAST,
347 class_offset: 0,
348 NULL, NULL,
349 c_marshaller: test_INT__VOID,
350 G_TYPE_INT,
351 n_params: 0);
352 g_signal_set_va_marshaller (signal_id: s, G_TYPE_FROM_CLASS (klass),
353 va_marshaller: test_INT__VOIDv);
354 g_signal_new (signal_name: "generic-marshaller-uint-return",
355 G_TYPE_FROM_CLASS (klass),
356 signal_flags: G_SIGNAL_RUN_LAST,
357 class_offset: 0,
358 NULL, NULL,
359 NULL,
360 G_TYPE_UINT,
361 n_params: 0);
362 g_signal_new (signal_name: "generic-marshaller-interface-return",
363 G_TYPE_FROM_CLASS (klass),
364 signal_flags: G_SIGNAL_RUN_LAST,
365 class_offset: 0,
366 NULL, NULL,
367 NULL,
368 return_type: foo_get_type (),
369 n_params: 0);
370 s = g_signal_new (signal_name: "va-marshaller-uint-return",
371 G_TYPE_FROM_CLASS (klass),
372 signal_flags: G_SIGNAL_RUN_LAST,
373 class_offset: 0,
374 NULL, NULL,
375 c_marshaller: test_INT__VOID,
376 G_TYPE_UINT,
377 n_params: 0);
378 g_signal_set_va_marshaller (signal_id: s, G_TYPE_FROM_CLASS (klass),
379 va_marshaller: test_UINT__VOIDv);
380 g_signal_new (signal_name: "custom-marshaller",
381 G_TYPE_FROM_CLASS (klass),
382 signal_flags: G_SIGNAL_RUN_LAST,
383 class_offset: 0,
384 NULL, NULL,
385 c_marshaller: custom_marshal_VOID__INVOCATIONHINT,
386 G_TYPE_NONE,
387 n_params: 1,
388 G_TYPE_POINTER);
389 g_signal_new (signal_name: "variant-changed-no-slot",
390 G_TYPE_FROM_CLASS (klass),
391 signal_flags: G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,
392 class_offset: 0,
393 NULL, NULL,
394 c_marshaller: g_cclosure_marshal_VOID__VARIANT,
395 G_TYPE_NONE,
396 n_params: 1,
397 G_TYPE_VARIANT);
398 g_signal_new (signal_name: "variant-changed",
399 G_TYPE_FROM_CLASS (klass),
400 signal_flags: G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,
401 G_STRUCT_OFFSET (TestClass, variant_changed),
402 NULL, NULL,
403 c_marshaller: g_cclosure_marshal_VOID__VARIANT,
404 G_TYPE_NONE,
405 n_params: 1,
406 G_TYPE_VARIANT);
407 g_signal_new (signal_name: "all-types",
408 G_TYPE_FROM_CLASS (klass),
409 signal_flags: G_SIGNAL_RUN_LAST,
410 G_STRUCT_OFFSET (TestClass, all_types),
411 NULL, NULL,
412 c_marshaller: 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 n_params: 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 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 s = g_signal_new (signal_name: "all-types-va",
435 G_TYPE_FROM_CLASS (klass),
436 signal_flags: G_SIGNAL_RUN_LAST,
437 G_STRUCT_OFFSET (TestClass, all_types),
438 NULL, NULL,
439 c_marshaller: 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 n_params: 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 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 g_signal_set_va_marshaller (signal_id: s, G_TYPE_FROM_CLASS (klass),
462 va_marshaller: test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64v);
463
464 g_signal_new (signal_name: "all-types-generic",
465 G_TYPE_FROM_CLASS (klass),
466 signal_flags: G_SIGNAL_RUN_LAST,
467 G_STRUCT_OFFSET (TestClass, all_types),
468 NULL, NULL,
469 NULL,
470 G_TYPE_NONE,
471 n_params: 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 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 g_signal_new (signal_name: "all-types-null",
492 G_TYPE_FROM_CLASS (klass),
493 signal_flags: G_SIGNAL_RUN_LAST,
494 G_STRUCT_OFFSET (TestClass, all_types_null),
495 NULL, NULL,
496 c_marshaller: 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 n_params: 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 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 g_signal_new (signal_name: "all-types-empty",
519 G_TYPE_FROM_CLASS (klass),
520 signal_flags: G_SIGNAL_RUN_LAST,
521 class_offset: 0,
522 NULL, NULL,
523 c_marshaller: 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 n_params: 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 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}
546
547typedef struct _Test Test2;
548typedef struct _TestClass Test2Class;
549
550static GType test2_get_type (void);
551G_DEFINE_TYPE (Test2, test2, G_TYPE_OBJECT)
552
553static void
554test2_init (Test2 *test)
555{
556}
557
558static void
559test2_class_init (Test2Class *klass)
560{
561}
562
563static void
564test_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 test = g_object_new (object_type: test_get_type (), NULL);
574
575 v = g_variant_new_boolean (TRUE);
576 g_variant_ref (value: v);
577 g_assert_true (g_variant_is_floating (v));
578 g_signal_emit_by_name (instance: test, detailed_signal: "variant-changed-no-slot", v);
579 g_assert_false (g_variant_is_floating (v));
580 g_variant_unref (value: v);
581
582 v = g_variant_new_boolean (TRUE);
583 g_variant_ref (value: v);
584 g_assert_true (g_variant_is_floating (v));
585 g_signal_emit_by_name (instance: test, detailed_signal: "variant-changed", v);
586 g_assert_false (g_variant_is_floating (v));
587 g_variant_unref (value: v);
588
589 g_object_unref (object: test);
590}
591
592static void
593on_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 g_assert_cmpint (v_schar, ==, 42);
604 g_assert_cmpint (v_uchar, ==, 43);
605 g_assert_cmpint (v_int, ==, 4096);
606 g_assert_cmpint (v_long, ==, 8192);
607 g_assert_null (v_pointer);
608 g_assert_cmpfloat (v_double, >, 0.0);
609 g_assert_cmpfloat (v_double, <, 1.0);
610 g_assert_cmpfloat (v_float, >, 5.0);
611 g_assert_cmpfloat (v_float, <, 6.0);
612}
613
614static void
615test_generic_marshaller_signal_1 (void)
616{
617 Test *test;
618 test = g_object_new (object_type: test_get_type (), NULL);
619
620 g_signal_connect (test, "generic-marshaller-1", G_CALLBACK (on_generic_marshaller_1), NULL);
621
622 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-1", 42, 43, 4096, 8192, NULL, 0.5, 5.5);
623
624 g_object_unref (object: test);
625}
626
627static void
628on_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 g_assert_cmpint (v_int1, ==, 42);
636 g_assert_cmpint (v_enum, ==, TEST_ENUM_BAR);
637 g_assert_cmpint (v_int2, ==, 43);
638 g_assert_cmpint (v_uenum, ==, TEST_UNSIGNED_ENUM_BAR);
639 g_assert_cmpint (v_int3, ==, 44);
640}
641
642static void
643test_generic_marshaller_signal_2 (void)
644{
645 Test *test;
646 test = g_object_new (object_type: test_get_type (), NULL);
647
648 g_signal_connect (test, "generic-marshaller-2", G_CALLBACK (on_generic_marshaller_2), NULL);
649
650 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-2", 42, TEST_ENUM_BAR, 43, TEST_UNSIGNED_ENUM_BAR, 44);
651
652 g_object_unref (object: test);
653}
654
655static TestEnum
656on_generic_marshaller_enum_return_signed_1 (Test *obj)
657{
658 return TEST_ENUM_NEGATIVE;
659}
660
661static TestEnum
662on_generic_marshaller_enum_return_signed_2 (Test *obj)
663{
664 return TEST_ENUM_BAR;
665}
666
667static void
668test_generic_marshaller_signal_enum_return_signed (void)
669{
670 Test *test;
671 guint id;
672 TestEnum retval = 0;
673
674 test = g_object_new (object_type: test_get_type (), NULL);
675
676 /* Test return value NEGATIVE */
677 id = g_signal_connect (test,
678 "generic-marshaller-enum-return-signed",
679 G_CALLBACK (on_generic_marshaller_enum_return_signed_1),
680 NULL);
681 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-enum-return-signed", &retval);
682 g_assert_cmpint (retval, ==, TEST_ENUM_NEGATIVE);
683 g_signal_handler_disconnect (instance: test, handler_id: id);
684
685 /* Test return value BAR */
686 retval = 0;
687 id = g_signal_connect (test,
688 "generic-marshaller-enum-return-signed",
689 G_CALLBACK (on_generic_marshaller_enum_return_signed_2),
690 NULL);
691 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-enum-return-signed", &retval);
692 g_assert_cmpint (retval, ==, TEST_ENUM_BAR);
693 g_signal_handler_disconnect (instance: test, handler_id: id);
694
695 g_object_unref (object: test);
696}
697
698static TestUnsignedEnum
699on_generic_marshaller_enum_return_unsigned_1 (Test *obj)
700{
701 return TEST_UNSIGNED_ENUM_FOO;
702}
703
704static TestUnsignedEnum
705on_generic_marshaller_enum_return_unsigned_2 (Test *obj)
706{
707 return TEST_UNSIGNED_ENUM_BAR;
708}
709
710static void
711test_generic_marshaller_signal_enum_return_unsigned (void)
712{
713 Test *test;
714 guint id;
715 TestUnsignedEnum retval = 0;
716
717 test = g_object_new (object_type: test_get_type (), NULL);
718
719 /* Test return value FOO */
720 id = g_signal_connect (test,
721 "generic-marshaller-enum-return-unsigned",
722 G_CALLBACK (on_generic_marshaller_enum_return_unsigned_1),
723 NULL);
724 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-enum-return-unsigned", &retval);
725 g_assert_cmpint (retval, ==, TEST_UNSIGNED_ENUM_FOO);
726 g_signal_handler_disconnect (instance: test, handler_id: id);
727
728 /* Test return value BAR */
729 retval = 0;
730 id = g_signal_connect (test,
731 "generic-marshaller-enum-return-unsigned",
732 G_CALLBACK (on_generic_marshaller_enum_return_unsigned_2),
733 NULL);
734 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-enum-return-unsigned", &retval);
735 g_assert_cmpint (retval, ==, TEST_UNSIGNED_ENUM_BAR);
736 g_signal_handler_disconnect (instance: test, handler_id: id);
737
738 g_object_unref (object: test);
739}
740
741/**********************/
742
743static gint
744on_generic_marshaller_int_return_signed_1 (Test *obj)
745{
746 return -30;
747}
748
749static gint
750on_generic_marshaller_int_return_signed_2 (Test *obj)
751{
752 return 2;
753}
754
755static void
756test_generic_marshaller_signal_int_return (void)
757{
758 Test *test;
759 guint id;
760 gint retval = 0;
761
762 test = g_object_new (object_type: test_get_type (), NULL);
763
764 /* Test return value -30 */
765 id = g_signal_connect (test,
766 "generic-marshaller-int-return",
767 G_CALLBACK (on_generic_marshaller_int_return_signed_1),
768 NULL);
769 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-int-return", &retval);
770 g_assert_cmpint (retval, ==, -30);
771 g_signal_handler_disconnect (instance: test, handler_id: id);
772
773 /* Test return value positive */
774 retval = 0;
775 id = g_signal_connect (test,
776 "generic-marshaller-int-return",
777 G_CALLBACK (on_generic_marshaller_int_return_signed_2),
778 NULL);
779 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-int-return", &retval);
780 g_assert_cmpint (retval, ==, 2);
781 g_signal_handler_disconnect (instance: test, handler_id: id);
782
783 /* Same test for va marshaller */
784
785 /* Test return value -30 */
786 id = g_signal_connect (test,
787 "va-marshaller-int-return",
788 G_CALLBACK (on_generic_marshaller_int_return_signed_1),
789 NULL);
790 g_signal_emit_by_name (instance: test, detailed_signal: "va-marshaller-int-return", &retval);
791 g_assert_cmpint (retval, ==, -30);
792 g_signal_handler_disconnect (instance: test, handler_id: id);
793
794 /* Test return value positive */
795 retval = 0;
796 id = g_signal_connect (test,
797 "va-marshaller-int-return",
798 G_CALLBACK (on_generic_marshaller_int_return_signed_2),
799 NULL);
800 g_signal_emit_by_name (instance: test, detailed_signal: "va-marshaller-int-return", &retval);
801 g_assert_cmpint (retval, ==, 2);
802 g_signal_handler_disconnect (instance: test, handler_id: id);
803
804 g_object_unref (object: test);
805}
806
807static guint
808on_generic_marshaller_uint_return_1 (Test *obj)
809{
810 return 1;
811}
812
813static guint
814on_generic_marshaller_uint_return_2 (Test *obj)
815{
816 return G_MAXUINT;
817}
818
819static void
820test_generic_marshaller_signal_uint_return (void)
821{
822 Test *test;
823 guint id;
824 guint retval = 0;
825
826 test = g_object_new (object_type: test_get_type (), NULL);
827
828 id = g_signal_connect (test,
829 "generic-marshaller-uint-return",
830 G_CALLBACK (on_generic_marshaller_uint_return_1),
831 NULL);
832 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-uint-return", &retval);
833 g_assert_cmpint (retval, ==, 1);
834 g_signal_handler_disconnect (instance: test, handler_id: id);
835
836 retval = 0;
837 id = g_signal_connect (test,
838 "generic-marshaller-uint-return",
839 G_CALLBACK (on_generic_marshaller_uint_return_2),
840 NULL);
841 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-uint-return", &retval);
842 g_assert_cmpint (retval, ==, G_MAXUINT);
843 g_signal_handler_disconnect (instance: test, handler_id: id);
844
845 /* Same test for va marshaller */
846
847 id = g_signal_connect (test,
848 "va-marshaller-uint-return",
849 G_CALLBACK (on_generic_marshaller_uint_return_1),
850 NULL);
851 g_signal_emit_by_name (instance: test, detailed_signal: "va-marshaller-uint-return", &retval);
852 g_assert_cmpint (retval, ==, 1);
853 g_signal_handler_disconnect (instance: test, handler_id: id);
854
855 retval = 0;
856 id = g_signal_connect (test,
857 "va-marshaller-uint-return",
858 G_CALLBACK (on_generic_marshaller_uint_return_2),
859 NULL);
860 g_signal_emit_by_name (instance: test, detailed_signal: "va-marshaller-uint-return", &retval);
861 g_assert_cmpint (retval, ==, G_MAXUINT);
862 g_signal_handler_disconnect (instance: test, handler_id: id);
863
864 g_object_unref (object: test);
865}
866
867static gpointer
868on_generic_marshaller_interface_return (Test *test)
869{
870 return g_object_new (object_type: baa_get_type (), NULL);
871}
872
873static void
874test_generic_marshaller_signal_interface_return (void)
875{
876 Test *test;
877 guint id;
878 gpointer retval;
879
880 test = g_object_new (object_type: test_get_type (), NULL);
881
882 /* Test return value -30 */
883 id = g_signal_connect (test,
884 "generic-marshaller-interface-return",
885 G_CALLBACK (on_generic_marshaller_interface_return),
886 NULL);
887 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-interface-return", &retval);
888 g_assert_true (g_type_check_instance_is_a ((GTypeInstance*)retval, foo_get_type ()));
889 g_object_unref (object: retval);
890
891 g_signal_handler_disconnect (instance: test, handler_id: id);
892
893 g_object_unref (object: test);
894}
895
896static const GSignalInvocationHint dont_use_this = { 0, };
897
898static void
899custom_marshaller_callback (Test *test,
900 GSignalInvocationHint *hint,
901 gpointer unused)
902{
903 GSignalInvocationHint *ihint;
904
905 g_assert_true (hint != &dont_use_this);
906
907 ihint = g_signal_get_invocation_hint (instance: test);
908
909 g_assert_cmpuint (hint->signal_id, ==, ihint->signal_id);
910 g_assert_cmpuint (hint->detail , ==, ihint->detail);
911 g_assert_cmpflags (GSignalFlags, hint->run_type, ==, ihint->run_type);
912}
913
914static void
915test_custom_marshaller (void)
916{
917 Test *test;
918
919 test = g_object_new (object_type: test_get_type (), NULL);
920
921 g_signal_connect (test,
922 "custom-marshaller",
923 G_CALLBACK (custom_marshaller_callback),
924 NULL);
925
926 g_signal_emit_by_name (instance: test, detailed_signal: "custom-marshaller", &dont_use_this);
927
928 g_object_unref (object: test);
929}
930
931static int all_type_handlers_count = 0;
932
933static void
934all_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 all_type_handlers_count++;
937
938 g_assert_cmpint (i, ==, 42);
939 g_assert_cmpint (b, ==, TRUE);
940 g_assert_cmpint (c, ==, 17);
941 g_assert_cmpuint (uc, ==, 140);
942 g_assert_cmpuint (ui, ==, G_MAXUINT - 42);
943 g_assert_cmpint (l, ==, -1117);
944 g_assert_cmpuint (ul, ==, G_MAXULONG - 999);
945 g_assert_cmpenum (MyEnum, e, ==, MY_ENUM_VALUE);
946 g_assert_cmpflags (MyFlags, f, ==, MY_FLAGS_FIRST_BIT | MY_FLAGS_THIRD_BIT | MY_FLAGS_LAST_BIT);
947 g_assert_cmpfloat (fl, ==, 0.25);
948 g_assert_cmpfloat (db, ==, 1.5);
949 g_assert_cmpstr (str, ==, "Test");
950 g_assert_cmpstr (g_param_spec_get_nick (param), ==, "nick");
951 g_assert_cmpstr (g_bytes_get_data (bytes, NULL), ==, "Blah");
952 g_assert_true (ptr == &enum_type);
953 g_assert_cmpuint (g_variant_get_uint16 (var), == , 99);
954 g_assert_cmpint (i64, ==, G_MAXINT64 - 1234);
955 g_assert_cmpuint (ui64, ==, G_MAXUINT64 - 123456);
956}
957
958static void
959all_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 g_assert_true (user_data == &flags_type);
962 all_types_handler (test, i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, obj, var, i64, ui64);
963}
964
965static void
966test_all_types (void)
967{
968 Test *test;
969
970 int i = 42;
971 gboolean b = TRUE;
972 char c = 17;
973 guchar uc = 140;
974 guint ui = G_MAXUINT - 42;
975 glong l = -1117;
976 gulong ul = G_MAXULONG - 999;
977 MyEnum e = MY_ENUM_VALUE;
978 MyFlags f = MY_FLAGS_FIRST_BIT | MY_FLAGS_THIRD_BIT | MY_FLAGS_LAST_BIT;
979 float fl = 0.25;
980 double db = 1.5;
981 char *str = "Test";
982 GParamSpec *param = g_param_spec_long (name: "param", nick: "nick", blurb: "blurb", minimum: 0, maximum: 10, default_value: 4, flags: 0);
983 GBytes *bytes = g_bytes_new_static (data: "Blah", size: 5);
984 gpointer ptr = &enum_type;
985 GVariant *var = g_variant_new_uint16 (value: 99);
986 gint64 i64;
987 guint64 ui64;
988 g_variant_ref_sink (value: var);
989 i64 = G_MAXINT64 - 1234;
990 ui64 = G_MAXUINT64 - 123456;
991
992 test = g_object_new (object_type: test_get_type (), NULL);
993
994 all_type_handlers_count = 0;
995
996 g_signal_emit_by_name (instance: test, detailed_signal: "all-types",
997 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
998 g_signal_emit_by_name (instance: test, detailed_signal: "all-types-va",
999 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1000 g_signal_emit_by_name (instance: test, detailed_signal: "all-types-generic",
1001 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1002 g_signal_emit_by_name (instance: test, detailed_signal: "all-types-empty",
1003 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1004 g_signal_emit_by_name (instance: test, detailed_signal: "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 g_assert_cmpint (all_type_handlers_count, ==, 3);
1008
1009 all_type_handlers_count = 0;
1010
1011 g_signal_connect (test, "all-types", G_CALLBACK (all_types_handler_cb), &flags_type);
1012 g_signal_connect (test, "all-types-va", G_CALLBACK (all_types_handler_cb), &flags_type);
1013 g_signal_connect (test, "all-types-generic", G_CALLBACK (all_types_handler_cb), &flags_type);
1014 g_signal_connect (test, "all-types-empty", G_CALLBACK (all_types_handler_cb), &flags_type);
1015 g_signal_connect (test, "all-types-null", G_CALLBACK (all_types_handler_cb), &flags_type);
1016
1017 g_signal_emit_by_name (instance: test, detailed_signal: "all-types",
1018 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1019 g_signal_emit_by_name (instance: test, detailed_signal: "all-types-va",
1020 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1021 g_signal_emit_by_name (instance: test, detailed_signal: "all-types-generic",
1022 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1023 g_signal_emit_by_name (instance: test, detailed_signal: "all-types-empty",
1024 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1025 g_signal_emit_by_name (instance: test, detailed_signal: "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 g_assert_cmpint (all_type_handlers_count, ==, 3 + 5);
1029
1030 all_type_handlers_count = 0;
1031
1032 g_signal_connect (test, "all-types", G_CALLBACK (all_types_handler_cb), &flags_type);
1033 g_signal_connect (test, "all-types-va", G_CALLBACK (all_types_handler_cb), &flags_type);
1034 g_signal_connect (test, "all-types-generic", G_CALLBACK (all_types_handler_cb), &flags_type);
1035 g_signal_connect (test, "all-types-empty", G_CALLBACK (all_types_handler_cb), &flags_type);
1036 g_signal_connect (test, "all-types-null", G_CALLBACK (all_types_handler_cb), &flags_type);
1037
1038 g_signal_emit_by_name (instance: test, detailed_signal: "all-types",
1039 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1040 g_signal_emit_by_name (instance: test, detailed_signal: "all-types-va",
1041 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1042 g_signal_emit_by_name (instance: test, detailed_signal: "all-types-generic",
1043 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1044 g_signal_emit_by_name (instance: test, detailed_signal: "all-types-empty",
1045 i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
1046 g_signal_emit_by_name (instance: test, detailed_signal: "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 g_assert_cmpint (all_type_handlers_count, ==, 3 + 5 + 5);
1050
1051 g_object_unref (object: test);
1052 g_param_spec_unref (pspec: param);
1053 g_bytes_unref (bytes);
1054 g_variant_unref (value: var);
1055}
1056
1057static void
1058test_connect (void)
1059{
1060 GObject *test;
1061 gint retval;
1062
1063 test = g_object_new (object_type: test_get_type (), NULL);
1064
1065 g_object_connect (object: test,
1066 signal_spec: "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 g_signal_emit_by_name (instance: test, detailed_signal: "generic-marshaller-int-return", &retval);
1074 g_assert_cmpint (retval, ==, -30);
1075 g_signal_emit_by_name (instance: test, detailed_signal: "va-marshaller-int-return", &retval);
1076 g_assert_cmpint (retval, ==, 2);
1077
1078 g_object_disconnect (object: test,
1079 signal_spec: "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 g_object_unref (object: test);
1088}
1089
1090static void
1091simple_handler1 (GObject *sender,
1092 GObject *target)
1093{
1094 g_object_unref (object: target);
1095}
1096
1097static void
1098simple_handler2 (GObject *sender,
1099 GObject *target)
1100{
1101 g_object_unref (object: target);
1102}
1103
1104static void
1105test_destroy_target_object (void)
1106{
1107 Test *sender, *target1, *target2;
1108
1109 sender = g_object_new (object_type: test_get_type (), NULL);
1110 target1 = g_object_new (object_type: test_get_type (), NULL);
1111 target2 = g_object_new (object_type: test_get_type (), NULL);
1112 g_signal_connect_object (instance: sender, detailed_signal: "simple", G_CALLBACK (simple_handler1), gobject: target1, connect_flags: 0);
1113 g_signal_connect_object (instance: sender, detailed_signal: "simple", G_CALLBACK (simple_handler2), gobject: target2, connect_flags: 0);
1114 g_signal_emit_by_name (instance: sender, detailed_signal: "simple");
1115 g_object_unref (object: sender);
1116}
1117
1118static gboolean
1119hook_func (GSignalInvocationHint *ihint,
1120 guint n_params,
1121 const GValue *params,
1122 gpointer data)
1123{
1124 gint *count = data;
1125
1126 (*count)++;
1127
1128 return TRUE;
1129}
1130
1131static void
1132test_emission_hook (void)
1133{
1134 GObject *test1, *test2;
1135 gint count = 0;
1136 gulong hook;
1137
1138 test1 = g_object_new (object_type: test_get_type (), NULL);
1139 test2 = g_object_new (object_type: test_get_type (), NULL);
1140
1141 hook = g_signal_add_emission_hook (signal_id: simple_id, detail: 0, hook_func, hook_data: &count, NULL);
1142 g_assert_cmpint (count, ==, 0);
1143 g_signal_emit_by_name (instance: test1, detailed_signal: "simple");
1144 g_assert_cmpint (count, ==, 1);
1145 g_signal_emit_by_name (instance: test2, detailed_signal: "simple");
1146 g_assert_cmpint (count, ==, 2);
1147 g_signal_remove_emission_hook (signal_id: simple_id, hook_id: hook);
1148 g_signal_emit_by_name (instance: test1, detailed_signal: "simple");
1149 g_assert_cmpint (count, ==, 2);
1150
1151 g_object_unref (object: test1);
1152 g_object_unref (object: test2);
1153}
1154
1155static void
1156simple_cb (gpointer instance, gpointer data)
1157{
1158 GSignalInvocationHint *ihint;
1159
1160 ihint = g_signal_get_invocation_hint (instance);
1161
1162 g_assert_cmpstr (g_signal_name (ihint->signal_id), ==, "simple");
1163
1164 g_signal_emit_by_name (instance, detailed_signal: "simple-2");
1165}
1166
1167static void
1168simple2_cb (gpointer instance, gpointer data)
1169{
1170 GSignalInvocationHint *ihint;
1171
1172 ihint = g_signal_get_invocation_hint (instance);
1173
1174 g_assert_cmpstr (g_signal_name (ihint->signal_id), ==, "simple-2");
1175}
1176
1177static void
1178test_invocation_hint (void)
1179{
1180 GObject *test;
1181
1182 test = g_object_new (object_type: test_get_type (), NULL);
1183
1184 g_signal_connect (test, "simple", G_CALLBACK (simple_cb), NULL);
1185 g_signal_connect (test, "simple-2", G_CALLBACK (simple2_cb), NULL);
1186 g_signal_emit_by_name (instance: test, detailed_signal: "simple");
1187
1188 g_object_unref (object: test);
1189}
1190
1191static gboolean
1192accumulator_sum (GSignalInvocationHint *ihint,
1193 GValue *return_accu,
1194 const GValue *handler_return,
1195 gpointer data)
1196{
1197 gint acc = g_value_get_int (value: return_accu);
1198 gint ret = g_value_get_int (value: handler_return);
1199
1200 g_assert_cmpint (ret, >, 0);
1201
1202 if (ihint->run_type & G_SIGNAL_ACCUMULATOR_FIRST_RUN)
1203 {
1204 g_assert_cmpint (acc, ==, 0);
1205 g_assert_cmpint (ret, ==, 1);
1206 g_assert_true (ihint->run_type & G_SIGNAL_RUN_FIRST);
1207 g_assert_false (ihint->run_type & G_SIGNAL_RUN_LAST);
1208 }
1209 else if (ihint->run_type & G_SIGNAL_RUN_FIRST)
1210 {
1211 /* Only the first signal handler was called so far */
1212 g_assert_cmpint (acc, ==, 1);
1213 g_assert_cmpint (ret, ==, 2);
1214 g_assert_false (ihint->run_type & G_SIGNAL_RUN_LAST);
1215 }
1216 else if (ihint->run_type & G_SIGNAL_RUN_LAST)
1217 {
1218 /* Only the first two signal handler were called so far */
1219 g_assert_cmpint (acc, ==, 3);
1220 g_assert_cmpint (ret, ==, 3);
1221 g_assert_false (ihint->run_type & G_SIGNAL_RUN_FIRST);
1222 }
1223 else
1224 {
1225 g_assert_not_reached ();
1226 }
1227
1228 g_value_set_int (value: return_accu, v_int: acc + ret);
1229
1230 /* Continue with the other signal handlers as long as the sum is < 6,
1231 * i.e. don't run simple_accumulator_4_cb() */
1232 return acc + ret < 6;
1233}
1234
1235static gint
1236simple_accumulator_1_cb (gpointer instance, gpointer data)
1237{
1238 return 1;
1239}
1240
1241static gint
1242simple_accumulator_2_cb (gpointer instance, gpointer data)
1243{
1244 return 2;
1245}
1246
1247static gint
1248simple_accumulator_3_cb (gpointer instance, gpointer data)
1249{
1250 return 3;
1251}
1252
1253static gint
1254simple_accumulator_4_cb (gpointer instance, gpointer data)
1255{
1256 return 4;
1257}
1258
1259static void
1260test_accumulator (void)
1261{
1262 GObject *test;
1263 gint ret = -1;
1264
1265 test = g_object_new (object_type: test_get_type (), NULL);
1266
1267 /* Connect in reverse order to make sure that LAST signal handlers are
1268 * called after FIRST signal handlers but signal handlers in each "group"
1269 * are called in the order they were registered */
1270 g_signal_connect_after (test, "simple-accumulator", G_CALLBACK (simple_accumulator_3_cb), NULL);
1271 g_signal_connect_after (test, "simple-accumulator", G_CALLBACK (simple_accumulator_4_cb), NULL);
1272 g_signal_connect (test, "simple-accumulator", G_CALLBACK (simple_accumulator_1_cb), NULL);
1273 g_signal_connect (test, "simple-accumulator", G_CALLBACK (simple_accumulator_2_cb), NULL);
1274 g_signal_emit_by_name (instance: test, detailed_signal: "simple-accumulator", &ret);
1275
1276 /* simple_accumulator_4_cb() is not run because accumulator is 6 */
1277 g_assert_cmpint (ret, ==, 6);
1278
1279 g_object_unref (object: test);
1280}
1281
1282static gboolean
1283accumulator_concat_string (GSignalInvocationHint *ihint, GValue *return_accu, const GValue *handler_return, gpointer data)
1284{
1285 const gchar *acc = g_value_get_string (value: return_accu);
1286 const gchar *ret = g_value_get_string (value: handler_return);
1287
1288 g_assert_nonnull (ret);
1289
1290 if (acc == NULL)
1291 g_value_set_string (value: return_accu, v_string: ret);
1292 else
1293 g_value_take_string (value: return_accu, v_string: g_strconcat (string1: acc, ret, NULL));
1294
1295 return TRUE;
1296}
1297
1298static gchar *
1299accumulator_class_before_cb (gpointer instance, gpointer data)
1300{
1301 return g_strdup (str: "before");
1302}
1303
1304static gchar *
1305accumulator_class_after_cb (gpointer instance, gpointer data)
1306{
1307 return g_strdup (str: "after");
1308}
1309
1310static gchar *
1311accumulator_class (Test *test)
1312{
1313 return g_strdup (str: "class");
1314}
1315
1316static void
1317test_accumulator_class (void)
1318{
1319 const struct {
1320 const gchar *signal_name;
1321 const gchar *return_string;
1322 } tests[] = {
1323 {"accumulator-class-first", "classbeforeafter"},
1324 {"accumulator-class-last", "beforeclassafter"},
1325 {"accumulator-class-cleanup", "beforeafterclass"},
1326 {"accumulator-class-first-last", "classbeforeclassafter"},
1327 {"accumulator-class-first-last-cleanup", "classbeforeclassafterclass"},
1328 {"accumulator-class-last-cleanup", "beforeclassafterclass"},
1329 };
1330 gsize i;
1331
1332 for (i = 0; i < G_N_ELEMENTS (tests); i++)
1333 {
1334 GObject *test;
1335 gchar *ret = NULL;
1336
1337 g_test_message (format: "Signal: %s", tests[i].signal_name);
1338
1339 test = g_object_new (object_type: test_get_type (), NULL);
1340
1341 g_signal_connect (test, tests[i].signal_name, G_CALLBACK (accumulator_class_before_cb), NULL);
1342 g_signal_connect_after (test, tests[i].signal_name, G_CALLBACK (accumulator_class_after_cb), NULL);
1343 g_signal_emit_by_name (instance: test, detailed_signal: tests[i].signal_name, &ret);
1344
1345 g_assert_cmpstr (ret, ==, tests[i].return_string);
1346 g_free (mem: ret);
1347
1348 g_object_unref (object: test);
1349 }
1350}
1351
1352static gboolean
1353in_set (const gchar *s,
1354 const gchar *set[])
1355{
1356 gint i;
1357
1358 for (i = 0; set[i]; i++)
1359 {
1360 if (g_strcmp0 (str1: s, str2: set[i]) == 0)
1361 return TRUE;
1362 }
1363
1364 return FALSE;
1365}
1366
1367static void
1368test_introspection (void)
1369{
1370 guint *ids;
1371 guint n_ids;
1372 const gchar *name;
1373 guint i;
1374 const gchar *names[] = {
1375 "simple",
1376 "simple-detailed",
1377 "simple-2",
1378 "simple-accumulator",
1379 "accumulator-class-first",
1380 "accumulator-class-last",
1381 "accumulator-class-cleanup",
1382 "accumulator-class-first-last",
1383 "accumulator-class-first-last-cleanup",
1384 "accumulator-class-last-cleanup",
1385 "generic-marshaller-1",
1386 "generic-marshaller-2",
1387 "generic-marshaller-enum-return-signed",
1388 "generic-marshaller-enum-return-unsigned",
1389 "generic-marshaller-int-return",
1390 "va-marshaller-int-return",
1391 "generic-marshaller-uint-return",
1392 "generic-marshaller-interface-return",
1393 "va-marshaller-uint-return",
1394 "variant-changed-no-slot",
1395 "variant-changed",
1396 "all-types",
1397 "all-types-va",
1398 "all-types-generic",
1399 "all-types-null",
1400 "all-types-empty",
1401 "custom-marshaller",
1402 NULL
1403 };
1404 GSignalQuery query;
1405
1406 ids = g_signal_list_ids (itype: test_get_type (), n_ids: &n_ids);
1407 g_assert_cmpuint (n_ids, ==, g_strv_length ((gchar**)names));
1408
1409 for (i = 0; i < n_ids; i++)
1410 {
1411 name = g_signal_name (signal_id: ids[i]);
1412 g_assert_true (in_set (name, names));
1413 }
1414
1415 g_signal_query (signal_id: simple_id, query: &query);
1416 g_assert_cmpuint (query.signal_id, ==, simple_id);
1417 g_assert_cmpstr (query.signal_name, ==, "simple");
1418 g_assert_true (query.itype == test_get_type ());
1419 g_assert_cmpint (query.signal_flags, ==, G_SIGNAL_RUN_LAST);
1420 g_assert_cmpint (query.return_type, ==, G_TYPE_NONE);
1421 g_assert_cmpuint (query.n_params, ==, 0);
1422
1423 g_free (mem: ids);
1424}
1425
1426static void
1427test_handler (gpointer instance, gpointer data)
1428{
1429 gint *count = data;
1430
1431 (*count)++;
1432}
1433
1434static void
1435test_block_handler (void)
1436{
1437 GObject *test1, *test2;
1438 gint count1 = 0;
1439 gint count2 = 0;
1440 gulong handler1, handler;
1441
1442 test1 = g_object_new (object_type: test_get_type (), NULL);
1443 test2 = g_object_new (object_type: test_get_type (), NULL);
1444
1445 handler1 = g_signal_connect (test1, "simple", G_CALLBACK (test_handler), &count1);
1446 g_signal_connect (test2, "simple", G_CALLBACK (test_handler), &count2);
1447
1448 handler = g_signal_handler_find (instance: test1, mask: G_SIGNAL_MATCH_ID, signal_id: simple_id, detail: 0, NULL, NULL, NULL);
1449
1450 g_assert_true (handler == handler1);
1451
1452 g_assert_cmpint (count1, ==, 0);
1453 g_assert_cmpint (count2, ==, 0);
1454
1455 g_signal_emit_by_name (instance: test1, detailed_signal: "simple");
1456 g_signal_emit_by_name (instance: test2, detailed_signal: "simple");
1457
1458 g_assert_cmpint (count1, ==, 1);
1459 g_assert_cmpint (count2, ==, 1);
1460
1461 g_signal_handler_block (instance: test1, handler_id: handler1);
1462
1463 g_signal_emit_by_name (instance: test1, detailed_signal: "simple");
1464 g_signal_emit_by_name (instance: test2, detailed_signal: "simple");
1465
1466 g_assert_cmpint (count1, ==, 1);
1467 g_assert_cmpint (count2, ==, 2);
1468
1469 g_signal_handler_unblock (instance: test1, handler_id: handler1);
1470
1471 g_signal_emit_by_name (instance: test1, detailed_signal: "simple");
1472 g_signal_emit_by_name (instance: test2, detailed_signal: "simple");
1473
1474 g_assert_cmpint (count1, ==, 2);
1475 g_assert_cmpint (count2, ==, 3);
1476
1477 g_assert_cmpuint (g_signal_handlers_block_matched (test1, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, test_block_handler, NULL), ==, 0);
1478 g_assert_cmpuint (g_signal_handlers_block_matched (test2, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, test_handler, NULL), ==, 1);
1479
1480 g_signal_emit_by_name (instance: test1, detailed_signal: "simple");
1481 g_signal_emit_by_name (instance: test2, detailed_signal: "simple");
1482
1483 g_assert_cmpint (count1, ==, 3);
1484 g_assert_cmpint (count2, ==, 3);
1485
1486 g_signal_handlers_unblock_matched (instance: test2, mask: G_SIGNAL_MATCH_FUNC, signal_id: 0, detail: 0, NULL, func: test_handler, NULL);
1487
1488 g_object_unref (object: test1);
1489 g_object_unref (object: test2);
1490}
1491
1492static void
1493stop_emission (gpointer instance, gpointer data)
1494{
1495 g_signal_stop_emission (instance, signal_id: simple_id, detail: 0);
1496}
1497
1498static void
1499stop_emission_by_name (gpointer instance, gpointer data)
1500{
1501 g_signal_stop_emission_by_name (instance, detailed_signal: "simple");
1502}
1503
1504static void
1505dont_reach (gpointer instance, gpointer data)
1506{
1507 g_assert_not_reached ();
1508}
1509
1510static void
1511test_stop_emission (void)
1512{
1513 GObject *test1;
1514 gulong handler;
1515
1516 test1 = g_object_new (object_type: test_get_type (), NULL);
1517 handler = g_signal_connect (test1, "simple", G_CALLBACK (stop_emission), NULL);
1518 g_signal_connect_after (test1, "simple", G_CALLBACK (dont_reach), NULL);
1519
1520 g_signal_emit_by_name (instance: test1, detailed_signal: "simple");
1521
1522 g_signal_handler_disconnect (instance: test1, handler_id: handler);
1523 g_signal_connect (test1, "simple", G_CALLBACK (stop_emission_by_name), NULL);
1524
1525 g_signal_emit_by_name (instance: test1, detailed_signal: "simple");
1526
1527 g_object_unref (object: test1);
1528}
1529
1530static void
1531test_signal_disconnect_wrong_object (void)
1532{
1533 Test *object, *object2;
1534 Test2 *object3;
1535 guint signal_id;
1536
1537 object = g_object_new (object_type: test_get_type (), NULL);
1538 object2 = g_object_new (object_type: test_get_type (), NULL);
1539 object3 = g_object_new (object_type: test2_get_type (), NULL);
1540
1541 signal_id = g_signal_connect (object,
1542 "simple",
1543 G_CALLBACK (simple_handler1),
1544 NULL);
1545
1546 /* disconnect from the wrong object (same type), should warn */
1547 g_test_expect_message (log_domain: "GLib-GObject", log_level: G_LOG_LEVEL_WARNING,
1548 pattern: "*: instance '*' has no handler with id '*'");
1549 g_signal_handler_disconnect (instance: object2, handler_id: signal_id);
1550 g_test_assert_expected_messages ();
1551
1552 /* and from an object of the wrong type */
1553 g_test_expect_message (log_domain: "GLib-GObject", log_level: G_LOG_LEVEL_WARNING,
1554 pattern: "*: instance '*' has no handler with id '*'");
1555 g_signal_handler_disconnect (instance: object3, handler_id: signal_id);
1556 g_test_assert_expected_messages ();
1557
1558 /* it's still connected */
1559 g_assert_true (g_signal_handler_is_connected (object, signal_id));
1560
1561 g_object_unref (object);
1562 g_object_unref (object: object2);
1563 g_object_unref (object: object3);
1564}
1565
1566static void
1567test_clear_signal_handler (void)
1568{
1569 GObject *test_obj;
1570 gulong handler;
1571
1572 test_obj = g_object_new (object_type: test_get_type (), NULL);
1573
1574 handler = g_signal_connect (test_obj, "simple", G_CALLBACK (dont_reach), NULL);
1575 g_assert_cmpuint (handler, >, 0);
1576
1577 g_clear_signal_handler (&handler, test_obj);
1578 g_assert_cmpuint (handler, ==, 0);
1579
1580 g_signal_emit_by_name (instance: test_obj, detailed_signal: "simple");
1581
1582 g_clear_signal_handler (&handler, test_obj);
1583
1584 if (g_test_undefined ())
1585 {
1586 handler = g_random_int_range (begin: 0x01, end: 0xFF);
1587 g_test_expect_message (G_LOG_DOMAIN, log_level: G_LOG_LEVEL_WARNING,
1588 pattern: "*instance '* has no handler with id *'");
1589 g_clear_signal_handler (&handler, test_obj);
1590 g_assert_cmpuint (handler, ==, 0);
1591 g_test_assert_expected_messages ();
1592 }
1593
1594 g_object_unref (object: test_obj);
1595}
1596
1597static void
1598test_lookup (void)
1599{
1600 GTypeClass *test_class;
1601 guint signal_id, saved_signal_id;
1602
1603 g_test_summary (summary: "Test that g_signal_lookup() works with a variety of inputs.");
1604
1605 test_class = g_type_class_ref (type: test_get_type ());
1606
1607 signal_id = g_signal_lookup (name: "all-types", itype: test_get_type ());
1608 g_assert_cmpint (signal_id, !=, 0);
1609
1610 saved_signal_id = signal_id;
1611
1612 /* Try with a non-canonical name. */
1613 signal_id = g_signal_lookup (name: "all_types", itype: test_get_type ());
1614 g_assert_cmpint (signal_id, ==, saved_signal_id);
1615
1616 /* Looking up a non-existent signal should return nothing. */
1617 g_assert_cmpint (g_signal_lookup ("nope", test_get_type ()), ==, 0);
1618
1619 g_type_class_unref (g_class: test_class);
1620}
1621
1622static void
1623test_lookup_invalid (void)
1624{
1625 g_test_summary (summary: "Test that g_signal_lookup() emits a warning if looking up an invalid signal name.");
1626
1627 if (g_test_subprocess ())
1628 {
1629 GTypeClass *test_class;
1630 guint signal_id;
1631
1632 test_class = g_type_class_ref (type: test_get_type ());
1633
1634 signal_id = g_signal_lookup (name: "", itype: test_get_type ());
1635 g_assert_cmpint (signal_id, ==, 0);
1636
1637 g_type_class_unref (g_class: test_class);
1638 return;
1639 }
1640
1641 g_test_trap_subprocess (NULL, usec_timeout: 0, test_flags: 0);
1642 g_test_trap_assert_failed ();
1643 g_test_trap_assert_stderr ("*WARNING*unable to look up invalid signal name*");
1644}
1645
1646static void
1647test_parse_name (void)
1648{
1649 GTypeClass *test_class;
1650 guint signal_id, saved_signal_id;
1651 gboolean retval;
1652 GQuark detail, saved_detail;
1653
1654 g_test_summary (summary: "Test that g_signal_parse_name() works with a variety of inputs.");
1655
1656 test_class = g_type_class_ref (type: test_get_type ());
1657
1658 /* Simple test. */
1659 retval = g_signal_parse_name (detailed_signal: "simple-detailed", itype: test_get_type (), signal_id_p: &signal_id, detail_p: &detail, TRUE);
1660 g_assert_true (retval);
1661 g_assert_cmpint (signal_id, !=, 0);
1662 g_assert_cmpint (detail, ==, 0);
1663
1664 saved_signal_id = signal_id;
1665
1666 /* Simple test with detail. */
1667 retval = g_signal_parse_name (detailed_signal: "simple-detailed::a-detail", itype: test_get_type (), signal_id_p: &signal_id, detail_p: &detail, TRUE);
1668 g_assert_true (retval);
1669 g_assert_cmpint (signal_id, ==, saved_signal_id);
1670 g_assert_cmpint (detail, !=, 0);
1671
1672 saved_detail = detail;
1673
1674 /* Simple test with the same detail again. */
1675 retval = g_signal_parse_name (detailed_signal: "simple-detailed::a-detail", itype: test_get_type (), signal_id_p: &signal_id, detail_p: &detail, FALSE);
1676 g_assert_true (retval);
1677 g_assert_cmpint (signal_id, ==, saved_signal_id);
1678 g_assert_cmpint (detail, ==, saved_detail);
1679
1680 /* Simple test with a new detail. */
1681 retval = g_signal_parse_name (detailed_signal: "simple-detailed::another-detail", itype: test_get_type (), signal_id_p: &signal_id, detail_p: &detail, FALSE);
1682 g_assert_true (retval);
1683 g_assert_cmpint (signal_id, ==, saved_signal_id);
1684 g_assert_cmpint (detail, ==, 0); /* we didn’t force the quark */
1685
1686 /* Canonicalisation shouldn’t affect the results. */
1687 retval = g_signal_parse_name (detailed_signal: "simple_detailed::a-detail", itype: test_get_type (), signal_id_p: &signal_id, detail_p: &detail, FALSE);
1688 g_assert_true (retval);
1689 g_assert_cmpint (signal_id, ==, saved_signal_id);
1690 g_assert_cmpint (detail, ==, saved_detail);
1691
1692 /* Details don’t have to look like property names. */
1693 retval = g_signal_parse_name (detailed_signal: "simple-detailed::hello::world", itype: test_get_type (), signal_id_p: &signal_id, detail_p: &detail, TRUE);
1694 g_assert_true (retval);
1695 g_assert_cmpint (signal_id, ==, saved_signal_id);
1696 g_assert_cmpint (detail, !=, 0);
1697
1698 /* Trying to parse a detail for a signal which isn’t %G_SIGNAL_DETAILED should fail. */
1699 retval = g_signal_parse_name (detailed_signal: "all-types::a-detail", itype: test_get_type (), signal_id_p: &signal_id, detail_p: &detail, FALSE);
1700 g_assert_false (retval);
1701
1702 g_type_class_unref (g_class: test_class);
1703}
1704
1705static void
1706test_parse_name_invalid (void)
1707{
1708 GTypeClass *test_class;
1709 gsize i;
1710 guint signal_id;
1711 GQuark detail;
1712 const gchar *vectors[] =
1713 {
1714 "",
1715 "7zip",
1716 "invalid:signal",
1717 "simple-detailed::",
1718 "simple-detailed:",
1719 ":",
1720 "::",
1721 ":valid-detail",
1722 "::valid-detail",
1723 };
1724
1725 g_test_summary (summary: "Test that g_signal_parse_name() ignores a variety of invalid inputs.");
1726
1727 test_class = g_type_class_ref (type: test_get_type ());
1728
1729 for (i = 0; i < G_N_ELEMENTS (vectors); i++)
1730 {
1731 g_test_message (format: "Parser input: %s", vectors[i]);
1732 g_assert_false (g_signal_parse_name (vectors[i], test_get_type (), &signal_id, &detail, TRUE));
1733 }
1734
1735 g_type_class_unref (g_class: test_class);
1736}
1737
1738static void
1739test_signals_invalid_name (gconstpointer test_data)
1740{
1741 const gchar *signal_name = test_data;
1742
1743 g_test_summary (summary: "Check that g_signal_new() rejects invalid signal names.");
1744
1745 if (g_test_subprocess ())
1746 {
1747 g_signal_new (signal_name,
1748 itype: test_get_type (),
1749 signal_flags: G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
1750 class_offset: 0,
1751 NULL, NULL,
1752 NULL,
1753 G_TYPE_NONE,
1754 n_params: 0);
1755 return;
1756 }
1757
1758 g_test_trap_subprocess (NULL, usec_timeout: 0, test_flags: 0);
1759 g_test_trap_assert_failed ();
1760 g_test_trap_assert_stderr ("*CRITICAL*g_signal_is_valid_name (signal_name)*");
1761}
1762
1763static void
1764test_signal_is_valid_name (void)
1765{
1766 const gchar *valid_names[] =
1767 {
1768 "signal",
1769 "i",
1770 "multiple-segments",
1771 "segment0-SEGMENT1",
1772 "using_underscores",
1773 };
1774 const gchar *invalid_names[] =
1775 {
1776 "",
1777 "7zip",
1778 "my_int:hello",
1779 };
1780 gsize i;
1781
1782 for (i = 0; i < G_N_ELEMENTS (valid_names); i++)
1783 g_assert_true (g_signal_is_valid_name (valid_names[i]));
1784
1785 for (i = 0; i < G_N_ELEMENTS (invalid_names); i++)
1786 g_assert_false (g_signal_is_valid_name (invalid_names[i]));
1787}
1788
1789/* --- */
1790
1791int
1792main (int argc,
1793 char *argv[])
1794{
1795 g_test_init (argc: &argc, argv: &argv, NULL);
1796
1797 g_test_add_func (testpath: "/gobject/signals/all-types", test_func: test_all_types);
1798 g_test_add_func (testpath: "/gobject/signals/variant", test_func: test_variant_signal);
1799 g_test_add_func (testpath: "/gobject/signals/destroy-target-object", test_func: test_destroy_target_object);
1800 g_test_add_func (testpath: "/gobject/signals/generic-marshaller-1", test_func: test_generic_marshaller_signal_1);
1801 g_test_add_func (testpath: "/gobject/signals/generic-marshaller-2", test_func: test_generic_marshaller_signal_2);
1802 g_test_add_func (testpath: "/gobject/signals/generic-marshaller-enum-return-signed", test_func: test_generic_marshaller_signal_enum_return_signed);
1803 g_test_add_func (testpath: "/gobject/signals/generic-marshaller-enum-return-unsigned", test_func: test_generic_marshaller_signal_enum_return_unsigned);
1804 g_test_add_func (testpath: "/gobject/signals/generic-marshaller-int-return", test_func: test_generic_marshaller_signal_int_return);
1805 g_test_add_func (testpath: "/gobject/signals/generic-marshaller-uint-return", test_func: test_generic_marshaller_signal_uint_return);
1806 g_test_add_func (testpath: "/gobject/signals/generic-marshaller-interface-return", test_func: test_generic_marshaller_signal_interface_return);
1807 g_test_add_func (testpath: "/gobject/signals/custom-marshaller", test_func: test_custom_marshaller);
1808 g_test_add_func (testpath: "/gobject/signals/connect", test_func: test_connect);
1809 g_test_add_func (testpath: "/gobject/signals/emission-hook", test_func: test_emission_hook);
1810 g_test_add_func (testpath: "/gobject/signals/accumulator", test_func: test_accumulator);
1811 g_test_add_func (testpath: "/gobject/signals/accumulator-class", test_func: test_accumulator_class);
1812 g_test_add_func (testpath: "/gobject/signals/introspection", test_func: test_introspection);
1813 g_test_add_func (testpath: "/gobject/signals/block-handler", test_func: test_block_handler);
1814 g_test_add_func (testpath: "/gobject/signals/stop-emission", test_func: test_stop_emission);
1815 g_test_add_func (testpath: "/gobject/signals/invocation-hint", test_func: test_invocation_hint);
1816 g_test_add_func (testpath: "/gobject/signals/test-disconnection-wrong-object", test_func: test_signal_disconnect_wrong_object);
1817 g_test_add_func (testpath: "/gobject/signals/clear-signal-handler", test_func: test_clear_signal_handler);
1818 g_test_add_func (testpath: "/gobject/signals/lookup", test_func: test_lookup);
1819 g_test_add_func (testpath: "/gobject/signals/lookup/invalid", test_func: test_lookup_invalid);
1820 g_test_add_func (testpath: "/gobject/signals/parse-name", test_func: test_parse_name);
1821 g_test_add_func (testpath: "/gobject/signals/parse-name/invalid", test_func: test_parse_name_invalid);
1822 g_test_add_data_func (testpath: "/gobject/signals/invalid-name/colon", test_data: "my_int:hello", test_func: test_signals_invalid_name);
1823 g_test_add_data_func (testpath: "/gobject/signals/invalid-name/first-char", test_data: "7zip", test_func: test_signals_invalid_name);
1824 g_test_add_data_func (testpath: "/gobject/signals/invalid-name/empty", test_data: "", test_func: test_signals_invalid_name);
1825 g_test_add_func (testpath: "/gobject/signals/is-valid-name", test_func: test_signal_is_valid_name);
1826
1827 return g_test_run ();
1828}
1829

source code of gtk/subprojects/glib/gobject/tests/signals.c