Merge branch 'master' into next

Conflicts:
	telepathy-glib/Makefile.am
	telepathy-glib/account.c
	telepathy-glib/channel-contacts.c
	telepathy-glib/channel.c

18 files changed, 894 insertions, 618 deletions

diff --git a/docs/reference/telepathy-glib-docs.sgml b/docs/reference/telepathy-glib-docs.sgml
index 0dbed5b6c..a472617cb 100644
--- a/docs/reference/telepathy-glib-docs.sgml
+++ b/docs/reference/telepathy-glib-docs.sgml
@@ -18,6 +18,8 @@
     <xi:include href="xml/proxy.xml"/>
     <xi:include href="xml/dbus.xml"/>
     <xi:include href="xml/asv.xml"/>
+    <xi:include href="xml/variant-util.xml"/>
+    <xi:include href="xml/vardict.xml"/>
     <xi:include href="xml/proxy-subclass.xml"/>
   </chapter>
   <chapter id="ch-protocol">
diff --git a/docs/reference/telepathy-glib-sections.txt b/docs/reference/telepathy-glib-sections.txt
index 31c4cb120..fb1367b2e 100644
--- a/docs/reference/telepathy-glib-sections.txt
+++ b/docs/reference/telepathy-glib-sections.txt
@@ -1875,6 +1875,28 @@ tp_asv_dump
 </SECTION>
 
 <SECTION>
+<FILE>variant-util</FILE>
+<TITLE>variant-util</TITLE>
+<INCLUDE>telepathy-glib/telepathy-glib.h</INCLUDE>
+tp_variant_type_classify
+tp_variant_convert
+</SECTION>
+
+<SECTION>
+<FILE>vardict</FILE>
+<TITLE>vardict</TITLE>
+<INCLUDE>telepathy-glib/telepathy-glib.h</INCLUDE>
+tp_vardict_get_boolean
+tp_vardict_get_double
+tp_vardict_get_int32
+tp_vardict_get_int64
+tp_vardict_get_object_path
+tp_vardict_get_string
+tp_vardict_get_uint32
+tp_vardict_get_uint64
+</SECTION>
+
+<SECTION>
 <FILE>dbus</FILE>
 <TITLE>dbus</TITLE>
 <INCLUDE>telepathy-glib/telepathy-glib.h</INCLUDE>
diff --git a/telepathy-glib/Makefile.am b/telepathy-glib/Makefile.am
index 00e7bebc5..031c73acb 100644
--- a/telepathy-glib/Makefile.am
+++ b/telepathy-glib/Makefile.am
@@ -131,6 +131,7 @@ tpginclude_HEADERS = \
     tls-certificate.h \
     tls-certificate-rejection.h \
     util.h \
+    variant-util.h \
     $(NULL)
 
 tpgdbusinclude_HEADERS = \
@@ -336,7 +337,9 @@ libtelepathy_glib_main_internal_la_SOURCES = \
     tls-certificate-rejection.c \
     tls-certificate-rejection-internal.h \
     util.c \
-    util-internal.h
+    util-internal.h \
+    variant-util.c \
+    variant-util-internal.h
 
 libtelepathy_glib_reentrants_la_SOURCES = \
     reentrants.c \
diff --git a/telepathy-glib/account-request.c b/telepathy-glib/account-request.c
index 431c6a713..d0f176f4d 100644
--- a/telepathy-glib/account-request.c
+++ b/telepathy-glib/account-request.c
@@ -32,6 +32,7 @@
 #include "telepathy-glib/dbus-internal.h"
 #include "telepathy-glib/debug-internal.h"
 #include "telepathy-glib/util-internal.h"
+#include "telepathy-glib/variant-util-internal.h"
 
 /**
  * SECTION:account-request
diff --git a/telepathy-glib/account.c b/telepathy-glib/account.c
index 55bcdb000..1bc8f3645 100644
--- a/telepathy-glib/account.c
+++ b/telepathy-glib/account.c
@@ -42,6 +42,7 @@
 #include "telepathy-glib/proxy-internal.h"
 #include "telepathy-glib/client-factory-internal.h"
 #include <telepathy-glib/util-internal.h>
+#include "telepathy-glib/variant-util-internal.h"
 
 /**
  * SECTION:account
diff --git a/telepathy-glib/base-connection.c b/telepathy-glib/base-connection.c
index 27a33e450..7bc088d01 100644
--- a/telepathy-glib/base-connection.c
+++ b/telepathy-glib/base-connection.c
@@ -247,6 +247,7 @@
 
 #define DEBUG_FLAG TP_DEBUG_CONNECTION
 #include "telepathy-glib/debug-internal.h"
+#include "telepathy-glib/variant-util-internal.h"
 
 static void conn_iface_init (gpointer, gpointer);
 static void requests_iface_init (gpointer, gpointer);
diff --git a/telepathy-glib/capabilities.c b/telepathy-glib/capabilities.c
index 633617da4..ae1d34f9f 100644
--- a/telepathy-glib/capabilities.c
+++ b/telepathy-glib/capabilities.c
@@ -31,6 +31,7 @@
 
 #define DEBUG_FLAG TP_DEBUG_CONNECTION
 #include "telepathy-glib/debug-internal.h"
+#include "telepathy-glib/variant-util-internal.h"
 
 /**
  * SECTION:capabilities
diff --git a/telepathy-glib/channel.c b/telepathy-glib/channel.c
index d4e609712..e84c20485 100644
--- a/telepathy-glib/channel.c
+++ b/telepathy-glib/channel.c
@@ -38,6 +38,7 @@
 #include "telepathy-glib/debug-internal.h"
 #include "telepathy-glib/proxy-internal.h"
 #include "telepathy-glib/client-factory-internal.h"
+#include "telepathy-glib/variant-util-internal.h"
 
 /**
  * SECTION:channel
diff --git a/telepathy-glib/connection.c b/telepathy-glib/connection.c
index f41587085..068eedd18 100644
--- a/telepathy-glib/connection.c
+++ b/telepathy-glib/connection.c
@@ -50,6 +50,7 @@
 #include "telepathy-glib/client-factory-internal.h"
 #include "telepathy-glib/contact-internal.h"
 #include "telepathy-glib/util-internal.h"
+#include "telepathy-glib/variant-util-internal.h"
 
 /**
  * SECTION:connection
diff --git a/telepathy-glib/dbus-internal.h b/telepathy-glib/dbus-internal.h
index 0d68a44be..728e6cd96 100644
--- a/telepathy-glib/dbus-internal.h
+++ b/telepathy-glib/dbus-internal.h
@@ -34,14 +34,6 @@ void _tp_register_dbus_glib_marshallers (void);
 
 gboolean _tp_dbus_daemon_is_the_shared_one (TpDBusDaemon *self);
 
-GVariant *_tp_asv_to_vardict (const GHashTable *asv);
-
-GVariant * _tp_boxed_to_variant (GType gtype,
-    const gchar *variant_type,
-    gpointer boxed);
-
-GHashTable * _tp_asv_from_vardict (GVariant *variant);
-
 G_END_DECLS
 
 #endif /* __TP_INTERNAL_DBUS_GLIB_H__ */
diff --git a/telepathy-glib/dbus.c b/telepathy-glib/dbus.c
index 553ea3e06..0a5c5c069 100644
--- a/telepathy-glib/dbus.c
+++ b/telepathy-glib/dbus.c
@@ -1854,61 +1854,3 @@ tp_asv_dump (GHashTable *asv)
 
   g_debug ("}");
 }
