gobject/tests/signals.c

   1 #include <glib-object.h>
   2 #include "marshalers.h"
   3
   4 typedef enum {
   5   TEST_ENUM_NEGATIVE = -30,
   6   TEST_ENUM_NONE = 0,
   7   TEST_ENUM_FOO = 1,
   8   TEST_ENUM_BAR = 2
   9 } TestEnum;
  10
  11 typedef enum {
  12   TEST_UNSIGNED_ENUM_FOO = 1,
  13   TEST_UNSIGNED_ENUM_BAR = 0x80000000
  14 } TestUnsignedEnum;
  15
  16 static GType
  17 test_enum_get_type (void)
  18 {
  19   static volatile gsize g_define_type_id__volatile = 0;
  20
  21   if (g_once_init_enter (&g_define_type_id__volatile))
  22     {
  23       static const GEnumValue values[] = {
  24         { TEST_ENUM_NEGATIVE, "TEST_ENUM_NEGATIVE", "negative" },
  25         { TEST_ENUM_NONE, "TEST_ENUM_NONE", "none" },
  26         { TEST_ENUM_FOO, "TEST_ENUM_FOO", "foo" },
  27         { TEST_ENUM_BAR, "TEST_ENUM_BAR", "bar" },
  28         { 0, NULL, NULL }
  29       };
  30       GType g_define_type_id =
  31         g_enum_register_static (g_intern_static_string ("TestEnum"), values);
  32       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  33     }
  34
  35   return g_define_type_id__volatile;
  36 }
  37
  38 static GType
  39 test_unsigned_enum_get_type (void)
  40 {
  41   static volatile gsize g_define_type_id__volatile = 0;
  42
  43   if (g_once_init_enter (&g_define_type_id__volatile))
  44     {
  45       static const GEnumValue values[] = {
  46         { TEST_UNSIGNED_ENUM_FOO, "TEST_UNSIGNED_ENUM_FOO", "foo" },
  47         { TEST_UNSIGNED_ENUM_BAR, "TEST_UNSIGNED_ENUM_BAR", "bar" },
  48         { 0, NULL, NULL }
  49       };
  50       GType g_define_type_id =
  51         g_enum_register_static (g_intern_static_string ("TestUnsignedEnum"), values);
  52       g_once_init_leave (&g_define_type_id__volatile, g_define_type_id);
  53     }
  54
  55   return g_define_type_id__volatile;
  56 }
  57
  58
  59 static const GEnumValue my_enum_values[] =
  60 {
  61   { 1, "the first value", "one" },
  62   { 0, NULL, NULL }
  63 };
  64
  65 static const GFlagsValue my_flag_values[] =
  66 {
  67   { 1, "the first value", "one" },
  68   { 0, NULL, NULL }
  69 };
  70
  71 static GType enum_type;
  72 static GType flags_type;
  73
  74
  75 typedef struct _Test Test;
  76 typedef struct _TestClass TestClass;
  77
  78 struct _Test
  79 {
  80   GObject parent_instance;
  81 };
  82
  83 static void all_types_handler (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, gint e, guint f, float fl, double db, char *str, GParamSpec *param, GBytes *bytes, gpointer ptr, Test *obj, GVariant *var, gint64 i64, guint64 ui64);
  84
  85 struct _TestClass
  86 {
  87   GObjectClass parent_class;
  88
  89   void (* variant_changed) (Test *, GVariant *);
  90   void (* all_types) (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, gint e, guint f, float fl, double db, char *str, GParamSpec *param, GBytes *bytes, gpointer ptr, Test *obj, GVariant *var, gint64 i64, guint64 ui64);
  91   void (* all_types_null) (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, gint e, guint f, float fl, double db, char *str, GParamSpec *param, GBytes *bytes, gpointer ptr, Test *obj, GVariant *var, gint64 i64, guint64 ui64);
  92 };
  93
  94 static GType test_get_type (void);
  95 G_DEFINE_TYPE (Test, test, G_TYPE_OBJECT)
  96
  97 static void
  98 test_init (Test *test)
  99 {
 100 }
 101
 102 static void
 103 test_class_init (TestClass *klass)
 104 {
 105   guint s;
 106
 107   enum_type = g_enum_register_static ("MyEnum", my_enum_values);
 108   flags_type = g_flags_register_static ("MyFlag", my_flag_values);
 109
 110   klass->all_types = all_types_handler;
 111
 112   g_signal_new ("generic-marshaller-1",
 113                 G_TYPE_FROM_CLASS (klass),
 114                 G_SIGNAL_RUN_LAST,
 115                 0,
 116                 NULL, NULL,
 117                 NULL,
 118                 G_TYPE_NONE,
 119                 7,
 120                 G_TYPE_CHAR, G_TYPE_UCHAR, G_TYPE_INT, G_TYPE_LONG, G_TYPE_POINTER, G_TYPE_DOUBLE, G_TYPE_FLOAT);
 121   g_signal_new ("generic-marshaller-2",
 122                 G_TYPE_FROM_CLASS (klass),
 123                 G_SIGNAL_RUN_LAST,
 124                 0,
 125                 NULL, NULL,
 126                 NULL,
 127                 G_TYPE_NONE,
 128                 5,
 129                 G_TYPE_INT, test_enum_get_type(), G_TYPE_INT, test_unsigned_enum_get_type (), G_TYPE_INT);
 130   g_signal_new ("generic-marshaller-enum-return-signed",
 131                 G_TYPE_FROM_CLASS (klass),
 132                 G_SIGNAL_RUN_LAST,
 133                 0,
 134                 NULL, NULL,
 135                 NULL,
 136                 test_enum_get_type(),
 137                 0);
 138   g_signal_new ("generic-marshaller-enum-return-unsigned",
 139                 G_TYPE_FROM_CLASS (klass),
 140                 G_SIGNAL_RUN_LAST,
 141                 0,
 142                 NULL, NULL,
 143                 NULL,
 144                 test_unsigned_enum_get_type(),
 145                 0);
 146   g_signal_new ("generic-marshaller-int-return",
 147                 G_TYPE_FROM_CLASS (klass),
 148                 G_SIGNAL_RUN_LAST,
 149                 0,
 150                 NULL, NULL,
 151                 NULL,
 152                 G_TYPE_INT,
 153                 0);
 154   s = g_signal_new ("va-marshaller-int-return",
 155                 G_TYPE_FROM_CLASS (klass),
 156                 G_SIGNAL_RUN_LAST,
 157                 0,
 158                 NULL, NULL,
 159                 test_INT__VOID,
 160                 G_TYPE_INT,
 161                 0);
 162   g_signal_set_va_marshaller (s, G_TYPE_FROM_CLASS (klass),
 163                               test_INT__VOIDv);
 164   g_signal_new ("generic-marshaller-uint-return",
 165                 G_TYPE_FROM_CLASS (klass),
 166                 G_SIGNAL_RUN_LAST,
 167                 0,
 168                 NULL, NULL,
 169                 NULL,
 170                 G_TYPE_UINT,
 171                 0);
 172   s = g_signal_new ("va-marshaller-uint-return",
 173                 G_TYPE_FROM_CLASS (klass),
 174                 G_SIGNAL_RUN_LAST,
 175                 0,
 176                 NULL, NULL,
 177                 test_INT__VOID,
 178                 G_TYPE_UINT,
 179                 0);
 180   g_signal_set_va_marshaller (s, G_TYPE_FROM_CLASS (klass),
 181                               test_UINT__VOIDv);
 182   g_signal_new ("variant-changed-no-slot",
 183                 G_TYPE_FROM_CLASS (klass),
 184                 G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,
 185                 0,
 186                 NULL, NULL,
 187                 g_cclosure_marshal_VOID__VARIANT,
 188                 G_TYPE_NONE,
 189                 1,
 190                 G_TYPE_VARIANT);
 191   g_signal_new ("variant-changed",
 192                 G_TYPE_FROM_CLASS (klass),
 193                 G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,
 194                 G_STRUCT_OFFSET (TestClass, variant_changed),
 195                 NULL, NULL,
 196                 g_cclosure_marshal_VOID__VARIANT,
 197                 G_TYPE_NONE,
 198                 1,
 199                 G_TYPE_VARIANT);
 200   g_signal_new ("all-types",
 201                 G_TYPE_FROM_CLASS (klass),
 202                 G_SIGNAL_RUN_LAST,
 203                 G_STRUCT_OFFSET (TestClass, all_types),
 204                 NULL, NULL,
 205                 test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
 206                 G_TYPE_NONE,
 207                 19,
 208                 G_TYPE_INT,
 209                 G_TYPE_BOOLEAN,
 210                 G_TYPE_CHAR,
 211                 G_TYPE_UCHAR,
 212                 G_TYPE_UINT,
 213                 G_TYPE_LONG,
 214                 G_TYPE_ULONG,
 215                 enum_type,
 216                 flags_type,
 217                 G_TYPE_FLOAT,
 218                 G_TYPE_DOUBLE,
 219                 G_TYPE_STRING,
 220                 G_TYPE_PARAM_LONG,
 221                 G_TYPE_BYTES,
 222                 G_TYPE_POINTER,
 223                 test_get_type (),
 224                 G_TYPE_VARIANT,
 225                 G_TYPE_INT64,
 226                 G_TYPE_UINT64);
 227   s = g_signal_new ("all-types-va",
 228                 G_TYPE_FROM_CLASS (klass),
 229                 G_SIGNAL_RUN_LAST,
 230                 G_STRUCT_OFFSET (TestClass, all_types),
 231                 NULL, NULL,
 232                 test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
 233                 G_TYPE_NONE,
 234                 19,
 235                 G_TYPE_INT,
 236                 G_TYPE_BOOLEAN,
 237                 G_TYPE_CHAR,
 238                 G_TYPE_UCHAR,
 239                 G_TYPE_UINT,
 240                 G_TYPE_LONG,
 241                 G_TYPE_ULONG,
 242                 enum_type,
 243                 flags_type,
 244                 G_TYPE_FLOAT,
 245                 G_TYPE_DOUBLE,
 246                 G_TYPE_STRING,
 247                 G_TYPE_PARAM_LONG,
 248                 G_TYPE_BYTES,
 249                 G_TYPE_POINTER,
 250                 test_get_type (),
 251                 G_TYPE_VARIANT,
 252                 G_TYPE_INT64,
 253                 G_TYPE_UINT64);
 254   g_signal_set_va_marshaller (s, G_TYPE_FROM_CLASS (klass),
 255                               test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64v);
 256
 257   g_signal_new ("all-types-generic",
 258                 G_TYPE_FROM_CLASS (klass),
 259                 G_SIGNAL_RUN_LAST,
 260                 G_STRUCT_OFFSET (TestClass, all_types),
 261                 NULL, NULL,
 262                 NULL,
 263                 G_TYPE_NONE,
 264                 19,
 265                 G_TYPE_INT,
 266                 G_TYPE_BOOLEAN,
 267                 G_TYPE_CHAR,
 268                 G_TYPE_UCHAR,
 269                 G_TYPE_UINT,
 270                 G_TYPE_LONG,
 271                 G_TYPE_ULONG,
 272                 enum_type,
 273                 flags_type,
 274                 G_TYPE_FLOAT,
 275                 G_TYPE_DOUBLE,
 276                 G_TYPE_STRING,
 277                 G_TYPE_PARAM_LONG,
 278                 G_TYPE_BYTES,
 279                 G_TYPE_POINTER,
 280                 test_get_type (),
 281                 G_TYPE_VARIANT,
 282                 G_TYPE_INT64,
 283                 G_TYPE_UINT64);
 284   g_signal_new ("all-types-null",
 285                 G_TYPE_FROM_CLASS (klass),
 286                 G_SIGNAL_RUN_LAST,
 287                 G_STRUCT_OFFSET (TestClass, all_types_null),
 288                 NULL, NULL,
 289                 test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
 290                 G_TYPE_NONE,
 291                 19,
 292                 G_TYPE_INT,
 293                 G_TYPE_BOOLEAN,
 294                 G_TYPE_CHAR,
 295                 G_TYPE_UCHAR,
 296                 G_TYPE_UINT,
 297                 G_TYPE_LONG,
 298                 G_TYPE_ULONG,
 299                 enum_type,
 300                 flags_type,
 301                 G_TYPE_FLOAT,
 302                 G_TYPE_DOUBLE,
 303                 G_TYPE_STRING,
 304                 G_TYPE_PARAM_LONG,
 305                 G_TYPE_BYTES,
 306                 G_TYPE_POINTER,
 307                 test_get_type (),
 308                 G_TYPE_VARIANT,
 309                 G_TYPE_INT64,
 310                 G_TYPE_UINT64);
 311   g_signal_new ("all-types-empty",
 312                 G_TYPE_FROM_CLASS (klass),
 313                 G_SIGNAL_RUN_LAST,
 314                 0,
 315                 NULL, NULL,
 316                 test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
 317                 G_TYPE_NONE,
 318                 19,
 319                 G_TYPE_INT,
 320                 G_TYPE_BOOLEAN,
 321                 G_TYPE_CHAR,
 322                 G_TYPE_UCHAR,
 323                 G_TYPE_UINT,
 324                 G_TYPE_LONG,
 325                 G_TYPE_ULONG,
 326                 enum_type,
 327                 flags_type,
 328                 G_TYPE_FLOAT,
 329                 G_TYPE_DOUBLE,
 330                 G_TYPE_STRING,
 331                 G_TYPE_PARAM_LONG,
 332                 G_TYPE_BYTES,
 333                 G_TYPE_POINTER,
 334                 test_get_type (),
 335                 G_TYPE_VARIANT,
 336                 G_TYPE_INT64,
 337                 G_TYPE_UINT64);
 338 }
 339
 340 static void
 341 test_variant_signal (void)
 342 {
 343   Test *test;
 344   GVariant *v;
 345
 346   /* Tests that the signal emission consumes the variant,
 347    * even if there are no handlers connected.
 348    */
 349
 350   test = g_object_new (test_get_type (), NULL);
 351
 352   v = g_variant_new_boolean (TRUE);
 353   g_variant_ref (v);
 354   g_assert (g_variant_is_floating (v));
 355   g_signal_emit_by_name (test, "variant-changed-no-slot", v);
 356   g_assert (!g_variant_is_floating (v));
 357   g_variant_unref (v);
 358
 359   v = g_variant_new_boolean (TRUE);
 360   g_variant_ref (v);
 361   g_assert (g_variant_is_floating (v));
 362   g_signal_emit_by_name (test, "variant-changed", v);
 363   g_assert (!g_variant_is_floating (v));
 364   g_variant_unref (v);
 365
 366   g_object_unref (test);
 367 }
 368
 369 static void
 370 on_generic_marshaller_1 (Test *obj,
 371                          gint8 v_schar,
 372                          guint8 v_uchar,
 373                          gint v_int,
 374                          glong v_long,
 375                          gpointer v_pointer,
 376                          gdouble v_double,
 377                          gfloat v_float,
 378                          gpointer user_data)
 379 {
 380   g_assert_cmpint (v_schar, ==, 42);
 381   g_assert_cmpint (v_uchar, ==, 43);
 382   g_assert_cmpint (v_int, ==, 4096);
 383   g_assert_cmpint (v_long, ==, 8192);
 384   g_assert (v_pointer == NULL);
 385   g_assert_cmpfloat (v_double, >, 0.0);
 386   g_assert_cmpfloat (v_double, <, 1.0);
 387   g_assert_cmpfloat (v_float, >, 5.0);
 388   g_assert_cmpfloat (v_float, <, 6.0);
 389 }
 390
 391 static void
 392 test_generic_marshaller_signal_1 (void)
 393 {
 394   Test *test;
 395   test = g_object_new (test_get_type (), NULL);
 396
 397   g_signal_connect (test, "generic-marshaller-1", G_CALLBACK (on_generic_marshaller_1), NULL);
 398
 399   g_signal_emit_by_name (test, "generic-marshaller-1", 42, 43, 4096, 8192, NULL, 0.5, 5.5);
 400
 401   g_object_unref (test);
 402 }
 403
 404 static void
 405 on_generic_marshaller_2 (Test *obj,
 406                          gint        v_int1,
 407                          TestEnum    v_enum,
 408                          gint        v_int2,
 409                          TestUnsignedEnum v_uenum,
 410                          gint        v_int3)
 411 {
 412   g_assert_cmpint (v_int1, ==, 42);
 413   g_assert_cmpint (v_enum, ==, TEST_ENUM_BAR);
 414   g_assert_cmpint (v_int2, ==, 43);
 415   g_assert_cmpint (v_uenum, ==, TEST_UNSIGNED_ENUM_BAR);
 416   g_assert_cmpint (v_int3, ==, 44);
 417 }
 418
 419 static void
 420 test_generic_marshaller_signal_2 (void)
 421 {
 422   Test *test;
 423   test = g_object_new (test_get_type (), NULL);
 424
 425   g_signal_connect (test, "generic-marshaller-2", G_CALLBACK (on_generic_marshaller_2), NULL);
 426
 427   g_signal_emit_by_name (test, "generic-marshaller-2", 42, TEST_ENUM_BAR, 43, TEST_UNSIGNED_ENUM_BAR, 44);
 428
 429   g_object_unref (test);
 430 }
 431
 432 static TestEnum
 433 on_generic_marshaller_enum_return_signed_1 (Test *obj)
 434 {
 435   return TEST_ENUM_NEGATIVE;
 436 }
 437
 438 static TestEnum
 439 on_generic_marshaller_enum_return_signed_2 (Test *obj)
 440 {
 441   return TEST_ENUM_BAR;
 442 }
 443
 444 static void
 445 test_generic_marshaller_signal_enum_return_signed (void)
 446 {
 447   Test *test;
 448   guint id;
 449   TestEnum retval = 0;
 450
 451   test = g_object_new (test_get_type (), NULL);
 452
 453   /* Test return value NEGATIVE */
 454   id = g_signal_connect (test,
 455                          "generic-marshaller-enum-return-signed",
 456                          G_CALLBACK (on_generic_marshaller_enum_return_signed_1),
 457                          NULL);
 458   g_signal_emit_by_name (test, "generic-marshaller-enum-return-signed", &retval);
 459   g_assert_cmpint (retval, ==, TEST_ENUM_NEGATIVE);
 460   g_signal_handler_disconnect (test, id);
 461
 462   /* Test return value BAR */
 463   retval = 0;
 464   id = g_signal_connect (test,
 465                          "generic-marshaller-enum-return-signed",
 466                          G_CALLBACK (on_generic_marshaller_enum_return_signed_2),
 467                          NULL);
 468   g_signal_emit_by_name (test, "generic-marshaller-enum-return-signed", &retval);
 469   g_assert_cmpint (retval, ==, TEST_ENUM_BAR);
 470   g_signal_handler_disconnect (test, id);
 471
 472   g_object_unref (test);
 473 }
 474
 475 static TestUnsignedEnum
 476 on_generic_marshaller_enum_return_unsigned_1 (Test *obj)
 477 {
 478   return TEST_UNSIGNED_ENUM_FOO;
 479 }
 480
 481 static TestUnsignedEnum
 482 on_generic_marshaller_enum_return_unsigned_2 (Test *obj)
 483 {
 484   return TEST_UNSIGNED_ENUM_BAR;
 485 }
 486
 487 static void
 488 test_generic_marshaller_signal_enum_return_unsigned (void)
 489 {
 490   Test *test;
 491   guint id;
 492   TestUnsignedEnum retval = 0;
 493
 494   test = g_object_new (test_get_type (), NULL);
 495
 496   /* Test return value FOO */
 497   id = g_signal_connect (test,
 498                          "generic-marshaller-enum-return-unsigned",
 499                          G_CALLBACK (on_generic_marshaller_enum_return_unsigned_1),
 500                          NULL);
 501   g_signal_emit_by_name (test, "generic-marshaller-enum-return-unsigned", &retval);
 502   g_assert_cmpint (retval, ==, TEST_UNSIGNED_ENUM_FOO);
 503   g_signal_handler_disconnect (test, id);
 504
 505   /* Test return value BAR */
 506   retval = 0;
 507   id = g_signal_connect (test,
 508                          "generic-marshaller-enum-return-unsigned",
 509                          G_CALLBACK (on_generic_marshaller_enum_return_unsigned_2),
 510                          NULL);
 511   g_signal_emit_by_name (test, "generic-marshaller-enum-return-unsigned", &retval);
 512   g_assert_cmpint (retval, ==, TEST_UNSIGNED_ENUM_BAR);
 513   g_signal_handler_disconnect (test, id);
 514
 515   g_object_unref (test);
 516 }
 517
 518 /**********************/
 519
 520 static gint
 521 on_generic_marshaller_int_return_signed_1 (Test *obj)
 522 {
 523   return -30;
 524 }
 525
 526 static gint
 527 on_generic_marshaller_int_return_signed_2 (Test *obj)
 528 {
 529   return 2;
 530 }
 531
 532 static void
 533 test_generic_marshaller_signal_int_return (void)
 534 {
 535   Test *test;
 536   guint id;
 537   gint retval = 0;
 538
 539   test = g_object_new (test_get_type (), NULL);
 540
 541   /* Test return value -30 */
 542   id = g_signal_connect (test,
 543                          "generic-marshaller-int-return",
 544                          G_CALLBACK (on_generic_marshaller_int_return_signed_1),
 545                          NULL);
 546   g_signal_emit_by_name (test, "generic-marshaller-int-return", &retval);
 547   g_assert_cmpint (retval, ==, -30);
 548   g_signal_handler_disconnect (test, id);
 549
 550   /* Test return value positive */
 551   retval = 0;
 552   id = g_signal_connect (test,
 553                          "generic-marshaller-int-return",
 554                          G_CALLBACK (on_generic_marshaller_int_return_signed_2),
 555                          NULL);
 556   g_signal_emit_by_name (test, "generic-marshaller-int-return", &retval);
 557   g_assert_cmpint (retval, ==, 2);
 558   g_signal_handler_disconnect (test, id);
 559
 560   /* Same test for va marshaller */
 561
 562   /* Test return value -30 */
 563   id = g_signal_connect (test,
 564                          "va-marshaller-int-return",
 565                          G_CALLBACK (on_generic_marshaller_int_return_signed_1),
 566                          NULL);
 567   g_signal_emit_by_name (test, "va-marshaller-int-return", &retval);
 568   g_assert_cmpint (retval, ==, -30);
 569   g_signal_handler_disconnect (test, id);
 570
 571   /* Test return value positive */
 572   retval = 0;
 573   id = g_signal_connect (test,
 574                          "va-marshaller-int-return",
 575                          G_CALLBACK (on_generic_marshaller_int_return_signed_2),
 576                          NULL);
 577   g_signal_emit_by_name (test, "va-marshaller-int-return", &retval);
 578   g_assert_cmpint (retval, ==, 2);
 579   g_signal_handler_disconnect (test, id);
 580
 581   g_object_unref (test);
 582 }
 583
 584 static guint
 585 on_generic_marshaller_uint_return_1 (Test *obj)
 586 {
 587   return 1;
 588 }
 589
 590 static guint
 591 on_generic_marshaller_uint_return_2 (Test *obj)
 592 {
 593   return G_MAXUINT;
 594 }
 595
 596 static void
 597 test_generic_marshaller_signal_uint_return (void)
 598 {
 599   Test *test;
 600   guint id;
 601   guint retval = 0;
 602
 603   test = g_object_new (test_get_type (), NULL);
 604
 605   id = g_signal_connect (test,
 606                          "generic-marshaller-uint-return",
 607                          G_CALLBACK (on_generic_marshaller_uint_return_1),
 608                          NULL);
 609   g_signal_emit_by_name (test, "generic-marshaller-uint-return", &retval);
 610   g_assert_cmpint (retval, ==, 1);
 611   g_signal_handler_disconnect (test, id);
 612
 613   retval = 0;
 614   id = g_signal_connect (test,
 615                          "generic-marshaller-uint-return",
 616                          G_CALLBACK (on_generic_marshaller_uint_return_2),
 617                          NULL);
 618   g_signal_emit_by_name (test, "generic-marshaller-uint-return", &retval);
 619   g_assert_cmpint (retval, ==, G_MAXUINT);
 620   g_signal_handler_disconnect (test, id);
 621
 622   /* Same test for va marshaller */
 623
 624   id = g_signal_connect (test,
 625                          "va-marshaller-uint-return",
 626                          G_CALLBACK (on_generic_marshaller_uint_return_1),
 627                          NULL);
 628   g_signal_emit_by_name (test, "va-marshaller-uint-return", &retval);
 629   g_assert_cmpint (retval, ==, 1);
 630   g_signal_handler_disconnect (test, id);
 631
 632   retval = 0;
 633   id = g_signal_connect (test,
 634                          "va-marshaller-uint-return",
 635                          G_CALLBACK (on_generic_marshaller_uint_return_2),
 636                          NULL);
 637   g_signal_emit_by_name (test, "va-marshaller-uint-return", &retval);
 638   g_assert_cmpint (retval, ==, G_MAXUINT);
 639   g_signal_handler_disconnect (test, id);
 640
 641   g_object_unref (test);
 642 }
 643
 644 static int all_type_handlers_count = 0;
 645
 646 static void
 647 all_types_handler (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, gint e, guint f, float fl, double db, char *str, GParamSpec *param, GBytes *bytes, gpointer ptr, Test *obj, GVariant *var, gint64 i64, guint64 ui64)
 648 {
 649   all_type_handlers_count++;
 650
 651   g_assert_cmpint (i, ==, 42);
 652   g_assert_cmpint (b, ==, TRUE);
 653   g_assert_cmpint (c, ==, 17);
 654   g_assert_cmpuint (uc, ==, 140);
 655   g_assert_cmpuint (ui, ==, G_MAXUINT - 42);
 656   g_assert_cmpint (l, ==, -1117);
 657   g_assert_cmpuint (ul, ==, G_MAXULONG - 999);
 658   g_assert_cmpint (e, ==, 1);
 659   g_assert_cmpuint (f, ==, 0);
 660   g_assert_cmpfloat (fl, ==, 0.25);
 661   g_assert_cmpfloat (db, ==, 1.5);
 662   g_assert_cmpstr (str, ==, "Test");
 663   g_assert_cmpstr (g_param_spec_get_nick (param), ==, "nick");
 664   g_assert_cmpstr (g_bytes_get_data (bytes, NULL), ==, "Blah");
 665   g_assert (ptr == &enum_type);
 666   g_assert_cmpuint (g_variant_get_uint16 (var), == , 99);
 667   g_assert_cmpint (i64, ==, G_MAXINT64 - 1234);
 668   g_assert_cmpuint (ui64, ==, G_MAXUINT64 - 123456);
 669 }
 670
 671 static void
 672 all_types_handler_cb (Test *test, int i, gboolean b, char c, guchar uc, guint ui, glong l, gulong ul, gint 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)
 673 {
 674   g_assert (user_data == &flags_type);
 675   all_types_handler (test, i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, obj, var, i64, ui64);
 676 }
 677
 678 static void
 679 test_all_types (void)
 680 {
 681   Test *test;
 682
 683   int i = 42;
 684   gboolean b = TRUE;
 685   char c = 17;
 686   guchar uc = 140;
 687   guint ui = G_MAXUINT - 42;
 688   glong l =  -1117;
 689   gulong ul = G_MAXULONG - 999;
 690   gint e = 1;
 691   guint f = 0;
 692   float fl = 0.25;
 693   double db = 1.5;
 694   char *str = "Test";
 695   GParamSpec *param = g_param_spec_long  ("param", "nick", "blurb", 0, 10, 4, 0);
 696   GBytes *bytes = g_bytes_new_static ("Blah", 5);
 697   gpointer ptr = &enum_type;
 698   GVariant *var = g_variant_new_uint16 (99);
 699   gint64 i64;
 700   guint64 ui64;
 701   g_variant_ref_sink (var);
 702   i64 = G_MAXINT64 - 1234;
 703   ui64 = G_MAXUINT64 - 123456;
 704
 705   test = g_object_new (test_get_type (), NULL);
 706
 707   all_type_handlers_count = 0;
 708
 709   g_signal_emit_by_name (test, "all-types",
 710                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 711   g_signal_emit_by_name (test, "all-types-va",
 712                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 713   g_signal_emit_by_name (test, "all-types-generic",
 714                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 715   g_signal_emit_by_name (test, "all-types-empty",
 716                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 717   g_signal_emit_by_name (test, "all-types-null",
 718                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 719
 720   g_assert_cmpint (all_type_handlers_count, ==, 3);
 721
 722   all_type_handlers_count = 0;
 723
 724   g_signal_connect (test, "all-types", G_CALLBACK (all_types_handler_cb), &flags_type);
 725   g_signal_connect (test, "all-types-va", G_CALLBACK (all_types_handler_cb), &flags_type);
 726   g_signal_connect (test, "all-types-generic", G_CALLBACK (all_types_handler_cb), &flags_type);
 727   g_signal_connect (test, "all-types-empty", G_CALLBACK (all_types_handler_cb), &flags_type);
 728   g_signal_connect (test, "all-types-null", G_CALLBACK (all_types_handler_cb), &flags_type);
 729
 730   g_signal_emit_by_name (test, "all-types",
 731                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 732   g_signal_emit_by_name (test, "all-types-va",
 733                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 734   g_signal_emit_by_name (test, "all-types-generic",
 735                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 736   g_signal_emit_by_name (test, "all-types-empty",
 737                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 738   g_signal_emit_by_name (test, "all-types-null",
 739                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 740
 741   g_assert_cmpint (all_type_handlers_count, ==, 3 + 5);
 742
 743   all_type_handlers_count = 0;
 744
 745   g_signal_connect (test, "all-types", G_CALLBACK (all_types_handler_cb), &flags_type);
 746   g_signal_connect (test, "all-types-va", G_CALLBACK (all_types_handler_cb), &flags_type);
 747   g_signal_connect (test, "all-types-generic", G_CALLBACK (all_types_handler_cb), &flags_type);
 748   g_signal_connect (test, "all-types-empty", G_CALLBACK (all_types_handler_cb), &flags_type);
 749   g_signal_connect (test, "all-types-null", G_CALLBACK (all_types_handler_cb), &flags_type);
 750
 751   g_signal_emit_by_name (test, "all-types",
 752                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 753   g_signal_emit_by_name (test, "all-types-va",
 754                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 755   g_signal_emit_by_name (test, "all-types-generic",
 756                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 757   g_signal_emit_by_name (test, "all-types-empty",
 758                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 759   g_signal_emit_by_name (test, "all-types-null",
 760                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 761
 762   g_assert_cmpint (all_type_handlers_count, ==, 3 + 5 + 5);
 763
 764   g_object_unref (test);
 765   g_param_spec_unref (param);
 766   g_bytes_unref (bytes);
 767   g_variant_unref (var);
 768 }
 769
 770 static void
 771 test_connect (void)
 772 {
 773   GObject *test;
 774   gint retval;
 775
 776   test = g_object_new (test_get_type (), NULL);
 777
 778   g_object_connect (test,
 779                     "signal::generic-marshaller-int-return",
 780                     G_CALLBACK (on_generic_marshaller_int_return_signed_1),
 781                     NULL,
 782                     "object-signal::va-marshaller-int-return",
 783                     G_CALLBACK (on_generic_marshaller_int_return_signed_2),
 784                     NULL,
 785                     NULL);
 786   g_signal_emit_by_name (test, "generic-marshaller-int-return", &retval);
 787   g_assert_cmpint (retval, ==, -30);
 788   g_signal_emit_by_name (test, "va-marshaller-int-return", &retval);
 789   g_assert_cmpint (retval, ==, 2);
 790
 791   g_object_disconnect (test,
 792                        "any-signal",
 793                        G_CALLBACK (on_generic_marshaller_int_return_signed_1),
 794                        NULL,
 795                        "any-signal::va-marshaller-int-return",
 796                        G_CALLBACK (on_generic_marshaller_int_return_signed_2),
 797                        NULL,
 798                        NULL);
 799
 800   g_object_unref (test);
 801 }
 802
 803 /* --- */
 804
 805 int
 806 main (int argc,
 807      char *argv[])
 808 {
 809   g_type_init ();
 810
 811   g_test_init (&argc, &argv, NULL);
 812
 813   g_test_add_func ("/gobject/signals/all-types", test_all_types);
 814   g_test_add_func ("/gobject/signals/variant", test_variant_signal);
 815   g_test_add_func ("/gobject/signals/generic-marshaller-1", test_generic_marshaller_signal_1);
 816   g_test_add_func ("/gobject/signals/generic-marshaller-2", test_generic_marshaller_signal_2);
 817   g_test_add_func ("/gobject/signals/generic-marshaller-enum-return-signed", test_generic_marshaller_signal_enum_return_signed);
 818   g_test_add_func ("/gobject/signals/generic-marshaller-enum-return-unsigned", test_generic_marshaller_signal_enum_return_unsigned);
 819   g_test_add_func ("/gobject/signals/generic-marshaller-int-return", test_generic_marshaller_signal_int_return);
 820   g_test_add_func ("/gobject/signals/generic-marshaller-uint-return", test_generic_marshaller_signal_uint_return);
 821   g_test_add_func ("/gobject/signals/connect", test_connect);
 822
 823   return g_test_run ();
 824 }