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