-
-/*
- * _tp_asv_to_vardict:
- *
- * Returns: (transfer full): a #GVariant of type %G_VARIANT_TYPE_VARDICT
- */
-GVariant *
-_tp_asv_to_vardict (const GHashTable *asv)
-{
-  return _tp_boxed_to_variant (TP_HASH_TYPE_STRING_VARIANT_MAP, "a{sv}", (gpointer) asv);
-}
-
-GVariant *
-_tp_boxed_to_variant (GType gtype,
-    const gchar *variant_type,
-    gpointer boxed)
-{
-  GValue v = G_VALUE_INIT;
-  GVariant *ret;
-
-  g_return_val_if_fail (boxed != NULL, NULL);
-
-  g_value_init (&v, gtype);
-  g_value_set_boxed (&v, boxed);
-
-  ret = dbus_g_value_build_g_variant (&v);
-  g_return_val_if_fail (!tp_strdiff (g_variant_get_type_string (ret), variant_type), NULL);
-
-  g_value_unset (&v);
-
-  return g_variant_ref_sink (ret);
-}
-
-/*
- * _tp_asv_from_vardict:
- * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
- *
- * Returns: (transfer full): a newly created #GHashTable of
- * type #TP_HASH_TYPE_STRING_VARIANT_MAP
- */
-GHashTable *
-_tp_asv_from_vardict (GVariant *variant)
-{
-  GValue v = G_VALUE_INIT;
-  GHashTable *result;
-
-  g_return_val_if_fail (variant != NULL, NULL);
-  g_return_val_if_fail (g_variant_is_of_type (variant, G_VARIANT_TYPE_VARDICT),
-      NULL);
-
-  dbus_g_value_parse_g_variant (variant, &v);
-  g_assert (G_VALUE_HOLDS (&v, TP_HASH_TYPE_STRING_VARIANT_MAP));
-
-  result = g_value_dup_boxed (&v);
-
-  g_value_unset (&v);
-  return result;
-}
diff --git a/telepathy-glib/telepathy-glib.h b/telepathy-glib/telepathy-glib.h
index e35d94c4f..bdd848a3e 100644
--- a/telepathy-glib/telepathy-glib.h
+++ b/telepathy-glib/telepathy-glib.h
@@ -111,6 +111,7 @@
 #include <telepathy-glib/stream-tube-connection.h>
 #include <telepathy-glib/text-channel.h>
 #include <telepathy-glib/tls-certificate.h>
+#include <telepathy-glib/variant-util.h>
 
 #undef _TP_GLIB_H_INSIDE
 
diff --git a/telepathy-glib/tls-certificate.c b/telepathy-glib/tls-certificate.c
index 0dd5aab52..c7d6721f2 100644
--- a/telepathy-glib/tls-certificate.c
+++ b/telepathy-glib/tls-certificate.c
@@ -36,6 +36,7 @@
 #include <telepathy-glib/util.h>
 #include <telepathy-glib/util-internal.h>
 #include <telepathy-glib/tls-certificate-rejection-internal.h>
+#include "telepathy-glib/variant-util-internal.h"
 
 #define DEBUG_FLAG TP_DEBUG_TLS
 #include "debug-internal.h"
