gobject/tests/reference.c

   1 #include <glib-object.h>
   2
   3 static void
   4 test_fundamentals (void)
   5 {
   6   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_NONE));
   7   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_INTERFACE));
   8   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_CHAR));
   9   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_UCHAR));
  10   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_BOOLEAN));
  11   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_INT));
  12   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_UINT));
  13   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_LONG));
  14   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_ULONG));
  15   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_INT64));
  16   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_UINT64));
  17   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_ENUM));
  18   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_FLAGS));
  19   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_FLOAT));
  20   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_DOUBLE));
  21   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_STRING));
  22   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_POINTER));
  23   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_BOXED));
  24   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_PARAM));
  25   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_OBJECT));
  26   g_assert (G_TYPE_OBJECT == g_object_get_type ());
  27   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_VARIANT));
  28   g_assert (G_TYPE_IS_DERIVED (G_TYPE_INITIALLY_UNOWNED));
  29
  30   g_assert (g_type_fundamental_next () == G_TYPE_MAKE_FUNDAMENTAL (G_TYPE_RESERVED_USER_FIRST));
  31 }
  32
  33 static void
  34 test_type_qdata (void)
  35 {
  36   gchar *data;
  37
  38   g_type_set_qdata (G_TYPE_ENUM, g_quark_from_string ("bla"), "bla");
  39   data = g_type_get_qdata (G_TYPE_ENUM, g_quark_from_string ("bla"));
  40   g_assert_cmpstr (data, ==, "bla");
  41 }
  42
  43 static void
  44 test_type_query (void)
  45 {
  46   GTypeQuery query;
  47
  48   g_type_query (G_TYPE_ENUM, &query);
  49   g_assert_cmpint (query.type, ==, G_TYPE_ENUM);
  50   g_assert_cmpstr (query.type_name, ==, "GEnum");
  51   g_assert_cmpint (query.class_size, ==, sizeof (GEnumClass));
  52   g_assert_cmpint (query.instance_size, ==, 0);
  53 }
  54
  55 typedef struct _MyObject MyObject;
  56 typedef struct _MyObjectClass MyObjectClass;
  57 typedef struct _MyObjectClassPrivate MyObjectClassPrivate;
  58
  59 struct _MyObject
  60 {
  61   GObject parent_instance;
  62
  63   gint count;
  64 };
  65
  66 struct _MyObjectClass
  67 {
  68   GObjectClass parent_class;
  69 };
  70
  71 struct _MyObjectClassPrivate
  72 {
  73   gint secret_class_count;
  74 };
  75
  76 static GType my_object_get_type (void);
  77 G_DEFINE_TYPE_WITH_CODE (MyObject, my_object, G_TYPE_OBJECT,
  78                          g_type_add_class_private (g_define_type_id, sizeof (MyObjectClassPrivate)) );
  79
  80 static void
  81 my_object_init (MyObject *obj)
  82 {
  83   obj->count = 42;
  84 }
  85
  86 static void
  87 my_object_class_init (MyObjectClass *klass)
  88 {
  89 }
  90
  91 static void
  92 test_class_private (void)
  93 {
  94   GObject *obj;
  95   MyObjectClass *class;
  96   MyObjectClassPrivate *priv;
  97
  98   obj = g_object_new (my_object_get_type (), NULL);
  99
 100   class = g_type_class_ref (my_object_get_type ());
 101   priv = G_TYPE_CLASS_GET_PRIVATE (class, my_object_get_type (), MyObjectClassPrivate);
 102   priv->secret_class_count = 13;
 103   g_type_class_unref (class);
 104
 105   g_object_unref (obj);
 106
 107   g_assert_cmpint (g_type_qname (my_object_get_type ()), ==, g_quark_from_string ("MyObject"));
 108 }
 109
 110 static void
 111 test_clear (void)
 112 {
 113   GObject *o = NULL;
 114   GObject *tmp;
 115
 116   g_clear_object (&o);
 117   g_assert (o == NULL);
 118
 119   tmp = g_object_new (G_TYPE_OBJECT, NULL);
 120   g_assert_cmpint (tmp->ref_count, ==, 1);
 121   o = g_object_ref (tmp);
 122   g_assert (o != NULL);
 123
 124   g_assert_cmpint (tmp->ref_count, ==, 2);
 125   g_clear_object (&o);
 126   g_assert_cmpint (tmp->ref_count, ==, 1);
 127   g_assert (o == NULL);
 128
 129   g_object_unref (tmp);
 130 }
 131
 132 static void
 133 test_clear_function (void)
 134 {
 135   GObject *o = NULL;
 136   GObject *tmp;
 137
 138   (g_clear_object) (&o);
 139   g_assert (o == NULL);
 140
 141   tmp = g_object_new (G_TYPE_OBJECT, NULL);
 142   g_assert_cmpint (tmp->ref_count, ==, 1);
 143   o = g_object_ref (tmp);
 144   g_assert (o != NULL);
 145
 146   g_assert_cmpint (tmp->ref_count, ==, 2);
 147   (g_clear_object) (&o);
 148   g_assert_cmpint (tmp->ref_count, ==, 1);
 149   g_assert (o == NULL);
 150
 151   g_object_unref (tmp);
 152 }
 153
 154 static void
 155 test_set (void)
 156 {
 157   GObject *o = NULL;
 158   GObject *tmp;
 159   gpointer tmp_weak = NULL;
 160
 161   g_assert (!g_set_object (&o, NULL));
 162   g_assert (o == NULL);
 163
 164   tmp = g_object_new (G_TYPE_OBJECT, NULL);
 165   tmp_weak = tmp;
 166   g_object_add_weak_pointer (tmp, &tmp_weak);
 167   g_assert_cmpint (tmp->ref_count, ==, 1);
 168
 169   g_assert (g_set_object (&o, tmp));
 170   g_assert (o == tmp);
 171   g_assert_cmpint (tmp->ref_count, ==, 2);
 172
 173   g_object_unref (tmp);
 174   g_assert_cmpint (tmp->ref_count, ==, 1);
 175
 176   /* Setting it again shouldn’t cause finalisation. */
 177   g_assert (!g_set_object (&o, tmp));
 178   g_assert (o == tmp);
 179   g_assert_cmpint (tmp->ref_count, ==, 1);
 180   g_assert_nonnull (tmp_weak);
 181
 182   g_assert (g_set_object (&o, NULL));
 183   g_assert (o == NULL);
 184   g_assert_null (tmp_weak);
 185 }
 186
 187 static void
 188 test_set_function (void)
 189 {
 190   GObject *o = NULL;
 191   GObject *tmp;
 192   gpointer tmp_weak = NULL;
 193
 194   g_assert (!(g_set_object) (&o, NULL));
 195   g_assert (o == NULL);
 196
 197   tmp = g_object_new (G_TYPE_OBJECT, NULL);
 198   tmp_weak = tmp;
 199   g_object_add_weak_pointer (tmp, &tmp_weak);
 200   g_assert_cmpint (tmp->ref_count, ==, 1);
 201
 202   g_assert ((g_set_object) (&o, tmp));
 203   g_assert (o == tmp);
 204   g_assert_cmpint (tmp->ref_count, ==, 2);
 205
 206   g_object_unref (tmp);
 207   g_assert_cmpint (tmp->ref_count, ==, 1);
 208
 209   /* Setting it again shouldn’t cause finalisation. */
 210   g_assert (!(g_set_object) (&o, tmp));
 211   g_assert (o == tmp);
 212   g_assert_cmpint (tmp->ref_count, ==, 1);
 213   g_assert_nonnull (tmp_weak);
 214
 215   g_assert ((g_set_object) (&o, NULL));
 216   g_assert (o == NULL);
 217   g_assert_null (tmp_weak);
 218 }
 219
 220 static void
 221 test_set_derived_type (void)
 222 {
 223   GBinding *obj = NULL;
 224   GObject *o = NULL;
 225   GBinding *b = NULL;
 226
 227   g_test_summary ("Check that g_set_object() doesn’t give strict aliasing "
 228                   "warnings when used on types derived from GObject");
 229
 230   g_assert_false (g_set_object (&o, NULL));
 231   g_assert_null (o);
 232
 233   g_assert_false (g_set_object (&b, NULL));
 234   g_assert_null (b);
 235
 236   obj = g_object_new (my_object_get_type (), NULL);
 237
 238   g_assert_true (g_set_object (&o, G_OBJECT (obj)));
 239   g_assert_true (o == G_OBJECT (obj));
 240
 241   g_assert_true (g_set_object (&b, obj));
 242   g_assert_true (b == obj);
 243
 244   g_object_unref (obj);
 245   g_clear_object (&b);
 246   g_clear_object (&o);
 247 }
 248
 249 static void
 250 toggle_cb (gpointer data, GObject *obj, gboolean is_last)
 251 {
 252   gboolean *b = data;
 253
 254   *b = TRUE;
 255 }
 256
 257 static void
 258 test_object_value (void)
 259 {
 260   GObject *v;
 261   GObject *v2;
 262   GValue value = G_VALUE_INIT;
 263   gboolean toggled = FALSE;
 264
 265   g_value_init (&value, G_TYPE_OBJECT);
 266
 267   v = g_object_new (G_TYPE_OBJECT, NULL);
 268   g_object_add_toggle_ref (v, toggle_cb, &toggled);
 269
 270   g_value_take_object (&value, v);
 271
 272   v2 = g_value_get_object (&value);
 273   g_assert (v2 == v);
 274
 275   v2 = g_value_dup_object (&value);
 276   g_assert (v2 == v);  /* objects use ref/unref for copy/free */
 277   g_object_unref (v2);
 278
 279   g_assert (!toggled);
 280   g_value_unset (&value);
 281   g_assert (toggled);
 282
 283   /* test the deprecated variant too */
 284   g_value_init (&value, G_TYPE_OBJECT);
 285   /* get a new reference */
 286   g_object_ref (v);
 287
 288 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 289   g_value_set_object_take_ownership (&value, v);
 290 G_GNUC_END_IGNORE_DEPRECATIONS
 291
 292   toggled = FALSE;
 293   g_value_unset (&value);
 294   g_assert (toggled);
 295
 296   g_object_remove_toggle_ref (v, toggle_cb, &toggled);
 297 }
 298
 299 static void
 300 test_initially_unowned (void)
 301 {
 302   GObject *obj;
 303
 304   obj = g_object_new (G_TYPE_INITIALLY_UNOWNED, NULL);
 305   g_assert (g_object_is_floating (obj));
 306   g_assert_cmpint (obj->ref_count, ==, 1);
 307
 308   g_object_ref_sink (obj);
 309   g_assert (!g_object_is_floating (obj));
 310   g_assert_cmpint (obj->ref_count, ==, 1);
 311
 312   g_object_ref_sink (obj);
 313   g_assert (!g_object_is_floating (obj));
 314   g_assert_cmpint (obj->ref_count, ==, 2);
 315
 316   g_object_unref (obj);
 317   g_assert_cmpint (obj->ref_count, ==, 1);
 318
 319   g_object_force_floating (obj);
 320   g_assert (g_object_is_floating (obj));
 321   g_assert_cmpint (obj->ref_count, ==, 1);
 322
 323   g_object_ref_sink (obj);
 324   g_object_unref (obj);
 325
 326   obj = g_object_new (G_TYPE_INITIALLY_UNOWNED, NULL);
 327   g_assert_true (g_object_is_floating (obj));
 328   g_assert_cmpint (obj->ref_count, ==, 1);
 329
 330   g_object_take_ref (obj);
 331   g_assert_false (g_object_is_floating (obj));
 332   g_assert_cmpint (obj->ref_count, ==, 1);
 333
 334   g_object_take_ref (obj);
 335   g_assert_false (g_object_is_floating (obj));
 336   g_assert_cmpint (obj->ref_count, ==, 1);
 337
 338   g_object_unref (obj);
 339
 340   if (g_test_undefined ())
 341     {
 342       obj = g_object_new (G_TYPE_INITIALLY_UNOWNED, NULL);
 343
 344 #ifdef G_ENABLE_DEBUG
 345       g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
 346                              "A floating object GInitiallyUnowned * was finalized*");
 347 #endif
 348       g_object_unref (obj);
 349 #ifdef G_ENABLE_DEBUG
 350       g_test_assert_expected_messages ();
 351 #endif
 352     }
 353 }
 354
 355 static void
 356 test_weak_pointer (void)
 357 {
 358   GObject *obj;
 359   gpointer weak;
 360   gpointer weak2;
 361
 362   weak = weak2 = obj = g_object_new (G_TYPE_OBJECT, NULL);
 363   g_assert_cmpint (obj->ref_count, ==, 1);
 364
 365   g_object_add_weak_pointer (obj, &weak);
 366   g_object_add_weak_pointer (obj, &weak2);
 367   g_assert_cmpint (obj->ref_count, ==, 1);
 368   g_assert (weak == obj);
 369   g_assert (weak2 == obj);
 370
 371   g_object_remove_weak_pointer (obj, &weak2);
 372   g_assert_cmpint (obj->ref_count, ==, 1);
 373   g_assert (weak == obj);
 374   g_assert (weak2 == obj);
 375
 376   g_object_unref (obj);
 377   g_assert (weak == NULL);
 378   g_assert (weak2 == obj);
 379 }
 380
 381 static void
 382 test_weak_pointer_clear (void)
 383 {
 384   GObject *obj;
 385   gpointer weak = NULL;
 386
 387   g_clear_weak_pointer (&weak);
 388   g_assert_null (weak);
 389
 390   weak = obj = g_object_new (G_TYPE_OBJECT, NULL);
 391   g_assert_cmpint (obj->ref_count, ==, 1);
 392
 393   g_object_add_weak_pointer (obj, &weak);
 394   g_assert_cmpint (obj->ref_count, ==, 1);
 395   g_assert_true (weak == obj);
 396
 397   g_clear_weak_pointer (&weak);
 398   g_assert_cmpint (obj->ref_count, ==, 1);
 399   g_assert_null (weak);
 400
 401   g_object_unref (obj);
 402 }
 403
 404 static void
 405 test_weak_pointer_clear_function (void)
 406 {
 407   GObject *obj;
 408   gpointer weak = NULL;
 409
 410   (g_clear_weak_pointer) (&weak);
 411   g_assert_null (weak);
 412
 413   weak = obj = g_object_new (G_TYPE_OBJECT, NULL);
 414   g_assert_cmpint (obj->ref_count, ==, 1);
 415
 416   g_object_add_weak_pointer (obj, &weak);
 417   g_assert_cmpint (obj->ref_count, ==, 1);
 418   g_assert_true (weak == obj);
 419
 420   (g_clear_weak_pointer) (&weak);
 421   g_assert_cmpint (obj->ref_count, ==, 1);
 422   g_assert_null (weak);
 423
 424   g_object_unref (obj);
 425 }
 426
 427 static void
 428 test_weak_pointer_set (void)
 429 {
 430   GObject *obj;
 431   gpointer weak = NULL;
 432
 433   g_assert_false (g_set_weak_pointer (&weak, NULL));
 434   g_assert_null (weak);
 435
 436   obj = g_object_new (G_TYPE_OBJECT, NULL);
 437   g_assert_cmpint (obj->ref_count, ==, 1);
 438
 439   g_assert_true (g_set_weak_pointer (&weak, obj));
 440   g_assert_cmpint (obj->ref_count, ==, 1);
 441   g_assert_true (weak == obj);
 442
 443   g_assert_true (g_set_weak_pointer (&weak, NULL));
 444   g_assert_cmpint (obj->ref_count, ==, 1);
 445   g_assert_null (weak);
 446
 447   g_assert_true (g_set_weak_pointer (&weak, obj));
 448   g_assert_cmpint (obj->ref_count, ==, 1);
 449   g_assert_true (weak == obj);
 450
 451   g_object_unref (obj);
 452   g_assert_null (weak);
 453 }
 454
 455 static void
 456 test_weak_pointer_set_function (void)
 457 {
 458   GObject *obj;
 459   gpointer weak = NULL;
 460
 461   g_assert_false ((g_set_weak_pointer) (&weak, NULL));
 462   g_assert_null (weak);
 463
 464   obj = g_object_new (G_TYPE_OBJECT, NULL);
 465   g_assert_cmpint (obj->ref_count, ==, 1);
 466
 467   g_assert_true ((g_set_weak_pointer) (&weak, obj));
 468   g_assert_cmpint (obj->ref_count, ==, 1);
 469   g_assert_true (weak == obj);
 470
 471   g_assert_true ((g_set_weak_pointer) (&weak, NULL));
 472   g_assert_cmpint (obj->ref_count, ==, 1);
 473   g_assert_null (weak);
 474
 475   g_assert_true ((g_set_weak_pointer) (&weak, obj));
 476   g_assert_cmpint (obj->ref_count, ==, 1);
 477   g_assert_true (weak == obj);
 478
 479   g_object_unref (obj);
 480   g_assert_null (weak);
 481 }
 482
 483 /* See gobject/tests/threadtests.c for the threaded version */
 484 static void
 485 test_weak_ref (void)
 486 {
 487   GObject *obj;
 488   GObject *obj2;
 489   GObject *tmp;
 490   GWeakRef weak = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
 491   GWeakRef weak2 = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
 492   GWeakRef weak3 = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
 493   GWeakRef *dynamic_weak = g_new (GWeakRef, 1);
 494
 495   /* you can initialize to empty like this... */
 496   g_weak_ref_init (&weak2, NULL);
 497   g_assert (g_weak_ref_get (&weak2) == NULL);
 498
 499   /* ... or via an initializer */
 500   g_weak_ref_init (&weak3, NULL);
 501   g_assert (g_weak_ref_get (&weak3) == NULL);
 502
 503   obj = g_object_new (G_TYPE_OBJECT, NULL);
 504   g_assert_cmpint (obj->ref_count, ==, 1);
 505
 506   obj2 = g_object_new (G_TYPE_OBJECT, NULL);
 507   g_assert_cmpint (obj2->ref_count, ==, 1);
 508
 509   /* you can init with an object (even if uninitialized) */
 510   g_weak_ref_init (&weak, obj);
 511   g_weak_ref_init (dynamic_weak, obj);
 512   /* or set to point at an object, if initialized (maybe to 0) */
 513   g_weak_ref_set (&weak2, obj);
 514   g_weak_ref_set (&weak3, obj);
 515   /* none of this affects its refcount */
 516   g_assert_cmpint (obj->ref_count, ==, 1);
 517
 518   /* getting the value takes a ref */
 519   tmp = g_weak_ref_get (&weak);
 520   g_assert (tmp == obj);
 521   g_assert_cmpint (obj->ref_count, ==, 2);
 522   g_object_unref (tmp);
 523   g_assert_cmpint (obj->ref_count, ==, 1);
 524
 525   tmp = g_weak_ref_get (&weak2);
 526   g_assert (tmp == obj);
 527   g_assert_cmpint (obj->ref_count, ==, 2);
 528   g_object_unref (tmp);
 529   g_assert_cmpint (obj->ref_count, ==, 1);
 530
 531   tmp = g_weak_ref_get (&weak3);
 532   g_assert (tmp == obj);
 533   g_assert_cmpint (obj->ref_count, ==, 2);
 534   g_object_unref (tmp);
 535   g_assert_cmpint (obj->ref_count, ==, 1);
 536
 537   tmp = g_weak_ref_get (dynamic_weak);
 538   g_assert (tmp == obj);
 539   g_assert_cmpint (obj->ref_count, ==, 2);
 540   g_object_unref (tmp);
 541   g_assert_cmpint (obj->ref_count, ==, 1);
 542
 543   /* clearing a weak ref stops tracking */
 544   g_weak_ref_clear (&weak);
 545
 546   /* setting a weak ref to NULL stops tracking too */
 547   g_weak_ref_set (&weak2, NULL);
 548   g_assert (g_weak_ref_get (&weak2) == NULL);
 549   g_weak_ref_clear (&weak2);
 550
 551   /* setting a weak ref to a new object stops tracking the old one */
 552   g_weak_ref_set (dynamic_weak, obj2);
 553   tmp = g_weak_ref_get (dynamic_weak);
 554   g_assert (tmp == obj2);
 555   g_assert_cmpint (obj2->ref_count, ==, 2);
 556   g_object_unref (tmp);
 557   g_assert_cmpint (obj2->ref_count, ==, 1);
 558
 559   g_assert_cmpint (obj->ref_count, ==, 1);
 560
 561   /* free the object: weak3 is the only one left pointing there */
 562   g_object_unref (obj);
 563   g_assert (g_weak_ref_get (&weak3) == NULL);
 564
 565   /* setting a weak ref to a new object stops tracking the old one */
 566   g_weak_ref_set (dynamic_weak, obj2);
 567   tmp = g_weak_ref_get (dynamic_weak);
 568   g_assert (tmp == obj2);
 569   g_assert_cmpint (obj2->ref_count, ==, 2);
 570   g_object_unref (tmp);
 571   g_assert_cmpint (obj2->ref_count, ==, 1);
 572
 573   g_weak_ref_clear (&weak3);
 574
 575   /* unset dynamic_weak... */
 576   g_weak_ref_set (dynamic_weak, NULL);
 577   g_assert_null (g_weak_ref_get (dynamic_weak));
 578
 579   /* initializing a weak reference to an object that had before works */
 580   g_weak_ref_set (dynamic_weak, obj2);
 581   tmp = g_weak_ref_get (dynamic_weak);
 582   g_assert_true (tmp == obj2);
 583   g_assert_cmpint (obj2->ref_count, ==, 2);
 584   g_object_unref (tmp);
 585   g_assert_cmpint (obj2->ref_count, ==, 1);
 586
 587   /* clear and free dynamic_weak... */
 588   g_weak_ref_clear (dynamic_weak);
 589
 590   /* ... to prove that doing so stops this from being a use-after-free */
 591   g_object_unref (obj2);
 592   g_free (dynamic_weak);
 593 }
 594
 595 G_DECLARE_FINAL_TYPE (WeakReffedObject, weak_reffed_object,
 596                       WEAK, REFFED_OBJECT, GObject)
 597
 598 struct _WeakReffedObject
 599 {
 600   GObject parent;
 601
 602   GWeakRef *weak_ref;
 603 };
 604
 605 G_DEFINE_TYPE (WeakReffedObject, weak_reffed_object, G_TYPE_OBJECT)
 606
 607 static void
 608 weak_reffed_object_dispose (GObject *object)
 609 {
 610   WeakReffedObject *weak_reffed = WEAK_REFFED_OBJECT (object);
 611
 612   g_assert_cmpint (object->ref_count, ==, 1);
 613
 614   g_weak_ref_set (weak_reffed->weak_ref, object);
 615
 616   G_OBJECT_CLASS (weak_reffed_object_parent_class)->dispose (object);
 617
 618   g_assert_null (g_weak_ref_get (weak_reffed->weak_ref));
 619 }
 620
 621 static void
 622 weak_reffed_object_init (WeakReffedObject *connector)
 623 {
 624 }
 625
 626 static void
 627 weak_reffed_object_class_init (WeakReffedObjectClass *klass)
 628 {
 629   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 630
 631   object_class->dispose = weak_reffed_object_dispose;
 632 }
 633
 634 static void
 635 test_weak_ref_on_dispose (void)
 636 {
 637   WeakReffedObject *obj;
 638   GWeakRef weak = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
 639
 640   g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/2390");
 641   g_test_summary ("Test that a weak ref set during dispose vfunc is cleared");
 642
 643   g_weak_ref_init (&weak, NULL);
 644
 645   obj = g_object_new (weak_reffed_object_get_type (), NULL);
 646   obj->weak_ref = &weak;
 647
 648   g_assert_cmpint (G_OBJECT (obj)->ref_count, ==, 1);
 649   g_clear_object (&obj);
 650
 651   g_assert_null (g_weak_ref_get (&weak));
 652 }
 653
 654 static void
 655 test_weak_ref_on_run_dispose (void)
 656 {
 657   GObject *obj;
 658   GWeakRef weak = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
 659
 660   g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/865");
 661   g_test_summary ("Test that a weak ref is cleared on g_object_run_dispose()");
 662
 663   obj = g_object_new (G_TYPE_OBJECT, NULL);
 664   g_weak_ref_init (&weak, obj);
 665
 666   g_assert_true (obj == g_weak_ref_get (&weak));
 667   g_object_unref (obj);
 668
 669   g_object_run_dispose (obj);
 670   g_assert_null (g_weak_ref_get (&weak));
 671
 672   g_clear_object (&obj);
 673   g_assert_null (g_weak_ref_get (&weak));
 674 }
 675
 676 static void
 677 on_weak_ref_toggle_notify (gpointer data,
 678                            GObject *object,
 679                            gboolean is_last_ref)
 680 {
 681   GWeakRef *weak = data;
 682
 683   if (is_last_ref)
 684     g_weak_ref_set (weak, object);
 685 }
 686
 687 static void
 688 on_weak_ref_toggle_notify_disposed (gpointer data,
 689                                     GObject *object)
 690 {
 691   g_assert_cmpint (object->ref_count, ==, 1);
 692
 693   g_object_ref (object);
 694   g_object_unref (object);
 695 }
 696
 697 static void
 698 test_weak_ref_on_toggle_notify (void)
 699 {
 700   GObject *obj;
 701   GWeakRef weak = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
 702
 703   g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/2390");
 704   g_test_summary ("Test that a weak ref set on toggle notify is cleared");
 705
 706   g_weak_ref_init (&weak, NULL);
 707
 708   obj = g_object_new (G_TYPE_OBJECT, NULL);
 709   g_object_add_toggle_ref (obj, on_weak_ref_toggle_notify, &weak);
 710   g_object_weak_ref (obj, on_weak_ref_toggle_notify_disposed, NULL);
 711   g_object_unref (obj);
 712
 713   g_assert_cmpint (obj->ref_count, ==, 1);
 714   g_clear_object (&obj);
 715
 716   g_assert_null (g_weak_ref_get (&weak));
 717 }
 718
 719 typedef struct
 720 {
 721   gboolean should_be_last;
 722   gint count;
 723 } Count;
 724
 725 static void
 726 toggle_notify (gpointer  data,
 727                GObject  *obj,
 728                gboolean  is_last)
 729 {
 730   Count *c = data;
 731
 732   g_assert (is_last == c->should_be_last);
 733
 734   if (is_last)
 735     g_assert_cmpint (g_atomic_int_get (&obj->ref_count), ==, 1);
 736   else
 737     g_assert_cmpint (g_atomic_int_get (&obj->ref_count), ==, 2);
 738
 739   c->count++;
 740 }
 741
 742 static void
 743 test_toggle_ref (void)
 744 {
 745   GObject *obj;
 746   Count c, c2;
 747
 748   obj = g_object_new (G_TYPE_OBJECT, NULL);
 749
 750   g_object_add_toggle_ref (obj, toggle_notify, &c);
 751   g_object_add_toggle_ref (obj, toggle_notify, &c2);
 752
 753   c.should_be_last = c2.should_be_last = TRUE;
 754   c.count = c2.count = 0;
 755
 756   g_object_unref (obj);
 757
 758   g_assert_cmpint (c.count, ==, 0);
 759   g_assert_cmpint (c2.count, ==, 0);
 760
 761   g_object_ref (obj);
 762
 763   g_assert_cmpint (c.count, ==, 0);
 764   g_assert_cmpint (c2.count, ==, 0);
 765
 766   g_object_remove_toggle_ref (obj, toggle_notify, &c2);
 767
 768   g_object_unref (obj);
 769
 770   g_assert_cmpint (c.count, ==, 1);
 771
 772   c.should_be_last = FALSE;
 773
 774   g_object_ref (obj);
 775
 776   g_assert_cmpint (c.count, ==, 2);
 777
 778   c.should_be_last = TRUE;
 779
 780   g_object_unref (obj);
 781
 782   g_assert_cmpint (c.count, ==, 3);
 783
 784   g_object_remove_toggle_ref (obj, toggle_notify, &c);
 785 }
 786
 787 G_DECLARE_FINAL_TYPE (DisposeReffingObject, dispose_reffing_object,
 788                       DISPOSE, REFFING_OBJECT, GObject)
 789
 790 typedef enum
 791 {
 792   PROP_INT_PROP = 1,
 793   N_PROPS,
 794 } DisposeReffingObjectProperty;
 795
 796 static GParamSpec *dispose_reffing_object_properties[N_PROPS] = {0};
 797
 798 struct _DisposeReffingObject
 799 {
 800   GObject parent;
 801
 802   GToggleNotify toggle_notify;
 803   Count actual;
 804   Count expected;
 805   unsigned disposing_refs;
 806   gboolean disposing_refs_all_normal;
 807
 808   GCallback notify_handler;
 809   unsigned notify_called;
 810
 811   int int_prop;
 812
 813   GWeakRef *weak_ref;
 814 };
 815
 816 G_DEFINE_TYPE (DisposeReffingObject, dispose_reffing_object, G_TYPE_OBJECT)
 817
 818 static void
 819 on_object_notify (GObject    *object,
 820                   GParamSpec *pspec,
 821                   void       *data)
 822 {
 823   DisposeReffingObject *obj = DISPOSE_REFFING_OBJECT (object);
 824
 825   obj->notify_called++;
 826 }
 827
 828 static void
 829 dispose_reffing_object_dispose (GObject *object)
 830 {
 831   DisposeReffingObject *obj = DISPOSE_REFFING_OBJECT (object);
 832
 833   g_assert_cmpint (object->ref_count, ==, 1);
 834   g_assert_cmpint (obj->actual.count, ==, obj->expected.count);
 835
 836   for (unsigned i = 0; i < obj->disposing_refs; ++i)
 837     {
 838       if (i == 0 && !obj->disposing_refs_all_normal)
 839         {
 840           g_object_add_toggle_ref (object, obj->toggle_notify, &obj->actual);
 841         }
 842       else
 843         {
 844           obj->actual.should_be_last = FALSE;
 845           g_object_ref (obj);
 846           g_assert_cmpint (obj->actual.count, ==, obj->expected.count);
 847         }
 848
 849       obj->actual.should_be_last = TRUE;
 850     }
 851
 852   G_OBJECT_CLASS (dispose_reffing_object_parent_class)->dispose (object);
 853
 854   if (obj->notify_handler)
 855     {
 856       unsigned old_notify_called = obj->notify_called;
 857
 858       g_assert_cmpuint (g_signal_handler_find (object, G_SIGNAL_MATCH_FUNC,
 859                         0, 0, NULL, obj->notify_handler, NULL), ==, 0);
 860
 861       g_signal_connect (object, "notify", G_CALLBACK (obj->notify_handler), NULL);
 862
 863       /* This would trigger a toggle notification, but is not something we may
 864        * want with https://gitlab.gnome.org/GNOME/glib/-/merge_requests/2377
 865        * so, we only test this in case we have more than one ref
 866        */
 867       if (obj->toggle_notify == toggle_notify)
 868         g_assert_cmpint (obj->disposing_refs, >, 1);
 869
 870       g_object_notify (object, "int-prop");
 871       g_assert_cmpuint (obj->notify_called, ==, old_notify_called);
 872     }
 873
 874   g_assert_cmpint (obj->actual.count, ==, obj->expected.count);
 875 }
 876
 877 static void
 878 dispose_reffing_object_init (DisposeReffingObject *connector)
 879 {
 880 }
 881
 882 static void
 883 dispose_reffing_object_set_property (GObject *object,
 884                                      guint property_id,
 885                                      const GValue *value,
 886                                      GParamSpec *pspec)
 887 {
 888   DisposeReffingObject *obj = DISPOSE_REFFING_OBJECT (object);
 889
 890   switch ((DisposeReffingObjectProperty) property_id)
 891     {
 892     case PROP_INT_PROP:
 893       obj->int_prop = g_value_get_int (value);
 894       break;
 895     default:
 896       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 897       break;
 898     }
 899 }
 900
 901 static void
 902 dispose_reffing_object_get_property (GObject *object,
 903                                      guint property_id,
 904                                      GValue *value,
 905                                      GParamSpec *pspec)
 906 {
 907   DisposeReffingObject *obj = DISPOSE_REFFING_OBJECT (object);
 908
 909   switch ((DisposeReffingObjectProperty) property_id)
 910     {
 911     case PROP_INT_PROP:
 912       g_value_set_int (value, obj->int_prop);
 913       break;
 914     default:
 915       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 916       break;
 917     }
 918 }
 919
 920 static void
 921 dispose_reffing_object_class_init (DisposeReffingObjectClass *klass)
 922 {
 923   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 924
 925   dispose_reffing_object_properties[PROP_INT_PROP] =
 926       g_param_spec_int ("int-prop", "int-prop", "int-prop",
 927                         G_MININT, G_MAXINT,
 928                         0,
 929                         G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
 930
 931   object_class->dispose = dispose_reffing_object_dispose;
 932   object_class->set_property = dispose_reffing_object_set_property;
 933   object_class->get_property = dispose_reffing_object_get_property;
 934
 935   g_object_class_install_properties (object_class, N_PROPS,
 936                                      dispose_reffing_object_properties);
 937 }
 938
 939 static void
 940 test_toggle_ref_on_dispose (void)
 941 {
 942   DisposeReffingObject *obj;
 943   gpointer disposed_checker = &obj;
 944
 945   /* This tests wants to ensure that an object that gets re-referenced
 946    * (one or multiple times) during its dispose virtual function:
 947    *  - Notifies all the queued "notify" signal handlers
 948    *  - Notifies toggle notifications if any
 949    *  - It does not get finalized
 950    */
 951
 952   obj = g_object_new (dispose_reffing_object_get_type (), NULL);
 953   obj->toggle_notify = toggle_notify;
 954   obj->notify_handler = G_CALLBACK (on_object_notify);
 955   g_object_add_weak_pointer (G_OBJECT (obj), &disposed_checker);
 956
 957   /* Convert to toggle notification */
 958   g_object_add_toggle_ref (G_OBJECT (obj), obj->toggle_notify, &obj->actual);
 959   g_assert_cmpint (obj->actual.count, ==, 0);
 960
 961   obj->actual.should_be_last = TRUE;
 962   obj->notify_handler = G_CALLBACK (on_object_notify);
 963   g_object_unref (obj);
 964   g_assert_cmpint (obj->actual.count, ==, 1);
 965   g_assert_cmpuint (obj->notify_called, ==, 0);
 966
 967   /* Remove the toggle reference, making it to dispose and resurrect again */
 968   obj->disposing_refs = 1;
 969   obj->expected.count = 1;
 970   obj->notify_handler = NULL; /* FIXME: enable it when !2377 is in */
 971   g_object_remove_toggle_ref (G_OBJECT (obj), obj->toggle_notify, NULL);
 972   g_assert_cmpint (obj->actual.count, ==, 2);
 973   g_assert_cmpuint (obj->notify_called, ==, 0);
 974
 975   g_assert_null (disposed_checker);
 976   g_assert_cmpint (g_atomic_int_get (&G_OBJECT (obj)->ref_count), ==,
 977                    obj->disposing_refs);
 978
 979   /* Object has been disposed, but is still alive, so add another weak pointer */
 980   disposed_checker = &obj;
 981   g_object_add_weak_pointer (G_OBJECT (obj), &disposed_checker);
 982
 983   /* Remove the toggle reference, making it to dispose and resurrect with
 984    * more references than before, so that no toggle notify is called
 985    */
 986   obj->disposing_refs = 3;
 987   obj->expected.count = 2;
 988   obj->notify_handler = G_CALLBACK (on_object_notify);
 989   g_object_remove_toggle_ref (G_OBJECT (obj), obj->toggle_notify, NULL);
 990   g_assert_cmpint (obj->actual.count, ==, 2);
 991   g_assert_cmpint (obj->notify_called, ==, 1);
 992   obj->expected.count = obj->actual.count;
 993
 994   g_assert_null (disposed_checker);
 995   g_assert_cmpint (g_atomic_int_get (&G_OBJECT (obj)->ref_count), ==,
 996                    obj->disposing_refs);
 997
 998   disposed_checker = &obj;
 999   g_object_add_weak_pointer (G_OBJECT (obj), &disposed_checker);
1000
1001   /* Now remove the first added reference */
1002   obj->disposing_refs = 0;
1003   g_object_unref (obj);
1004   g_assert_nonnull (disposed_checker);
1005   g_assert_cmpint (g_atomic_int_get (&G_OBJECT (obj)->ref_count), ==, 2);
1006   g_assert_cmpint (obj->actual.count, ==, 2);
1007   g_assert_cmpint (obj->notify_called, ==, 1);
1008
1009   /* And the toggle one */
1010   obj->actual.should_be_last = TRUE;
1011   obj->notify_handler = NULL;
1012   g_object_remove_toggle_ref (G_OBJECT (obj), obj->toggle_notify, NULL);
1013   g_assert_nonnull (disposed_checker);
1014   g_assert_cmpint (g_atomic_int_get (&G_OBJECT (obj)->ref_count), ==, 1);
1015   g_assert_cmpint (obj->actual.count, ==, 2);
1016   obj->expected.count = obj->actual.count;
1017
1018   g_clear_object (&obj);
1019   g_assert_null (disposed_checker);
1020 }
1021
1022 static void
1023 toggle_notify_counter (gpointer  data,
1024                        GObject  *obj,
1025                        gboolean  is_last)
1026 {
1027   Count *c = data;
1028   c->count++;
1029
1030   if (is_last)
1031     g_assert_cmpint (g_atomic_int_get (&obj->ref_count), ==, 1);
1032   else
1033     g_assert_cmpint (g_atomic_int_get (&obj->ref_count), ==, 2);
1034 }
1035
1036 static void
1037 on_object_notify_switch_to_normal_ref (GObject    *object,
1038                                        GParamSpec *pspec,
1039                                        void       *data)
1040 {
1041   DisposeReffingObject *obj = DISPOSE_REFFING_OBJECT (object);
1042
1043   obj->notify_called++;
1044
1045   g_object_ref (object);
1046   g_object_remove_toggle_ref (object, obj->toggle_notify, NULL);
1047 }
1048
1049 static void
1050 on_object_notify_switch_to_toggle_ref (GObject    *object,
1051                                        GParamSpec *pspec,
1052                                        void       *data)
1053 {
1054   DisposeReffingObject *obj = DISPOSE_REFFING_OBJECT (object);
1055
1056   obj->notify_called++;
1057
1058   g_object_add_toggle_ref (object, obj->toggle_notify, &obj->actual);
1059   g_object_unref (object);
1060 }
1061
1062 static void
1063 on_object_notify_add_ref (GObject    *object,
1064                           GParamSpec *pspec,
1065                           void       *data)
1066 {
1067   DisposeReffingObject *obj = DISPOSE_REFFING_OBJECT (object);
1068   int old_toggle_cout = obj->actual.count;
1069
1070   obj->notify_called++;
1071
1072   g_object_ref (object);
1073   g_assert_cmpint (obj->actual.count, ==, old_toggle_cout);
1074 }
1075
1076 static void
1077 test_toggle_ref_and_notify_on_dispose (void)
1078 {
1079   DisposeReffingObject *obj;
1080   gpointer disposed_checker = &obj;
1081
1082   /* This tests wants to ensure that toggle signal emission during dispose
1083    * is properly working if the object is revitalized by adding new references.
1084    * It also wants to check that toggle notifications are not happening if a
1085    * notify handler is removing them at this phase.
1086    */
1087
1088   obj = g_object_new (dispose_reffing_object_get_type (), NULL);
1089   obj->toggle_notify = toggle_notify_counter;
1090   g_object_add_weak_pointer (G_OBJECT (obj), &disposed_checker);
1091
1092   /* Convert to toggle notification */
1093   g_object_add_toggle_ref (G_OBJECT (obj), obj->toggle_notify, &obj->actual);
1094   g_assert_cmpint (obj->actual.count, ==, 0);
1095
1096   obj->notify_handler = G_CALLBACK (on_object_notify);
1097   g_object_unref (obj);
1098   g_assert_cmpint (obj->actual.count, ==, 1);
1099   g_assert_cmpuint (obj->notify_called, ==, 0);
1100
1101   disposed_checker = &obj;
1102   g_object_add_weak_pointer (G_OBJECT (obj), &disposed_checker);
1103
1104   /* Check that notification is triggered after being queued */
1105   obj->disposing_refs = 1;
1106   obj->expected.count = 1;
1107   obj->notify_handler = G_CALLBACK (on_object_notify);
1108   g_object_remove_toggle_ref (G_OBJECT (obj), obj->toggle_notify, NULL);
1109    /* FIXME: adjust the count to 1 when !2377 is in */
1110   g_assert_cmpint (obj->actual.count, ==, 4);
1111   g_assert_cmpuint (obj->notify_called, ==, 1);
1112
1113   disposed_checker = &obj;
1114   g_object_add_weak_pointer (G_OBJECT (obj), &disposed_checker);
1115
1116   /* Check that notification is triggered after being queued, but no toggle
1117    * notification is happening if notify handler switches to normal reference
1118    */
1119   obj->disposing_refs = 1;
1120   obj->expected.count = 4;
1121   obj->notify_handler = G_CALLBACK (on_object_notify_switch_to_normal_ref);
1122   g_object_remove_toggle_ref (G_OBJECT (obj), obj->toggle_notify, NULL);
1123   g_assert_cmpint (obj->actual.count, ==, 5);
1124   g_assert_cmpuint (obj->notify_called, ==, 2);
1125
1126   disposed_checker = &obj;
1127   g_object_add_weak_pointer (G_OBJECT (obj), &disposed_checker);
1128
1129   /* Check that notification is triggered after being queued, but that toggle
1130    * is happening if notify handler switched to toggle reference
1131    */
1132   obj->disposing_refs = 1;
1133   obj->disposing_refs_all_normal = TRUE;
1134   obj->expected.count = 5;
1135   obj->notify_handler = G_CALLBACK (on_object_notify_switch_to_toggle_ref);
1136   g_object_unref (obj);
1137   g_assert_cmpint (obj->actual.count, ==, 7);
1138   g_assert_cmpuint (obj->notify_called, ==, 3);
1139
1140   disposed_checker = &obj;
1141   g_object_add_weak_pointer (G_OBJECT (obj), &disposed_checker);
1142
1143   /* Check that notification is triggered after being queued, but that toggle
1144    * is not happening if current refcount changed.
1145    */
1146   obj->disposing_refs = 1;
1147   obj->disposing_refs_all_normal = FALSE;
1148   obj->expected.count = 7;
1149   obj->notify_handler = G_CALLBACK (on_object_notify_add_ref);
1150   g_object_remove_toggle_ref (G_OBJECT (obj), obj->toggle_notify, NULL);
1151   g_assert_cmpint (obj->actual.count, ==, 8);
1152   g_assert_cmpuint (obj->notify_called, ==, 4);
1153   g_object_unref (obj);
1154
1155   disposed_checker = &obj;
1156   g_object_add_weak_pointer (G_OBJECT (obj), &disposed_checker);
1157
1158   obj->disposing_refs = 0;
1159   obj->expected.count = 9;
1160   g_clear_object (&obj);
1161   g_assert_null (disposed_checker);
1162 }
1163
1164 static gboolean global_destroyed;
1165 static gint global_value;
1166
1167 static void
1168 data_destroy (gpointer data)
1169 {
1170   g_assert_cmpint (GPOINTER_TO_INT (data), ==, global_value);
1171
1172   global_destroyed = TRUE;
1173 }
1174
1175 static void
1176 test_object_qdata (void)
1177 {
1178   GObject *obj;
1179   gpointer v;
1180   GQuark quark;
1181
1182   obj = g_object_new (G_TYPE_OBJECT, NULL);
1183
1184   global_value = 1;
1185   global_destroyed = FALSE;
1186   g_object_set_data_full (obj, "test", GINT_TO_POINTER (1), data_destroy);
1187   v = g_object_get_data (obj, "test");
1188   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 1);
1189   g_object_set_data_full (obj, "test", GINT_TO_POINTER (2), data_destroy);
1190   g_assert (global_destroyed);
1191   global_value = 2;
1192   global_destroyed = FALSE;
1193   v = g_object_steal_data (obj, "test");
1194   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 2);
1195   g_assert (!global_destroyed);
1196
1197   global_value = 1;
1198   global_destroyed = FALSE;
1199   quark = g_quark_from_string ("test");
1200   g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (1), data_destroy);
1201   v = g_object_get_qdata (obj, quark);
1202   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 1);
1203   g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (2), data_destroy);
1204   g_assert (global_destroyed);
1205   global_value = 2;
1206   global_destroyed = FALSE;
1207   v = g_object_steal_qdata (obj, quark);
1208   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 2);
1209   g_assert (!global_destroyed);
1210
1211   g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (3), data_destroy);
1212   global_value = 3;
1213   global_destroyed = FALSE;
1214   g_object_unref (obj);
1215
1216   g_assert (global_destroyed);
1217 }
1218
1219 typedef struct {
1220   const gchar *value;
1221   gint refcount;
1222 } Value;
1223
1224 static gpointer
1225 ref_value (gpointer value, gpointer user_data)
1226 {
1227   Value *v = value;
1228   Value **old_value_p = user_data;
1229
1230   if (old_value_p)
1231     *old_value_p = v;
1232
1233   if (v)
1234     v->refcount += 1;
1235
1236   return value;
1237 }
1238
1239 static void
1240 unref_value (gpointer value)
1241 {
1242   Value *v = value;
1243
1244   v->refcount -= 1;
1245   if (v->refcount == 0)
1246     g_free (value);
1247 }
1248
1249 static
1250 Value *
1251 new_value (const gchar *s)
1252 {
1253   Value *v;
1254
1255   v = g_new (Value, 1);
1256   v->value = s;
1257   v->refcount = 1;
1258
1259   return v;
1260 }
1261
1262 static void
1263 test_object_qdata2 (void)
1264 {
1265   GObject *obj;
1266   Value *v, *v1, *v2, *v3, *old_val;
1267   GDestroyNotify old_destroy;
1268   gboolean res;
1269
1270   obj = g_object_new (G_TYPE_OBJECT, NULL);
1271
1272   v1 = new_value ("bla");
1273
1274   g_object_set_data_full (obj, "test", v1, unref_value);
1275
1276   v = g_object_get_data (obj, "test");
1277   g_assert_cmpstr (v->value, ==, "bla");
1278   g_assert_cmpint (v->refcount, ==, 1);
1279
1280   v = g_object_dup_data (obj, "test", ref_value, &old_val);
1281   g_assert (old_val == v1);
1282   g_assert_cmpstr (v->value, ==, "bla");
1283   g_assert_cmpint (v->refcount, ==, 2);
1284   unref_value (v);
1285
1286   v = g_object_dup_data (obj, "nono", ref_value, &old_val);
1287   g_assert (old_val == NULL);
1288   g_assert (v == NULL);
1289
1290   v2 = new_value ("not");
1291
1292   res = g_object_replace_data (obj, "test", v1, v2, unref_value, &old_destroy);
1293   g_assert (res == TRUE);
1294   g_assert (old_destroy == unref_value);
1295   g_assert_cmpstr (v1->value, ==, "bla");
1296   g_assert_cmpint (v1->refcount, ==, 1);
1297
1298   v = g_object_get_data (obj, "test");
1299   g_assert_cmpstr (v->value, ==, "not");
1300   g_assert_cmpint (v->refcount, ==, 1);
1301
1302   v3 = new_value ("xyz");
1303   res = g_object_replace_data (obj, "test", v1, v3, unref_value, &old_destroy);
1304   g_assert (res == FALSE);
1305   g_assert_cmpstr (v2->value, ==, "not");
1306   g_assert_cmpint (v2->refcount, ==, 1);
1307
1308   unref_value (v1);
1309
1310   res = g_object_replace_data (obj, "test", NULL, v3, unref_value, &old_destroy);
1311   g_assert (res == FALSE);
1312   g_assert_cmpstr (v2->value, ==, "not");
1313   g_assert_cmpint (v2->refcount, ==, 1);
1314
1315   res = g_object_replace_data (obj, "test", v2, NULL, unref_value, &old_destroy);
1316   g_assert (res == TRUE);
1317   g_assert (old_destroy == unref_value);
1318   g_assert_cmpstr (v2->value, ==, "not");
1319   g_assert_cmpint (v2->refcount, ==, 1);
1320
1321   unref_value (v2);
1322
1323   v = g_object_get_data (obj, "test");
1324   g_assert (v == NULL);
1325
1326   res = g_object_replace_data (obj, "test", NULL, v3, unref_value, &old_destroy);
1327   g_assert (res == TRUE);
1328
1329   v = g_object_get_data (obj, "test");
1330   g_assert (v == v3);
1331
1332   ref_value (v3, NULL);
1333   g_assert_cmpint (v3->refcount, ==, 2);
1334   g_object_unref (obj);
1335   g_assert_cmpint (v3->refcount, ==, 1);
1336   unref_value (v3);
1337 }
1338
1339 int
1340 main (int argc, char **argv)
1341 {
1342   g_test_init (&argc, &argv, NULL);
1343
1344   g_setenv ("G_ENABLE_DIAGNOSTIC", "1", TRUE);
1345
1346   g_test_add_func ("/type/fundamentals", test_fundamentals);
1347   g_test_add_func ("/type/qdata", test_type_qdata);
1348   g_test_add_func ("/type/query", test_type_query);
1349   g_test_add_func ("/type/class-private", test_class_private);
1350   g_test_add_func ("/object/clear", test_clear);
1351   g_test_add_func ("/object/clear-function", test_clear_function);
1352   g_test_add_func ("/object/set", test_set);
1353   g_test_add_func ("/object/set-function", test_set_function);
1354   g_test_add_func ("/object/set/derived-type", test_set_derived_type);
1355   g_test_add_func ("/object/value", test_object_value);
1356   g_test_add_func ("/object/initially-unowned", test_initially_unowned);
1357   g_test_add_func ("/object/weak-pointer", test_weak_pointer);
1358   g_test_add_func ("/object/weak-pointer/clear", test_weak_pointer_clear);
1359   g_test_add_func ("/object/weak-pointer/clear-function", test_weak_pointer_clear_function);
1360   g_test_add_func ("/object/weak-pointer/set", test_weak_pointer_set);
1361   g_test_add_func ("/object/weak-pointer/set-function", test_weak_pointer_set_function);
1362   g_test_add_func ("/object/weak-ref", test_weak_ref);
1363   g_test_add_func ("/object/weak-ref/on-dispose", test_weak_ref_on_dispose);
1364   g_test_add_func ("/object/weak-ref/on-run-dispose", test_weak_ref_on_run_dispose);
1365   g_test_add_func ("/object/weak-ref/on-toggle-notify", test_weak_ref_on_toggle_notify);
1366   g_test_add_func ("/object/toggle-ref", test_toggle_ref);
1367   g_test_add_func ("/object/toggle-ref/ref-on-dispose", test_toggle_ref_on_dispose);
1368   g_test_add_func ("/object/toggle-ref/ref-and-notify-on-dispose", test_toggle_ref_and_notify_on_dispose);
1369   g_test_add_func ("/object/qdata", test_object_qdata);
1370   g_test_add_func ("/object/qdata2", test_object_qdata2);
1371
1372   return g_test_run ();
1373 }