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   volatile 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
 160   g_assert (!g_set_object (&o, NULL));
 161   g_assert (o == NULL);
 162
 163   tmp = g_object_new (G_TYPE_OBJECT, NULL);
 164   g_assert_cmpint (tmp->ref_count, ==, 1);
 165
 166   g_assert (g_set_object (&o, tmp));
 167   g_assert (o == tmp);
 168   g_assert_cmpint (tmp->ref_count, ==, 2);
 169
 170   g_object_unref (tmp);
 171   g_assert_cmpint (tmp->ref_count, ==, 1);
 172
 173   /* Setting it again shouldn’t cause finalisation. */
 174   g_assert (!g_set_object (&o, tmp));
 175   g_assert (o == tmp);
 176   g_assert_cmpint (tmp->ref_count, ==, 1);
 177
 178   g_assert (g_set_object (&o, NULL));
 179   g_assert (o == NULL);
 180   g_assert (!G_IS_OBJECT (tmp));  /* finalised */
 181 }
 182
 183 static void
 184 test_set_function (void)
 185 {
 186   GObject *o = NULL;
 187   GObject *tmp;
 188
 189   g_assert (!(g_set_object) (&o, NULL));
 190   g_assert (o == NULL);
 191
 192   tmp = g_object_new (G_TYPE_OBJECT, NULL);
 193   g_assert_cmpint (tmp->ref_count, ==, 1);
 194
 195   g_assert ((g_set_object) (&o, tmp));
 196   g_assert (o == tmp);
 197   g_assert_cmpint (tmp->ref_count, ==, 2);
 198
 199   g_object_unref (tmp);
 200   g_assert_cmpint (tmp->ref_count, ==, 1);
 201
 202   /* Setting it again shouldn’t cause finalisation. */
 203   g_assert (!(g_set_object) (&o, tmp));
 204   g_assert (o == tmp);
 205   g_assert_cmpint (tmp->ref_count, ==, 1);
 206
 207   g_assert ((g_set_object) (&o, NULL));
 208   g_assert (o == NULL);
 209   g_assert (!G_IS_OBJECT (tmp));  /* finalised */
 210 }
 211
 212 static void
 213 toggle_cb (gpointer data, GObject *obj, gboolean is_last)
 214 {
 215   gboolean *b = data;
 216
 217   *b = TRUE;
 218 }
 219
 220 static void
 221 test_object_value (void)
 222 {
 223   GObject *v;
 224   GObject *v2;
 225   GValue value = G_VALUE_INIT;
 226   gboolean toggled = FALSE;
 227
 228   g_value_init (&value, G_TYPE_OBJECT);
 229
 230   v = g_object_new (G_TYPE_OBJECT, NULL);
 231   g_object_add_toggle_ref (v, toggle_cb, &toggled);
 232
 233   g_value_take_object (&value, v);
 234
 235   v2 = g_value_get_object (&value);
 236   g_assert (v2 == v);
 237
 238   v2 = g_value_dup_object (&value);
 239   g_assert (v2 == v);  /* objects use ref/unref for copy/free */
 240   g_object_unref (v2);
 241
 242   g_assert (!toggled);
 243   g_value_unset (&value);
 244   g_assert (toggled);
 245
 246   /* test the deprecated variant too */
 247   g_value_init (&value, G_TYPE_OBJECT);
 248   /* get a new reference */
 249   g_object_ref (v);
 250
 251 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
 252   g_value_set_object_take_ownership (&value, v);
 253 G_GNUC_END_IGNORE_DEPRECATIONS
 254
 255   toggled = FALSE;
 256   g_value_unset (&value);
 257   g_assert (toggled);
 258
 259   g_object_remove_toggle_ref (v, toggle_cb, &toggled);
 260 }
 261
 262 static void
 263 test_initially_unowned (void)
 264 {
 265   GObject *obj;
 266
 267   obj = g_object_new (G_TYPE_INITIALLY_UNOWNED, NULL);
 268   g_assert (g_object_is_floating (obj));
 269   g_assert_cmpint (obj->ref_count, ==, 1);
 270
 271   g_object_ref_sink (obj);
 272   g_assert (!g_object_is_floating (obj));
 273   g_assert_cmpint (obj->ref_count, ==, 1);
 274
 275   g_object_ref_sink (obj);
 276   g_assert (!g_object_is_floating (obj));
 277   g_assert_cmpint (obj->ref_count, ==, 2);
 278
 279   g_object_unref (obj);
 280   g_assert_cmpint (obj->ref_count, ==, 1);
 281
 282   g_object_force_floating (obj);
 283   g_assert (g_object_is_floating (obj));
 284   g_assert_cmpint (obj->ref_count, ==, 1);
 285
 286   g_object_ref_sink (obj);
 287   g_object_unref (obj);
 288 }
 289
 290 static void
 291 test_weak_pointer (void)
 292 {
 293   GObject *obj;
 294   gpointer weak;
 295   gpointer weak2;
 296
 297   weak = weak2 = obj = g_object_new (G_TYPE_OBJECT, NULL);
 298   g_assert_cmpint (obj->ref_count, ==, 1);
 299
 300   g_object_add_weak_pointer (obj, &weak);
 301   g_object_add_weak_pointer (obj, &weak2);
 302   g_assert_cmpint (obj->ref_count, ==, 1);
 303   g_assert (weak == obj);
 304   g_assert (weak2 == obj);
 305
 306   g_object_remove_weak_pointer (obj, &weak2);
 307   g_assert_cmpint (obj->ref_count, ==, 1);
 308   g_assert (weak == obj);
 309   g_assert (weak2 == obj);
 310
 311   g_object_unref (obj);
 312   g_assert (weak == NULL);
 313   g_assert (weak2 == obj);
 314 }
 315
 316 static void
 317 test_weak_pointer_clear (void)
 318 {
 319   GObject *obj;
 320   gpointer weak = NULL;
 321
 322   g_clear_weak_pointer (&weak);
 323   g_assert_null (weak);
 324
 325   weak = obj = g_object_new (G_TYPE_OBJECT, NULL);
 326   g_assert_cmpint (obj->ref_count, ==, 1);
 327
 328   g_object_add_weak_pointer (obj, &weak);
 329   g_assert_cmpint (obj->ref_count, ==, 1);
 330   g_assert_true (weak == obj);
 331
 332   g_clear_weak_pointer (&weak);
 333   g_assert_cmpint (obj->ref_count, ==, 1);
 334   g_assert_null (weak);
 335
 336   g_object_unref (obj);
 337 }
 338
 339 static void
 340 test_weak_pointer_clear_function (void)
 341 {
 342   GObject *obj;
 343   gpointer weak = NULL;
 344
 345   (g_clear_weak_pointer) (&weak);
 346   g_assert_null (weak);
 347
 348   weak = obj = g_object_new (G_TYPE_OBJECT, NULL);
 349   g_assert_cmpint (obj->ref_count, ==, 1);
 350
 351   g_object_add_weak_pointer (obj, &weak);
 352   g_assert_cmpint (obj->ref_count, ==, 1);
 353   g_assert_true (weak == obj);
 354
 355   (g_clear_weak_pointer) (&weak);
 356   g_assert_cmpint (obj->ref_count, ==, 1);
 357   g_assert_null (weak);
 358
 359   g_object_unref (obj);
 360 }
 361
 362 static void
 363 test_weak_pointer_set (void)
 364 {
 365   GObject *obj;
 366   gpointer weak = NULL;
 367
 368   g_assert_false (g_set_weak_pointer (&weak, NULL));
 369   g_assert_null (weak);
 370
 371   obj = g_object_new (G_TYPE_OBJECT, NULL);
 372   g_assert_cmpint (obj->ref_count, ==, 1);
 373
 374   g_assert_true (g_set_weak_pointer (&weak, obj));
 375   g_assert_cmpint (obj->ref_count, ==, 1);
 376   g_assert_true (weak == obj);
 377
 378   g_assert_true (g_set_weak_pointer (&weak, NULL));
 379   g_assert_cmpint (obj->ref_count, ==, 1);
 380   g_assert_null (weak);
 381
 382   g_assert_true (g_set_weak_pointer (&weak, obj));
 383   g_assert_cmpint (obj->ref_count, ==, 1);
 384   g_assert_true (weak == obj);
 385
 386   g_object_unref (obj);
 387   g_assert_null (weak);
 388 }
 389
 390 static void
 391 test_weak_pointer_set_function (void)
 392 {
 393   GObject *obj;
 394   gpointer weak = NULL;
 395
 396   g_assert_false ((g_set_weak_pointer) (&weak, NULL));
 397   g_assert_null (weak);
 398
 399   obj = g_object_new (G_TYPE_OBJECT, NULL);
 400   g_assert_cmpint (obj->ref_count, ==, 1);
 401
 402   g_assert_true ((g_set_weak_pointer) (&weak, obj));
 403   g_assert_cmpint (obj->ref_count, ==, 1);
 404   g_assert_true (weak == obj);
 405
 406   g_assert_true ((g_set_weak_pointer) (&weak, NULL));
 407   g_assert_cmpint (obj->ref_count, ==, 1);
 408   g_assert_null (weak);
 409
 410   g_assert_true ((g_set_weak_pointer) (&weak, obj));
 411   g_assert_cmpint (obj->ref_count, ==, 1);
 412   g_assert_true (weak == obj);
 413
 414   g_object_unref (obj);
 415   g_assert_null (weak);
 416 }
 417
 418 /* See gobject/tests/threadtests.c for the threaded version */
 419 static void
 420 test_weak_ref (void)
 421 {
 422   GObject *obj;
 423   GObject *obj2;
 424   GObject *tmp;
 425   GWeakRef weak = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
 426   GWeakRef weak2 = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
 427   GWeakRef weak3 = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
 428   GWeakRef *dynamic_weak = g_new (GWeakRef, 1);
 429
 430   /* you can initialize to empty like this... */
 431   g_weak_ref_init (&weak2, NULL);
 432   g_assert (g_weak_ref_get (&weak2) == NULL);
 433
 434   /* ... or via an initializer */
 435   g_weak_ref_init (&weak3, NULL);
 436   g_assert (g_weak_ref_get (&weak3) == NULL);
 437
 438   obj = g_object_new (G_TYPE_OBJECT, NULL);
 439   g_assert_cmpint (obj->ref_count, ==, 1);
 440
 441   obj2 = g_object_new (G_TYPE_OBJECT, NULL);
 442   g_assert_cmpint (obj2->ref_count, ==, 1);
 443
 444   /* you can init with an object (even if uninitialized) */
 445   g_weak_ref_init (&weak, obj);
 446   g_weak_ref_init (dynamic_weak, obj);
 447   /* or set to point at an object, if initialized (maybe to 0) */
 448   g_weak_ref_set (&weak2, obj);
 449   g_weak_ref_set (&weak3, obj);
 450   /* none of this affects its refcount */
 451   g_assert_cmpint (obj->ref_count, ==, 1);
 452
 453   /* getting the value takes a ref */
 454   tmp = g_weak_ref_get (&weak);
 455   g_assert (tmp == obj);
 456   g_assert_cmpint (obj->ref_count, ==, 2);
 457   g_object_unref (tmp);
 458   g_assert_cmpint (obj->ref_count, ==, 1);
 459
 460   tmp = g_weak_ref_get (&weak2);
 461   g_assert (tmp == obj);
 462   g_assert_cmpint (obj->ref_count, ==, 2);
 463   g_object_unref (tmp);
 464   g_assert_cmpint (obj->ref_count, ==, 1);
 465
 466   tmp = g_weak_ref_get (&weak3);
 467   g_assert (tmp == obj);
 468   g_assert_cmpint (obj->ref_count, ==, 2);
 469   g_object_unref (tmp);
 470   g_assert_cmpint (obj->ref_count, ==, 1);
 471
 472   tmp = g_weak_ref_get (dynamic_weak);
 473   g_assert (tmp == obj);
 474   g_assert_cmpint (obj->ref_count, ==, 2);
 475   g_object_unref (tmp);
 476   g_assert_cmpint (obj->ref_count, ==, 1);
 477
 478   /* clearing a weak ref stops tracking */
 479   g_weak_ref_clear (&weak);
 480
 481   /* setting a weak ref to NULL stops tracking too */
 482   g_weak_ref_set (&weak2, NULL);
 483   g_assert (g_weak_ref_get (&weak2) == NULL);
 484   g_weak_ref_clear (&weak2);
 485
 486   /* setting a weak ref to a new object stops tracking the old one */
 487   g_weak_ref_set (dynamic_weak, obj2);
 488   tmp = g_weak_ref_get (dynamic_weak);
 489   g_assert (tmp == obj2);
 490   g_assert_cmpint (obj2->ref_count, ==, 2);
 491   g_object_unref (tmp);
 492   g_assert_cmpint (obj2->ref_count, ==, 1);
 493
 494   g_assert_cmpint (obj->ref_count, ==, 1);
 495
 496   /* free the object: weak3 is the only one left pointing there */
 497   g_object_unref (obj);
 498   g_assert (g_weak_ref_get (&weak3) == NULL);
 499
 500   /* setting a weak ref to a new object stops tracking the old one */
 501   g_weak_ref_set (dynamic_weak, obj2);
 502   tmp = g_weak_ref_get (dynamic_weak);
 503   g_assert (tmp == obj2);
 504   g_assert_cmpint (obj2->ref_count, ==, 2);
 505   g_object_unref (tmp);
 506   g_assert_cmpint (obj2->ref_count, ==, 1);
 507
 508   g_weak_ref_clear (&weak3);
 509
 510   /* clear and free dynamic_weak... */
 511   g_weak_ref_clear (dynamic_weak);
 512
 513   /* ... to prove that doing so stops this from being a use-after-free */
 514   g_object_unref (obj2);
 515   g_free (dynamic_weak);
 516 }
 517
 518 typedef struct
 519 {
 520   gboolean should_be_last;
 521   gint count;
 522 } Count;
 523
 524 static void
 525 toggle_notify (gpointer  data,
 526                GObject  *obj,
 527                gboolean  is_last)
 528 {
 529   Count *c = data;
 530
 531   g_assert (is_last == c->should_be_last);
 532
 533   c->count++;
 534 }
 535
 536 static void
 537 test_toggle_ref (void)
 538 {
 539   GObject *obj;
 540   Count c, c2;
 541
 542   obj = g_object_new (G_TYPE_OBJECT, NULL);
 543
 544   g_object_add_toggle_ref (obj, toggle_notify, &c);
 545   g_object_add_toggle_ref (obj, toggle_notify, &c2);
 546
 547   c.should_be_last = c2.should_be_last = TRUE;
 548   c.count = c2.count = 0;
 549
 550   g_object_unref (obj);
 551
 552   g_assert_cmpint (c.count, ==, 0);
 553   g_assert_cmpint (c2.count, ==, 0);
 554
 555   g_object_ref (obj);
 556
 557   g_assert_cmpint (c.count, ==, 0);
 558   g_assert_cmpint (c2.count, ==, 0);
 559
 560   g_object_remove_toggle_ref (obj, toggle_notify, &c2);
 561
 562   g_object_unref (obj);
 563
 564   g_assert_cmpint (c.count, ==, 1);
 565
 566   c.should_be_last = FALSE;
 567
 568   g_object_ref (obj);
 569
 570   g_assert_cmpint (c.count, ==, 2);
 571
 572   c.should_be_last = TRUE;
 573
 574   g_object_unref (obj);
 575
 576   g_assert_cmpint (c.count, ==, 3);
 577
 578   g_object_remove_toggle_ref (obj, toggle_notify, &c);
 579 }
 580
 581 static gboolean destroyed;
 582 static gint value;
 583
 584 static void
 585 data_destroy (gpointer data)
 586 {
 587   g_assert_cmpint (GPOINTER_TO_INT (data), ==, value);
 588
 589   destroyed = TRUE;
 590 }
 591
 592 static void
 593 test_object_qdata (void)
 594 {
 595   GObject *obj;
 596   gpointer v;
 597   GQuark quark;
 598
 599   obj = g_object_new (G_TYPE_OBJECT, NULL);
 600
 601   value = 1;
 602   destroyed = FALSE;
 603   g_object_set_data_full (obj, "test", GINT_TO_POINTER (1), data_destroy);
 604   v = g_object_get_data (obj, "test");
 605   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 1);
 606   g_object_set_data_full (obj, "test", GINT_TO_POINTER (2), data_destroy);
 607   g_assert (destroyed);
 608   value = 2;
 609   destroyed = FALSE;
 610   v = g_object_steal_data (obj, "test");
 611   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 2);
 612   g_assert (!destroyed);
 613
 614   value = 1;
 615   destroyed = FALSE;
 616   quark = g_quark_from_string ("test");
 617   g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (1), data_destroy);
 618   v = g_object_get_qdata (obj, quark);
 619   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 1);
 620   g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (2), data_destroy);
 621   g_assert (destroyed);
 622   value = 2;
 623   destroyed = FALSE;
 624   v = g_object_steal_qdata (obj, quark);
 625   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 2);
 626   g_assert (!destroyed);
 627
 628   g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (3), data_destroy);
 629   value = 3;
 630   destroyed = FALSE;
 631   g_object_unref (obj);
 632
 633   g_assert (destroyed);
 634 }
 635
 636 typedef struct {
 637   const gchar *value;
 638   gint refcount;
 639 } Value;
 640
 641 static gpointer
 642 ref_value (gpointer value, gpointer user_data)
 643 {
 644   Value *v = value;
 645   Value **old_value_p = user_data;
 646
 647   if (old_value_p)
 648     *old_value_p = v;
 649
 650   if (v)
 651     v->refcount += 1;
 652
 653   return value;
 654 }
 655
 656 static void
 657 unref_value (gpointer value)
 658 {
 659   Value *v = value;
 660
 661   v->refcount -= 1;
 662   if (v->refcount == 0)
 663     g_free (value);
 664 }
 665
 666 static
 667 Value *
 668 new_value (const gchar *s)
 669 {
 670   Value *v;
 671
 672   v = g_new (Value, 1);
 673   v->value = s;
 674   v->refcount = 1;
 675
 676   return v;
 677 }
 678
 679 static void
 680 test_object_qdata2 (void)
 681 {
 682   GObject *obj;
 683   Value *v, *v1, *v2, *v3, *old_val;
 684   GDestroyNotify old_destroy;
 685   gboolean res;
 686
 687   obj = g_object_new (G_TYPE_OBJECT, NULL);
 688
 689   v1 = new_value ("bla");
 690
 691   g_object_set_data_full (obj, "test", v1, unref_value);
 692
 693   v = g_object_get_data (obj, "test");
 694   g_assert_cmpstr (v->value, ==, "bla");
 695   g_assert_cmpint (v->refcount, ==, 1);
 696
 697   v = g_object_dup_data (obj, "test", ref_value, &old_val);
 698   g_assert (old_val == v1);
 699   g_assert_cmpstr (v->value, ==, "bla");
 700   g_assert_cmpint (v->refcount, ==, 2);
 701   unref_value (v);
 702
 703   v = g_object_dup_data (obj, "nono", ref_value, &old_val);
 704   g_assert (old_val == NULL);
 705   g_assert (v == NULL);
 706
 707   v2 = new_value ("not");
 708
 709   res = g_object_replace_data (obj, "test", v1, v2, unref_value, &old_destroy);
 710   g_assert (res == TRUE);
 711   g_assert (old_destroy == unref_value);
 712   g_assert_cmpstr (v1->value, ==, "bla");
 713   g_assert_cmpint (v1->refcount, ==, 1);
 714
 715   v = g_object_get_data (obj, "test");
 716   g_assert_cmpstr (v->value, ==, "not");
 717   g_assert_cmpint (v->refcount, ==, 1);
 718
 719   v3 = new_value ("xyz");
 720   res = g_object_replace_data (obj, "test", v1, v3, unref_value, &old_destroy);
 721   g_assert (res == FALSE);
 722   g_assert_cmpstr (v2->value, ==, "not");
 723   g_assert_cmpint (v2->refcount, ==, 1);
 724
 725   unref_value (v1);
 726
 727   res = g_object_replace_data (obj, "test", NULL, v3, unref_value, &old_destroy);
 728   g_assert (res == FALSE);
 729   g_assert_cmpstr (v2->value, ==, "not");
 730   g_assert_cmpint (v2->refcount, ==, 1);
 731
 732   res = g_object_replace_data (obj, "test", v2, NULL, unref_value, &old_destroy);
 733   g_assert (res == TRUE);
 734   g_assert (old_destroy == unref_value);
 735   g_assert_cmpstr (v2->value, ==, "not");
 736   g_assert_cmpint (v2->refcount, ==, 1);
 737
 738   unref_value (v2);
 739
 740   v = g_object_get_data (obj, "test");
 741   g_assert (v == NULL);
 742
 743   res = g_object_replace_data (obj, "test", NULL, v3, unref_value, &old_destroy);
 744   g_assert (res == TRUE);
 745
 746   v = g_object_get_data (obj, "test");
 747   g_assert (v == v3);
 748
 749   ref_value (v3, NULL);
 750   g_assert_cmpint (v3->refcount, ==, 2);
 751   g_object_unref (obj);
 752   g_assert_cmpint (v3->refcount, ==, 1);
 753   unref_value (v3);
 754 }
 755
 756 int
 757 main (int argc, char **argv)
 758 {
 759   g_test_init (&argc, &argv, NULL);
 760
 761   g_test_add_func ("/type/fundamentals", test_fundamentals);
 762   g_test_add_func ("/type/qdata", test_type_qdata);
 763   g_test_add_func ("/type/query", test_type_query);
 764   g_test_add_func ("/type/class-private", test_class_private);
 765   g_test_add_func ("/object/clear", test_clear);
 766   g_test_add_func ("/object/clear-function", test_clear_function);
 767   g_test_add_func ("/object/set", test_set);
 768   g_test_add_func ("/object/set-function", test_set_function);
 769   g_test_add_func ("/object/value", test_object_value);
 770   g_test_add_func ("/object/initially-unowned", test_initially_unowned);
 771   g_test_add_func ("/object/weak-pointer", test_weak_pointer);
 772   g_test_add_func ("/object/weak-pointer/clear", test_weak_pointer_clear);
 773   g_test_add_func ("/object/weak-pointer/clear-function", test_weak_pointer_clear_function);
 774   g_test_add_func ("/object/weak-pointer/set", test_weak_pointer_set);
 775   g_test_add_func ("/object/weak-pointer/set-function", test_weak_pointer_set_function);
 776   g_test_add_func ("/object/weak-ref", test_weak_ref);
 777   g_test_add_func ("/object/toggle-ref", test_toggle_ref);
 778   g_test_add_func ("/object/qdata", test_object_qdata);
 779   g_test_add_func ("/object/qdata2", test_object_qdata2);
 780
 781   return g_test_run ();
 782 }