diff --git a/telepathy-glib/variant-util-internal.h b/telepathy-glib/variant-util-internal.h
new file mode 100644
index 000000000..16257e55e
--- /dev/null
+++ b/telepathy-glib/variant-util-internal.h
@@ -0,0 +1,36 @@
+/*<private_header>*/
+/*
+ * variant-util-internal.h - Headers for non-public GVariant utility functions
+ *
+ * Copyright (C) 2012 Collabora Ltd. <http://www.collabora.co.uk/>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef __TP_VARIANT_UTIL_INTERNAL_H__
+#define __TP_VARIANT_UTIL_INTERNAL_H__
+
+#include <glib.h>
+#include <gio/gio.h>
+
+GVariant *_tp_asv_to_vardict (const GHashTable *asv);
+
+GVariant * _tp_boxed_to_variant (GType gtype,
+    const gchar *variant_type,
+    gpointer boxed);
+
+GHashTable * _tp_asv_from_vardict (GVariant *variant);
+
+#endif /* __TP_VARIANT_UTIL_INTERNAL_H__ */
diff --git a/telepathy-glib/variant-util.c b/telepathy-glib/variant-util.c
new file mode 100644
index 000000000..c9ae69992
--- /dev/null
+++ b/telepathy-glib/variant-util.c
@@ -0,0 +1,611 @@
+/*
+ * variant-util.c - Source for GVariant utilities
+ *
+ * Copyright (C) 2012 Collabora Ltd. <http://www.collabora.co.uk/>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+/**
+ * SECTION:variant-util
+ * @title: GVariant utilities
+ * @short_description: some GVariant utility functions
+ *
+ * GVariant utility functions used in telepathy-glib.
+ */
+
+/**
+ * SECTION:vardict
+ * @title: Manipulating a{sv} mappings
+ * @short_description: Functions to manipulate mappings from string to
+ *  variant, as represented in GVariant by a %G_VARIANT_TYPE_VARDICT
+ *
+ * These functions provide convenient access to the values in such
+ * a mapping.
+ *
+ * Since: 0.UNRELEASED
+ */
+
+#include "config.h"
+
+#include <telepathy-glib/variant-util.h>
+#include <telepathy-glib/variant-util-internal.h>
+
+#include <telepathy-glib/gtypes.h>
+#include <telepathy-glib/util.h>
+
+#define DEBUG_FLAG TP_DEBUG_MISC
+#include "debug-internal.h"
+
+/*
+ * _tp_asv_to_vardict:
+ *
+ * Returns: (transfer full): a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ */
+GVariant *
+_tp_asv_to_vardict (const GHashTable *asv)
+{
+  return _tp_boxed_to_variant (TP_HASH_TYPE_STRING_VARIANT_MAP, "a{sv}", (gpointer) asv);
+}
+
+GVariant *
+_tp_boxed_to_variant (GType gtype,
+    const gchar *variant_type,
+    gpointer boxed)
+{
+  GValue v = G_VALUE_INIT;
+  GVariant *ret;
+
+  g_return_val_if_fail (boxed != NULL, NULL);
+
+  g_value_init (&v, gtype);
+  g_value_set_boxed (&v, boxed);
+
+  ret = dbus_g_value_build_g_variant (&v);
+  g_return_val_if_fail (!tp_strdiff (g_variant_get_type_string (ret), variant_type), NULL);
+
+  g_value_unset (&v);
+
+  return g_variant_ref_sink (ret);
+}
+
+/*
+ * _tp_asv_from_vardict:
+ * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ *
+ * Returns: (transfer full): a newly created #GHashTable of
+ * type #TP_HASH_TYPE_STRING_VARIANT_MAP
+ */
+GHashTable *
+_tp_asv_from_vardict (GVariant *variant)
+{
+  GValue v = G_VALUE_INIT;
+  GHashTable *result;
+
+  g_return_val_if_fail (variant != NULL, NULL);
+  g_return_val_if_fail (g_variant_is_of_type (variant, G_VARIANT_TYPE_VARDICT),
+      NULL);
+
+  dbus_g_value_parse_g_variant (variant, &v);
+  g_assert (G_VALUE_HOLDS (&v, TP_HASH_TYPE_STRING_VARIANT_MAP));
+
+  result = g_value_dup_boxed (&v);
+
+  g_value_unset (&v);
+  return result;
+}
+
+/**
+ * tp_variant_type_classify:
+ * @type: a #GVariantType
+ *
+ * Classifies @type according to its top-level type.
+ *
+ * Returns: the #GVariantClass of @type
+ * Since: 0.UNRELEASED
+ **/
+GVariantClass
+tp_variant_type_classify (const GVariantType *type)
+{
+  /* Same as g_variant_classify() but for a GVariantType. This returns the first
+   * letter of the dbus type and cast it to an enum where elements have the
+   * ascii value of the type letters. */
+  return g_variant_type_peek_string (type)[0];
+}
+
+static gdouble
+_tp_variant_convert_double (GVariant *variant,
+    gboolean *valid)
+{
+  *valid = TRUE;
+
+  switch (g_variant_classify (variant))
+    {
+      case G_VARIANT_CLASS_DOUBLE:
+        return g_variant_get_double (variant);
+
+      case G_VARIANT_CLASS_BYTE:
+        return g_variant_get_byte (variant);
+
+      case G_VARIANT_CLASS_UINT32:
+        return g_variant_get_uint32 (variant);
+
+      case G_VARIANT_CLASS_INT32:
+        return g_variant_get_int32 (variant);
+
+      case G_VARIANT_CLASS_INT64:
+        return g_variant_get_int64 (variant);
+
+      case G_VARIANT_CLASS_UINT64:
+        return g_variant_get_uint64 (variant);
+
+      default:
+        break;
+    }
+
+  *valid = FALSE;
+  return 0.0;
+}
+
+static gint32
+_tp_variant_convert_int32 (GVariant *variant,
+    gboolean *valid)
+{
+  gint64 i;
+  guint64 u;
+
+  *valid = TRUE;
+
+  switch (g_variant_classify (variant))
+    {
+      case G_VARIANT_CLASS_BYTE:
+        return g_variant_get_byte (variant);
+
+      case G_VARIANT_CLASS_UINT32:
+        u = g_variant_get_uint32 (variant);
+        if (G_LIKELY (u <= G_MAXINT32))
+          return u;
+        break;
+
+      case G_VARIANT_CLASS_INT32:
+        return g_variant_get_int32 (variant);
+
+      case G_VARIANT_CLASS_INT64:
+        i = g_variant_get_int64 (variant);
+        if (G_LIKELY (i >= G_MININT32 && i <= G_MAXINT32))
+          return i;
+        break;
+
+      case G_VARIANT_CLASS_UINT64:
+        u = g_variant_get_uint64 (variant);
+        if (G_LIKELY (u <= G_MAXINT32))
+          return u;
+        break;
+
+      default:
+        break;
+    }
+
+  *valid = FALSE;
+  return 0;
+}
+
+static gint64
+_tp_variant_convert_int64 (GVariant *variant,
+    gboolean *valid)
+{
+  guint64 u;
+
+  *valid = TRUE;
+
+  switch (g_variant_classify (variant))
+    {
+      case G_VARIANT_CLASS_BYTE:
+        return g_variant_get_byte (variant);
+
+      case G_VARIANT_CLASS_UINT32:
+        return g_variant_get_uint32 (variant);
+
+      case G_VARIANT_CLASS_INT32:
+        return g_variant_get_int32 (variant);
+
+      case G_VARIANT_CLASS_INT64:
+        return g_variant_get_int64 (variant);
+
+      case G_VARIANT_CLASS_UINT64:
+        u = g_variant_get_uint64 (variant);
+        if (G_LIKELY (u <= G_MAXINT64))
+          return u;
+        break;
+
+      default:
+        break;
+    }
+
+  *valid = FALSE;
+  return 0;
+}
+
+static guint32
+_tp_variant_convert_uint32 (GVariant *variant,
+    gboolean *valid)
+{
+  gint64 i;
+  guint64 u;
+
+  *valid = TRUE;
+
+  switch (g_variant_classify (variant))
+    {
+      case G_VARIANT_CLASS_BYTE:
+        return g_variant_get_byte (variant);
+
+      case G_VARIANT_CLASS_UINT32:
+        return g_variant_get_uint32 (variant);
+
+      case G_VARIANT_CLASS_INT32:
+        i = g_variant_get_int32 (variant);
+        if (G_LIKELY (i >= 0))
+          return i;
+        break;
+
+      case G_VARIANT_CLASS_INT64:
+        i = g_variant_get_int64 (variant);
+        if (G_LIKELY (i >= 0 && i <= G_MAXUINT32))
+          return i;
+        break;
+
+      case G_VARIANT_CLASS_UINT64:
+        u = g_variant_get_uint64 (variant);
+        if (G_LIKELY (u <= G_MAXUINT32))
+          return u;
+        break;
+
+      default:
+        break;
+    }
+
+  *valid = FALSE;
+  return 0;
+}
+
+static guint64
+_tp_variant_convert_uint64 (GVariant *variant,
+    gboolean *valid)
+{
+  gint64 tmp;
+
+  *valid = TRUE;
+
+  switch (g_variant_classify (variant))
+    {
+      case G_VARIANT_CLASS_BYTE:
+        return g_variant_get_byte (variant);
+
+      case G_VARIANT_CLASS_UINT32:
+        return g_variant_get_uint32 (variant);
+
+      case G_VARIANT_CLASS_INT32:
+        tmp = g_variant_get_int32 (variant);
+        if (G_LIKELY (tmp >= 0))
+          return tmp;
+        break;
+
+      case G_VARIANT_CLASS_INT64:
+        tmp = g_variant_get_int64 (variant);
+        if (G_LIKELY (tmp >= 0))
+          return tmp;
+        break;
+
+      case G_VARIANT_CLASS_UINT64:
+        return g_variant_get_uint64 (variant);
+
+      default:
+        break;
+    }
+
+  *valid = FALSE;
+  return 0;
+}
+
+/**
+ * tp_variant_convert:
+ * @variant: (transfer full): a #GVariant to convert
+ * @type: a #GVariantType @variant must be converted to
+ *
+ * Convert the type of @variant to @type if possible. This takes ownership of
+ * @variant. If no conversion is needed, simply return @variant. If conversion
+ * is not possible, %NULL is returned.
+ *
+ * Returns: (transfer full): a new #GVariant owned by the caller.
+ * Since: 0.UNRELEASED
+ **/
+GVariant *
+tp_variant_convert (GVariant *variant,
+    const GVariantType *type)
+{
+  GVariant *ret = NULL;
+  gboolean valid;
+
+  if (variant == NULL)
+    return NULL;
+
+  g_variant_ref_sink (variant);
+
+  if (g_variant_is_of_type (variant, type))
+    return variant;
+
+  switch (tp_variant_type_classify (type))
+    {
+      #define CASE(type) \
+        { \
+          g##type tmp = _tp_variant_convert_##type (variant, &valid); \
+          if (valid) \
+            ret = g_variant_new_##type (tmp); \
+        }
+      case G_VARIANT_CLASS_DOUBLE:
+        CASE (double);
+        break;
+
+      case G_VARIANT_CLASS_INT32:
+        CASE (int32);
+        break;
+
+      case G_VARIANT_CLASS_INT64:
+        CASE (int64);
+        break;
+
+      case G_VARIANT_CLASS_UINT32:
+        CASE (uint32);
+        break;
+
+      case G_VARIANT_CLASS_UINT64:
+        CASE (uint64);
+        break;
+
+      default:
+        break;
+      #undef CASE
+    }
+
+  g_variant_unref (variant);
+
+  return (ret != NULL) ? g_variant_ref_sink (ret) : NULL;
+}
+
+/**
+ * tp_vardict_get_string:
+ * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ * @key: The key to look up
+ *
+ * If a value for @key in @variant is present and is a string, return it.
+ *
+ * Otherwise return %NULL.
+ *
+ * The returned value is not copied, and is only valid as long as @variant is
+ * kept. Copy it with g_strdup() if you need to keep it for longer.
+ *
+ * Returns: (transfer none) (allow-none): the string value of @key, or %NULL
+ * Since: 0.UNRELEASED
+ */
+const gchar *
+tp_vardict_get_string (GVariant *variant,
+    const gchar *key)
+{
+  const gchar *ret;
+
+  g_return_val_if_fail (variant != NULL, NULL);
+  g_return_val_if_fail (key != NULL, NULL);
+  g_return_val_if_fail (g_variant_is_of_type (variant, G_VARIANT_TYPE_VARDICT), NULL);
+
+  if (!g_variant_lookup (variant, key, "&s", &ret))
+    return NULL;
+
+  return ret;
+}
+
+/**
+ * tp_vardict_get_object_path:
+ * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ * @key: The key to look up
+ *
+ * If a value for @key in @variant is present and is an object path, return it.
+ *
+ * Otherwise return %NULL.
+ *
+ * The returned value is not copied, and is only valid as long as @variant is
+ * kept. Copy it with g_strdup() if you need to keep it for longer.
+ *
+ * Returns: (transfer none) (allow-none): the object path value of @key, or
+ *  %NULL
+ * Since: 0.UNRELEASED
+ */
+const gchar *
+tp_vardict_get_object_path (GVariant *variant,
+    const gchar *key)
+{
+  const gchar *ret;
+
+  g_return_val_if_fail (variant != NULL, NULL);
+  g_return_val_if_fail (key != NULL, NULL);
+  g_return_val_if_fail (g_variant_is_of_type (variant, G_VARIANT_TYPE_VARDICT), NULL);
+
+  if (!g_variant_lookup (variant, key, "&o", &ret))
+    return NULL;
+
+  return ret;
+}
+
+/**
+ * tp_vardict_get_boolean:
+ * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ * @key: The key to look up
+ * @valid: (out): Either %NULL, or a location to store %TRUE if the key actually
+ *  exists and has a boolean value
+ *
+ * If a value for @key in @variant is present and boolean, return it,
+ * and set *@valid to %TRUE if @valid is not %NULL.
+ *
+ * Otherwise return %FALSE, and set *@valid to %FALSE if @valid is not %NULL.
+ *
+ * Returns: a boolean value for @key
+ * Since: 0.UNRELEASED
+ */
+gboolean
+tp_vardict_get_boolean (GVariant *variant,
+    const gchar *key,
+    gboolean *valid)
+{
+  gboolean ret;
+
+  g_return_val_if_fail (variant != NULL, FALSE);
+  g_return_val_if_fail (key != NULL, FALSE);
+  g_return_val_if_fail (g_variant_is_of_type (variant, G_VARIANT_TYPE_VARDICT), FALSE);
+
+  if (!g_variant_lookup (variant, key, "b", &ret))
+    {
+      if (valid != NULL)
+        *valid = FALSE;
+
+      return FALSE;
+    }
+
+  if (valid != NULL)
+    *valid = TRUE;
+
+  return ret;
+}
+
+#define IMPLEMENT(type) \
+  g##type \
+  tp_vardict_get_##type (GVariant *variant, \
+      const gchar *key, \
+      gboolean *valid) \
+  { \
+    g##type ret = 0; \
+    gboolean ret_valid = FALSE; \
+    GVariant *value; \
+    \
+    g_return_val_if_fail (variant != NULL, 0); \
+    g_return_val_if_fail (key != NULL, 0); \
+    g_return_val_if_fail (g_variant_is_of_type (variant, G_VARIANT_TYPE_VARDICT), 0); \
+    \
+    value = g_variant_lookup_value (variant, key, NULL); \
+    if (value != NULL) \
+      { \
+        ret = _tp_variant_convert_##type (value, &ret_valid); \
+        g_variant_unref (value); \
+      } \
+    \
+    if (valid != NULL) \
+      *valid = ret_valid; \
+    \
+    return ret; \
+  }
+
+/**
+ * tp_vardict_get_double:
+ * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ * @key: The key to look up
+ * @valid: (out): Either %NULL, or a location in which to store %TRUE on success
+ * or %FALSE on failure
+ *
+ * If a value for @key in @variant is present and has any numeric type used by
+ * GVariant (gint32, guint32, gint64, guint64 or gdouble),
+ * return it as a double, and if @valid is not %NULL, set *@valid to %TRUE.
+ *
+ * Otherwise, return 0.0, and if @valid is not %NULL, set *@valid to %FALSE.
+ *
+ * Returns: the double precision floating-point value of @key, or 0.0
+ * Since: 0.UNRELEASED
+ */
+IMPLEMENT (double)
+
+/**
+ * tp_vardict_get_int32:
+ * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ * @key: The key to look up
+ * @valid: (out): Either %NULL, or a location in which to store %TRUE on success
+ * or %FALSE on failure
+ *
+ * If a value for @key in @variant is present, has an integer type used by
+ * GVariant (gint32, guint32, gint64 or guint64) and fits in the
+ * range of a gint32, return it, and if @valid is not %NULL, set *@valid to
+ * %TRUE.
+ *
+ * Otherwise, return 0, and if @valid is not %NULL, set *@valid to %FALSE.
+ *
+ * Returns: the 32-bit signed integer value of @key, or 0
+ * Since: 0.UNRELEASED
+ */
+IMPLEMENT (int32)
+
+/**
+ * tp_vardict_get_int64:
+ * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ * @key: The key to look up
+ * @valid: (out): Either %NULL, or a location in which to store %TRUE on success
+ * or %FALSE on failure
+ *
+ * If a value for @key in @variant is present, has an integer type used by
+ * GVariant (gint32, guint32, gint64 or guint64) and fits in the
+ * range of a gint64, return it, and if @valid is not %NULL, set *@valid to
+ * %TRUE.
+ *
+ * Otherwise, return 0, and if @valid is not %NULL, set *@valid to %FALSE.
+ *
+ * Returns: the 64-bit signed integer value of @key, or 0
+ * Since: 0.UNRELEASED
+ */
+IMPLEMENT (int64)
+
+/**
+ * tp_vardict_get_uint32:
+ * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ * @key: The key to look up
+ * @valid: (out): Either %NULL, or a location in which to store %TRUE on success
+ * or %FALSE on failure
+ *
+ * If a value for @key in @variant is present, has an integer type used by
+ * GVariant (gint32, guint32, gint64 or guint64) and fits in the
+ * range of a guint32, return it, and if @valid is not %NULL, set *@valid to
+ * %TRUE.
+ *
+ * Otherwise, return 0, and if @valid is not %NULL, set *@valid to %FALSE.
+ *
+ * Returns: the 32-bit unsigned integer value of @key, or 0
+ * Since: 0.UNRELEASED
+ */
+IMPLEMENT (uint32)
+
+/**
+ * tp_vardict_get_uint64:
+ * @variant: a #GVariant of type %G_VARIANT_TYPE_VARDICT
+ * @key: The key to look up
+ * @valid: (out): Either %NULL, or a location in which to store %TRUE on success
+ * or %FALSE on failure
+ *
+ * If a value for @key in @variant is present, has an integer type used by
+ * GVariant (gint32, guint32, gint64 or guint64) and is non-negative,
+ * return it, and if @valid is not %NULL, set *@valid to %TRUE.
+ *
+ * Otherwise, return 0, and if @valid is not %NULL, set *@valid to %FALSE.
+ *
+ * Returns: the 64-bit unsigned integer value of @key, or 0
+ * Since: 0.UNRELEASED
+ */
+IMPLEMENT (uint64)
+
+#undef IMPLEMENT
diff --git a/telepathy-glib/variant-util.h b/telepathy-glib/variant-util.h
new file mode 100644
index 000000000..55124d444
--- /dev/null
+++ b/telepathy-glib/variant-util.h
@@ -0,0 +1,63 @@
+/*
+ * variant-util.h - Header for GVariant utilities
+ *
+ * Copyright (C) 2012 Collabora Ltd. <http://www.collabora.co.uk/>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#if defined (TP_DISABLE_SINGLE_INCLUDE) && !defined (_TP_IN_META_HEADER) && !defined (_TP_COMPILATION)
+#error "Only <telepathy-glib/telepathy-glib.h> and <telepathy-glib/telepathy-glib-dbus.h> can be included directly."
+#endif
+
+#ifndef __TP_VARIANT_UTIL_H__
+#define __TP_VARIANT_UTIL_H__
+
+#include <glib.h>
+#include <gio/gio.h>
+
+G_BEGIN_DECLS
+
+GVariantClass tp_variant_type_classify (const GVariantType *type);
+
+GVariant *tp_variant_convert (GVariant *variant,
+    const GVariantType *type);
+
+const gchar *tp_vardict_get_string (GVariant *variant,
+    const gchar *key);
+const gchar *tp_vardict_get_object_path (GVariant *variant,
+    const gchar *key);
+gboolean tp_vardict_get_boolean (GVariant *variant,
+    const gchar *key,
+    gboolean *valid);
+gdouble tp_vardict_get_double (GVariant *variant,
+    const gchar *key,
+    gboolean *valid);
+gint32 tp_vardict_get_int32 (GVariant *variant,
+    const gchar *key,
+    gboolean *valid);
+gint64 tp_vardict_get_int64 (GVariant *variant,
+    const gchar *key,
+    gboolean *valid);
+guint32 tp_vardict_get_uint32 (GVariant *variant,
+    const gchar *key,
+    gboolean *valid);
+guint64 tp_vardict_get_uint64 (GVariant *variant,
+    const gchar *key,
+    gboolean *valid);
+
+G_END_DECLS
+
+#endif /* __TP_VARIANT_UTIL_H__ */
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 15339f9a4..b85d30d31 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -69,8 +69,15 @@ EXTRA_DIST = README \
     all-errors-documented.py \
     tests.supp
 
