/* GLib testing framework examples and tests

 *

 * Copyright (C) 2008-2010 Red Hat, Inc.

 *

 * 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, see <http://www.gnu.org/licenses/>.

 *

 * Author: David Zeuthen <davidz@redhat.com>

 */

#include <gio/gio.h>

#include <unistd.h>

#include <string.h>

#include "gdbus-tests.h"

/* all tests rely on a shared mainloop */

static GMainLoop *loop = NULL;

static GDBusConnection *c = NULL;

/* ---------------------------------------------------------------------------------------------------- */

/* Test that we can export objects, the hierarchy is correct and the right handlers are invoked */

/* ---------------------------------------------------------------------------------------------------- */

static const GDBusArgInfo foo_method1_in_args =

{

  -1,

  "an_input_string",

  "s",

  NULL

};

static const GDBusArgInfo * const foo_method1_in_arg_pointers[] = {&foo_method1_in_args, NULL};

static const GDBusArgInfo foo_method1_out_args =

{

  -1,

  "an_output_string",

  "s",

  NULL

};

static const GDBusArgInfo * const foo_method1_out_arg_pointers[] = {&foo_method1_out_args, NULL};

static const GDBusMethodInfo foo_method_info_method1 =

{

  -1,

  "Method1",

  (GDBusArgInfo **) &foo_method1_in_arg_pointers,

  (GDBusArgInfo **) &foo_method1_out_arg_pointers,

  NULL

};

static const GDBusMethodInfo foo_method_info_method2 =

{

  -1,

  "Method2",

  NULL,

  NULL,

  NULL

};

static const GDBusMethodInfo * const foo_method_info_pointers[] = {&foo_method_info_method1, &foo_method_info_method2, NULL};

static const GDBusSignalInfo foo_signal_info =

{

  -1,

  "SignalAlpha",

  NULL,

  NULL

};

static const GDBusSignalInfo * const foo_signal_info_pointers[] = {&foo_signal_info, NULL};

static const GDBusPropertyInfo foo_property_info[] =

{

  {

    -1,

    "PropertyUno",

    "s",

    G_DBUS_PROPERTY_INFO_FLAGS_READABLE | G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE,

    NULL

  },

  {

    -1,

    "NotWritable",

    "s",

    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,

    NULL

  },

  {

    -1,

    "NotReadable",

    "s",

    G_DBUS_PROPERTY_INFO_FLAGS_WRITABLE,

    NULL

  }

};

static const GDBusPropertyInfo * const foo_property_info_pointers[] =

{

  &foo_property_info[0],

  &foo_property_info[1],

  &foo_property_info[2],

  NULL

};

static const GDBusInterfaceInfo foo_interface_info =

{

  -1,

  "org.example.Foo",

  (GDBusMethodInfo **) &foo_method_info_pointers,

  (GDBusSignalInfo **) &foo_signal_info_pointers,

  (GDBusPropertyInfo **)&foo_property_info_pointers,

  NULL,

};

/* Foo2 is just Foo without the properties */

static const GDBusInterfaceInfo foo2_interface_info =

{

  -1,

  "org.example.Foo2",

  (GDBusMethodInfo **) &foo_method_info_pointers,

  (GDBusSignalInfo **) &foo_signal_info_pointers,

};

static void

foo_method_call (GDBusConnection       *connection,

                 const gchar           *sender,

                 const gchar           *object_path,

                 const gchar           *interface_name,

                 const gchar           *method_name,

                 GVariant              *parameters,

                 GDBusMethodInvocation *invocation,

                 gpointer               user_data)

{

  if (g_strcmp0 (method_name, "Method1") == 0)

    {

      const gchar *input;

      gchar *output;

      g_variant_get (parameters, "(&s)", &input);

      output = g_strdup_printf ("You passed the string '%s'. Jolly good!", input);

      g_dbus_method_invocation_return_value (invocation, g_variant_new ("(s)", output));

      g_free (output);

    }

  else

    {

      g_dbus_method_invocation_return_dbus_error (invocation,

                                                  "org.example.SomeError",

                                                  "How do you like them apples, buddy!");

    }

}

