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