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 static guint simple_id;
  78 static guint simple2_id;
  79
  80 typedef struct _Test Test;
  81 typedef struct _TestClass TestClass;
  82
  83 struct _Test
  84 {
  85   GObject parent_instance;
  86 };
  87
  88 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);
  89
  90 struct _TestClass
  91 {
  92   GObjectClass parent_class;
  93
  94   void (* variant_changed) (Test *, GVariant *);
  95   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);
  96   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);
  97 };
  98
  99 static GType test_get_type (void);
 100 G_DEFINE_TYPE (Test, test, G_TYPE_OBJECT)
 101
 102 static void
 103 test_init (Test *test)
 104 {
 105 }
 106
 107 static void
 108 test_class_init (TestClass *klass)
 109 {
 110   guint s;
 111
 112   enum_type = g_enum_register_static ("MyEnum", my_enum_values);
 113   flags_type = g_flags_register_static ("MyFlag", my_flag_values);
 114
 115   klass->all_types = all_types_handler;
 116
 117   simple_id = g_signal_new ("simple",
 118                 G_TYPE_FROM_CLASS (klass),
 119                 G_SIGNAL_RUN_LAST,
 120                 0,
 121                 NULL, NULL,
 122                 NULL,
 123                 G_TYPE_NONE,
 124                 0);
 125   simple2_id = g_signal_new ("simple-2",
 126                 G_TYPE_FROM_CLASS (klass),
 127                 G_SIGNAL_RUN_LAST | G_SIGNAL_NO_RECURSE,
 128                 0,
 129                 NULL, NULL,
 130                 NULL,
 131                 G_TYPE_NONE,
 132                 0);
 133   g_signal_new ("generic-marshaller-1",
 134                 G_TYPE_FROM_CLASS (klass),
 135                 G_SIGNAL_RUN_LAST,
 136                 0,
 137                 NULL, NULL,
 138                 NULL,
 139                 G_TYPE_NONE,
 140                 7,
 141                 G_TYPE_CHAR, G_TYPE_UCHAR, G_TYPE_INT, G_TYPE_LONG, G_TYPE_POINTER, G_TYPE_DOUBLE, G_TYPE_FLOAT);
 142   g_signal_new ("generic-marshaller-2",
 143                 G_TYPE_FROM_CLASS (klass),
 144                 G_SIGNAL_RUN_LAST,
 145                 0,
 146                 NULL, NULL,
 147                 NULL,
 148                 G_TYPE_NONE,
 149                 5,
 150                 G_TYPE_INT, test_enum_get_type(), G_TYPE_INT, test_unsigned_enum_get_type (), G_TYPE_INT);
 151   g_signal_new ("generic-marshaller-enum-return-signed",
 152                 G_TYPE_FROM_CLASS (klass),
 153                 G_SIGNAL_RUN_LAST,
 154                 0,
 155                 NULL, NULL,
 156                 NULL,
 157                 test_enum_get_type(),
 158                 0);
 159   g_signal_new ("generic-marshaller-enum-return-unsigned",
 160                 G_TYPE_FROM_CLASS (klass),
 161                 G_SIGNAL_RUN_LAST,
 162                 0,
 163                 NULL, NULL,
 164                 NULL,
 165                 test_unsigned_enum_get_type(),
 166                 0);
 167   g_signal_new ("generic-marshaller-int-return",
 168                 G_TYPE_FROM_CLASS (klass),
 169                 G_SIGNAL_RUN_LAST,
 170                 0,
 171                 NULL, NULL,
 172                 NULL,
 173                 G_TYPE_INT,
 174                 0);
 175   s = g_signal_new ("va-marshaller-int-return",
 176                 G_TYPE_FROM_CLASS (klass),
 177                 G_SIGNAL_RUN_LAST,
 178                 0,
 179                 NULL, NULL,
 180                 test_INT__VOID,
 181                 G_TYPE_INT,
 182                 0);
 183   g_signal_set_va_marshaller (s, G_TYPE_FROM_CLASS (klass),
 184                               test_INT__VOIDv);
 185   g_signal_new ("generic-marshaller-uint-return",
 186                 G_TYPE_FROM_CLASS (klass),
 187                 G_SIGNAL_RUN_LAST,
 188                 0,
 189                 NULL, NULL,
 190                 NULL,
 191                 G_TYPE_UINT,
 192                 0);
 193   s = g_signal_new ("va-marshaller-uint-return",
 194                 G_TYPE_FROM_CLASS (klass),
 195                 G_SIGNAL_RUN_LAST,
 196                 0,
 197                 NULL, NULL,
 198                 test_INT__VOID,
 199                 G_TYPE_UINT,
 200                 0);
 201   g_signal_set_va_marshaller (s, G_TYPE_FROM_CLASS (klass),
 202                               test_UINT__VOIDv);
 203   g_signal_new ("variant-changed-no-slot",
 204                 G_TYPE_FROM_CLASS (klass),
 205                 G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,
 206                 0,
 207                 NULL, NULL,
 208                 g_cclosure_marshal_VOID__VARIANT,
 209                 G_TYPE_NONE,
 210                 1,
 211                 G_TYPE_VARIANT);
 212   g_signal_new ("variant-changed",
 213                 G_TYPE_FROM_CLASS (klass),
 214                 G_SIGNAL_RUN_LAST | G_SIGNAL_MUST_COLLECT,
 215                 G_STRUCT_OFFSET (TestClass, variant_changed),
 216                 NULL, NULL,
 217                 g_cclosure_marshal_VOID__VARIANT,
 218                 G_TYPE_NONE,
 219                 1,
 220                 G_TYPE_VARIANT);
 221   g_signal_new ("all-types",
 222                 G_TYPE_FROM_CLASS (klass),
 223                 G_SIGNAL_RUN_LAST,
 224                 G_STRUCT_OFFSET (TestClass, all_types),
 225                 NULL, NULL,
 226                 test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
 227                 G_TYPE_NONE,
 228                 19,
 229                 G_TYPE_INT,
 230                 G_TYPE_BOOLEAN,
 231                 G_TYPE_CHAR,
 232                 G_TYPE_UCHAR,
 233                 G_TYPE_UINT,
 234                 G_TYPE_LONG,
 235                 G_TYPE_ULONG,
 236                 enum_type,
 237                 flags_type,
 238                 G_TYPE_FLOAT,
 239                 G_TYPE_DOUBLE,
 240                 G_TYPE_STRING,
 241                 G_TYPE_PARAM_LONG,
 242                 G_TYPE_BYTES,
 243                 G_TYPE_POINTER,
 244                 test_get_type (),
 245                 G_TYPE_VARIANT,
 246                 G_TYPE_INT64,
 247                 G_TYPE_UINT64);
 248   s = g_signal_new ("all-types-va",
 249                 G_TYPE_FROM_CLASS (klass),
 250                 G_SIGNAL_RUN_LAST,
 251                 G_STRUCT_OFFSET (TestClass, all_types),
 252                 NULL, NULL,
 253                 test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
 254                 G_TYPE_NONE,
 255                 19,
 256                 G_TYPE_INT,
 257                 G_TYPE_BOOLEAN,
 258                 G_TYPE_CHAR,
 259                 G_TYPE_UCHAR,
 260                 G_TYPE_UINT,
 261                 G_TYPE_LONG,
 262                 G_TYPE_ULONG,
 263                 enum_type,
 264                 flags_type,
 265                 G_TYPE_FLOAT,
 266                 G_TYPE_DOUBLE,
 267                 G_TYPE_STRING,
 268                 G_TYPE_PARAM_LONG,
 269                 G_TYPE_BYTES,
 270                 G_TYPE_POINTER,
 271                 test_get_type (),
 272                 G_TYPE_VARIANT,
 273                 G_TYPE_INT64,
 274                 G_TYPE_UINT64);
 275   g_signal_set_va_marshaller (s, G_TYPE_FROM_CLASS (klass),
 276                               test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64v);
 277
 278   g_signal_new ("all-types-generic",
 279                 G_TYPE_FROM_CLASS (klass),
 280                 G_SIGNAL_RUN_LAST,
 281                 G_STRUCT_OFFSET (TestClass, all_types),
 282                 NULL, NULL,
 283                 NULL,
 284                 G_TYPE_NONE,
 285                 19,
 286                 G_TYPE_INT,
 287                 G_TYPE_BOOLEAN,
 288                 G_TYPE_CHAR,
 289                 G_TYPE_UCHAR,
 290                 G_TYPE_UINT,
 291                 G_TYPE_LONG,
 292                 G_TYPE_ULONG,
 293                 enum_type,
 294                 flags_type,
 295                 G_TYPE_FLOAT,
 296                 G_TYPE_DOUBLE,
 297                 G_TYPE_STRING,
 298                 G_TYPE_PARAM_LONG,
 299                 G_TYPE_BYTES,
 300                 G_TYPE_POINTER,
 301                 test_get_type (),
 302                 G_TYPE_VARIANT,
 303                 G_TYPE_INT64,
 304                 G_TYPE_UINT64);
 305   g_signal_new ("all-types-null",
 306                 G_TYPE_FROM_CLASS (klass),
 307                 G_SIGNAL_RUN_LAST,
 308                 G_STRUCT_OFFSET (TestClass, all_types_null),
 309                 NULL, NULL,
 310                 test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
 311                 G_TYPE_NONE,
 312                 19,
 313                 G_TYPE_INT,
 314                 G_TYPE_BOOLEAN,
 315                 G_TYPE_CHAR,
 316                 G_TYPE_UCHAR,
 317                 G_TYPE_UINT,
 318                 G_TYPE_LONG,
 319                 G_TYPE_ULONG,
 320                 enum_type,
 321                 flags_type,
 322                 G_TYPE_FLOAT,
 323                 G_TYPE_DOUBLE,
 324                 G_TYPE_STRING,
 325                 G_TYPE_PARAM_LONG,
 326                 G_TYPE_BYTES,
 327                 G_TYPE_POINTER,
 328                 test_get_type (),
 329                 G_TYPE_VARIANT,
 330                 G_TYPE_INT64,
 331                 G_TYPE_UINT64);
 332   g_signal_new ("all-types-empty",
 333                 G_TYPE_FROM_CLASS (klass),
 334                 G_SIGNAL_RUN_LAST,
 335                 0,
 336                 NULL, NULL,
 337                 test_VOID__INT_BOOLEAN_CHAR_UCHAR_UINT_LONG_ULONG_ENUM_FLAGS_FLOAT_DOUBLE_STRING_PARAM_BOXED_POINTER_OBJECT_VARIANT_INT64_UINT64,
 338                 G_TYPE_NONE,
 339                 19,
 340                 G_TYPE_INT,
 341                 G_TYPE_BOOLEAN,
 342                 G_TYPE_CHAR,
 343                 G_TYPE_UCHAR,
 344                 G_TYPE_UINT,
 345                 G_TYPE_LONG,
 346                 G_TYPE_ULONG,
 347                 enum_type,
 348                 flags_type,
 349                 G_TYPE_FLOAT,
 350                 G_TYPE_DOUBLE,
 351                 G_TYPE_STRING,
 352                 G_TYPE_PARAM_LONG,
 353                 G_TYPE_BYTES,
 354                 G_TYPE_POINTER,
 355                 test_get_type (),
 356                 G_TYPE_VARIANT,
 357                 G_TYPE_INT64,
 358                 G_TYPE_UINT64);
 359 }
 360
 361 static void
 362 test_variant_signal (void)
 363 {
 364   Test *test;
 365   GVariant *v;
 366
 367   /* Tests that the signal emission consumes the variant,
 368    * even if there are no handlers connected.
 369    */
 370
 371   test = g_object_new (test_get_type (), NULL);
 372
 373   v = g_variant_new_boolean (TRUE);
 374   g_variant_ref (v);
 375   g_assert (g_variant_is_floating (v));
 376   g_signal_emit_by_name (test, "variant-changed-no-slot", v);
 377   g_assert (!g_variant_is_floating (v));
 378   g_variant_unref (v);
 379
 380   v = g_variant_new_boolean (TRUE);
 381   g_variant_ref (v);
 382   g_assert (g_variant_is_floating (v));
 383   g_signal_emit_by_name (test, "variant-changed", v);
 384   g_assert (!g_variant_is_floating (v));
 385   g_variant_unref (v);
 386
 387   g_object_unref (test);
 388 }
 389
 390 static void
 391 on_generic_marshaller_1 (Test *obj,
 392                          gint8 v_schar,
 393                          guint8 v_uchar,
 394                          gint v_int,
 395                          glong v_long,
 396                          gpointer v_pointer,
 397                          gdouble v_double,
 398                          gfloat v_float,
 399                          gpointer user_data)
 400 {
 401   g_assert_cmpint (v_schar, ==, 42);
 402   g_assert_cmpint (v_uchar, ==, 43);
 403   g_assert_cmpint (v_int, ==, 4096);
 404   g_assert_cmpint (v_long, ==, 8192);
 405   g_assert (v_pointer == NULL);
 406   g_assert_cmpfloat (v_double, >, 0.0);
 407   g_assert_cmpfloat (v_double, <, 1.0);
 408   g_assert_cmpfloat (v_float, >, 5.0);
 409   g_assert_cmpfloat (v_float, <, 6.0);
 410 }
 411
 412 static void
 413 test_generic_marshaller_signal_1 (void)
 414 {
 415   Test *test;
 416   test = g_object_new (test_get_type (), NULL);
 417
 418   g_signal_connect (test, "generic-marshaller-1", G_CALLBACK (on_generic_marshaller_1), NULL);
 419
 420   g_signal_emit_by_name (test, "generic-marshaller-1", 42, 43, 4096, 8192, NULL, 0.5, 5.5);
 421
 422   g_object_unref (test);
 423 }
 424
 425 static void
 426 on_generic_marshaller_2 (Test *obj,
 427                          gint        v_int1,
 428                          TestEnum    v_enum,
 429                          gint        v_int2,
 430                          TestUnsignedEnum v_uenum,
 431                          gint        v_int3)
 432 {
 433   g_assert_cmpint (v_int1, ==, 42);
 434   g_assert_cmpint (v_enum, ==, TEST_ENUM_BAR);
 435   g_assert_cmpint (v_int2, ==, 43);
 436   g_assert_cmpint (v_uenum, ==, TEST_UNSIGNED_ENUM_BAR);
 437   g_assert_cmpint (v_int3, ==, 44);
 438 }
 439
 440 static void
 441 test_generic_marshaller_signal_2 (void)
 442 {
 443   Test *test;
 444   test = g_object_new (test_get_type (), NULL);
 445
 446   g_signal_connect (test, "generic-marshaller-2", G_CALLBACK (on_generic_marshaller_2), NULL);
 447
 448   g_signal_emit_by_name (test, "generic-marshaller-2", 42, TEST_ENUM_BAR, 43, TEST_UNSIGNED_ENUM_BAR, 44);
 449
 450   g_object_unref (test);
 451 }
 452
 453 static TestEnum
 454 on_generic_marshaller_enum_return_signed_1 (Test *obj)
 455 {
 456   return TEST_ENUM_NEGATIVE;
 457 }
 458
 459 static TestEnum
 460 on_generic_marshaller_enum_return_signed_2 (Test *obj)
 461 {
 462   return TEST_ENUM_BAR;
 463 }
 464
 465 static void
 466 test_generic_marshaller_signal_enum_return_signed (void)
 467 {
 468   Test *test;
 469   guint id;
 470   TestEnum retval = 0;
 471
 472   test = g_object_new (test_get_type (), NULL);
 473
 474   /* Test return value NEGATIVE */
 475   id = g_signal_connect (test,
 476                          "generic-marshaller-enum-return-signed",
 477                          G_CALLBACK (on_generic_marshaller_enum_return_signed_1),
 478                          NULL);
 479   g_signal_emit_by_name (test, "generic-marshaller-enum-return-signed", &retval);
 480   g_assert_cmpint (retval, ==, TEST_ENUM_NEGATIVE);
 481   g_signal_handler_disconnect (test, id);
 482
 483   /* Test return value BAR */
 484   retval = 0;
 485   id = g_signal_connect (test,
 486                          "generic-marshaller-enum-return-signed",
 487                          G_CALLBACK (on_generic_marshaller_enum_return_signed_2),
 488                          NULL);
 489   g_signal_emit_by_name (test, "generic-marshaller-enum-return-signed", &retval);
 490   g_assert_cmpint (retval, ==, TEST_ENUM_BAR);
 491   g_signal_handler_disconnect (test, id);
 492
 493   g_object_unref (test);
 494 }
 495
 496 static TestUnsignedEnum
 497 on_generic_marshaller_enum_return_unsigned_1 (Test *obj)
 498 {
 499   return TEST_UNSIGNED_ENUM_FOO;
 500 }
 501
 502 static TestUnsignedEnum
 503 on_generic_marshaller_enum_return_unsigned_2 (Test *obj)
 504 {
 505   return TEST_UNSIGNED_ENUM_BAR;
 506 }
 507
 508 static void
 509 test_generic_marshaller_signal_enum_return_unsigned (void)
 510 {
 511   Test *test;
 512   guint id;
 513   TestUnsignedEnum retval = 0;
 514
 515   test = g_object_new (test_get_type (), NULL);
 516
 517   /* Test return value FOO */
 518   id = g_signal_connect (test,
 519                          "generic-marshaller-enum-return-unsigned",
 520                          G_CALLBACK (on_generic_marshaller_enum_return_unsigned_1),
 521                          NULL);
 522   g_signal_emit_by_name (test, "generic-marshaller-enum-return-unsigned", &retval);
 523   g_assert_cmpint (retval, ==, TEST_UNSIGNED_ENUM_FOO);
 524   g_signal_handler_disconnect (test, id);
 525
 526   /* Test return value BAR */
 527   retval = 0;
 528   id = g_signal_connect (test,
 529                          "generic-marshaller-enum-return-unsigned",
 530                          G_CALLBACK (on_generic_marshaller_enum_return_unsigned_2),
 531                          NULL);
 532   g_signal_emit_by_name (test, "generic-marshaller-enum-return-unsigned", &retval);
 533   g_assert_cmpint (retval, ==, TEST_UNSIGNED_ENUM_BAR);
 534   g_signal_handler_disconnect (test, id);
 535
 536   g_object_unref (test);
 537 }
 538
 539 /**********************/
 540
 541 static gint
 542 on_generic_marshaller_int_return_signed_1 (Test *obj)
 543 {
 544   return -30;
 545 }
 546
 547 static gint
 548 on_generic_marshaller_int_return_signed_2 (Test *obj)
 549 {
 550   return 2;
 551 }
 552
 553 static void
 554 test_generic_marshaller_signal_int_return (void)
 555 {
 556   Test *test;
 557   guint id;
 558   gint retval = 0;
 559
 560   test = g_object_new (test_get_type (), NULL);
 561
 562   /* Test return value -30 */
 563   id = g_signal_connect (test,
 564                          "generic-marshaller-int-return",
 565                          G_CALLBACK (on_generic_marshaller_int_return_signed_1),
 566                          NULL);
 567   g_signal_emit_by_name (test, "generic-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                          "generic-marshaller-int-return",
 575                          G_CALLBACK (on_generic_marshaller_int_return_signed_2),
 576                          NULL);
 577   g_signal_emit_by_name (test, "generic-marshaller-int-return", &retval);
 578   g_assert_cmpint (retval, ==, 2);
 579   g_signal_handler_disconnect (test, id);
 580
 581   /* Same test for va marshaller */
 582
 583   /* Test return value -30 */
 584   id = g_signal_connect (test,
 585                          "va-marshaller-int-return",
 586                          G_CALLBACK (on_generic_marshaller_int_return_signed_1),
 587                          NULL);
 588   g_signal_emit_by_name (test, "va-marshaller-int-return", &retval);
 589   g_assert_cmpint (retval, ==, -30);
 590   g_signal_handler_disconnect (test, id);
 591
 592   /* Test return value positive */
 593   retval = 0;
 594   id = g_signal_connect (test,
 595                          "va-marshaller-int-return",
 596                          G_CALLBACK (on_generic_marshaller_int_return_signed_2),
 597                          NULL);
 598   g_signal_emit_by_name (test, "va-marshaller-int-return", &retval);
 599   g_assert_cmpint (retval, ==, 2);
 600   g_signal_handler_disconnect (test, id);
 601
 602   g_object_unref (test);
 603 }
 604
 605 static guint
 606 on_generic_marshaller_uint_return_1 (Test *obj)
 607 {
 608   return 1;
 609 }
 610
 611 static guint
 612 on_generic_marshaller_uint_return_2 (Test *obj)
 613 {
 614   return G_MAXUINT;
 615 }
 616
 617 static void
 618 test_generic_marshaller_signal_uint_return (void)
 619 {
 620   Test *test;
 621   guint id;
 622   guint retval = 0;
 623
 624   test = g_object_new (test_get_type (), NULL);
 625
 626   id = g_signal_connect (test,
 627                          "generic-marshaller-uint-return",
 628                          G_CALLBACK (on_generic_marshaller_uint_return_1),
 629                          NULL);
 630   g_signal_emit_by_name (test, "generic-marshaller-uint-return", &retval);
 631   g_assert_cmpint (retval, ==, 1);
 632   g_signal_handler_disconnect (test, id);
 633
 634   retval = 0;
 635   id = g_signal_connect (test,
 636                          "generic-marshaller-uint-return",
 637                          G_CALLBACK (on_generic_marshaller_uint_return_2),
 638                          NULL);
 639   g_signal_emit_by_name (test, "generic-marshaller-uint-return", &retval);
 640   g_assert_cmpint (retval, ==, G_MAXUINT);
 641   g_signal_handler_disconnect (test, id);
 642
 643   /* Same test for va marshaller */
 644
 645   id = g_signal_connect (test,
 646                          "va-marshaller-uint-return",
 647                          G_CALLBACK (on_generic_marshaller_uint_return_1),
 648                          NULL);
 649   g_signal_emit_by_name (test, "va-marshaller-uint-return", &retval);
 650   g_assert_cmpint (retval, ==, 1);
 651   g_signal_handler_disconnect (test, id);
 652
 653   retval = 0;
 654   id = g_signal_connect (test,
 655                          "va-marshaller-uint-return",
 656                          G_CALLBACK (on_generic_marshaller_uint_return_2),
 657                          NULL);
 658   g_signal_emit_by_name (test, "va-marshaller-uint-return", &retval);
 659   g_assert_cmpint (retval, ==, G_MAXUINT);
 660   g_signal_handler_disconnect (test, id);
 661
 662   g_object_unref (test);
 663 }
 664
 665 static int all_type_handlers_count = 0;
 666
 667 static void
 668 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)
 669 {
 670   all_type_handlers_count++;
 671
 672   g_assert_cmpint (i, ==, 42);
 673   g_assert_cmpint (b, ==, TRUE);
 674   g_assert_cmpint (c, ==, 17);
 675   g_assert_cmpuint (uc, ==, 140);
 676   g_assert_cmpuint (ui, ==, G_MAXUINT - 42);
 677   g_assert_cmpint (l, ==, -1117);
 678   g_assert_cmpuint (ul, ==, G_MAXULONG - 999);
 679   g_assert_cmpint (e, ==, 1);
 680   g_assert_cmpuint (f, ==, 0);
 681   g_assert_cmpfloat (fl, ==, 0.25);
 682   g_assert_cmpfloat (db, ==, 1.5);
 683   g_assert_cmpstr (str, ==, "Test");
 684   g_assert_cmpstr (g_param_spec_get_nick (param), ==, "nick");
 685   g_assert_cmpstr (g_bytes_get_data (bytes, NULL), ==, "Blah");
 686   g_assert (ptr == &enum_type);
 687   g_assert_cmpuint (g_variant_get_uint16 (var), == , 99);
 688   g_assert_cmpint (i64, ==, G_MAXINT64 - 1234);
 689   g_assert_cmpuint (ui64, ==, G_MAXUINT64 - 123456);
 690 }
 691
 692 static void
 693 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)
 694 {
 695   g_assert (user_data == &flags_type);
 696   all_types_handler (test, i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, obj, var, i64, ui64);
 697 }
 698
 699 static void
 700 test_all_types (void)
 701 {
 702   Test *test;
 703
 704   int i = 42;
 705   gboolean b = TRUE;
 706   char c = 17;
 707   guchar uc = 140;
 708   guint ui = G_MAXUINT - 42;
 709   glong l =  -1117;
 710   gulong ul = G_MAXULONG - 999;
 711   gint e = 1;
 712   guint f = 0;
 713   float fl = 0.25;
 714   double db = 1.5;
 715   char *str = "Test";
 716   GParamSpec *param = g_param_spec_long  ("param", "nick", "blurb", 0, 10, 4, 0);
 717   GBytes *bytes = g_bytes_new_static ("Blah", 5);
 718   gpointer ptr = &enum_type;
 719   GVariant *var = g_variant_new_uint16 (99);
 720   gint64 i64;
 721   guint64 ui64;
 722   g_variant_ref_sink (var);
 723   i64 = G_MAXINT64 - 1234;
 724   ui64 = G_MAXUINT64 - 123456;
 725
 726   test = g_object_new (test_get_type (), NULL);
 727
 728   all_type_handlers_count = 0;
 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);
 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);
 763
 764   all_type_handlers_count = 0;
 765
 766   g_signal_connect (test, "all-types", G_CALLBACK (all_types_handler_cb), &flags_type);
 767   g_signal_connect (test, "all-types-va", G_CALLBACK (all_types_handler_cb), &flags_type);
 768   g_signal_connect (test, "all-types-generic", G_CALLBACK (all_types_handler_cb), &flags_type);
 769   g_signal_connect (test, "all-types-empty", G_CALLBACK (all_types_handler_cb), &flags_type);
 770   g_signal_connect (test, "all-types-null", G_CALLBACK (all_types_handler_cb), &flags_type);
 771
 772   g_signal_emit_by_name (test, "all-types",
 773                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 774   g_signal_emit_by_name (test, "all-types-va",
 775                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 776   g_signal_emit_by_name (test, "all-types-generic",
 777                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 778   g_signal_emit_by_name (test, "all-types-empty",
 779                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 780   g_signal_emit_by_name (test, "all-types-null",
 781                          i, b, c, uc, ui, l, ul, e, f, fl, db, str, param, bytes, ptr, test, var, i64, ui64);
 782
 783   g_assert_cmpint (all_type_handlers_count, ==, 3 + 5 + 5);
 784
 785   g_object_unref (test);
 786   g_param_spec_unref (param);
 787   g_bytes_unref (bytes);
 788   g_variant_unref (var);
 789 }
 790
 791 static void
 792 test_connect (void)
 793 {
 794   GObject *test;
 795   gint retval;
 796
 797   test = g_object_new (test_get_type (), NULL);
 798
 799   g_object_connect (test,
 800                     "signal::generic-marshaller-int-return",
 801                     G_CALLBACK (on_generic_marshaller_int_return_signed_1),
 802                     NULL,
 803                     "object-signal::va-marshaller-int-return",
 804                     G_CALLBACK (on_generic_marshaller_int_return_signed_2),
 805                     NULL,
 806                     NULL);
 807   g_signal_emit_by_name (test, "generic-marshaller-int-return", &retval);
 808   g_assert_cmpint (retval, ==, -30);
 809   g_signal_emit_by_name (test, "va-marshaller-int-return", &retval);
 810   g_assert_cmpint (retval, ==, 2);
 811
 812   g_object_disconnect (test,
 813                        "any-signal",
 814                        G_CALLBACK (on_generic_marshaller_int_return_signed_1),
 815                        NULL,
 816                        "any-signal::va-marshaller-int-return",
 817                        G_CALLBACK (on_generic_marshaller_int_return_signed_2),
 818                        NULL,
 819                        NULL);
 820
 821   g_object_unref (test);
 822 }
 823
 824 static void
 825 simple_handler1 (GObject *sender,
 826                  GObject *target)
 827 {
 828   g_object_unref (target);
 829 }
 830
 831 static void
 832 simple_handler2 (GObject *sender,
 833                  GObject *target)
 834 {
 835   g_object_unref (target);
 836 }
 837
 838 static void
 839 test_destroy_target_object (void)
 840 {
 841   Test *sender, *target1, *target2;
 842
 843   sender = g_object_new (test_get_type (), NULL);
 844   target1 = g_object_new (test_get_type (), NULL);
 845   target2 = g_object_new (test_get_type (), NULL);
 846   g_signal_connect_object (sender, "simple", G_CALLBACK (simple_handler1), target1, 0);
 847   g_signal_connect_object (sender, "simple", G_CALLBACK (simple_handler2), target2, 0);
 848   g_signal_emit_by_name (sender, "simple");
 849   g_object_unref (sender);
 850 }
 851
 852 static gboolean
 853 hook_func (GSignalInvocationHint *ihint,
 854            guint                  n_params,
 855            const GValue          *params,
 856            gpointer               data)
 857 {
 858   gint *count = data;
 859
 860   (*count)++;
 861
 862   return TRUE;
 863 }
 864
 865 static void
 866 test_emission_hook (void)
 867 {
 868   GObject *test1, *test2;
 869   gint count = 0;
 870   gulong hook;
 871
 872   test1 = g_object_new (test_get_type (), NULL);
 873   test2 = g_object_new (test_get_type (), NULL);
 874
 875   hook = g_signal_add_emission_hook (simple_id, 0, hook_func, &count, NULL);
 876   g_assert_cmpint (count, ==, 0);
 877   g_signal_emit_by_name (test1, "simple");
 878   g_assert_cmpint (count, ==, 1);
 879   g_signal_emit_by_name (test2, "simple");
 880   g_assert_cmpint (count, ==, 2);
 881   g_signal_remove_emission_hook (simple_id, hook);
 882   g_signal_emit_by_name (test1, "simple");
 883   g_assert_cmpint (count, ==, 2);
 884
 885   g_object_unref (test1);
 886   g_object_unref (test2);
 887 }
 888
 889 static void
 890 simple_cb (gpointer instance, gpointer data)
 891 {
 892   GSignalInvocationHint *ihint;
 893
 894   ihint = g_signal_get_invocation_hint (instance);
 895
 896   g_assert_cmpstr (g_signal_name (ihint->signal_id), ==, "simple");
 897
 898   g_signal_emit_by_name (instance, "simple-2");
 899 }
 900
 901 static void
 902 simple2_cb (gpointer instance, gpointer data)
 903 {
 904   GSignalInvocationHint *ihint;
 905
 906   ihint = g_signal_get_invocation_hint (instance);
 907
 908   g_assert_cmpstr (g_signal_name (ihint->signal_id), ==, "simple-2");
 909 }
 910
 911 static void
 912 test_invocation_hint (void)
 913 {
 914   GObject *test;
 915
 916   test = g_object_new (test_get_type (), NULL);
 917
 918   g_signal_connect (test, "simple", G_CALLBACK (simple_cb), NULL);
 919   g_signal_connect (test, "simple-2", G_CALLBACK (simple2_cb), NULL);
 920   g_signal_emit_by_name (test, "simple");
 921
 922   g_object_unref (test);
 923 }
 924
 925 static gboolean
 926 in_set (const gchar *s,
 927         const gchar *set[])
 928 {
 929   gint i;
 930
 931   for (i = 0; set[i]; i++)
 932     {
 933       if (g_strcmp0 (s, set[i]) == 0)
 934         return TRUE;
 935     }
 936
 937   return FALSE;
 938 }
 939
 940 static void
 941 test_introspection (void)
 942 {
 943   guint *ids;
 944   guint n_ids;
 945   const gchar *name;
 946   gint i;
 947   const gchar *names[] = {
 948     "simple",
 949     "simple-2",
 950     "generic-marshaller-1",
 951     "generic-marshaller-2",
 952     "generic-marshaller-enum-return-signed",
 953     "generic-marshaller-enum-return-unsigned",
 954     "generic-marshaller-int-return",
 955     "va-marshaller-int-return",
 956     "generic-marshaller-uint-return",
 957     "va-marshaller-uint-return",
 958     "variant-changed-no-slot",
 959     "variant-changed",
 960     "all-types",
 961     "all-types-va",
 962     "all-types-generic",
 963     "all-types-null",
 964     "all-types-empty",
 965     NULL
 966   };
 967   GSignalQuery query;
 968
 969   ids = g_signal_list_ids (test_get_type (), &n_ids);
 970   g_assert_cmpuint (n_ids, ==, g_strv_length ((gchar**)names));
 971
 972   for (i = 0; i < n_ids; i++)
 973     {
 974       name = g_signal_name (ids[i]);
 975       g_assert (in_set (name, names));
 976     }
 977
 978   g_signal_query (simple_id, &query);
 979   g_assert_cmpuint (query.signal_id, ==, simple_id);
 980   g_assert_cmpstr (query.signal_name, ==, "simple");
 981   g_assert (query.itype == test_get_type ());
 982   g_assert (query.signal_flags == G_SIGNAL_RUN_LAST);
 983   g_assert (query.return_type == G_TYPE_NONE);
 984   g_assert_cmpuint (query.n_params, ==, 0);
 985
 986   g_free (ids);
 987 }
 988
 989 static void
 990 test_handler (gpointer instance, gpointer data)
 991 {
 992   gint *count = data;
 993
 994   (*count)++;
 995 }
 996
 997 static void
 998 test_block_handler (void)
 999 {
1000   GObject *test1, *test2;
1001   gint count1 = 0;
1002   gint count2 = 0;
1003   gulong handler1, handler;
1004
1005   test1 = g_object_new (test_get_type (), NULL);
1006   test2 = g_object_new (test_get_type (), NULL);
1007
1008   handler1 = g_signal_connect (test1, "simple", G_CALLBACK (test_handler), &count1);
1009   g_signal_connect (test2, "simple", G_CALLBACK (test_handler), &count2);
1010
1011   handler = g_signal_handler_find (test1, G_SIGNAL_MATCH_ID, simple_id, 0, NULL, NULL, NULL);
1012
1013   g_assert (handler == handler1);
1014
1015   g_assert_cmpint (count1, ==, 0);
1016   g_assert_cmpint (count2, ==, 0);
1017
1018   g_signal_emit_by_name (test1, "simple");
1019   g_signal_emit_by_name (test2, "simple");
1020
1021   g_assert_cmpint (count1, ==, 1);
1022   g_assert_cmpint (count2, ==, 1);
1023
1024   g_signal_handler_block (test1, handler1);
1025
1026   g_signal_emit_by_name (test1, "simple");
1027   g_signal_emit_by_name (test2, "simple");
1028
1029   g_assert_cmpint (count1, ==, 1);
1030   g_assert_cmpint (count2, ==, 2);
1031
1032   g_signal_handler_unblock (test1, handler1);
1033
1034   g_signal_emit_by_name (test1, "simple");
1035   g_signal_emit_by_name (test2, "simple");
1036
1037   g_assert_cmpint (count1, ==, 2);
1038   g_assert_cmpint (count2, ==, 3);
1039
1040   g_assert_cmpuint (g_signal_handlers_block_matched (test1, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, test_block_handler, NULL), ==, 0);
1041   g_assert_cmpuint (g_signal_handlers_block_matched (test2, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, test_handler, NULL), ==, 1);
1042
1043   g_signal_emit_by_name (test1, "simple");
1044   g_signal_emit_by_name (test2, "simple");
1045
1046   g_assert_cmpint (count1, ==, 3);
1047   g_assert_cmpint (count2, ==, 3);
1048
1049   g_signal_handlers_unblock_matched (test2, G_SIGNAL_MATCH_FUNC, 0, 0, NULL, test_handler, NULL);
1050
1051   g_object_unref (test1);
1052   g_object_unref (test2);
1053 }
1054
1055 static void
1056 stop_emission (gpointer instance, gpointer data)
1057 {
1058   g_signal_stop_emission (instance, simple_id, 0);
1059 }
1060
1061 static void
1062 stop_emission_by_name (gpointer instance, gpointer data)
1063 {
1064   g_signal_stop_emission_by_name (instance, "simple");
1065 }
1066
1067 static void
1068 dont_reach (gpointer instance, gpointer data)
1069 {
1070   g_assert_not_reached ();
1071 }
1072
1073 static void
1074 test_stop_emission (void)
1075 {
1076   GObject *test1;
1077   gulong handler;
1078
1079   test1 = g_object_new (test_get_type (), NULL);
1080   handler = g_signal_connect (test1, "simple", G_CALLBACK (stop_emission), NULL);
1081   g_signal_connect_after (test1, "simple", G_CALLBACK (dont_reach), NULL);
1082
1083   g_signal_emit_by_name (test1, "simple");
1084
1085   g_signal_handler_disconnect (test1, handler);
1086   g_signal_connect (test1, "simple", G_CALLBACK (stop_emission_by_name), NULL);
1087
1088   g_signal_emit_by_name (test1, "simple");
1089
1090   g_object_unref (test1);
1091 }
1092
1093 /* --- */
1094
1095 int
1096 main (int argc,
1097      char *argv[])
1098 {
1099   g_test_init (&argc, &argv, NULL);
1100
1101   g_test_add_func ("/gobject/signals/all-types", test_all_types);
1102   g_test_add_func ("/gobject/signals/variant", test_variant_signal);
1103   g_test_add_func ("/gobject/signals/destroy-target-object", test_destroy_target_object);
1104   g_test_add_func ("/gobject/signals/generic-marshaller-1", test_generic_marshaller_signal_1);
1105   g_test_add_func ("/gobject/signals/generic-marshaller-2", test_generic_marshaller_signal_2);
1106   g_test_add_func ("/gobject/signals/generic-marshaller-enum-return-signed", test_generic_marshaller_signal_enum_return_signed);
1107   g_test_add_func ("/gobject/signals/generic-marshaller-enum-return-unsigned", test_generic_marshaller_signal_enum_return_unsigned);
1108   g_test_add_func ("/gobject/signals/generic-marshaller-int-return", test_generic_marshaller_signal_int_return);
1109   g_test_add_func ("/gobject/signals/generic-marshaller-uint-return", test_generic_marshaller_signal_uint_return);
1110   g_test_add_func ("/gobject/signals/connect", test_connect);
1111   g_test_add_func ("/gobject/signals/emission-hook", test_emission_hook);
1112   g_test_add_func ("/gobject/signals/introspection", test_introspection);
1113   g_test_add_func ("/gobject/signals/block-handler", test_block_handler);
1114   g_test_add_func ("/gobject/signals/stop-emission", test_stop_emission);
1115   g_test_add_func ("/gobject/signals/invocation-hint", test_invocation_hint);
1116
1117   return g_test_run ();
1118 }