static GVariant *

foo_get_property (GDBusConnection       *connection,

                  const gchar           *sender,

                  const gchar           *object_path,

                  const gchar           *interface_name,

                  const gchar           *property_name,

                  GError               **error,

                  gpointer               user_data)

{

  GVariant *ret;

  gchar *s;

  s = g_strdup_printf ("Property '%s' Is What It Is!", property_name);

  ret = g_variant_new_string (s);

  g_free (s);

  return ret;

}

static gboolean

foo_set_property (GDBusConnection       *connection,

                  const gchar           *sender,

                  const gchar           *object_path,

                  const gchar           *interface_name,

                  const gchar           *property_name,

                  GVariant              *value,

                  GError               **error,

                  gpointer               user_data)

{

  gchar *s;

  s = g_variant_print (value, TRUE);

  g_set_error (error,

               G_DBUS_ERROR,

               G_DBUS_ERROR_SPAWN_FILE_INVALID,

               "Returning some error instead of writing the value '%s' to the property '%s'",

               property_name, s);

  g_free (s);

  return FALSE;

}

static const GDBusInterfaceVTable foo_vtable =

{

  foo_method_call,

  foo_get_property,

  foo_set_property

};

/* -------------------- */

static const GDBusMethodInfo bar_method_info[] =

{

  {

    -1,

    "MethodA",

    NULL,

    NULL,

    NULL

  },

  {

    -1,

    "MethodB",

    NULL,

    NULL,

    NULL

  }

};

static const GDBusMethodInfo * const bar_method_info_pointers[] = {&bar_method_info[0], &bar_method_info[1], NULL};

static const GDBusSignalInfo bar_signal_info[] =

{

  {

    -1,

    "SignalMars",

    NULL,

    NULL

  }

};

static const GDBusSignalInfo * const bar_signal_info_pointers[] = {&bar_signal_info[0], NULL};

static const GDBusPropertyInfo bar_property_info[] =

{

  {

    -1,

    "PropertyDuo",

    "s",

    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,

    NULL

  }

};

static const GDBusPropertyInfo * const bar_property_info_pointers[] = {&bar_property_info[0], NULL};

static const GDBusInterfaceInfo bar_interface_info =

{

  -1,

  "org.example.Bar",

  (GDBusMethodInfo **) bar_method_info_pointers,

  (GDBusSignalInfo **) bar_signal_info_pointers,

  (GDBusPropertyInfo **) bar_property_info_pointers,

  NULL,

};

/* -------------------- */

static const GDBusMethodInfo dyna_method_info[] =

{

  {

    -1,

    "DynaCyber",

    NULL,

    NULL,

    NULL

  }

};

static const GDBusMethodInfo * const dyna_method_info_pointers[] = {&dyna_method_info[0], NULL};

static const GDBusInterfaceInfo dyna_interface_info =

{

  -1,

  "org.example.Dyna",

  (GDBusMethodInfo **) dyna_method_info_pointers,

  NULL, /* no signals */

  NULL, /* no properties */

  NULL,

};

static void

dyna_cyber (GDBusConnection *connection,

            const gchar *sender,

            const gchar *object_path,

            const gchar *interface_name,

            const gchar *method_name,

            GVariant *parameters,

            GDBusMethodInvocation *invocation,

            gpointer user_data)

{

  GPtrArray *data = user_data;

  gchar *node_name;

  guint n;

  node_name = strrchr (object_path, '/') + 1;

  /* Add new node if it is not already known */

  for (n = 0; n < data->len ; n++)

    {

      if (g_strcmp0 (g_ptr_array_index (data, n), node_name) == 0)

        goto out;

    }

  g_ptr_array_add (data, g_strdup(node_name));

  out:

    g_dbus_method_invocation_return_value (invocation, NULL);

}

static const GDBusInterfaceVTable dyna_interface_vtable =

{

  dyna_cyber,

  NULL,

  NULL

};

/* ---------------------------------------------------------------------------------------------------- */

static void

