gobject/tests/reference.c - third_party/glib - Git at Google

 #include <glib-object.h>

 static void
 test_fundamentals (void)
 {
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_NONE));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_INTERFACE));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_CHAR));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_UCHAR));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_BOOLEAN));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_INT));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_UINT));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_LONG));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_ULONG));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_INT64));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_UINT64));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_ENUM));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_FLAGS));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_FLOAT));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_DOUBLE));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_STRING));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_POINTER));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_BOXED));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_PARAM));
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_OBJECT));
   g_assert (G_TYPE_OBJECT == g_object_get_type ());
   g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_VARIANT));
   g_assert (G_TYPE_IS_DERIVED (G_TYPE_INITIALLY_UNOWNED));

   g_assert (g_type_fundamental_next () == G_TYPE_MAKE_FUNDAMENTAL (G_TYPE_RESERVED_USER_FIRST));
 }

 static void
 test_type_qdata (void)
 {
   gchar *data;

   g_type_set_qdata (G_TYPE_ENUM, g_quark_from_string ("bla"), "bla");
   data = g_type_get_qdata (G_TYPE_ENUM, g_quark_from_string ("bla"));
   g_assert_cmpstr (data, ==, "bla");
 }

 static void
 test_type_query (void)
 {
   GTypeQuery query;

   g_type_query (G_TYPE_ENUM, &query);
   g_assert_cmpint (query.type, ==, G_TYPE_ENUM);
   g_assert_cmpstr (query.type_name, ==, "GEnum");
   g_assert_cmpint (query.class_size, ==, sizeof (GEnumClass));
   g_assert_cmpint (query.instance_size, ==, 0);
 }

 typedef struct _MyObject MyObject;
 typedef struct _MyObjectClass MyObjectClass;
 typedef struct _MyObjectClassPrivate MyObjectClassPrivate;

 struct _MyObject
 {
   GObject parent_instance;

   gint count;
 };

 struct _MyObjectClass
 {
   GObjectClass parent_class;
 };

 struct _MyObjectClassPrivate
 {
   gint secret_class_count;
 };

 static GType my_object_get_type (void);
 G_DEFINE_TYPE_WITH_CODE (MyObject, my_object, G_TYPE_OBJECT,
                          g_type_add_class_private (g_define_type_id, sizeof (MyObjectClassPrivate)) );

 static void
 my_object_init (MyObject *obj)
 {
   obj->count = 42;
 }

 static void
 my_object_class_init (MyObjectClass *klass)
 {
 }

 static void
 test_class_private (void)
 {
   GObject *obj;
   MyObjectClass *class;
   MyObjectClassPrivate *priv;

   obj = g_object_new (my_object_get_type (), NULL);

   class = g_type_class_ref (my_object_get_type ());
   priv = G_TYPE_CLASS_GET_PRIVATE (class, my_object_get_type (), MyObjectClassPrivate);
   priv->secret_class_count = 13;
   g_type_class_unref (class);

   g_object_unref (obj);

   g_assert_cmpint (g_type_qname (my_object_get_type ()), ==, g_quark_from_string ("MyObject"));
 }

 static void
 test_clear (void)
 {
   GObject *o = NULL;
   GObject *tmp;

   g_clear_object (&o);
   g_assert (o == NULL);

   tmp = g_object_new (G_TYPE_OBJECT, NULL);
   g_assert_cmpint (tmp->ref_count, ==, 1);
   o = g_object_ref (tmp);
   g_assert (o != NULL);

   g_assert_cmpint (tmp->ref_count, ==, 2);
   g_clear_object (&o);
   g_assert_cmpint (tmp->ref_count, ==, 1);
   g_assert (o == NULL);

   g_object_unref (tmp);
 }

 static void
 test_clear_function (void)
 {
   volatile GObject *o = NULL;
   GObject *tmp;

   (g_clear_object) (&o);
   g_assert (o == NULL);

   tmp = g_object_new (G_TYPE_OBJECT, NULL);
   g_assert_cmpint (tmp->ref_count, ==, 1);
   o = g_object_ref (tmp);
   g_assert (o != NULL);

   g_assert_cmpint (tmp->ref_count, ==, 2);
   (g_clear_object) (&o);
   g_assert_cmpint (tmp->ref_count, ==, 1);
   g_assert (o == NULL);

   g_object_unref (tmp);
 }

 static void
 test_set (void)
 {
   GObject *o = NULL;
   GObject *tmp;
   gpointer tmp_weak = NULL;

   g_assert (!g_set_object (&o, NULL));
   g_assert (o == NULL);

   tmp = g_object_new (G_TYPE_OBJECT, NULL);
   tmp_weak = tmp;
   g_object_add_weak_pointer (tmp, &tmp_weak);
   g_assert_cmpint (tmp->ref_count, ==, 1);

   g_assert (g_set_object (&o, tmp));
   g_assert (o == tmp);
   g_assert_cmpint (tmp->ref_count, ==, 2);

   g_object_unref (tmp);
   g_assert_cmpint (tmp->ref_count, ==, 1);

   /* Setting it again shouldn’t cause finalisation. */
   g_assert (!g_set_object (&o, tmp));
   g_assert (o == tmp);
   g_assert_cmpint (tmp->ref_count, ==, 1);
   g_assert_nonnull (tmp_weak);

   g_assert (g_set_object (&o, NULL));
   g_assert (o == NULL);
   g_assert_null (tmp_weak);
 }

 static void
 test_set_function (void)
 {
   GObject *o = NULL;
   GObject *tmp;
   gpointer tmp_weak = NULL;

   g_assert (!(g_set_object) (&o, NULL));
   g_assert (o == NULL);

   tmp = g_object_new (G_TYPE_OBJECT, NULL);
   tmp_weak = tmp;
   g_object_add_weak_pointer (tmp, &tmp_weak);
   g_assert_cmpint (tmp->ref_count, ==, 1);

   g_assert ((g_set_object) (&o, tmp));
   g_assert (o == tmp);
   g_assert_cmpint (tmp->ref_count, ==, 2);

   g_object_unref (tmp);
   g_assert_cmpint (tmp->ref_count, ==, 1);

   /* Setting it again shouldn’t cause finalisation. */
   g_assert (!(g_set_object) (&o, tmp));
   g_assert (o == tmp);
   g_assert_cmpint (tmp->ref_count, ==, 1);
   g_assert_nonnull (tmp_weak);

   g_assert ((g_set_object) (&o, NULL));
   g_assert (o == NULL);
   g_assert_null (tmp_weak);
 }

 static void
 toggle_cb (gpointer data, GObject *obj, gboolean is_last)
 {
   gboolean *b = data;

   *b = TRUE;
 }

 static void
 test_object_value (void)
 {
   GObject *v;
   GObject *v2;
   GValue value = G_VALUE_INIT;
   gboolean toggled = FALSE;

   g_value_init (&value, G_TYPE_OBJECT);

   v = g_object_new (G_TYPE_OBJECT, NULL);
   g_object_add_toggle_ref (v, toggle_cb, &toggled);

   g_value_take_object (&value, v);

   v2 = g_value_get_object (&value);
   g_assert (v2 == v);

   v2 = g_value_dup_object (&value);
   g_assert (v2 == v);  /* objects use ref/unref for copy/free */
   g_object_unref (v2);

   g_assert (!toggled);
   g_value_unset (&value);
   g_assert (toggled);

   /* test the deprecated variant too */
   g_value_init (&value, G_TYPE_OBJECT);
   /* get a new reference */
   g_object_ref (v);

 G_GNUC_BEGIN_IGNORE_DEPRECATIONS
   g_value_set_object_take_ownership (&value, v);
 G_GNUC_END_IGNORE_DEPRECATIONS

   toggled = FALSE;
   g_value_unset (&value);
   g_assert (toggled);

   g_object_remove_toggle_ref (v, toggle_cb, &toggled);
 }

 static void
 test_initially_unowned (void)
 {
   GObject *obj;

   obj = g_object_new (G_TYPE_INITIALLY_UNOWNED, NULL);
   g_assert (g_object_is_floating (obj));
   g_assert_cmpint (obj->ref_count, ==, 1);

   g_object_ref_sink (obj);
   g_assert (!g_object_is_floating (obj));
   g_assert_cmpint (obj->ref_count, ==, 1);

   g_object_ref_sink (obj);
   g_assert (!g_object_is_floating (obj));
   g_assert_cmpint (obj->ref_count, ==, 2);

   g_object_unref (obj);
   g_assert_cmpint (obj->ref_count, ==, 1);

   g_object_force_floating (obj);
   g_assert (g_object_is_floating (obj));
   g_assert_cmpint (obj->ref_count, ==, 1);

   g_object_ref_sink (obj);
   g_object_unref (obj);
 }

 static void
 test_weak_pointer (void)
 {
   GObject *obj;
   gpointer weak;
   gpointer weak2;

   weak = weak2 = obj = g_object_new (G_TYPE_OBJECT, NULL);
   g_assert_cmpint (obj->ref_count, ==, 1);

   g_object_add_weak_pointer (obj, &weak);
   g_object_add_weak_pointer (obj, &weak2);
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert (weak == obj);
   g_assert (weak2 == obj);

   g_object_remove_weak_pointer (obj, &weak2);
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert (weak == obj);
   g_assert (weak2 == obj);

   g_object_unref (obj);
   g_assert (weak == NULL);
   g_assert (weak2 == obj);
 }

 static void
 test_weak_pointer_clear (void)
 {
   GObject *obj;
   gpointer weak = NULL;

   g_clear_weak_pointer (&weak);
   g_assert_null (weak);

   weak = obj = g_object_new (G_TYPE_OBJECT, NULL);
   g_assert_cmpint (obj->ref_count, ==, 1);

   g_object_add_weak_pointer (obj, &weak);
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_true (weak == obj);

   g_clear_weak_pointer (&weak);
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_null (weak);

   g_object_unref (obj);
 }

 static void
 test_weak_pointer_clear_function (void)
 {
   GObject *obj;
   gpointer weak = NULL;

   (g_clear_weak_pointer) (&weak);
   g_assert_null (weak);

   weak = obj = g_object_new (G_TYPE_OBJECT, NULL);
   g_assert_cmpint (obj->ref_count, ==, 1);

   g_object_add_weak_pointer (obj, &weak);
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_true (weak == obj);

   (g_clear_weak_pointer) (&weak);
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_null (weak);

   g_object_unref (obj);
 }

 static void
 test_weak_pointer_set (void)
 {
   GObject *obj;
   gpointer weak = NULL;

   g_assert_false (g_set_weak_pointer (&weak, NULL));
   g_assert_null (weak);

   obj = g_object_new (G_TYPE_OBJECT, NULL);
   g_assert_cmpint (obj->ref_count, ==, 1);

   g_assert_true (g_set_weak_pointer (&weak, obj));
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_true (weak == obj);

   g_assert_true (g_set_weak_pointer (&weak, NULL));
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_null (weak);

   g_assert_true (g_set_weak_pointer (&weak, obj));
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_true (weak == obj);

   g_object_unref (obj);
   g_assert_null (weak);
 }

 static void
 test_weak_pointer_set_function (void)
 {
   GObject *obj;
   gpointer weak = NULL;

   g_assert_false ((g_set_weak_pointer) (&weak, NULL));
   g_assert_null (weak);

   obj = g_object_new (G_TYPE_OBJECT, NULL);
   g_assert_cmpint (obj->ref_count, ==, 1);

   g_assert_true ((g_set_weak_pointer) (&weak, obj));
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_true (weak == obj);

   g_assert_true ((g_set_weak_pointer) (&weak, NULL));
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_null (weak);

   g_assert_true ((g_set_weak_pointer) (&weak, obj));
   g_assert_cmpint (obj->ref_count, ==, 1);
   g_assert_true (weak == obj);

   g_object_unref (obj);
   g_assert_null (weak);
 }

 /* See gobject/tests/threadtests.c for the threaded version */
 static void
 test_weak_ref (void)
 {
   GObject *obj;
   GObject *obj2;
   GObject *tmp;
   GWeakRef weak = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
   GWeakRef weak2 = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
   GWeakRef weak3 = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
   GWeakRef *dynamic_weak = g_new (GWeakRef, 1);

   /* you can initialize to empty like this... */
   g_weak_ref_init (&weak2, NULL);
   g_assert (g_weak_ref_get (&weak2) == NULL);

   /* ... or via an initializer */
   g_weak_ref_init (&weak3, NULL);
   g_assert (g_weak_ref_get (&weak3) == NULL);

   obj = g_object_new (G_TYPE_OBJECT, NULL);
   g_assert_cmpint (obj->ref_count, ==, 1);

   obj2 = g_object_new (G_TYPE_OBJECT, NULL);
   g_assert_cmpint (obj2->ref_count, ==, 1);

   /* you can init with an object (even if uninitialized) */
   g_weak_ref_init (&weak, obj);
   g_weak_ref_init (dynamic_weak, obj);
   /* or set to point at an object, if initialized (maybe to 0) */
   g_weak_ref_set (&weak2, obj);
   g_weak_ref_set (&weak3, obj);
   /* none of this affects its refcount */
   g_assert_cmpint (obj->ref_count, ==, 1);

   /* getting the value takes a ref */
   tmp = g_weak_ref_get (&weak);
   g_assert (tmp == obj);
   g_assert_cmpint (obj->ref_count, ==, 2);
   g_object_unref (tmp);
   g_assert_cmpint (obj->ref_count, ==, 1);

   tmp = g_weak_ref_get (&weak2);
   g_assert (tmp == obj);
   g_assert_cmpint (obj->ref_count, ==, 2);
   g_object_unref (tmp);
   g_assert_cmpint (obj->ref_count, ==, 1);

   tmp = g_weak_ref_get (&weak3);
   g_assert (tmp == obj);
   g_assert_cmpint (obj->ref_count, ==, 2);
   g_object_unref (tmp);
   g_assert_cmpint (obj->ref_count, ==, 1);

   tmp = g_weak_ref_get (dynamic_weak);
   g_assert (tmp == obj);
   g_assert_cmpint (obj->ref_count, ==, 2);
   g_object_unref (tmp);
   g_assert_cmpint (obj->ref_count, ==, 1);

   /* clearing a weak ref stops tracking */
   g_weak_ref_clear (&weak);

   /* setting a weak ref to NULL stops tracking too */
   g_weak_ref_set (&weak2, NULL);
   g_assert (g_weak_ref_get (&weak2) == NULL);
   g_weak_ref_clear (&weak2);

   /* setting a weak ref to a new object stops tracking the old one */
   g_weak_ref_set (dynamic_weak, obj2);
   tmp = g_weak_ref_get (dynamic_weak);
   g_assert (tmp == obj2);
   g_assert_cmpint (obj2->ref_count, ==, 2);
   g_object_unref (tmp);
   g_assert_cmpint (obj2->ref_count, ==, 1);

   g_assert_cmpint (obj->ref_count, ==, 1);

   /* free the object: weak3 is the only one left pointing there */
   g_object_unref (obj);
   g_assert (g_weak_ref_get (&weak3) == NULL);

   /* setting a weak ref to a new object stops tracking the old one */
   g_weak_ref_set (dynamic_weak, obj2);
   tmp = g_weak_ref_get (dynamic_weak);
   g_assert (tmp == obj2);
   g_assert_cmpint (obj2->ref_count, ==, 2);
   g_object_unref (tmp);
   g_assert_cmpint (obj2->ref_count, ==, 1);

   g_weak_ref_clear (&weak3);

   /* clear and free dynamic_weak... */
   g_weak_ref_clear (dynamic_weak);

   /* ... to prove that doing so stops this from being a use-after-free */
   g_object_unref (obj2);
   g_free (dynamic_weak);
 }

 typedef struct
 {
   gboolean should_be_last;
   gint count;
 } Count;

 static void
 toggle_notify (gpointer  data,
                GObject  *obj,
                gboolean  is_last)
 {
   Count *c = data;

   g_assert (is_last == c->should_be_last);

   c->count++;
 }

 static void
 test_toggle_ref (void)
 {
   GObject *obj;
   Count c, c2;

   obj = g_object_new (G_TYPE_OBJECT, NULL);

   g_object_add_toggle_ref (obj, toggle_notify, &c);
   g_object_add_toggle_ref (obj, toggle_notify, &c2);

   c.should_be_last = c2.should_be_last = TRUE;
   c.count = c2.count = 0;

   g_object_unref (obj);

   g_assert_cmpint (c.count, ==, 0);
   g_assert_cmpint (c2.count, ==, 0);

   g_object_ref (obj);

   g_assert_cmpint (c.count, ==, 0);
   g_assert_cmpint (c2.count, ==, 0);

   g_object_remove_toggle_ref (obj, toggle_notify, &c2);

   g_object_unref (obj);

   g_assert_cmpint (c.count, ==, 1);

   c.should_be_last = FALSE;

   g_object_ref (obj);

   g_assert_cmpint (c.count, ==, 2);

   c.should_be_last = TRUE;

   g_object_unref (obj);

   g_assert_cmpint (c.count, ==, 3);

   g_object_remove_toggle_ref (obj, toggle_notify, &c);
 }

 static gboolean destroyed;
 static gint value;

 static void
 data_destroy (gpointer data)
 {
   g_assert_cmpint (GPOINTER_TO_INT (data), ==, value);

   destroyed = TRUE;
 }

 static void
 test_object_qdata (void)
 {
   GObject *obj;
   gpointer v;
   GQuark quark;

   obj = g_object_new (G_TYPE_OBJECT, NULL);

   value = 1;
   destroyed = FALSE;
   g_object_set_data_full (obj, "test", GINT_TO_POINTER (1), data_destroy);
   v = g_object_get_data (obj, "test");
   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 1);
   g_object_set_data_full (obj, "test", GINT_TO_POINTER (2), data_destroy);
   g_assert (destroyed);
   value = 2;
   destroyed = FALSE;
   v = g_object_steal_data (obj, "test");
   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 2);
   g_assert (!destroyed);

   value = 1;
   destroyed = FALSE;
   quark = g_quark_from_string ("test");
   g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (1), data_destroy);
   v = g_object_get_qdata (obj, quark);
   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 1);
   g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (2), data_destroy);
   g_assert (destroyed);
   value = 2;
   destroyed = FALSE;
   v = g_object_steal_qdata (obj, quark);
   g_assert_cmpint (GPOINTER_TO_INT (v), ==, 2);
   g_assert (!destroyed);

   g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (3), data_destroy);
   value = 3;
   destroyed = FALSE;
   g_object_unref (obj);

   g_assert (destroyed);
 }

 typedef struct {
   const gchar *value;
   gint refcount;
 } Value;

 static gpointer
 ref_value (gpointer value, gpointer user_data)
 {
   Value *v = value;
   Value **old_value_p = user_data;

   if (old_value_p)
     *old_value_p = v;

   if (v)
     v->refcount += 1;

   return value;
 }

 static void
 unref_value (gpointer value)
 {
   Value *v = value;

   v->refcount -= 1;
   if (v->refcount == 0)
     g_free (value);
 }

 static
 Value *
 new_value (const gchar *s)
 {
   Value *v;

   v = g_new (Value, 1);
   v->value = s;
   v->refcount = 1;

   return v;
 }

 static void
 test_object_qdata2 (void)
 {
   GObject *obj;
   Value *v, *v1, *v2, *v3, *old_val;
   GDestroyNotify old_destroy;
   gboolean res;

   obj = g_object_new (G_TYPE_OBJECT, NULL);

   v1 = new_value ("bla");

   g_object_set_data_full (obj, "test", v1, unref_value);

   v = g_object_get_data (obj, "test");
   g_assert_cmpstr (v->value, ==, "bla");
   g_assert_cmpint (v->refcount, ==, 1);

   v = g_object_dup_data (obj, "test", ref_value, &old_val);
   g_assert (old_val == v1);
   g_assert_cmpstr (v->value, ==, "bla");
   g_assert_cmpint (v->refcount, ==, 2);
   unref_value (v);

   v = g_object_dup_data (obj, "nono", ref_value, &old_val);
   g_assert (old_val == NULL);
   g_assert (v == NULL);

   v2 = new_value ("not");

   res = g_object_replace_data (obj, "test", v1, v2, unref_value, &old_destroy);
   g_assert (res == TRUE);
   g_assert (old_destroy == unref_value);
   g_assert_cmpstr (v1->value, ==, "bla");
   g_assert_cmpint (v1->refcount, ==, 1);

   v = g_object_get_data (obj, "test");
   g_assert_cmpstr (v->value, ==, "not");
   g_assert_cmpint (v->refcount, ==, 1);

   v3 = new_value ("xyz");
   res = g_object_replace_data (obj, "test", v1, v3, unref_value, &old_destroy);
   g_assert (res == FALSE);
   g_assert_cmpstr (v2->value, ==, "not");
   g_assert_cmpint (v2->refcount, ==, 1);

   unref_value (v1);

   res = g_object_replace_data (obj, "test", NULL, v3, unref_value, &old_destroy);
   g_assert (res == FALSE);
   g_assert_cmpstr (v2->value, ==, "not");
   g_assert_cmpint (v2->refcount, ==, 1);

   res = g_object_replace_data (obj, "test", v2, NULL, unref_value, &old_destroy);
   g_assert (res == TRUE);
   g_assert (old_destroy == unref_value);
   g_assert_cmpstr (v2->value, ==, "not");
   g_assert_cmpint (v2->refcount, ==, 1);

   unref_value (v2);

   v = g_object_get_data (obj, "test");
   g_assert (v == NULL);

   res = g_object_replace_data (obj, "test", NULL, v3, unref_value, &old_destroy);
   g_assert (res == TRUE);

   v = g_object_get_data (obj, "test");
   g_assert (v == v3);

   ref_value (v3, NULL);
   g_assert_cmpint (v3->refcount, ==, 2);
   g_object_unref (obj);
   g_assert_cmpint (v3->refcount, ==, 1);
   unref_value (v3);
 }

 int
 main (int argc, char **argv)
 {
   g_test_init (&argc, &argv, NULL);

   g_test_add_func ("/type/fundamentals", test_fundamentals);
   g_test_add_func ("/type/qdata", test_type_qdata);
   g_test_add_func ("/type/query", test_type_query);
   g_test_add_func ("/type/class-private", test_class_private);
   g_test_add_func ("/object/clear", test_clear);
   g_test_add_func ("/object/clear-function", test_clear_function);
   g_test_add_func ("/object/set", test_set);
   g_test_add_func ("/object/set-function", test_set_function);
   g_test_add_func ("/object/value", test_object_value);
   g_test_add_func ("/object/initially-unowned", test_initially_unowned);
   g_test_add_func ("/object/weak-pointer", test_weak_pointer);
   g_test_add_func ("/object/weak-pointer/clear", test_weak_pointer_clear);
   g_test_add_func ("/object/weak-pointer/clear-function", test_weak_pointer_clear_function);
   g_test_add_func ("/object/weak-pointer/set", test_weak_pointer_set);
   g_test_add_func ("/object/weak-pointer/set-function", test_weak_pointer_set_function);
   g_test_add_func ("/object/weak-ref", test_weak_ref);
   g_test_add_func ("/object/toggle-ref", test_toggle_ref);
   g_test_add_func ("/object/qdata", test_object_qdata);
   g_test_add_func ("/object/qdata2", test_object_qdata2);

   return g_test_run ();
 }
	#include <glib-object.h>

	static void
	test_fundamentals (void)
	{
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_NONE));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_INTERFACE));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_CHAR));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_UCHAR));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_BOOLEAN));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_INT));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_UINT));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_LONG));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_ULONG));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_INT64));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_UINT64));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_ENUM));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_FLAGS));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_FLOAT));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_DOUBLE));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_STRING));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_POINTER));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_BOXED));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_PARAM));
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_OBJECT));
	g_assert (G_TYPE_OBJECT == g_object_get_type ());
	g_assert (G_TYPE_IS_FUNDAMENTAL (G_TYPE_VARIANT));
	g_assert (G_TYPE_IS_DERIVED (G_TYPE_INITIALLY_UNOWNED));

	g_assert (g_type_fundamental_next () == G_TYPE_MAKE_FUNDAMENTAL (G_TYPE_RESERVED_USER_FIRST));
	}

	static void
	test_type_qdata (void)
	{
	gchar *data;

	g_type_set_qdata (G_TYPE_ENUM, g_quark_from_string ("bla"), "bla");
	data = g_type_get_qdata (G_TYPE_ENUM, g_quark_from_string ("bla"));
	g_assert_cmpstr (data, ==, "bla");
	}

	static void
	test_type_query (void)
	{
	GTypeQuery query;

	g_type_query (G_TYPE_ENUM, &query);
	g_assert_cmpint (query.type, ==, G_TYPE_ENUM);
	g_assert_cmpstr (query.type_name, ==, "GEnum");
	g_assert_cmpint (query.class_size, ==, sizeof (GEnumClass));
	g_assert_cmpint (query.instance_size, ==, 0);
	}

	typedef struct _MyObject MyObject;
	typedef struct _MyObjectClass MyObjectClass;
	typedef struct _MyObjectClassPrivate MyObjectClassPrivate;

	struct _MyObject
	{
	GObject parent_instance;

	gint count;
	};

	struct _MyObjectClass
	{
	GObjectClass parent_class;
	};

	struct _MyObjectClassPrivate
	{
	gint secret_class_count;
	};

	static GType my_object_get_type (void);
	G_DEFINE_TYPE_WITH_CODE (MyObject, my_object, G_TYPE_OBJECT,
	g_type_add_class_private (g_define_type_id, sizeof (MyObjectClassPrivate)) );

	static void
	my_object_init (MyObject *obj)
	{
	obj->count = 42;
	}

	static void
	my_object_class_init (MyObjectClass *klass)
	{
	}

	static void
	test_class_private (void)
	{
	GObject *obj;
	MyObjectClass *class;
	MyObjectClassPrivate *priv;

	obj = g_object_new (my_object_get_type (), NULL);

	class = g_type_class_ref (my_object_get_type ());
	priv = G_TYPE_CLASS_GET_PRIVATE (class, my_object_get_type (), MyObjectClassPrivate);
	priv->secret_class_count = 13;
	g_type_class_unref (class);

	g_object_unref (obj);

	g_assert_cmpint (g_type_qname (my_object_get_type ()), ==, g_quark_from_string ("MyObject"));
	}

	static void
	test_clear (void)
	{
	GObject *o = NULL;
	GObject *tmp;

	g_clear_object (&o);
	g_assert (o == NULL);

	tmp = g_object_new (G_TYPE_OBJECT, NULL);
	g_assert_cmpint (tmp->ref_count, ==, 1);
	o = g_object_ref (tmp);
	g_assert (o != NULL);

	g_assert_cmpint (tmp->ref_count, ==, 2);
	g_clear_object (&o);
	g_assert_cmpint (tmp->ref_count, ==, 1);
	g_assert (o == NULL);

	g_object_unref (tmp);
	}

	static void
	test_clear_function (void)
	{
	volatile GObject *o = NULL;
	GObject *tmp;

	(g_clear_object) (&o);
	g_assert (o == NULL);

	tmp = g_object_new (G_TYPE_OBJECT, NULL);
	g_assert_cmpint (tmp->ref_count, ==, 1);
	o = g_object_ref (tmp);
	g_assert (o != NULL);

	g_assert_cmpint (tmp->ref_count, ==, 2);
	(g_clear_object) (&o);
	g_assert_cmpint (tmp->ref_count, ==, 1);
	g_assert (o == NULL);

	g_object_unref (tmp);
	}

	static void
	test_set (void)
	{
	GObject *o = NULL;
	GObject *tmp;
	gpointer tmp_weak = NULL;

	g_assert (!g_set_object (&o, NULL));
	g_assert (o == NULL);

	tmp = g_object_new (G_TYPE_OBJECT, NULL);
	tmp_weak = tmp;
	g_object_add_weak_pointer (tmp, &tmp_weak);
	g_assert_cmpint (tmp->ref_count, ==, 1);

	g_assert (g_set_object (&o, tmp));
	g_assert (o == tmp);
	g_assert_cmpint (tmp->ref_count, ==, 2);

	g_object_unref (tmp);
	g_assert_cmpint (tmp->ref_count, ==, 1);

	/* Setting it again shouldn’t cause finalisation. */
	g_assert (!g_set_object (&o, tmp));
	g_assert (o == tmp);
	g_assert_cmpint (tmp->ref_count, ==, 1);
	g_assert_nonnull (tmp_weak);

	g_assert (g_set_object (&o, NULL));
	g_assert (o == NULL);
	g_assert_null (tmp_weak);
	}

	static void
	test_set_function (void)
	{
	GObject *o = NULL;
	GObject *tmp;
	gpointer tmp_weak = NULL;

	g_assert (!(g_set_object) (&o, NULL));
	g_assert (o == NULL);

	tmp = g_object_new (G_TYPE_OBJECT, NULL);
	tmp_weak = tmp;
	g_object_add_weak_pointer (tmp, &tmp_weak);
	g_assert_cmpint (tmp->ref_count, ==, 1);

	g_assert ((g_set_object) (&o, tmp));
	g_assert (o == tmp);
	g_assert_cmpint (tmp->ref_count, ==, 2);

	g_object_unref (tmp);
	g_assert_cmpint (tmp->ref_count, ==, 1);

	/* Setting it again shouldn’t cause finalisation. */
	g_assert (!(g_set_object) (&o, tmp));
	g_assert (o == tmp);
	g_assert_cmpint (tmp->ref_count, ==, 1);
	g_assert_nonnull (tmp_weak);

	g_assert ((g_set_object) (&o, NULL));
	g_assert (o == NULL);
	g_assert_null (tmp_weak);
	}

	static void
	toggle_cb (gpointer data, GObject *obj, gboolean is_last)
	{
	gboolean *b = data;

	*b = TRUE;
	}

	static void
	test_object_value (void)
	{
	GObject *v;
	GObject *v2;
	GValue value = G_VALUE_INIT;
	gboolean toggled = FALSE;

	g_value_init (&value, G_TYPE_OBJECT);

	v = g_object_new (G_TYPE_OBJECT, NULL);
	g_object_add_toggle_ref (v, toggle_cb, &toggled);

	g_value_take_object (&value, v);

	v2 = g_value_get_object (&value);
	g_assert (v2 == v);

	v2 = g_value_dup_object (&value);
	g_assert (v2 == v); /* objects use ref/unref for copy/free */
	g_object_unref (v2);

	g_assert (!toggled);
	g_value_unset (&value);
	g_assert (toggled);

	/* test the deprecated variant too */
	g_value_init (&value, G_TYPE_OBJECT);
	/* get a new reference */
	g_object_ref (v);

	G_GNUC_BEGIN_IGNORE_DEPRECATIONS
	g_value_set_object_take_ownership (&value, v);
	G_GNUC_END_IGNORE_DEPRECATIONS

	toggled = FALSE;
	g_value_unset (&value);
	g_assert (toggled);

	g_object_remove_toggle_ref (v, toggle_cb, &toggled);
	}

	static void
	test_initially_unowned (void)
	{
	GObject *obj;

	obj = g_object_new (G_TYPE_INITIALLY_UNOWNED, NULL);
	g_assert (g_object_is_floating (obj));
	g_assert_cmpint (obj->ref_count, ==, 1);

	g_object_ref_sink (obj);
	g_assert (!g_object_is_floating (obj));
	g_assert_cmpint (obj->ref_count, ==, 1);

	g_object_ref_sink (obj);
	g_assert (!g_object_is_floating (obj));
	g_assert_cmpint (obj->ref_count, ==, 2);

	g_object_unref (obj);
	g_assert_cmpint (obj->ref_count, ==, 1);

	g_object_force_floating (obj);
	g_assert (g_object_is_floating (obj));
	g_assert_cmpint (obj->ref_count, ==, 1);

	g_object_ref_sink (obj);
	g_object_unref (obj);
	}

	static void
	test_weak_pointer (void)
	{
	GObject *obj;
	gpointer weak;
	gpointer weak2;

	weak = weak2 = obj = g_object_new (G_TYPE_OBJECT, NULL);
	g_assert_cmpint (obj->ref_count, ==, 1);

	g_object_add_weak_pointer (obj, &weak);
	g_object_add_weak_pointer (obj, &weak2);
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert (weak == obj);
	g_assert (weak2 == obj);

	g_object_remove_weak_pointer (obj, &weak2);
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert (weak == obj);
	g_assert (weak2 == obj);

	g_object_unref (obj);
	g_assert (weak == NULL);
	g_assert (weak2 == obj);
	}

	static void
	test_weak_pointer_clear (void)
	{
	GObject *obj;
	gpointer weak = NULL;

	g_clear_weak_pointer (&weak);
	g_assert_null (weak);

	weak = obj = g_object_new (G_TYPE_OBJECT, NULL);
	g_assert_cmpint (obj->ref_count, ==, 1);

	g_object_add_weak_pointer (obj, &weak);
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_true (weak == obj);

	g_clear_weak_pointer (&weak);
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_null (weak);

	g_object_unref (obj);
	}

	static void
	test_weak_pointer_clear_function (void)
	{
	GObject *obj;
	gpointer weak = NULL;

	(g_clear_weak_pointer) (&weak);
	g_assert_null (weak);

	weak = obj = g_object_new (G_TYPE_OBJECT, NULL);
	g_assert_cmpint (obj->ref_count, ==, 1);

	g_object_add_weak_pointer (obj, &weak);
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_true (weak == obj);

	(g_clear_weak_pointer) (&weak);
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_null (weak);

	g_object_unref (obj);
	}

	static void
	test_weak_pointer_set (void)
	{
	GObject *obj;
	gpointer weak = NULL;

	g_assert_false (g_set_weak_pointer (&weak, NULL));
	g_assert_null (weak);

	obj = g_object_new (G_TYPE_OBJECT, NULL);
	g_assert_cmpint (obj->ref_count, ==, 1);

	g_assert_true (g_set_weak_pointer (&weak, obj));
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_true (weak == obj);

	g_assert_true (g_set_weak_pointer (&weak, NULL));
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_null (weak);

	g_assert_true (g_set_weak_pointer (&weak, obj));
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_true (weak == obj);

	g_object_unref (obj);
	g_assert_null (weak);
	}

	static void
	test_weak_pointer_set_function (void)
	{
	GObject *obj;
	gpointer weak = NULL;

	g_assert_false ((g_set_weak_pointer) (&weak, NULL));
	g_assert_null (weak);

	obj = g_object_new (G_TYPE_OBJECT, NULL);
	g_assert_cmpint (obj->ref_count, ==, 1);

	g_assert_true ((g_set_weak_pointer) (&weak, obj));
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_true (weak == obj);

	g_assert_true ((g_set_weak_pointer) (&weak, NULL));
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_null (weak);

	g_assert_true ((g_set_weak_pointer) (&weak, obj));
	g_assert_cmpint (obj->ref_count, ==, 1);
	g_assert_true (weak == obj);

	g_object_unref (obj);
	g_assert_null (weak);
	}

	/* See gobject/tests/threadtests.c for the threaded version */
	static void
	test_weak_ref (void)
	{
	GObject *obj;
	GObject *obj2;
	GObject *tmp;
	GWeakRef weak = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
	GWeakRef weak2 = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
	GWeakRef weak3 = { { GUINT_TO_POINTER (0xDEADBEEFU) } };
	GWeakRef *dynamic_weak = g_new (GWeakRef, 1);

	/* you can initialize to empty like this... */
	g_weak_ref_init (&weak2, NULL);
	g_assert (g_weak_ref_get (&weak2) == NULL);

	/* ... or via an initializer */
	g_weak_ref_init (&weak3, NULL);
	g_assert (g_weak_ref_get (&weak3) == NULL);

	obj = g_object_new (G_TYPE_OBJECT, NULL);
	g_assert_cmpint (obj->ref_count, ==, 1);

	obj2 = g_object_new (G_TYPE_OBJECT, NULL);
	g_assert_cmpint (obj2->ref_count, ==, 1);

	/* you can init with an object (even if uninitialized) */
	g_weak_ref_init (&weak, obj);
	g_weak_ref_init (dynamic_weak, obj);
	/* or set to point at an object, if initialized (maybe to 0) */
	g_weak_ref_set (&weak2, obj);
	g_weak_ref_set (&weak3, obj);
	/* none of this affects its refcount */
	g_assert_cmpint (obj->ref_count, ==, 1);

	/* getting the value takes a ref */
	tmp = g_weak_ref_get (&weak);
	g_assert (tmp == obj);
	g_assert_cmpint (obj->ref_count, ==, 2);
	g_object_unref (tmp);
	g_assert_cmpint (obj->ref_count, ==, 1);

	tmp = g_weak_ref_get (&weak2);
	g_assert (tmp == obj);
	g_assert_cmpint (obj->ref_count, ==, 2);
	g_object_unref (tmp);
	g_assert_cmpint (obj->ref_count, ==, 1);

	tmp = g_weak_ref_get (&weak3);
	g_assert (tmp == obj);
	g_assert_cmpint (obj->ref_count, ==, 2);
	g_object_unref (tmp);
	g_assert_cmpint (obj->ref_count, ==, 1);

	tmp = g_weak_ref_get (dynamic_weak);
	g_assert (tmp == obj);
	g_assert_cmpint (obj->ref_count, ==, 2);
	g_object_unref (tmp);
	g_assert_cmpint (obj->ref_count, ==, 1);

	/* clearing a weak ref stops tracking */
	g_weak_ref_clear (&weak);

	/* setting a weak ref to NULL stops tracking too */
	g_weak_ref_set (&weak2, NULL);
	g_assert (g_weak_ref_get (&weak2) == NULL);
	g_weak_ref_clear (&weak2);

	/* setting a weak ref to a new object stops tracking the old one */
	g_weak_ref_set (dynamic_weak, obj2);
	tmp = g_weak_ref_get (dynamic_weak);
	g_assert (tmp == obj2);
	g_assert_cmpint (obj2->ref_count, ==, 2);
	g_object_unref (tmp);
	g_assert_cmpint (obj2->ref_count, ==, 1);

	g_assert_cmpint (obj->ref_count, ==, 1);

	/* free the object: weak3 is the only one left pointing there */
	g_object_unref (obj);
	g_assert (g_weak_ref_get (&weak3) == NULL);

	/* setting a weak ref to a new object stops tracking the old one */
	g_weak_ref_set (dynamic_weak, obj2);
	tmp = g_weak_ref_get (dynamic_weak);
	g_assert (tmp == obj2);
	g_assert_cmpint (obj2->ref_count, ==, 2);
	g_object_unref (tmp);
	g_assert_cmpint (obj2->ref_count, ==, 1);

	g_weak_ref_clear (&weak3);

	/* clear and free dynamic_weak... */
	g_weak_ref_clear (dynamic_weak);

	/* ... to prove that doing so stops this from being a use-after-free */
	g_object_unref (obj2);
	g_free (dynamic_weak);
	}

	typedef struct
	{
	gboolean should_be_last;
	gint count;
	} Count;

	static void
	toggle_notify (gpointer data,
	GObject *obj,
	gboolean is_last)
	{
	Count *c = data;

	g_assert (is_last == c->should_be_last);

	c->count++;
	}

	static void
	test_toggle_ref (void)
	{
	GObject *obj;
	Count c, c2;

	obj = g_object_new (G_TYPE_OBJECT, NULL);

	g_object_add_toggle_ref (obj, toggle_notify, &c);
	g_object_add_toggle_ref (obj, toggle_notify, &c2);

	c.should_be_last = c2.should_be_last = TRUE;
	c.count = c2.count = 0;

	g_object_unref (obj);

	g_assert_cmpint (c.count, ==, 0);
	g_assert_cmpint (c2.count, ==, 0);

	g_object_ref (obj);

	g_assert_cmpint (c.count, ==, 0);
	g_assert_cmpint (c2.count, ==, 0);

	g_object_remove_toggle_ref (obj, toggle_notify, &c2);

	g_object_unref (obj);

	g_assert_cmpint (c.count, ==, 1);

	c.should_be_last = FALSE;

	g_object_ref (obj);

	g_assert_cmpint (c.count, ==, 2);

	c.should_be_last = TRUE;

	g_object_unref (obj);

	g_assert_cmpint (c.count, ==, 3);

	g_object_remove_toggle_ref (obj, toggle_notify, &c);
	}

	static gboolean destroyed;
	static gint value;

	static void
	data_destroy (gpointer data)
	{
	g_assert_cmpint (GPOINTER_TO_INT (data), ==, value);

	destroyed = TRUE;
	}

	static void
	test_object_qdata (void)
	{
	GObject *obj;
	gpointer v;
	GQuark quark;

	obj = g_object_new (G_TYPE_OBJECT, NULL);

	value = 1;
	destroyed = FALSE;
	g_object_set_data_full (obj, "test", GINT_TO_POINTER (1), data_destroy);
	v = g_object_get_data (obj, "test");
	g_assert_cmpint (GPOINTER_TO_INT (v), ==, 1);
	g_object_set_data_full (obj, "test", GINT_TO_POINTER (2), data_destroy);
	g_assert (destroyed);
	value = 2;
	destroyed = FALSE;
	v = g_object_steal_data (obj, "test");
	g_assert_cmpint (GPOINTER_TO_INT (v), ==, 2);
	g_assert (!destroyed);

	value = 1;
	destroyed = FALSE;
	quark = g_quark_from_string ("test");
	g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (1), data_destroy);
	v = g_object_get_qdata (obj, quark);
	g_assert_cmpint (GPOINTER_TO_INT (v), ==, 1);
	g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (2), data_destroy);
	g_assert (destroyed);
	value = 2;
	destroyed = FALSE;
	v = g_object_steal_qdata (obj, quark);
	g_assert_cmpint (GPOINTER_TO_INT (v), ==, 2);
	g_assert (!destroyed);

	g_object_set_qdata_full (obj, quark, GINT_TO_POINTER (3), data_destroy);
	value = 3;
	destroyed = FALSE;
	g_object_unref (obj);

	g_assert (destroyed);
	}

	typedef struct {
	const gchar *value;
	gint refcount;
	} Value;

	static gpointer
	ref_value (gpointer value, gpointer user_data)
	{
	Value *v = value;
	Value **old_value_p = user_data;

	if (old_value_p)
	*old_value_p = v;

	if (v)
	v->refcount += 1;

	return value;
	}

	static void
	unref_value (gpointer value)
	{
	Value *v = value;

	v->refcount -= 1;
	if (v->refcount == 0)
	g_free (value);
	}

	static
	Value *
	new_value (const gchar *s)
	{
	Value *v;

	v = g_new (Value, 1);
	v->value = s;
	v->refcount = 1;

	return v;
	}

	static void
	test_object_qdata2 (void)
	{
	GObject *obj;
	Value v, v1, v2, v3, *old_val;
	GDestroyNotify old_destroy;
	gboolean res;

	obj = g_object_new (G_TYPE_OBJECT, NULL);

	v1 = new_value ("bla");

	g_object_set_data_full (obj, "test", v1, unref_value);

	v = g_object_get_data (obj, "test");
	g_assert_cmpstr (v->value, ==, "bla");
	g_assert_cmpint (v->refcount, ==, 1);

	v = g_object_dup_data (obj, "test", ref_value, &old_val);
	g_assert (old_val == v1);
	g_assert_cmpstr (v->value, ==, "bla");
	g_assert_cmpint (v->refcount, ==, 2);
	unref_value (v);

	v = g_object_dup_data (obj, "nono", ref_value, &old_val);
	g_assert (old_val == NULL);
	g_assert (v == NULL);

	v2 = new_value ("not");

	res = g_object_replace_data (obj, "test", v1, v2, unref_value, &old_destroy);
	g_assert (res == TRUE);
	g_assert (old_destroy == unref_value);
	g_assert_cmpstr (v1->value, ==, "bla");
	g_assert_cmpint (v1->refcount, ==, 1);

	v = g_object_get_data (obj, "test");
	g_assert_cmpstr (v->value, ==, "not");
	g_assert_cmpint (v->refcount, ==, 1);

	v3 = new_value ("xyz");
	res = g_object_replace_data (obj, "test", v1, v3, unref_value, &old_destroy);
	g_assert (res == FALSE);
	g_assert_cmpstr (v2->value, ==, "not");
	g_assert_cmpint (v2->refcount, ==, 1);

	unref_value (v1);

	res = g_object_replace_data (obj, "test", NULL, v3, unref_value, &old_destroy);
	g_assert (res == FALSE);
	g_assert_cmpstr (v2->value, ==, "not");
	g_assert_cmpint (v2->refcount, ==, 1);

	res = g_object_replace_data (obj, "test", v2, NULL, unref_value, &old_destroy);
	g_assert (res == TRUE);
	g_assert (old_destroy == unref_value);
	g_assert_cmpstr (v2->value, ==, "not");
	g_assert_cmpint (v2->refcount, ==, 1);

	unref_value (v2);

	v = g_object_get_data (obj, "test");
	g_assert (v == NULL);

	res = g_object_replace_data (obj, "test", NULL, v3, unref_value, &old_destroy);
	g_assert (res == TRUE);

	v = g_object_get_data (obj, "test");
	g_assert (v == v3);

	ref_value (v3, NULL);
	g_assert_cmpint (v3->refcount, ==, 2);
	g_object_unref (obj);
	g_assert_cmpint (v3->refcount, ==, 1);
	unref_value (v3);
	}

	int
	main (int argc, char **argv)
	{
	g_test_init (&argc, &argv, NULL);

	g_test_add_func ("/type/fundamentals", test_fundamentals);
	g_test_add_func ("/type/qdata", test_type_qdata);
	g_test_add_func ("/type/query", test_type_query);
	g_test_add_func ("/type/class-private", test_class_private);
	g_test_add_func ("/object/clear", test_clear);
	g_test_add_func ("/object/clear-function", test_clear_function);
	g_test_add_func ("/object/set", test_set);
	g_test_add_func ("/object/set-function", test_set_function);
	g_test_add_func ("/object/value", test_object_value);
	g_test_add_func ("/object/initially-unowned", test_initially_unowned);
	g_test_add_func ("/object/weak-pointer", test_weak_pointer);
	g_test_add_func ("/object/weak-pointer/clear", test_weak_pointer_clear);
	g_test_add_func ("/object/weak-pointer/clear-function", test_weak_pointer_clear_function);
	g_test_add_func ("/object/weak-pointer/set", test_weak_pointer_set);
	g_test_add_func ("/object/weak-pointer/set-function", test_weak_pointer_set_function);
	g_test_add_func ("/object/weak-ref", test_weak_ref);
	g_test_add_func ("/object/toggle-ref", test_toggle_ref);
	g_test_add_func ("/object/qdata", test_object_qdata);
	g_test_add_func ("/object/qdata2", test_object_qdata2);

	return g_test_run ();
	}