+# this one uses internal ABI
 test_asv_SOURCES = \
     asv.c
+test_asv_LDADD = \
+    $(top_builddir)/tests/lib/libtp-glib-tests-internal.la \
+    $(top_builddir)/telepathy-glib/libtelepathy-glib-main-internal.la \
+    $(top_builddir)/telepathy-glib/libtelepathy-glib-1-dbus.la \
+    $(top_builddir)/telepathy-glib/libtelepathy-glib-1-core.la \
+    $(GLIB_LIBS)
 
 # this one uses internal ABI
 test_capabilities_SOURCES = \
diff --git a/tests/asv.c b/tests/asv.c
index 3a737f818..80981ff18 100644
--- a/tests/asv.c
+++ b/tests/asv.c
@@ -4,14 +4,34 @@
 
 #include <glib.h>
 
-#include <telepathy-glib/dbus.h>
-#include <telepathy-glib/util.h>
+#include <telepathy-glib/telepathy-glib-dbus.h>
 
 #include "tests/lib/myassert.h"
+#include "telepathy-glib/variant-util-internal.h"
+
+#define asv_assert(type, key, expected_value, expected_valid) \
+    valid = (gboolean) 123; \
+    g_assert (tp_asv_get_##type (hash, key, NULL) == expected_value); \
+    g_assert (tp_asv_get_##type (hash, key, &valid) == expected_value); \
+    g_assert (valid == expected_valid); \
+\
+    valid = (gboolean) 123; \
+    g_assert (tp_vardict_get_##type (vardict, key, NULL) == expected_value); \
+    g_assert (tp_vardict_get_##type (vardict, key, &valid) == expected_value); \
+    g_assert (valid == expected_valid)
+
+#define asv_assert_string(key, expected_value) \
+    g_assert_cmpstr (tp_asv_get_string (hash, key), ==, expected_value); \
+    g_assert_cmpstr (tp_vardict_get_string (vardict, key), ==, expected_value); \
+
+#define asv_assert_object_path(key, expected_value) \
+    g_assert_cmpstr (tp_asv_get_object_path (hash, key), ==, expected_value); \
+    g_assert_cmpstr (tp_vardict_get_object_path (vardict, key), ==, expected_value); \
 
 int main (int argc, char **argv)
 {
   GHashTable *hash;
+  GVariant *vardict;
   gboolean valid;
   static const char * const strv[] = { "Foo", "Bar", NULL };
 
@@ -95,578 +115,147 @@ int main (int argc, char **argv)
 
   tp_asv_dump (hash);
 
+  vardict = _tp_asv_to_vardict (hash);
+
   /* Tests: tp_asv_get_boolean */
 
-  valid = (gboolean) 123;
-  MYASSERT (!tp_asv_get_boolean (hash, "b:FALSE", NULL), "");
-  MYASSERT (!tp_asv_get_boolean (hash, "b:FALSE", &valid), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_boolean (hash, "b:TRUE", NULL), "");
-  MYASSERT (tp_asv_get_boolean (hash, "b:TRUE", &valid), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (!tp_asv_get_boolean (hash, "s", NULL), "");
-  MYASSERT (!tp_asv_get_boolean (hash, "s", &valid), "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (!tp_asv_get_boolean (hash, "not-there", NULL), "");
-  MYASSERT (!tp_asv_get_boolean (hash, "not-there", &valid), "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (!tp_asv_get_boolean (hash, "i32:2**16", NULL), "");
-  MYASSERT (!tp_asv_get_boolean (hash, "i32:2**16", &valid), "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (!tp_asv_get_boolean (hash, "d:0", NULL), "");
-  MYASSERT (!tp_asv_get_boolean (hash, "d:0", &valid), "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (!tp_asv_get_boolean (hash, "d:-123", NULL), "");
-  MYASSERT (!tp_asv_get_boolean (hash, "d:-123", &valid), "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (!tp_asv_get_boolean (hash, "d:123.2", NULL), "");
-  MYASSERT (!tp_asv_get_boolean (hash, "d:123.2", &valid), "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
+  asv_assert (boolean, "b:FALSE", FALSE, TRUE);
+  asv_assert (boolean, "b:TRUE", TRUE, TRUE);
+  asv_assert (boolean, "s", FALSE, FALSE);
+  asv_assert (boolean, "not-there", FALSE, FALSE);
+  asv_assert (boolean, "i32:2**16", FALSE, FALSE);
+  asv_assert (boolean, "d:0", FALSE, FALSE);
+  asv_assert (boolean, "d:-123", FALSE, FALSE);
+  asv_assert (boolean, "d:123.2", FALSE, FALSE);
 
   /* Tests: tp_asv_get_double */
 
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "s", NULL) == 0, "");
-  MYASSERT (tp_asv_get_double (hash, "s", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "b:TRUE", NULL) == 0, "");
-  MYASSERT (tp_asv_get_double (hash, "b:TRUE", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "not-there", NULL) == 0.0, "");
-  MYASSERT (tp_asv_get_double (hash, "not-there", &valid) == 0.0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "i32:0", NULL) == 0.0, "");
-  MYASSERT (tp_asv_get_double (hash, "i32:0", &valid) == 0.0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "u32:0", NULL) == 0.0, "");
-  MYASSERT (tp_asv_get_double (hash, "u32:0", &valid) == 0.0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "u32:2**16", NULL)
-      == (double) 0x10000, "");
-  MYASSERT (tp_asv_get_double (hash, "u32:2**16", &valid)
-      == (double) 0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "i32:-2**16", NULL) ==
-      (double) -0x10000, "");
-  MYASSERT (tp_asv_get_double (hash, "i32:-2**16", &valid) ==
-      (double) -0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "u64:0", NULL) == 0.0, "");
-  MYASSERT (tp_asv_get_double (hash, "u64:0", &valid) == 0.0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "d:0", NULL) == 0.0, "");
-  MYASSERT (tp_asv_get_double (hash, "d:0", &valid) == 0.0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "d:-123", NULL) == -123.0, "");
-  MYASSERT (tp_asv_get_double (hash, "d:-123", &valid) == -123.0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_double (hash, "d:123.2", NULL) == 123.2, "");
-  MYASSERT (tp_asv_get_double (hash, "d:123.2", &valid) == 123.2, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
+  asv_assert (double, "s", 0.0, FALSE);
+  asv_assert (double, "b:TRUE", 0.0, FALSE);
+  asv_assert (double, "not-there", 0.0, FALSE);
+  asv_assert (double, "i32:0", 0.0, TRUE);
+  asv_assert (double, "u32:0", 0.0, TRUE);
+  asv_assert (double, "u32:2**16", (double) 0x10000, TRUE);
+  asv_assert (double, "i32:-2**16", (double) -0x10000, TRUE);
+  asv_assert (double, "u64:0", 0.0, TRUE);
+  asv_assert (double, "d:0", 0.0, TRUE);
+  asv_assert (double, "d:-123", -123.0, TRUE);
+  asv_assert (double, "d:123.2", 123.2, TRUE);
 
   /* Tests: tp_asv_get_int32 */
 
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "s", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "s", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "b:TRUE", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "b:TRUE", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "d:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "d:0", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "not-there", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "not-there", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "i32:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "i32:0", &valid) == 0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "u32:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "u32:0", &valid) == 0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "i32:2**16", NULL) == 0x10000, "");
-  MYASSERT (tp_asv_get_int32 (hash, "i32:2**16", &valid) == 0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "u32:2**16", NULL) == 0x10000, "");
-  MYASSERT (tp_asv_get_int32 (hash, "u32:2**16", &valid) == 0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "i32:-2**16", NULL) == -0x10000, "");
-  MYASSERT (tp_asv_get_int32 (hash, "i32:-2**16", &valid) == -0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "i32:-2**31", NULL) == 0x10000 * -0x8000,
-      "");
-  MYASSERT (tp_asv_get_int32 (hash, "i32:-2**31", &valid) == 0x10000 * -0x8000,
-      "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "i32:2**31-1", NULL) == 0x7FFFFFFF, "");
-  MYASSERT (tp_asv_get_int32 (hash, "i32:2**31-1", &valid) == 0x7FFFFFFF, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "u32:2**31-1", NULL) == 0x7FFFFFFF, "");
-  MYASSERT (tp_asv_get_int32 (hash, "u32:2**31-1", &valid) == 0x7FFFFFFF, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "u32:2**31", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "u32:2**31", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "u32:2**32-1", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "u32:2**32-1", &valid) == 0,
-      "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "u64:2**32-1", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "u64:2**32-1", &valid) == 0,
-      "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "u64:2**32", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "u64:2**32", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "u64:2**64-1", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "u64:2**64-1", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "i64:-2**63", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "i64:-2**63", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "i64:2**63-1", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "i64:2**63-1", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int32 (hash, "u64:2**63-1", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int32 (hash, "u64:2**63-1", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
+  asv_assert (int32, "s", 0, FALSE);
+  asv_assert (int32, "b:TRUE", 0, FALSE);
+  asv_assert (int32, "d:0", 0, FALSE);
+  asv_assert (int32, "not-there", 0, FALSE);
+  asv_assert (int32, "i32:0", 0, TRUE);
+  asv_assert (int32, "u32:0", 0, TRUE);
+  asv_assert (int32, "i32:2**16", 0x10000, TRUE);
+  asv_assert (int32, "u32:2**16", 0x10000, TRUE);
+  asv_assert (int32, "i32:-2**16", -0x10000, TRUE);
+  asv_assert (int32, "i32:-2**31", 0x10000 * -0x8000, TRUE);
+  asv_assert (int32, "i32:2**31-1", 0x7FFFFFFF, TRUE);
+  asv_assert (int32, "u32:2**31-1", 0x7FFFFFFF, TRUE);
+  asv_assert (int32, "u32:2**31", 0, FALSE);
+  asv_assert (int32, "u32:2**32-1", 0, FALSE);
+  asv_assert (int32, "u64:2**32-1", 0, FALSE);
+  asv_assert (int32, "u64:2**32", 0, FALSE);
+  asv_assert (int32, "u64:2**64-1", 0, FALSE);
+  asv_assert (int32, "i64:-2**63", 0, FALSE);
+  asv_assert (int32, "i64:2**63-1", 0, FALSE);
+  asv_assert (int32, "u64:2**63-1", 0, FALSE);
 
   /* Tests: tp_asv_get_uint32 */
 
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "s", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "s", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "b:TRUE", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "b:TRUE", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "d:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "d:0", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "not-there", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "not-there", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:0", &valid) == 0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:0", &valid) == 0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:2**16", NULL) == 0x10000, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:2**16", &valid) == 0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:2**16", NULL) == 0x10000, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:2**16", &valid) == 0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:-2**16", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:-2**16", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:-2**31", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:-2**31", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:2**31-1", NULL) == 0x7FFFFFFF, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "i32:2**31-1", &valid) == 0x7FFFFFFF, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:2**31-1", NULL) == 0x7FFFFFFF, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:2**31-1", &valid) == 0x7FFFFFFF, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:2**31", NULL) == 0x80000000U, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:2**31", &valid) == 0x80000000U, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:2**32-1", NULL) == 0xFFFFFFFFU, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "u32:2**32-1", &valid) == 0xFFFFFFFFU,
-      "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "u64:2**32-1", NULL) == 0xFFFFFFFFU, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "u64:2**32-1", &valid) == 0xFFFFFFFFU,
-      "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "u64:2**32", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "u64:2**32", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "u64:2**64-1", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "u64:2**64-1", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "i64:-2**63", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "i64:-2**63", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "i64:2**63-1", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "i64:2**63-1", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint32 (hash, "u64:2**63-1", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint32 (hash, "u64:2**63-1", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
+  asv_assert (uint32, "s", 0, FALSE);
+  asv_assert (uint32, "b:TRUE", 0, FALSE);
+  asv_assert (uint32, "d:0", 0, FALSE);
+  asv_assert (uint32, "not-there", 0, FALSE);
+  asv_assert (uint32, "i32:0", 0, TRUE);
+  asv_assert (uint32, "u32:0", 0, TRUE);
+  asv_assert (uint32, "i32:2**16", 0x10000, TRUE);
+  asv_assert (uint32, "u32:2**16", 0x10000, TRUE);
+  asv_assert (uint32, "i32:-2**16", 0, FALSE);
+  asv_assert (uint32, "i32:-2**31", 0, FALSE);
+  asv_assert (uint32, "i32:2**31-1", 0x7FFFFFFF, TRUE);
+  asv_assert (uint32, "u32:2**31-1", 0x7FFFFFFF, TRUE);
+  asv_assert (uint32, "u32:2**31", 0x80000000U, TRUE);
+  asv_assert (uint32, "u32:2**32-1", 0xFFFFFFFFU, TRUE);
+  asv_assert (uint32, "u64:2**32-1", 0xFFFFFFFFU, TRUE);
+  asv_assert (uint32, "u64:2**32", 0, FALSE);
+  asv_assert (uint32, "u64:2**64-1", 0, FALSE);
+  asv_assert (uint32, "i64:-2**63", 0, FALSE);
+  asv_assert (uint32, "i64:2**63-1", 0, FALSE);
+  asv_assert (uint32, "u64:2**63-1", 0, FALSE);
 
   /* Tests: tp_asv_get_int64 */
 
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "s", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int64 (hash, "s", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "b:TRUE", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int64 (hash, "b:TRUE", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "d:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int64 (hash, "d:0", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "not-there", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int64 (hash, "not-there", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "i32:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int64 (hash, "i32:0", &valid) == 0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "u32:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int64 (hash, "u32:0", &valid) == 0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "i32:2**16", NULL) == 0x10000, "");
-  MYASSERT (tp_asv_get_int64 (hash, "i32:2**16", &valid) == 0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "u32:2**16", NULL) == 0x10000, "");
-  MYASSERT (tp_asv_get_int64 (hash, "u32:2**16", &valid) == 0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "i32:-2**16", NULL) == -0x10000, "");
-  MYASSERT (tp_asv_get_int64 (hash, "i32:-2**16", &valid) == -0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "i32:-2**31", NULL) == 0x10000 * -0x8000,
-      "");
-  MYASSERT (tp_asv_get_int64 (hash, "i32:-2**31", &valid) == 0x10000 * -0x8000,
-      "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "i32:2**31-1", NULL) == 0x7FFFFFFF, "");
-  MYASSERT (tp_asv_get_int64 (hash, "i32:2**31-1", &valid) == 0x7FFFFFFF, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "u32:2**31-1", NULL) == 0x7FFFFFFF, "");
-  MYASSERT (tp_asv_get_int64 (hash, "u32:2**31-1", &valid) == 0x7FFFFFFF, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "u32:2**31", NULL) ==
-      G_GINT64_CONSTANT (0x80000000), "");
-  MYASSERT (tp_asv_get_int64 (hash, "u32:2**31", &valid) ==
-      G_GINT64_CONSTANT (0x80000000), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "u32:2**32-1", NULL) ==
-      G_GINT64_CONSTANT (0xFFFFFFFF), "");
-  MYASSERT (tp_asv_get_int64 (hash, "u32:2**32-1", &valid) ==
-      G_GINT64_CONSTANT (0xFFFFFFFF), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "u64:2**32-1", NULL) ==
-      G_GINT64_CONSTANT (0xFFFFFFFF), "");
-  MYASSERT (tp_asv_get_int64 (hash, "u64:2**32-1", &valid) ==
-      G_GINT64_CONSTANT (0xFFFFFFFF), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "u64:2**32", NULL) ==
-      G_GINT64_CONSTANT (0x100000000), "");
-  MYASSERT (tp_asv_get_int64 (hash, "u64:2**32", &valid) ==
-      G_GINT64_CONSTANT (0x100000000), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "u64:2**64-1", NULL) == 0, "");
-  MYASSERT (tp_asv_get_int64 (hash, "u64:2**64-1", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "i64:-2**63", NULL) ==
-      G_GINT64_CONSTANT (-0x80000000) * G_GINT64_CONSTANT (0x100000000), "");
-  MYASSERT (tp_asv_get_int64 (hash, "i64:-2**63", &valid) ==
-      G_GINT64_CONSTANT (-0x80000000) * G_GINT64_CONSTANT (0x100000000), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "i64:2**63-1", NULL) ==
-      G_GINT64_CONSTANT (0x7FFFFFFFFFFFFFFF), "");
-  MYASSERT (tp_asv_get_int64 (hash, "i64:2**63-1", &valid) ==
-      G_GINT64_CONSTANT (0x7FFFFFFFFFFFFFFF), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_int64 (hash, "u64:2**63-1", NULL) ==
-      G_GINT64_CONSTANT (0x7FFFFFFFFFFFFFFF), "");
-  MYASSERT (tp_asv_get_int64 (hash, "u64:2**63-1", &valid) ==
-      G_GINT64_CONSTANT (0x7FFFFFFFFFFFFFFF), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
+  asv_assert (int64, "s", 0, FALSE);
+  asv_assert (int64, "b:TRUE", 0, FALSE);
+  asv_assert (int64, "d:0", 0, FALSE);
+  asv_assert (int64, "not-there", 0, FALSE);
+  asv_assert (int64, "i32:0", 0, TRUE);
+  asv_assert (int64, "u32:0", 0, TRUE);
+  asv_assert (int64, "i32:2**16", 0x10000, TRUE);
+  asv_assert (int64, "u32:2**16", 0x10000, TRUE);
+  asv_assert (int64, "i32:-2**16", -0x10000, TRUE);
+  asv_assert (int64, "i32:-2**31", 0x10000 * -0x8000, TRUE);
+  asv_assert (int64, "i32:2**31-1", 0x7FFFFFFF, TRUE);
+  asv_assert (int64, "u32:2**31-1", 0x7FFFFFFF, TRUE);
+  asv_assert (int64, "u32:2**31", G_GINT64_CONSTANT (0x80000000), TRUE);
+  asv_assert (int64, "u32:2**32-1", G_GINT64_CONSTANT (0xFFFFFFFF), TRUE);
+  asv_assert (int64, "u64:2**32-1", G_GINT64_CONSTANT (0xFFFFFFFF), TRUE);
+  asv_assert (int64, "u64:2**32", G_GINT64_CONSTANT (0x100000000), TRUE);
+  asv_assert (int64, "u64:2**64-1", 0, FALSE);
+  asv_assert (int64, "i64:-2**63", G_GINT64_CONSTANT (-0x80000000) * G_GINT64_CONSTANT (0x100000000), TRUE);
+  asv_assert (int64, "i64:2**63-1", G_GINT64_CONSTANT (0x7FFFFFFFFFFFFFFF), TRUE);
+  asv_assert (int64, "u64:2**63-1", G_GINT64_CONSTANT (0x7FFFFFFFFFFFFFFF), TRUE);
 
   /* Tests: tp_asv_get_uint64 */
 
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "s", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "s", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "b:TRUE", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "b:TRUE", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "d:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "d:0", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "not-there", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "not-there", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:0", &valid) == 0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:0", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:0", &valid) == 0, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:2**16", NULL) == 0x10000, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:2**16", &valid) == 0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:2**16", NULL) == 0x10000, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:2**16", &valid) == 0x10000, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:-2**16", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:-2**16", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:-2**31", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:-2**31", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:2**31-1", NULL) == 0x7FFFFFFF, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "i32:2**31-1", &valid) == 0x7FFFFFFF, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:2**31-1", NULL) == 0x7FFFFFFF, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:2**31-1", &valid) == 0x7FFFFFFF, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:2**31", NULL) == 0x80000000U, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:2**31", &valid) == 0x80000000U, "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:2**32-1", NULL) == 0xFFFFFFFFU, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "u32:2**32-1", &valid) == 0xFFFFFFFFU,
-      "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "u64:2**32-1", NULL) == 0xFFFFFFFFU, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "u64:2**32-1", &valid) == 0xFFFFFFFFU,
-      "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "u64:2**32", NULL) ==
-      G_GUINT64_CONSTANT (0x100000000), "");
-  MYASSERT (tp_asv_get_uint64 (hash, "u64:2**32", &valid) ==
-      G_GUINT64_CONSTANT (0x100000000), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "u64:2**64-1", NULL) ==
-      G_GUINT64_CONSTANT (0xFFFFffffFFFFffff), "");
-  MYASSERT (tp_asv_get_uint64 (hash, "u64:2**64-1", &valid) ==
-      G_GUINT64_CONSTANT (0xFFFFffffFFFFffff), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "i64:-2**63", NULL) == 0, "");
-  MYASSERT (tp_asv_get_uint64 (hash, "i64:-2**63", &valid) == 0, "");
-  MYASSERT (valid == FALSE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "i64:2**63-1", NULL) ==
-      G_GUINT64_CONSTANT (0x7FFFffffFFFFffff), "");
-  MYASSERT (tp_asv_get_uint64 (hash, "i64:2**63-1", &valid) ==
-      G_GUINT64_CONSTANT (0x7FFFffffFFFFffff), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
-
-  valid = (gboolean) 123;
-  MYASSERT (tp_asv_get_uint64 (hash, "u64:2**63-1", NULL) ==
-      G_GUINT64_CONSTANT (0x7FFFffffFFFFffff), "");
-  MYASSERT (tp_asv_get_uint64 (hash, "u64:2**63-1", &valid) ==
-      G_GUINT64_CONSTANT (0x7FFFffffFFFFffff), "");
-  MYASSERT (valid == TRUE, ": %u", (guint) valid);
+  asv_assert (uint64, "s", 0, FALSE);
+  asv_assert (uint64, "b:TRUE", 0, FALSE);
+  asv_assert (uint64, "d:0", 0, FALSE);
+  asv_assert (uint64, "not-there", 0, FALSE);
+  asv_assert (uint64, "i32:0", 0, TRUE);
+  asv_assert (uint64, "u32:0", 0, TRUE);
+  asv_assert (uint64, "i32:2**16", 0x10000, TRUE);
+  asv_assert (uint64, "u32:2**16", 0x10000, TRUE);
+  asv_assert (uint64, "i32:-2**16", 0, FALSE);
+  asv_assert (uint64, "i32:-2**31", 0, FALSE);
+  asv_assert (uint64, "i32:2**31-1", 0x7FFFFFFF, TRUE);
+  asv_assert (uint64, "u32:2**31-1", 0x7FFFFFFF, TRUE);
+  asv_assert (uint64, "u32:2**31", 0x80000000U, TRUE);
+  asv_assert (uint64, "u32:2**32-1", 0xFFFFFFFFU, TRUE);
+  asv_assert (uint64, "u64:2**32-1", 0xFFFFFFFFU, TRUE);
+  asv_assert (uint64, "u64:2**32", G_GUINT64_CONSTANT (0x100000000), TRUE);
+  asv_assert (uint64, "u64:2**64-1", G_GUINT64_CONSTANT (0xFFFFffffFFFFffff), TRUE);
+  asv_assert (uint64, "i64:-2**63", 0, FALSE);
+  asv_assert (uint64, "i64:2**63-1", G_GUINT64_CONSTANT (0x7FFFffffFFFFffff), TRUE);
+  asv_assert (uint64, "u64:2**63-1", G_GUINT64_CONSTANT (0x7FFFffffFFFFffff), TRUE);
 
   /* Tests: tp_asv_get_string */
 
-  MYASSERT (tp_asv_get_string (hash, "s") != NULL, "");
-  MYASSERT (g_str_equal (tp_asv_get_string (hash, "s"), "hello, world!"), "");
-
-  MYASSERT (tp_asv_get_string (hash, "s0") != NULL, "");
-  MYASSERT (g_str_equal (tp_asv_get_string (hash, "s0"), ""), "");
-
-  MYASSERT (tp_asv_get_string (hash, "b:TRUE") == NULL, "");
-  MYASSERT (tp_asv_get_string (hash, "b:FALSE") == NULL, "");
-  MYASSERT (tp_asv_get_string (hash, "not-there") == NULL, "");
-  MYASSERT (tp_asv_get_string (hash, "i32:0") == NULL, "");
-  MYASSERT (tp_asv_get_string (hash, "u32:0") == NULL, "");
-  MYASSERT (tp_asv_get_string (hash, "d:0") == NULL, "");
+  asv_assert_string ("s", "hello, world!");
+  asv_assert_string ("s0", "");
+  asv_assert_string ("b:TRUE", NULL);
+  asv_assert_string ("b:FALSE", NULL);
+  asv_assert_string ("not-there", NULL);
+  asv_assert_string ("i32:0", NULL);
+  asv_assert_string ("u32:0", NULL);
+  asv_assert_string ("d:0", NULL);
 
   /* Tests: tp_asv_get_object_path */
 
-  MYASSERT (tp_asv_get_object_path (hash, "o") != NULL, "");
-  MYASSERT (g_str_equal (tp_asv_get_object_path (hash, "o"),
-        "/com/example/Object"), "");
-
-  MYASSERT (tp_asv_get_object_path (hash, "s") == NULL, "");
-  MYASSERT (tp_asv_get_object_path (hash, "s0") == NULL, "");
-  MYASSERT (tp_asv_get_object_path (hash, "b:TRUE") == NULL, "");
-  MYASSERT (tp_asv_get_object_path (hash, "b:FALSE") == NULL, "");
-  MYASSERT (tp_asv_get_object_path (hash, "not-there") == NULL, "");
-  MYASSERT (tp_asv_get_object_path (hash, "i32:0") == NULL, "");
-  MYASSERT (tp_asv_get_object_path (hash, "u32:0") == NULL, "");
-  MYASSERT (tp_asv_get_object_path (hash, "d:0") == NULL, "");
+  asv_assert_object_path ("o", "/com/example/Object");
+  asv_assert_object_path ("s", NULL);
+  asv_assert_object_path ("s0", NULL);
+  asv_assert_object_path ("b:TRUE", NULL);
+  asv_assert_object_path ("b:FALSE", NULL);
+  asv_assert_object_path ("not-there", NULL);
+  asv_assert_object_path ("i32:0", NULL);
+  asv_assert_object_path ("u32:0", NULL);
+  asv_assert_object_path ("d:0", NULL);
 
   /* Tests: tp_asv_get_strv */
 
@@ -690,6 +279,7 @@ int main (int argc, char **argv)
   /* Teardown */
 
   g_hash_table_unref (hash);
+  g_variant_unref (vardict);
 
   return 0;
 }