introspect_callback (GDBusProxy   *proxy,

                     GAsyncResult *res,

                     gpointer      user_data)

{

  gchar **xml_data = user_data;

  GVariant *result;

  GError *error;

  error = NULL;

  result = g_dbus_proxy_call_finish (proxy,

                                              res,

                                              &error);

  g_assert_no_error (error);

  g_assert (result != NULL);

  g_variant_get (result, "(s)", xml_data);

  g_variant_unref (result);

  g_main_loop_quit (loop);

}

static gchar **

get_nodes_at (GDBusConnection  *c,

              const gchar      *object_path)

{

  GError *error;

  GDBusProxy *proxy;

  gchar *xml_data;

  GPtrArray *p;

  GDBusNodeInfo *node_info;

  guint n;

  error = NULL;

  proxy = g_dbus_proxy_new_sync (c,

                                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |

                                 G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,

                                 NULL,

                                 g_dbus_connection_get_unique_name (c),

                                 object_path,

                                 "org.freedesktop.DBus.Introspectable",

                                 NULL,

                                 &error);

  g_assert_no_error (error);

  g_assert (proxy != NULL);

  /* do this async to avoid libdbus-1 deadlocks */

  xml_data = NULL;

  g_dbus_proxy_call (proxy,

                     "Introspect",

                     NULL,

                     G_DBUS_CALL_FLAGS_NONE,

                     -1,

                     NULL,

                     (GAsyncReadyCallback) introspect_callback,

                     &xml_data);

  g_main_loop_run (loop);

  g_assert (xml_data != NULL);

  node_info = g_dbus_node_info_new_for_xml (xml_data, &error);

  g_assert_no_error (error);

  g_assert (node_info != NULL);

  p = g_ptr_array_new ();

  for (n = 0; node_info->nodes != NULL && node_info->nodes[n] != NULL; n++)

    {

      const GDBusNodeInfo *sub_node_info = node_info->nodes[n];

      g_ptr_array_add (p, g_strdup (sub_node_info->path));

    }

  g_ptr_array_add (p, NULL);

  g_object_unref (proxy);

  g_free (xml_data);

  g_dbus_node_info_unref (node_info);

  return (gchar **) g_ptr_array_free (p, FALSE);

}

static gboolean

has_interface (GDBusConnection *c,

               const gchar     *object_path,

               const gchar     *interface_name)

{

  GError *error;

  GDBusProxy *proxy;

  gchar *xml_data;

  GDBusNodeInfo *node_info;

  gboolean ret;

  error = NULL;

  proxy = g_dbus_proxy_new_sync (c,

                                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |

                                 G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,

                                 NULL,

                                 g_dbus_connection_get_unique_name (c),

                                 object_path,

                                 "org.freedesktop.DBus.Introspectable",

                                 NULL,

                                 &error);

  g_assert_no_error (error);

  g_assert (proxy != NULL);

  /* do this async to avoid libdbus-1 deadlocks */

  xml_data = NULL;

  g_dbus_proxy_call (proxy,

                     "Introspect",

                     NULL,

                     G_DBUS_CALL_FLAGS_NONE,

                     -1,

                     NULL,

                     (GAsyncReadyCallback) introspect_callback,

                     &xml_data);

  g_main_loop_run (loop);

  g_assert (xml_data != NULL);

  node_info = g_dbus_node_info_new_for_xml (xml_data, &error);

  g_assert_no_error (error);

  g_assert (node_info != NULL);

  ret = (g_dbus_node_info_lookup_interface (node_info, interface_name) != NULL);

  g_object_unref (proxy);

  g_free (xml_data);

  g_dbus_node_info_unref (node_info);

  return ret;

}

static guint

count_interfaces (GDBusConnection *c,

                  const gchar     *object_path)

