gobject/tests/signalgroup.c

   1 /* GObject - GLib Type, Object, Parameter and Signal Library
   2  *
   3  * Copyright (C) 2015-2022 Christian Hergert <christian@hergert.me>
   4  * Copyright (C) 2015 Garrett Regier <garrettregier@gmail.com>
   5  *
   6  * SPDX-License-Identifier: LGPL-2.1-or-later
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General
  19  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  20  *
  21  * SPDX-License-Identifier: LGPL-2.1-or-later
  22  */
  23
  24 #include <glib-object.h>
  25
  26 G_DECLARE_FINAL_TYPE (SignalTarget, signal_target, TEST, SIGNAL_TARGET, GObject)
  27
  28 struct _SignalTarget
  29 {
  30   GObject parent_instance;
  31 };
  32
  33 G_DEFINE_TYPE (SignalTarget, signal_target, G_TYPE_OBJECT)
  34
  35 static G_DEFINE_QUARK (detail, signal_detail);
  36
  37 enum {
  38   THE_SIGNAL,
  39   NEVER_EMITTED,
  40   LAST_SIGNAL
  41 };
  42
  43 static guint signals[LAST_SIGNAL];
  44
  45 static void
  46 signal_target_class_init (SignalTargetClass *klass)
  47 {
  48   signals[THE_SIGNAL] =
  49       g_signal_new ("the-signal",
  50                     G_TYPE_FROM_CLASS (klass),
  51                     G_SIGNAL_RUN_LAST | G_SIGNAL_DETAILED,
  52                     0,
  53                     NULL, NULL, NULL,
  54                     G_TYPE_NONE,
  55                     1,
  56                     G_TYPE_OBJECT);
  57
  58   signals[NEVER_EMITTED] =
  59       g_signal_new ("never-emitted",
  60                     G_TYPE_FROM_CLASS (klass),
  61                     G_SIGNAL_RUN_LAST,
  62                     0,
  63                     NULL, NULL, NULL,
  64                     G_TYPE_NONE,
  65                     1,
  66                     G_TYPE_OBJECT);
  67 }
  68
  69 static void
  70 signal_target_init (SignalTarget *self)
  71 {
  72 }
  73
  74 static gint global_signal_calls;
  75 static gint global_weak_notify_called;
  76
  77 static void
  78 connect_before_cb (SignalTarget *target,
  79                    GSignalGroup *group,
  80                    gint         *signal_calls)
  81 {
  82   SignalTarget *readback;
  83
  84   g_assert_true (TEST_IS_SIGNAL_TARGET (target));
  85   g_assert_true (G_IS_SIGNAL_GROUP (group));
  86   g_assert_nonnull (signal_calls);
  87   g_assert_true (signal_calls == &global_signal_calls);
  88
  89   readback = g_signal_group_dup_target (group);
  90   g_assert_true (readback == target);
  91   g_object_unref (readback);
  92
  93   *signal_calls += 1;
  94 }
  95
  96 static void
  97 connect_after_cb (SignalTarget *target,
  98                   GSignalGroup *group,
  99                   gint         *signal_calls)
 100 {
 101   SignalTarget *readback;
 102
 103   g_assert_true (TEST_IS_SIGNAL_TARGET (target));
 104   g_assert_true (G_IS_SIGNAL_GROUP (group));
 105   g_assert_nonnull (signal_calls);
 106   g_assert_true (signal_calls == &global_signal_calls);
 107
 108   readback = g_signal_group_dup_target (group);
 109   g_assert_true (readback == target);
 110   g_object_unref (readback);
 111
 112   g_assert_cmpint (*signal_calls, ==, 5);
 113   *signal_calls += 1;
 114 }
 115
 116 static void
 117 connect_swapped_cb (gint         *signal_calls,
 118                     GSignalGroup *group,
 119                     SignalTarget *target)
 120 {
 121   SignalTarget *readback;
 122
 123   g_assert_true (signal_calls != NULL);
 124   g_assert_true (signal_calls == &global_signal_calls);
 125   g_assert_true (G_IS_SIGNAL_GROUP (group));
 126   g_assert_true (TEST_IS_SIGNAL_TARGET (target));
 127
 128   readback = g_signal_group_dup_target (group);
 129   g_assert_true (readback == target);
 130   g_object_unref (readback);
 131
 132   *signal_calls += 1;
 133 }
 134
 135 static void
 136 connect_object_cb (SignalTarget *target,
 137                    GSignalGroup *group,
 138                    GObject      *object)
 139 {
 140   SignalTarget *readback;
 141   gint *signal_calls;
 142
 143   g_assert_true (TEST_IS_SIGNAL_TARGET (target));
 144   g_assert_true (G_IS_SIGNAL_GROUP (group));
 145   g_assert_true (G_IS_OBJECT (object));
 146
 147   readback = g_signal_group_dup_target (group);
 148   g_assert_true (readback == target);
 149   g_object_unref (readback);
 150
 151   signal_calls = g_object_get_data (object, "signal-calls");
 152   g_assert_nonnull (signal_calls);
 153   g_assert_true (signal_calls == &global_signal_calls);
 154
 155   *signal_calls += 1;
 156 }
 157
 158 static void
 159 connect_bad_detail_cb (SignalTarget *target,
 160                        GSignalGroup *group,
 161                        GObject      *object)
 162 {
 163   g_error ("This detailed signal is never emitted!");
 164 }
 165
 166 static void
 167 connect_never_emitted_cb (SignalTarget *target,
 168                           gboolean     *weak_notify_called)
 169 {
 170   g_error ("This signal is never emitted!");
 171 }
 172
 173 static void
 174 connect_data_notify_cb (gboolean *weak_notify_called,
 175                         GClosure *closure)
 176 {
 177   g_assert_nonnull (weak_notify_called);
 178   g_assert_true (weak_notify_called == &global_weak_notify_called);
 179   g_assert_nonnull (closure);
 180
 181   g_assert_false (*weak_notify_called);
 182   *weak_notify_called = TRUE;
 183 }
 184
 185 static void
 186 connect_data_weak_notify_cb (gboolean     *weak_notify_called,
 187                              GSignalGroup *group)
 188 {
 189   g_assert_nonnull (weak_notify_called);
 190   g_assert_true (weak_notify_called == &global_weak_notify_called);
 191   g_assert_true (G_IS_SIGNAL_GROUP (group));
 192
 193   g_assert_true (*weak_notify_called);
 194 }
 195
 196 static void
 197 connect_all_signals (GSignalGroup *group)
 198 {
 199   GObject  *object;
 200   GClosure *closure;
 201
 202   /* Check that these are called in the right order */
 203   g_signal_group_connect (group,
 204                           "the-signal",
 205                           G_CALLBACK (connect_before_cb),
 206                           &global_signal_calls);
 207   g_signal_group_connect_after (group,
 208                                 "the-signal",
 209                                 G_CALLBACK (connect_after_cb),
 210                                 &global_signal_calls);
 211
 212   /* Check that this is called with the arguments swapped */
 213   g_signal_group_connect_swapped (group,
 214                                   "the-signal",
 215                                   G_CALLBACK (connect_swapped_cb),
 216                                   &global_signal_calls);
 217
 218   /* Check that this is called with the arguments swapped */
 219   object = g_object_new (G_TYPE_OBJECT, NULL);
 220   g_object_set_data (object, "signal-calls", &global_signal_calls);
 221   g_signal_group_connect_object (group,
 222                                  "the-signal",
 223                                  G_CALLBACK (connect_object_cb),
 224                                  object,
 225                                  0);
 226   g_object_weak_ref (G_OBJECT (group),
 227                      (GWeakNotify)g_object_unref,
 228                      object);
 229
 230   /* Check that a detailed signal is handled correctly */
 231   g_signal_group_connect (group,
 232                           "the-signal::detail",
 233                           G_CALLBACK (connect_before_cb),
 234                           &global_signal_calls);
 235   g_signal_group_connect (group,
 236                           "the-signal::bad-detail",
 237                           G_CALLBACK (connect_bad_detail_cb),
 238                           NULL);
 239
 240   /* Check that the notify is called correctly */
 241   global_weak_notify_called = FALSE;
 242   g_signal_group_connect_data (group,
 243                                "never-emitted",
 244                                G_CALLBACK (connect_never_emitted_cb),
 245                                &global_weak_notify_called,
 246                                (GClosureNotify)connect_data_notify_cb,
 247                                0);
 248   g_object_weak_ref (G_OBJECT (group),
 249                      (GWeakNotify)connect_data_weak_notify_cb,
 250                      &global_weak_notify_called);
 251
 252
 253   /* Check that this can be called as a GClosure */
 254   closure = g_cclosure_new (G_CALLBACK (connect_before_cb),
 255                             &global_signal_calls,
 256                             NULL);
 257   g_signal_group_connect_closure (group, "the-signal", closure, FALSE);
 258
 259   /* Check that invalidated GClosures don't get called */
 260   closure = g_cclosure_new (G_CALLBACK (connect_before_cb),
 261                             &global_signal_calls,
 262                             NULL);
 263   g_closure_invalidate (closure);
 264   g_signal_group_connect_closure (group, "the-signal", closure, FALSE);
 265 }
 266
 267 static void
 268 assert_signals (SignalTarget *target,
 269                 GSignalGroup *group,
 270                 gboolean      success)
 271 {
 272   g_assert (TEST_IS_SIGNAL_TARGET (target));
 273   g_assert (group == NULL || G_IS_SIGNAL_GROUP (group));
 274
 275   global_signal_calls = 0;
 276   g_signal_emit (target, signals[THE_SIGNAL],
 277                  signal_detail_quark (), group);
 278   g_assert_cmpint (global_signal_calls, ==, success ? 6 : 0);
 279 }
 280
 281 static void
 282 dummy_handler (void)
 283 {
 284 }
 285
 286 static void
 287 test_signal_group_invalid (void)
 288 {
 289   GObject *invalid_target = g_object_new (G_TYPE_OBJECT, NULL);
 290   SignalTarget *target = g_object_new (signal_target_get_type (), NULL);
 291   GSignalGroup *group = g_signal_group_new (signal_target_get_type ());
 292
 293   /* Invalid Target Type */
 294   g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 295                          "*g_type_is_a*G_TYPE_OBJECT*");
 296   g_signal_group_new (G_TYPE_DATE_TIME);
 297   g_test_assert_expected_messages ();
 298
 299   /* Invalid Target */
 300   g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 301                          "*Failed to set GSignalGroup of target type SignalTarget using target * of type GObject*");
 302   g_signal_group_set_target (group, invalid_target);
 303   g_assert_finalize_object (group);
 304   g_test_assert_expected_messages ();
 305
 306   /* Invalid Signal Name */
 307   g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 308                          "*Invalid signal name “does-not-exist”*");
 309   group = g_signal_group_new (signal_target_get_type ());
 310   g_signal_group_connect (group,
 311                           "does-not-exist",
 312                           G_CALLBACK (connect_before_cb),
 313                           NULL);
 314   g_test_assert_expected_messages ();
 315   g_assert_finalize_object (group);
 316
 317   /* Invalid Callback */
 318   g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 319                          "*c_handler != NULL*");
 320   group = g_signal_group_new (signal_target_get_type ());
 321   g_signal_group_connect (group,
 322                           "the-signal",
 323                           G_CALLBACK (NULL),
 324                           NULL);
 325   g_test_assert_expected_messages ();
 326   g_assert_finalize_object (group);
 327
 328   /* Connecting after setting target */
 329   g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 330                          "*Cannot add signals after setting target*");
 331   group = g_signal_group_new (signal_target_get_type ());
 332   g_signal_group_set_target (group, target);
 333   g_signal_group_connect (group,
 334                           "the-signal",
 335                           G_CALLBACK (dummy_handler),
 336                           NULL);
 337   g_test_assert_expected_messages ();
 338   g_assert_finalize_object (group);
 339
 340   g_assert_finalize_object (target);
 341   g_assert_finalize_object (invalid_target);
 342 }
 343
 344 static void
 345 test_signal_group_simple (void)
 346 {
 347   SignalTarget *target;
 348   GSignalGroup *group;
 349   SignalTarget *readback;
 350
 351   /* Set the target before connecting the signals */
 352   group = g_signal_group_new (signal_target_get_type ());
 353   target = g_object_new (signal_target_get_type (), NULL);
 354   g_assert_null (g_signal_group_dup_target (group));
 355   g_signal_group_set_target (group, target);
 356   readback = g_signal_group_dup_target (group);
 357   g_assert_true (readback == target);
 358   g_object_unref (readback);
 359   g_assert_finalize_object (group);
 360   assert_signals (target, NULL, FALSE);
 361   g_assert_finalize_object (target);
 362
 363   group = g_signal_group_new (signal_target_get_type ());
 364   target = g_object_new (signal_target_get_type (), NULL);
 365   connect_all_signals (group);
 366   g_signal_group_set_target (group, target);
 367   assert_signals (target, group, TRUE);
 368   g_assert_finalize_object (target);
 369   g_assert_finalize_object (group);
 370 }
 371
 372 static void
 373 test_signal_group_changing_target (void)
 374 {
 375   SignalTarget *target1, *target2;
 376   GSignalGroup *group = g_signal_group_new (signal_target_get_type ());
 377   SignalTarget *readback;
 378
 379   connect_all_signals (group);
 380   g_assert_null (g_signal_group_dup_target (group));
 381
 382   /* Set the target after connecting the signals */
 383   target1 = g_object_new (signal_target_get_type (), NULL);
 384   g_signal_group_set_target (group, target1);
 385   readback = g_signal_group_dup_target (group);
 386   g_assert_true (readback == target1);
 387   g_object_unref (readback);
 388
 389   assert_signals (target1, group, TRUE);
 390
 391   /* Set the same target */
 392   readback = g_signal_group_dup_target (group);
 393   g_assert_true (readback == target1);
 394   g_object_unref (readback);
 395   g_signal_group_set_target (group, target1);
 396
 397   readback = g_signal_group_dup_target (group);
 398   g_assert_true (readback == target1);
 399   g_object_unref (readback);
 400
 401   assert_signals (target1, group, TRUE);
 402
 403   /* Set a new target when the current target is non-NULL */
 404   target2 = g_object_new (signal_target_get_type (), NULL);
 405   readback = g_signal_group_dup_target (group);
 406   g_assert_true (readback == target1);
 407   g_object_unref (readback);
 408
 409   g_signal_group_set_target (group, target2);
 410   readback = g_signal_group_dup_target (group);
 411   g_assert_true (readback == target2);
 412   g_object_unref (readback);
 413
 414   assert_signals (target2, group, TRUE);
 415
 416   g_assert_finalize_object (target2);
 417   g_assert_finalize_object (target1);
 418   g_assert_finalize_object (group);
 419 }
 420
 421 static void
 422 assert_blocking (SignalTarget *target,
 423                  GSignalGroup *group,
 424                  gint          count)
 425 {
 426   gint i;
 427
 428   assert_signals (target, group, TRUE);
 429
 430   /* Assert that multiple blocks are effective */
 431   for (i = 0; i < count; ++i)
 432     {
 433       g_signal_group_block (group);
 434       assert_signals (target, group, FALSE);
 435     }
 436
 437   /* Assert that the signal is not emitted after the first unblock */
 438   for (i = 0; i < count; ++i)
 439     {
 440       assert_signals (target, group, FALSE);
 441       g_signal_group_unblock (group);
 442     }
 443
 444   assert_signals (target, group, TRUE);
 445 }
 446
 447 static void
 448 test_signal_group_blocking (void)
 449 {
 450   SignalTarget *target1, *target2, *readback;
 451   GSignalGroup *group = g_signal_group_new (signal_target_get_type ());
 452
 453   /* Test blocking and unblocking null target */
 454   g_signal_group_block (group);
 455   g_signal_group_unblock (group);
 456
 457   connect_all_signals (group);
 458   g_assert_null (g_signal_group_dup_target (group));
 459
 460   target1 = g_object_new (signal_target_get_type (), NULL);
 461   g_signal_group_set_target (group, target1);
 462   readback = g_signal_group_dup_target (group);
 463   g_assert_true (readback == target1);
 464   g_object_unref (readback);
 465
 466   assert_blocking (target1, group, 1);
 467   assert_blocking (target1, group, 3);
 468   assert_blocking (target1, group, 15);
 469
 470   /* Assert that blocking transfers across changing the target */
 471   g_signal_group_block (group);
 472   g_signal_group_block (group);
 473
 474   /* Set a new target when the current target is non-NULL */
 475   target2 = g_object_new (signal_target_get_type (), NULL);
 476   readback = g_signal_group_dup_target (group);
 477   g_assert_true (readback == target1);
 478   g_object_unref (readback);
 479   g_signal_group_set_target (group, target2);
 480   readback = g_signal_group_dup_target (group);
 481   g_assert_true (readback == target2);
 482   g_object_unref (readback);
 483
 484   assert_signals (target2, group, FALSE);
 485   g_signal_group_unblock (group);
 486   assert_signals (target2, group, FALSE);
 487   g_signal_group_unblock (group);
 488   assert_signals (target2, group, TRUE);
 489
 490   g_assert_finalize_object (target2);
 491   g_assert_finalize_object (target1);
 492   g_assert_finalize_object (group);
 493 }
 494
 495 static void
 496 test_signal_group_weak_ref_target (void)
 497 {
 498   SignalTarget *target = g_object_new (signal_target_get_type (), NULL);
 499   GSignalGroup *group = g_signal_group_new (signal_target_get_type ());
 500   SignalTarget *readback;
 501
 502   g_assert_null (g_signal_group_dup_target (group));
 503   g_signal_group_set_target (group, target);
 504   readback = g_signal_group_dup_target (group);
 505   g_assert_true (readback == target);
 506   g_object_unref (readback);
 507
 508   g_assert_finalize_object (target);
 509   g_assert_null (g_signal_group_dup_target (group));
 510   g_assert_finalize_object (group);
 511 }
 512
 513 static void
 514 test_signal_group_connect_object (void)
 515 {
 516   GObject *object = g_object_new (G_TYPE_OBJECT, NULL);
 517   SignalTarget *target = g_object_new (signal_target_get_type (), NULL);
 518   GSignalGroup *group = g_signal_group_new (signal_target_get_type ());
 519   SignalTarget *readback;
 520
 521   /* We already do basic connect_object() tests in connect_signals(),
 522    * this is only needed to test the specifics of connect_object()
 523    */
 524   g_signal_group_connect_object (group,
 525                                  "the-signal",
 526                                  G_CALLBACK (connect_object_cb),
 527                                  object,
 528                                  0);
 529
 530   g_assert_null (g_signal_group_dup_target (group));
 531   g_signal_group_set_target (group, target);
 532   readback = g_signal_group_dup_target (group);
 533   g_assert_true (readback == target);
 534   g_object_unref (readback);
 535
 536   g_assert_finalize_object (object);
 537
 538   /* This would cause a warning if the SignalGroup did not
 539    * have a weakref on the object as it would try to connect again
 540    */
 541   g_signal_group_set_target (group, NULL);
 542   g_assert_null (g_signal_group_dup_target (group));
 543   g_signal_group_set_target (group, target);
 544   readback = g_signal_group_dup_target (group);
 545   g_assert_true (readback == target);
 546   g_object_unref (readback);
 547
 548   g_assert_finalize_object (group);
 549   g_assert_finalize_object (target);
 550 }
 551
 552 static void
 553 test_signal_group_signal_parsing (void)
 554 {
 555   g_test_trap_subprocess ("/GObject/SignalGroup/signal-parsing/subprocess", 0,
 556                           G_TEST_SUBPROCESS_INHERIT_STDERR);
 557   g_test_trap_assert_passed ();
 558   g_test_trap_assert_stderr ("");
 559 }
 560
 561 static void
 562 test_signal_group_signal_parsing_subprocess (void)
 563 {
 564   GSignalGroup *group;
 565
 566   /* Check that the class has not been created and with it the
 567    * signals registered. This will cause g_signal_parse_name()
 568    * to fail unless GSignalGroup calls g_type_class_ref().
 569    */
 570   g_assert_null (g_type_class_peek (signal_target_get_type ()));
 571
 572   group = g_signal_group_new (signal_target_get_type ());
 573   g_signal_group_connect (group,
 574                           "the-signal",
 575                           G_CALLBACK (connect_before_cb),
 576                           NULL);
 577
 578   g_assert_finalize_object (group);
 579 }
 580
 581 static void
 582 test_signal_group_properties (void)
 583 {
 584   GSignalGroup *group;
 585   SignalTarget *target, *other;
 586   GType gtype;
 587
 588   group = g_signal_group_new (signal_target_get_type ());
 589   g_object_get (group,
 590                 "target", &target,
 591                 "target-type", &gtype,
 592                 NULL);
 593   g_assert_cmpint (gtype, ==, signal_target_get_type ());
 594   g_assert_null (target);
 595
 596   target = g_object_new (signal_target_get_type (), NULL);
 597   g_object_set (group, "target", target, NULL);
 598   g_object_get (group, "target", &other, NULL);
 599   g_assert_true (target == other);
 600   g_object_unref (other);
 601
 602   g_assert_finalize_object (target);
 603   g_assert_null (g_signal_group_dup_target (group));
 604   g_assert_finalize_object (group);
 605 }
 606
 607 G_DECLARE_INTERFACE (SignalThing, signal_thing, SIGNAL, THING, GObject)
 608
 609 struct _SignalThingInterface
 610 {
 611   GTypeInterface iface;
 612   void (*changed) (SignalThing *thing);
 613 };
 614
 615 G_DEFINE_INTERFACE (SignalThing, signal_thing, G_TYPE_OBJECT)
 616
 617 static guint signal_thing_changed;
 618
 619 static void
 620 signal_thing_default_init (SignalThingInterface *iface)
 621 {
 622   signal_thing_changed =
 623       g_signal_new ("changed",
 624                     G_TYPE_FROM_INTERFACE (iface),
 625                     G_SIGNAL_RUN_LAST,
 626                     G_STRUCT_OFFSET (SignalThingInterface, changed),
 627                     NULL, NULL, NULL,
 628                     G_TYPE_NONE, 0);
 629 }
 630
 631 G_GNUC_NORETURN static void
 632 thing_changed_cb (SignalThing *thing,
 633                   gpointer     user_data G_GNUC_UNUSED)
 634 {
 635   g_assert_not_reached ();
 636 }
 637
 638 static void
 639 test_signal_group_interface (void)
 640 {
 641   GSignalGroup *group;
 642
 643   group = g_signal_group_new (signal_thing_get_type ());
 644   g_signal_group_connect (group,
 645                           "changed",
 646                           G_CALLBACK (thing_changed_cb),
 647                           NULL);
 648   g_assert_finalize_object (group);
 649 }
 650
 651 gint
 652 main (gint   argc,
 653       gchar *argv[])
 654 {
 655   g_test_init (&argc, &argv, NULL);
 656   g_test_add_func ("/GObject/SignalGroup/invalid", test_signal_group_invalid);
 657   g_test_add_func ("/GObject/SignalGroup/simple", test_signal_group_simple);
 658   g_test_add_func ("/GObject/SignalGroup/changing-target", test_signal_group_changing_target);
 659   g_test_add_func ("/GObject/SignalGroup/blocking", test_signal_group_blocking);
 660   g_test_add_func ("/GObject/SignalGroup/weak-ref-target", test_signal_group_weak_ref_target);
 661   g_test_add_func ("/GObject/SignalGroup/connect-object", test_signal_group_connect_object);
 662   g_test_add_func ("/GObject/SignalGroup/signal-parsing", test_signal_group_signal_parsing);
 663   g_test_add_func ("/GObject/SignalGroup/signal-parsing/subprocess", test_signal_group_signal_parsing_subprocess);
 664   g_test_add_func ("/GObject/SignalGroup/properties", test_signal_group_properties);
 665   g_test_add_func ("/GObject/SignalGroup/interface", test_signal_group_interface);
 666   return g_test_run ();
 667 }