gobject/tests/binding.c

   1 #include <stdlib.h>
   2 #include <gstdio.h>
   3 #include <glib-object.h>
   4
   5 typedef struct _BindingSource
   6 {
   7   GObject parent_instance;
   8
   9   gint foo;
  10   gint bar;
  11   gdouble value;
  12   gboolean toggle;
  13 } BindingSource;
  14
  15 typedef struct _BindingSourceClass
  16 {
  17   GObjectClass parent_class;
  18 } BindingSourceClass;
  19
  20 enum
  21 {
  22   PROP_SOURCE_0,
  23
  24   PROP_SOURCE_FOO,
  25   PROP_SOURCE_BAR,
  26   PROP_SOURCE_VALUE,
  27   PROP_SOURCE_TOGGLE
  28 };
  29
  30 static GType binding_source_get_type (void);
  31 G_DEFINE_TYPE (BindingSource, binding_source, G_TYPE_OBJECT)
  32
  33 static void
  34 binding_source_set_property (GObject      *gobject,
  35                              guint         prop_id,
  36                              const GValue *value,
  37                              GParamSpec   *pspec)
  38 {
  39   BindingSource *source = (BindingSource *) gobject;
  40
  41   switch (prop_id)
  42     {
  43     case PROP_SOURCE_FOO:
  44       source->foo = g_value_get_int (value);
  45       break;
  46
  47     case PROP_SOURCE_BAR:
  48       source->bar = g_value_get_int (value);
  49       break;
  50
  51     case PROP_SOURCE_VALUE:
  52       source->value = g_value_get_double (value);
  53       break;
  54
  55     case PROP_SOURCE_TOGGLE:
  56       source->toggle = g_value_get_boolean (value);
  57       break;
  58
  59     default:
  60       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
  61     }
  62 }
  63
  64 static void
  65 binding_source_get_property (GObject    *gobject,
  66                              guint       prop_id,
  67                              GValue     *value,
  68                              GParamSpec *pspec)
  69 {
  70   BindingSource *source = (BindingSource *) gobject;
  71
  72   switch (prop_id)
  73     {
  74     case PROP_SOURCE_FOO:
  75       g_value_set_int (value, source->foo);
  76       break;
  77
  78     case PROP_SOURCE_BAR:
  79       g_value_set_int (value, source->bar);
  80       break;
  81
  82     case PROP_SOURCE_VALUE:
  83       g_value_set_double (value, source->value);
  84       break;
  85
  86     case PROP_SOURCE_TOGGLE:
  87       g_value_set_boolean (value, source->toggle);
  88       break;
  89
  90     default:
  91       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
  92     }
  93 }
  94
  95 static void
  96 binding_source_class_init (BindingSourceClass *klass)
  97 {
  98   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
  99
 100   gobject_class->set_property = binding_source_set_property;
 101   gobject_class->get_property = binding_source_get_property;
 102
 103   g_object_class_install_property (gobject_class, PROP_SOURCE_FOO,
 104                                    g_param_spec_int ("foo", "Foo", "Foo",
 105                                                      -1, 100,
 106                                                      0,
 107                                                      G_PARAM_READWRITE));
 108   g_object_class_install_property (gobject_class, PROP_SOURCE_BAR,
 109                                    g_param_spec_int ("bar", "Bar", "Bar",
 110                                                      -1, 100,
 111                                                      0,
 112                                                      G_PARAM_READWRITE));
 113   g_object_class_install_property (gobject_class, PROP_SOURCE_VALUE,
 114                                    g_param_spec_double ("value", "Value", "Value",
 115                                                         -100.0, 200.0,
 116                                                         0.0,
 117                                                         G_PARAM_READWRITE));
 118   g_object_class_install_property (gobject_class, PROP_SOURCE_TOGGLE,
 119                                    g_param_spec_boolean ("toggle", "Toggle", "Toggle",
 120                                                          FALSE,
 121                                                          G_PARAM_READWRITE));
 122 }
 123
 124 static void
 125 binding_source_init (BindingSource *self)
 126 {
 127 }
 128
 129 typedef struct _BindingTarget
 130 {
 131   GObject parent_instance;
 132
 133   gint bar;
 134   gdouble value;
 135   gboolean toggle;
 136 } BindingTarget;
 137
 138 typedef struct _BindingTargetClass
 139 {
 140   GObjectClass parent_class;
 141 } BindingTargetClass;
 142
 143 enum
 144 {
 145   PROP_TARGET_0,
 146
 147   PROP_TARGET_BAR,
 148   PROP_TARGET_VALUE,
 149   PROP_TARGET_TOGGLE
 150 };
 151
 152 static GType binding_target_get_type (void);
 153 G_DEFINE_TYPE (BindingTarget, binding_target, G_TYPE_OBJECT)
 154
 155 static void
 156 binding_target_set_property (GObject      *gobject,
 157                              guint         prop_id,
 158                              const GValue *value,
 159                              GParamSpec   *pspec)
 160 {
 161   BindingTarget *target = (BindingTarget *) gobject;
 162
 163   switch (prop_id)
 164     {
 165     case PROP_TARGET_BAR:
 166       target->bar = g_value_get_int (value);
 167       break;
 168
 169     case PROP_TARGET_VALUE:
 170       target->value = g_value_get_double (value);
 171       break;
 172
 173     case PROP_TARGET_TOGGLE:
 174       target->toggle = g_value_get_boolean (value);
 175       break;
 176
 177     default:
 178       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
 179     }
 180 }
 181
 182 static void
 183 binding_target_get_property (GObject    *gobject,
 184                              guint       prop_id,
 185                              GValue     *value,
 186                              GParamSpec *pspec)
 187 {
 188   BindingTarget *target = (BindingTarget *) gobject;
 189
 190   switch (prop_id)
 191     {
 192     case PROP_TARGET_BAR:
 193       g_value_set_int (value, target->bar);
 194       break;
 195
 196     case PROP_TARGET_VALUE:
 197       g_value_set_double (value, target->value);
 198       break;
 199
 200     case PROP_TARGET_TOGGLE:
 201       g_value_set_boolean (value, target->toggle);
 202       break;
 203
 204     default:
 205       G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
 206     }
 207 }
 208
 209 static void
 210 binding_target_class_init (BindingTargetClass *klass)
 211 {
 212   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 213
 214   gobject_class->set_property = binding_target_set_property;
 215   gobject_class->get_property = binding_target_get_property;
 216
 217   g_object_class_install_property (gobject_class, PROP_TARGET_BAR,
 218                                    g_param_spec_int ("bar", "Bar", "Bar",
 219                                                      -1, 100,
 220                                                      0,
 221                                                      G_PARAM_READWRITE));
 222   g_object_class_install_property (gobject_class, PROP_TARGET_VALUE,
 223                                    g_param_spec_double ("value", "Value", "Value",
 224                                                         -100.0, 200.0,
 225                                                         0.0,
 226                                                         G_PARAM_READWRITE));
 227   g_object_class_install_property (gobject_class, PROP_TARGET_TOGGLE,
 228                                    g_param_spec_boolean ("toggle", "Toggle", "Toggle",
 229                                                          FALSE,
 230                                                          G_PARAM_READWRITE));
 231 }
 232
 233 static void
 234 binding_target_init (BindingTarget *self)
 235 {
 236 }
 237
 238 static gboolean
 239 celsius_to_fahrenheit (GBinding     *binding,
 240                        const GValue *from_value,
 241                        GValue       *to_value,
 242                        gpointer      user_data G_GNUC_UNUSED)
 243 {
 244   gdouble celsius, fahrenheit;
 245
 246   g_assert (G_VALUE_HOLDS (from_value, G_TYPE_DOUBLE));
 247   g_assert (G_VALUE_HOLDS (to_value, G_TYPE_DOUBLE));
 248
 249   celsius = g_value_get_double (from_value);
 250   fahrenheit = (9 * celsius / 5) + 32.0;
 251
 252   if (g_test_verbose ())
 253     g_printerr ("Converting %.2fC to %.2fF\n", celsius, fahrenheit);
 254
 255   g_value_set_double (to_value, fahrenheit);
 256
 257   return TRUE;
 258 }
 259
 260 static gboolean
 261 fahrenheit_to_celsius (GBinding     *binding,
 262                        const GValue *from_value,
 263                        GValue       *to_value,
 264                        gpointer      user_data G_GNUC_UNUSED)
 265 {
 266   gdouble celsius, fahrenheit;
 267
 268   g_assert (G_VALUE_HOLDS (from_value, G_TYPE_DOUBLE));
 269   g_assert (G_VALUE_HOLDS (to_value, G_TYPE_DOUBLE));
 270
 271   fahrenheit = g_value_get_double (from_value);
 272   celsius = 5 * (fahrenheit - 32.0) / 9;
 273
 274   if (g_test_verbose ())
 275     g_printerr ("Converting %.2fF to %.2fC\n", fahrenheit, celsius);
 276
 277   g_value_set_double (to_value, celsius);
 278
 279   return TRUE;
 280 }
 281
 282 static void
 283 binding_default (void)
 284 {
 285   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 286   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 287   GBinding *binding;
 288
 289   binding = g_object_bind_property (source, "foo",
 290                                     target, "bar",
 291                                     G_BINDING_DEFAULT);
 292
 293   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 294   g_assert ((BindingSource *) g_binding_get_source (binding) == source);
 295   g_assert ((BindingTarget *) g_binding_get_target (binding) == target);
 296   g_assert_cmpstr (g_binding_get_source_property (binding), ==, "foo");
 297   g_assert_cmpstr (g_binding_get_target_property (binding), ==, "bar");
 298   g_assert_cmpint (g_binding_get_flags (binding), ==, G_BINDING_DEFAULT);
 299
 300   g_object_set (source, "foo", 42, NULL);
 301   g_assert_cmpint (source->foo, ==, target->bar);
 302
 303   g_object_set (target, "bar", 47, NULL);
 304   g_assert_cmpint (source->foo, !=, target->bar);
 305
 306   g_object_unref (binding);
 307
 308   g_object_set (source, "foo", 0, NULL);
 309   g_assert_cmpint (source->foo, !=, target->bar);
 310
 311   g_object_unref (source);
 312   g_object_unref (target);
 313   g_assert (binding == NULL);
 314 }
 315
 316 static void
 317 binding_bidirectional (void)
 318 {
 319   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 320   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 321   GBinding *binding;
 322
 323   binding = g_object_bind_property (source, "foo",
 324                                     target, "bar",
 325                                     G_BINDING_BIDIRECTIONAL);
 326   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 327
 328   g_object_set (source, "foo", 42, NULL);
 329   g_assert_cmpint (source->foo, ==, target->bar);
 330
 331   g_object_set (target, "bar", 47, NULL);
 332   g_assert_cmpint (source->foo, ==, target->bar);
 333
 334   g_object_unref (binding);
 335
 336   g_object_set (source, "foo", 0, NULL);
 337   g_assert_cmpint (source->foo, !=, target->bar);
 338
 339   g_object_unref (source);
 340   g_object_unref (target);
 341   g_assert (binding == NULL);
 342 }
 343
 344 static void
 345 data_free (gpointer data)
 346 {
 347   gboolean *b = data;
 348
 349   *b = TRUE;
 350 }
 351
 352 static void
 353 binding_transform_default (void)
 354 {
 355   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 356   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 357   GBinding *binding;
 358   gpointer src, trg;
 359   gchar *src_prop, *trg_prop;
 360   GBindingFlags flags;
 361
 362   binding = g_object_bind_property (source, "foo",
 363                                     target, "value",
 364                                     G_BINDING_BIDIRECTIONAL);
 365
 366   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 367
 368   g_object_get (binding,
 369                 "source", &src,
 370                 "source-property", &src_prop,
 371                 "target", &trg,
 372                 "target-property", &trg_prop,
 373                 "flags", &flags,
 374                 NULL);
 375   g_assert (src == source);
 376   g_assert (trg == target);
 377   g_assert_cmpstr (src_prop, ==, "foo");
 378   g_assert_cmpstr (trg_prop, ==, "value");
 379   g_assert_cmpint (flags, ==, G_BINDING_BIDIRECTIONAL);
 380   g_object_unref (src);
 381   g_object_unref (trg);
 382   g_free (src_prop);
 383   g_free (trg_prop);
 384
 385   g_object_set (source, "foo", 24, NULL);
 386   g_assert_cmpfloat (target->value, ==, 24.0);
 387
 388   g_object_set (target, "value", 69.0, NULL);
 389   g_assert_cmpint (source->foo, ==, 69);
 390
 391   g_object_unref (target);
 392   g_object_unref (source);
 393   g_assert (binding == NULL);
 394 }
 395
 396 static void
 397 binding_transform (void)
 398 {
 399   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 400   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 401   GBinding *binding G_GNUC_UNUSED;
 402   gboolean unused_data = FALSE;
 403
 404   binding = g_object_bind_property_full (source, "value",
 405                                          target, "value",
 406                                          G_BINDING_BIDIRECTIONAL,
 407                                          celsius_to_fahrenheit,
 408                                          fahrenheit_to_celsius,
 409                                          &unused_data, data_free);
 410
 411   g_object_set (source, "value", 24.0, NULL);
 412   g_assert_cmpfloat (target->value, ==, ((9 * 24.0 / 5) + 32.0));
 413
 414   g_object_set (target, "value", 69.0, NULL);
 415   g_assert_cmpfloat (source->value, ==, (5 * (69.0 - 32.0) / 9));
 416
 417   g_object_unref (source);
 418   g_object_unref (target);
 419
 420   g_assert (unused_data);
 421 }
 422
 423 static void
 424 binding_transform_closure (void)
 425 {
 426   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 427   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 428   GBinding *binding G_GNUC_UNUSED;
 429   gboolean unused_data_1 = FALSE, unused_data_2 = FALSE;
 430   GClosure *c2f_clos, *f2c_clos;
 431
 432   c2f_clos = g_cclosure_new (G_CALLBACK (celsius_to_fahrenheit), &unused_data_1, (GClosureNotify) data_free);
 433
 434   f2c_clos = g_cclosure_new (G_CALLBACK (fahrenheit_to_celsius), &unused_data_2, (GClosureNotify) data_free);
 435
 436   binding = g_object_bind_property_with_closures (source, "value",
 437                                                   target, "value",
 438                                                   G_BINDING_BIDIRECTIONAL,
 439                                                   c2f_clos,
 440                                                   f2c_clos);
 441
 442   g_object_set (source, "value", 24.0, NULL);
 443   g_assert_cmpfloat (target->value, ==, ((9 * 24.0 / 5) + 32.0));
 444
 445   g_object_set (target, "value", 69.0, NULL);
 446   g_assert_cmpfloat (source->value, ==, (5 * (69.0 - 32.0) / 9));
 447
 448   g_object_unref (source);
 449   g_object_unref (target);
 450
 451   g_assert (unused_data_1);
 452   g_assert (unused_data_2);
 453 }
 454
 455 static void
 456 binding_chain (void)
 457 {
 458   BindingSource *a = g_object_new (binding_source_get_type (), NULL);
 459   BindingSource *b = g_object_new (binding_source_get_type (), NULL);
 460   BindingSource *c = g_object_new (binding_source_get_type (), NULL);
 461   GBinding *binding_1, *binding_2;
 462
 463   g_test_bug_base ("http://bugzilla.gnome.org/");
 464   g_test_bug ("621782");
 465
 466   /* A -> B, B -> C */
 467   binding_1 = g_object_bind_property (a, "foo", b, "foo", G_BINDING_BIDIRECTIONAL);
 468   g_object_add_weak_pointer (G_OBJECT (binding_1), (gpointer *) &binding_1);
 469
 470   binding_2 = g_object_bind_property (b, "foo", c, "foo", G_BINDING_BIDIRECTIONAL);
 471   g_object_add_weak_pointer (G_OBJECT (binding_2), (gpointer *) &binding_2);
 472
 473   /* verify the chain */
 474   g_object_set (a, "foo", 42, NULL);
 475   g_assert_cmpint (a->foo, ==, b->foo);
 476   g_assert_cmpint (b->foo, ==, c->foo);
 477
 478   /* unbind A -> B and B -> C */
 479   g_object_unref (binding_1);
 480   g_assert (binding_1 == NULL);
 481   g_object_unref (binding_2);
 482   g_assert (binding_2 == NULL);
 483
 484   /* bind A -> C directly */
 485   binding_2 = g_object_bind_property (a, "foo", c, "foo", G_BINDING_BIDIRECTIONAL);
 486
 487   /* verify the chain is broken */
 488   g_object_set (a, "foo", 47, NULL);
 489   g_assert_cmpint (a->foo, !=, b->foo);
 490   g_assert_cmpint (a->foo, ==, c->foo);
 491
 492   g_object_unref (a);
 493   g_object_unref (b);
 494   g_object_unref (c);
 495 }
 496
 497 static void
 498 binding_sync_create (void)
 499 {
 500   BindingSource *source = g_object_new (binding_source_get_type (),
 501                                         "foo", 42,
 502                                         NULL);
 503   BindingTarget *target = g_object_new (binding_target_get_type (),
 504                                         "bar", 47,
 505                                         NULL);
 506   GBinding *binding;
 507
 508   binding = g_object_bind_property (source, "foo",
 509                                     target, "bar",
 510                                     G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
 511
 512   g_assert_cmpint (source->foo, ==, 42);
 513   g_assert_cmpint (target->bar, ==, 42);
 514
 515   g_object_set (source, "foo", 47, NULL);
 516   g_assert_cmpint (source->foo, ==, target->bar);
 517
 518   g_object_unref (binding);
 519
 520   g_object_set (target, "bar", 49, NULL);
 521
 522   binding = g_object_bind_property (source, "foo",
 523                                     target, "bar",
 524                                     G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
 525   g_assert_cmpint (source->foo, ==, 47);
 526   g_assert_cmpint (target->bar, ==, 47);
 527
 528   g_object_unref (source);
 529   g_object_unref (target);
 530 }
 531
 532 static void
 533 binding_invert_boolean (void)
 534 {
 535   BindingSource *source = g_object_new (binding_source_get_type (),
 536                                         "toggle", TRUE,
 537                                         NULL);
 538   BindingTarget *target = g_object_new (binding_target_get_type (),
 539                                         "toggle", FALSE,
 540                                         NULL);
 541   GBinding *binding;
 542
 543   binding = g_object_bind_property (source, "toggle",
 544                                     target, "toggle",
 545                                     G_BINDING_BIDIRECTIONAL | G_BINDING_INVERT_BOOLEAN);
 546
 547   g_assert (source->toggle);
 548   g_assert (!target->toggle);
 549
 550   g_object_set (source, "toggle", FALSE, NULL);
 551   g_assert (!source->toggle);
 552   g_assert (target->toggle);
 553
 554   g_object_set (target, "toggle", FALSE, NULL);
 555   g_assert (source->toggle);
 556   g_assert (!target->toggle);
 557
 558   g_object_unref (binding);
 559   g_object_unref (source);
 560   g_object_unref (target);
 561 }
 562
 563 static void
 564 binding_same_object (void)
 565 {
 566   BindingSource *source = g_object_new (binding_source_get_type (),
 567                                         "foo", 100,
 568                                         "bar", 50,
 569                                         NULL);
 570   GBinding *binding;
 571
 572   binding = g_object_bind_property (source, "foo",
 573                                     source, "bar",
 574                                     G_BINDING_BIDIRECTIONAL);
 575   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 576
 577   g_object_set (source, "foo", 10, NULL);
 578   g_assert_cmpint (source->foo, ==, 10);
 579   g_assert_cmpint (source->bar, ==, 10);
 580   g_object_set (source, "bar", 30, NULL);
 581   g_assert_cmpint (source->foo, ==, 30);
 582   g_assert_cmpint (source->bar, ==, 30);
 583
 584   g_object_unref (source);
 585   g_assert (binding == NULL);
 586 }
 587
 588 static void
 589 binding_unbind (void)
 590 {
 591   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 592   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 593   GBinding *binding;
 594
 595   binding = g_object_bind_property (source, "foo",
 596                                     target, "bar",
 597                                     G_BINDING_DEFAULT);
 598   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 599
 600   g_object_set (source, "foo", 42, NULL);
 601   g_assert_cmpint (source->foo, ==, target->bar);
 602
 603   g_object_set (target, "bar", 47, NULL);
 604   g_assert_cmpint (source->foo, !=, target->bar);
 605
 606   g_binding_unbind (binding);
 607   g_assert (binding == NULL);
 608
 609   g_object_set (source, "foo", 0, NULL);
 610   g_assert_cmpint (source->foo, !=, target->bar);
 611
 612   g_object_unref (source);
 613   g_object_unref (target);
 614
 615
 616   /* g_binding_unbind() has a special case for this */
 617   source = g_object_new (binding_source_get_type (), NULL);
 618   binding = g_object_bind_property (source, "foo",
 619                                     source, "bar",
 620                                     G_BINDING_DEFAULT);
 621   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 622
 623   g_binding_unbind (binding);
 624   g_assert (binding == NULL);
 625
 626   g_object_unref (source);
 627 }
 628
 629 /* When source or target die, so does the binding if there is no other ref */
 630 static void
 631 binding_unbind_weak (void)
 632 {
 633   GBinding *binding;
 634   BindingSource *source;
 635   BindingTarget *target;
 636
 637   /* first source, then target */
 638   source = g_object_new (binding_source_get_type (), NULL);
 639   target = g_object_new (binding_target_get_type (), NULL);
 640   binding = g_object_bind_property (source, "foo",
 641                                     target, "bar",
 642                                     G_BINDING_DEFAULT);
 643   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 644   g_assert_nonnull (binding);
 645   g_object_unref (source);
 646   g_assert_null (binding);
 647   g_object_unref (target);
 648   g_assert_null (binding);
 649
 650   /* first target, then source */
 651   source = g_object_new (binding_source_get_type (), NULL);
 652   target = g_object_new (binding_target_get_type (), NULL);
 653   binding = g_object_bind_property (source, "foo",
 654                                     target, "bar",
 655                                     G_BINDING_DEFAULT);
 656   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 657   g_assert_nonnull (binding);
 658   g_object_unref (target);
 659   g_assert_null (binding);
 660   g_object_unref (source);
 661   g_assert_null (binding);
 662
 663   /* target and source are the same */
 664   source = g_object_new (binding_source_get_type (), NULL);
 665   binding = g_object_bind_property (source, "foo",
 666                                     source, "bar",
 667                                     G_BINDING_DEFAULT);
 668   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 669   g_assert_nonnull (binding);
 670   g_object_unref (source);
 671   g_assert_null (binding);
 672 }
 673
 674 /* Test that every call to unbind() after the first is a noop */
 675 static void
 676 binding_unbind_multiple (void)
 677 {
 678   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 679   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 680   GBinding *binding;
 681   guint i;
 682
 683   g_test_bug ("1373");
 684
 685   binding = g_object_bind_property (source, "foo",
 686                                     target, "bar",
 687                                     G_BINDING_DEFAULT);
 688   g_object_ref (binding);
 689   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 690   g_assert_nonnull (binding);
 691
 692   /* this shouldn't crash */
 693   for (i = 0; i < 50; i++)
 694     {
 695       g_binding_unbind (binding);
 696       g_assert_nonnull (binding);
 697     }
 698
 699   g_object_unref (binding);
 700   g_assert_null (binding);
 701
 702   g_object_unref (source);
 703   g_object_unref (target);
 704 }
 705
 706 static void
 707 binding_fail (void)
 708 {
 709   BindingSource *source = g_object_new (binding_source_get_type (), NULL);
 710   BindingTarget *target = g_object_new (binding_target_get_type (), NULL);
 711   GBinding *binding;
 712
 713   /* double -> boolean is not supported */
 714   binding = g_object_bind_property (source, "value",
 715                                     target, "toggle",
 716                                     G_BINDING_DEFAULT);
 717   g_object_add_weak_pointer (G_OBJECT (binding), (gpointer *) &binding);
 718
 719   g_test_expect_message ("GLib-GObject", G_LOG_LEVEL_WARNING,
 720                          "*Unable to convert*double*boolean*");
 721   g_object_set (source, "value", 1.0, NULL);
 722   g_test_assert_expected_messages ();
 723
 724   g_object_unref (source);
 725   g_object_unref (target);
 726   g_assert (binding == NULL);
 727 }
 728
 729 int
 730 main (int argc, char *argv[])
 731 {
 732   g_test_init (&argc, &argv, NULL);
 733
 734   g_test_bug_base ("https://gitlab.gnome.org/GNOME/glib/issues/");
 735
 736   g_test_add_func ("/binding/default", binding_default);
 737   g_test_add_func ("/binding/bidirectional", binding_bidirectional);
 738   g_test_add_func ("/binding/transform", binding_transform);
 739   g_test_add_func ("/binding/transform-default", binding_transform_default);
 740   g_test_add_func ("/binding/transform-closure", binding_transform_closure);
 741   g_test_add_func ("/binding/chain", binding_chain);
 742   g_test_add_func ("/binding/sync-create", binding_sync_create);
 743   g_test_add_func ("/binding/invert-boolean", binding_invert_boolean);
 744   g_test_add_func ("/binding/same-object", binding_same_object);
 745   g_test_add_func ("/binding/unbind", binding_unbind);
 746   g_test_add_func ("/binding/unbind-weak", binding_unbind_weak);
 747   g_test_add_func ("/binding/unbind-multiple", binding_unbind_multiple);
 748   g_test_add_func ("/binding/fail", binding_fail);
 749
 750   return g_test_run ();
 751 }