{

  GError *error;

  GDBusProxy *proxy;

  gchar *xml_data;

  GDBusNodeInfo *node_info;

  guint ret;

  error = NULL;

  proxy = g_dbus_proxy_new_sync (c,

                                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |

                                 G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,

                                 NULL,

                                 g_dbus_connection_get_unique_name (c),

                                 object_path,

                                 "org.freedesktop.DBus.Introspectable",

                                 NULL,

                                 &error);

  g_assert_no_error (error);

  g_assert (proxy != NULL);

  /* do this async to avoid libdbus-1 deadlocks */

  xml_data = NULL;

  g_dbus_proxy_call (proxy,

                     "Introspect",

                     NULL,

                     G_DBUS_CALL_FLAGS_NONE,

                     -1,

                     NULL,

                     (GAsyncReadyCallback) introspect_callback,

                     &xml_data);

  g_main_loop_run (loop);

  g_assert (xml_data != NULL);

  node_info = g_dbus_node_info_new_for_xml (xml_data, &error);

  g_assert_no_error (error);

  g_assert (node_info != NULL);

  ret = 0;

  while (node_info->interfaces != NULL && node_info->interfaces[ret] != NULL)

    ret++;

  g_object_unref (proxy);

  g_free (xml_data);

  g_dbus_node_info_unref (node_info);

  return ret;

}

static void

dyna_create_callback (GDBusProxy   *proxy,

                      GAsyncResult  *res,

                      gpointer      user_data)

{

  GVariant *result;

  GError *error;

  error = NULL;

  result = g_dbus_proxy_call_finish (proxy,

                                     res,

                                     &error);

  g_assert_no_error (error);

  g_assert (result != NULL);

  g_variant_unref (result);

  g_main_loop_quit (loop);

}

/* Dynamically create @object_name under /foo/dyna */

static void

dyna_create (GDBusConnection *c,

             const gchar     *object_name)

{

  GError *error;

  GDBusProxy *proxy;

  gchar *object_path;

  object_path = g_strconcat ("/foo/dyna/", object_name, NULL);

  error = NULL;

  proxy = g_dbus_proxy_new_sync (c,

                                 G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES |

                                 G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS,

                                 NULL,

                                 g_dbus_connection_get_unique_name (c),

                                 object_path,

                                 "org.example.Dyna",

                                 NULL,

                                 &error);

  g_assert_no_error (error);

  g_assert (proxy != NULL);

  /* do this async to avoid libdbus-1 deadlocks */

  g_dbus_proxy_call (proxy,

                     "DynaCyber",

                     g_variant_new ("()"),

                     G_DBUS_CALL_FLAGS_NONE,

                     -1,

                     NULL,

                     (GAsyncReadyCallback) dyna_create_callback,

                     NULL);

  g_main_loop_run (loop);

  g_assert_no_error (error);

  g_object_unref (proxy);

  g_free (object_path);

  return;

}

typedef struct

{

  guint num_unregistered_calls;

  guint num_unregistered_subtree_calls;

  guint num_subtree_nodes;

} ObjectRegistrationData;

static void

on_object_unregistered (gpointer user_data)

{

  ObjectRegistrationData *data = user_data;

  data->num_unregistered_calls++;

}

static void

on_subtree_unregistered (gpointer user_data)

{

  ObjectRegistrationData *data = user_data;

  data->num_unregistered_subtree_calls++;

}

static gboolean

_g_strv_has_string (const gchar* const * haystack,

                    const gchar *needle)

{

  guint n;

  for (n = 0; haystack != NULL && haystack[n] != NULL; n++)

    {

      if (g_strcmp0 (haystack[n], needle) == 0)

        return TRUE;

    }

  return FALSE;

}

/* -------------------- */

static gchar **

subtree_enumerate (GDBusConnection       *connection,

                   const gchar           *sender,

                   const gchar           *object_path,

                   gpointer               user_data)

{

  ObjectRegistrationData *data = user_data;

  GPtrArray *p;

  gchar **nodes;

  guint n;

  p = g_ptr_array_new ();

  for (n = 0; n < data->num_subtree_nodes; n++)

    {

      g_ptr_array_add (p, g_strdup_printf ("vp%d", n));

      g_ptr_array_add (p, g_strdup_printf ("evp%d", n));

    }

  g_ptr_array_add (p, NULL);

  nodes = (gchar **) g_ptr_array_free (p, FALSE);

  return nodes;

}

/* Only allows certain objects, and aborts on unknowns */

static GDBusInterfaceInfo **

subtree_introspect (GDBusConnection       *connection,

                    const gchar           *sender,

                    const gchar           *object_path,

                    const gchar           *node,

                    gpointer               user_data)

{

  const GDBusInterfaceInfo *interfaces[2] = {

     NULL /* filled in below */, NULL

  };

  /* VPs implement the Foo interface, EVPs implement the Bar interface. The root

   * does not implement any interfaces

   */

  if (node == NULL)

    {

      return NULL;

    }

  else if (g_str_has_prefix (node, "vp"))

    {

      interfaces[0] = &foo_interface_info;

    }

  else if (g_str_has_prefix (node, "evp"))

    {

      interfaces[0] = &bar_interface_info;

    }

  else

    {

      g_assert_not_reached ();

    }

  return g_memdup (interfaces, 2 * sizeof (void *));

}

static const GDBusInterfaceVTable *

subtree_dispatch (GDBusConnection             *connection,

                  const gchar                 *sender,

                  const gchar                 *object_path,

                  const gchar                 *interface_name,

                  const gchar                 *node,

                  gpointer                    *out_user_data,

                  gpointer                     user_data)

{

  if (g_strcmp0 (interface_name, "org.example.Foo") == 0)

    return &foo_vtable;

  else

    return NULL;

}

static const GDBusSubtreeVTable subtree_vtable =

{

  subtree_enumerate,

  subtree_introspect,

  subtree_dispatch

};

/* -------------------- */

static gchar **

dynamic_subtree_enumerate (GDBusConnection       *connection,

                           const gchar           *sender,

                           const gchar           *object_path,

                           gpointer               user_data)

{

  GPtrArray *data = user_data;

  gchar **nodes = g_new (gchar*, data->len + 1);

  guint n;

  for (n = 0; n < data->len; n++)

    {

      nodes[n] = g_strdup (g_ptr_array_index (data, n));

    }

  nodes[data->len] = NULL;

  return nodes;

}

/* Allow all objects to be introspected */

static GDBusInterfaceInfo **

dynamic_subtree_introspect (GDBusConnection       *connection,

                            const gchar           *sender,

                            const gchar           *object_path,

                            const gchar           *node,

                            gpointer               user_data)

{

  const GDBusInterfaceInfo *interfaces[2] = { &dyna_interface_info, NULL };

  return g_memdup (interfaces, 2 * sizeof (void *));

}

static const GDBusInterfaceVTable *

dynamic_subtree_dispatch (GDBusConnection             *connection,

                          const gchar                 *sender,

                          const gchar                 *object_path,

                          const gchar                 *interface_name,

                          const gchar                 *node,

                          gpointer                    *out_user_data,

                          gpointer                     user_data)

{

  *out_user_data = user_data;

  return &dyna_interface_vtable;

}

static const GDBusSubtreeVTable dynamic_subtree_vtable =

{

  dynamic_subtree_enumerate,

  dynamic_subtree_introspect,

  dynamic_subtree_dispatch

};

/* -------------------- */

typedef struct

{

  const gchar *object_path;

  gboolean check_remote_errors;

} TestDispatchThreadFuncArgs;

static gpointer

test_dispatch_thread_func (gpointer user_data)

{

  TestDispatchThreadFuncArgs *args = user_data;

  const gchar *object_path = args->object_path;

  GDBusProxy *foo_proxy;

  GVariant *value;

  GVariant *inner;

  GError *error;

  gchar *s;

  const gchar *value_str;

  foo_proxy = g_dbus_proxy_new_sync (c,

                                     G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS |

                                     G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,

                                     NULL,

                                     g_dbus_connection_get_unique_name (c),

                                     object_path,

                                     "org.example.Foo",

                                     NULL,

                                     &error);

  g_assert (foo_proxy != NULL);

  /* generic interfaces */

  error = NULL;

  value = g_dbus_proxy_call_sync (foo_proxy,

                                  "org.freedesktop.DBus.Peer.Ping",

                                  NULL,

                                  G_DBUS_CALL_FLAGS_NONE,

                                  -1,

                                  NULL,

                                  &error);

  g_assert_no_error (error);

  g_assert (value != NULL);

  g_variant_unref (value);

  /* user methods */

  error = NULL;

  value = g_dbus_proxy_call_sync (foo_proxy,

                                  "Method1",

                                  g_variant_new ("(s)", "winwinwin"),

                                  G_DBUS_CALL_FLAGS_NONE,

                                  -1,

                                  NULL,

                                  &error);

  g_assert_no_error (error);

  g_assert (value != NULL);

  g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE ("(s)")));

  g_variant_get (value, "(&s)", &value_str);

  g_assert_cmpstr (value_str, ==, "You passed the string 'winwinwin'. Jolly good!");

  g_variant_unref (value);

  error = NULL;

  value = g_dbus_proxy_call_sync (foo_proxy,

                                  "Method2",

                                  NULL,

                                  G_DBUS_CALL_FLAGS_NONE,

                                  -1,

                                  NULL,

                                  &error);

  g_assert_error (error, G_IO_ERROR, G_IO_ERROR_DBUS_ERROR);

  g_assert_cmpstr (error->message, ==, "GDBus.Error:org.example.SomeError: How do you like them apples, buddy!");

  g_error_free (error);

  g_assert (value == NULL);

  error = NULL;

  value = g_dbus_proxy_call_sync (foo_proxy,

                                  "Method2",

                                  g_variant_new ("(s)", "failfailfail"),

                                  G_DBUS_CALL_FLAGS_NONE,

                                  -1,

                                  NULL,

                                  &error);

  g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS);

  g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: Type of message, '(s)', does not match expected type '()'");

  g_error_free (error);

  g_assert (value == NULL);

  error = NULL;

  value = g_dbus_proxy_call_sync (foo_proxy,

                                  "NonExistantMethod",

                                  NULL,

                                  G_DBUS_CALL_FLAGS_NONE,

                                  -1,

                                  NULL,

                                  &error);

  g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD);

  g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.UnknownMethod: No such method 'NonExistantMethod'");

  g_error_free (error);

  g_assert (value == NULL);

  error = NULL;

  value = g_dbus_proxy_call_sync (foo_proxy,

                                  "org.example.FooXYZ.NonExistant",

                                  NULL,

                                  G_DBUS_CALL_FLAGS_NONE,

                                  -1,

                                  NULL,

                                  &error);

  g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD);

  g_error_free (error);

  g_assert (value == NULL);

  /* user properties */

  error = NULL;

  value = g_dbus_proxy_call_sync (foo_proxy,

                                  "org.freedesktop.DBus.Properties.Get",

                                  g_variant_new ("(ss)",

                                                 "org.example.Foo",

                                                 "PropertyUno"),

                                  G_DBUS_CALL_FLAGS_NONE,

                                  -1,

                                  NULL,

                                  &error);

  g_assert_no_error (error);

  g_assert (value != NULL);

  g_assert (g_variant_is_of_type (value, G_VARIANT_TYPE ("(v)")));

  g_variant_get (value, "(v)", &inner);

  g_assert (g_variant_is_of_type (inner, G_VARIANT_TYPE_STRING));

  g_assert_cmpstr (g_variant_get_string (inner, NULL), ==, "Property 'PropertyUno' Is What It Is!");

  g_variant_unref (value);

  g_variant_unref (inner);

  error = NULL;

  value = g_dbus_proxy_call_sync (foo_proxy,

                                  "org.freedesktop.DBus.Properties.Get",

                                  g_variant_new ("(ss)",

                                                 "org.example.Foo",

                                                 "ThisDoesntExist"),

                                  G_DBUS_CALL_FLAGS_NONE,

                                  -1,

                                  NULL,

                                  &error);

  g_assert (value == NULL);

  g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS);

  g_assert_cmpstr (error->message, ==, "GDBus.Error:org.freedesktop.DBus.Error.InvalidArgs: No such property 'ThisDoesntExist'");

  g_error_free (error);

  error = NULL;