/* GLib testing framework examples and tests

 *

 * Copyright (C) 2008-2011 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 <stdio.h>

#include "gdbus-tests.h"

#include "gdbus-test-codegen-generated.h"

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

static guint

count_annotations (GDBusAnnotationInfo **annotations)

{

  guint ret;

  ret = 0;

  while (annotations != NULL && annotations[ret] != NULL)

    ret++;

  return ret;

}

/* checks that

 *

 *  - non-internal annotations are written out correctly; and

 *  - injection via --annotation --key --value works

 */

static void

test_annotations (void)

{

  GDBusInterfaceInfo *iface;

  GDBusMethodInfo *method;

  GDBusSignalInfo *signal;

  GDBusPropertyInfo *property;

  iface = foo_igen_bar_interface_info ();

  g_assert (iface != NULL);

  /* see Makefile.am for where these annotations are injected */

  g_assert_cmpint (count_annotations (iface->annotations), ==, 1);

  g_assert_cmpstr (g_dbus_annotation_info_lookup (iface->annotations, "Key1"), ==, "Value1");

  method = g_dbus_interface_info_lookup_method (iface, "HelloWorld");

  g_assert (method != NULL);

  g_assert_cmpint (count_annotations (method->annotations), ==, 2);

  g_assert_cmpstr (g_dbus_annotation_info_lookup (method->annotations, "ExistingAnnotation"), ==, "blah");

  g_assert_cmpstr (g_dbus_annotation_info_lookup (method->annotations, "Key3"), ==, "Value3");

  signal = g_dbus_interface_info_lookup_signal (iface, "TestSignal");

  g_assert (signal != NULL);

  g_assert_cmpint (count_annotations (signal->annotations), ==, 1);

  g_assert_cmpstr (g_dbus_annotation_info_lookup (signal->annotations, "Key4"), ==, "Value4");

  g_assert_cmpstr (g_dbus_annotation_info_lookup (signal->args[1]->annotations, "Key8"), ==, "Value8");

  property = g_dbus_interface_info_lookup_property (iface, "ay");

  g_assert (property != NULL);

  g_assert_cmpint (count_annotations (property->annotations), ==, 1);

  g_assert_cmpstr (g_dbus_annotation_info_lookup (property->annotations, "Key5"), ==, "Value5");

  method = g_dbus_interface_info_lookup_method (iface, "TestPrimitiveTypes");

  g_assert (method != NULL);

  g_assert_cmpstr (g_dbus_annotation_info_lookup (method->in_args[4]->annotations, "Key6"), ==, "Value6");

  g_assert_cmpstr (g_dbus_annotation_info_lookup (method->out_args[5]->annotations, "Key7"), ==, "Value7");

}

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

static gboolean

on_handle_hello_world (FooiGenBar             *object,

                       GDBusMethodInvocation  *invocation,

                       const gchar            *greeting,

                       gpointer                user_data)

{

  gchar *response;

  response = g_strdup_printf ("Word! You said '%s'. I'm Skeleton, btw!", greeting);

  foo_igen_bar_complete_hello_world (object, invocation, response);

  g_free (response);

  return TRUE;

}

static gboolean

on_handle_test_primitive_types (FooiGenBar            *object,

                                GDBusMethodInvocation *invocation,

                                guchar                 val_byte,

                                gboolean               val_boolean,

                                gint16                 val_int16,

                                guint16                val_uint16,

                                gint                   val_int32,

                                guint                  val_uint32,

                                gint64                 val_int64,

                                guint64                val_uint64,

                                gdouble                val_double,

                                const gchar           *val_string,

                                const gchar           *val_objpath,

                                const gchar           *val_signature,

                                const gchar           *val_bytestring,

                                gpointer               user_data)

{

  gchar *s1;

  gchar *s2;

  gchar *s3;

  s1 = g_strdup_printf ("Word! You said '%s'. Rock'n'roll!", val_string);

  s2 = g_strdup_printf ("/modified%s", val_objpath);

  s3 = g_strdup_printf ("assgit%s", val_signature);

  foo_igen_bar_complete_test_primitive_types (object,

                                              invocation,

                                              10 + val_byte,

                                              !val_boolean,

                                              100 + val_int16,

                                              1000 + val_uint16,

                                              10000 + val_int32,

                                              100000 + val_uint32,

                                              1000000 + val_int64,

                                              10000000 + val_uint64,

                                              val_double / G_PI,

                                              s1,

                                              s2,

                                              s3,

                                              "bytestring!\xff");

  g_free (s1);

  g_free (s2);

  g_free (s3);

  return TRUE;

}

static gboolean

on_handle_test_non_primitive_types (FooiGenBar            *object,

                                    GDBusMethodInvocation *invocation,

                                    GVariant              *dict_s_to_s,

                                    GVariant              *dict_s_to_pairs,

                                    GVariant              *a_struct,

                                    const gchar* const    *array_of_strings,

                                    const gchar* const    *array_of_objpaths,

                                    GVariant              *array_of_signatures,

                                    const gchar* const    *array_of_bytestrings,

                                    gpointer               user_data)

{

  gchar *s;

  GString *str;

  str = g_string_new (NULL);

  s = g_variant_print (dict_s_to_s, TRUE); g_string_append (str, s); g_free (s);

  s = g_variant_print (dict_s_to_pairs, TRUE); g_string_append (str, s); g_free (s);

  s = g_variant_print (a_struct, TRUE); g_string_append (str, s); g_free (s);

  s = g_strjoinv (", ", (gchar **) array_of_strings);

  g_string_append_printf (str, "array_of_strings: [%s] ", s);

  g_free (s);

  s = g_strjoinv (", ", (gchar **) array_of_objpaths);

  g_string_append_printf (str, "array_of_objpaths: [%s] ", s);

  g_free (s);

  s = g_variant_print (array_of_signatures, TRUE);

  g_string_append_printf (str, "array_of_signatures: %s ", s);

  g_free (s);

  s = g_strjoinv (", ", (gchar **) array_of_bytestrings);

  g_string_append_printf (str, "array_of_bytestrings: [%s] ", s);

  g_free (s);

  foo_igen_bar_complete_test_non_primitive_types (object, invocation,

                                                  array_of_strings,

                                                  array_of_objpaths,

                                                  array_of_signatures,

                                                  array_of_bytestrings,

                                                  str->str);

  g_string_free (str, TRUE);

  return TRUE;

}

static gboolean

on_handle_request_signal_emission (FooiGenBar             *object,

                                   GDBusMethodInvocation  *invocation,

                                   gint                    which_one,

                                   gpointer                user_data)

{

  if (which_one == 0)

    {

      const gchar *a_strv[] = {"foo", "bar", NULL};

      const gchar *a_bytestring_array[] = {"foo\xff", "bar\xff", NULL};

      GVariant *a_variant = g_variant_new_parsed ("{'first': (42, 42), 'second': (43, 43)}");

      foo_igen_bar_emit_test_signal (object, 43, a_strv, a_bytestring_array, a_variant); /* consumes a_variant */

      foo_igen_bar_complete_request_signal_emission (object, invocation);

    }

  return TRUE;

}

static gboolean

on_handle_request_multi_property_mods (FooiGenBar             *object,

                                       GDBusMethodInvocation  *invocation,

                                       gpointer                user_data)

{

  foo_igen_bar_set_y (object, foo_igen_bar_get_y (object) + 1);

  foo_igen_bar_set_i (object, foo_igen_bar_get_i (object) + 1);

  foo_igen_bar_set_y (object, foo_igen_bar_get_y (object) + 1);

  foo_igen_bar_set_i (object, foo_igen_bar_get_i (object) + 1);

  g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (object));

  foo_igen_bar_set_y (object, foo_igen_bar_get_y (object) + 1);

  foo_igen_bar_set_i (object, foo_igen_bar_get_i (object) + 1);

  foo_igen_bar_complete_request_multi_property_mods (object, invocation);

  return TRUE;

}

static gboolean

on_handle_property_cancellation (FooiGenBar             *object,

                                 GDBusMethodInvocation  *invocation,

                                 gpointer                user_data)

{

  guint n;

  n = foo_igen_bar_get_n (object);

  /* This queues up a PropertiesChange event */

  foo_igen_bar_set_n (object, n + 1);

  /* this modifies the queued up event */

  foo_igen_bar_set_n (object, n);

  /* this flushes all PropertiesChanges event (sends the D-Bus message right

   * away, if any - there should not be any)

   */

  g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (object));

  /* this makes us return the reply D-Bus method */

  foo_igen_bar_complete_property_cancellation (object, invocation);

  return TRUE;

}

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

static gboolean

on_handle_force_method (FooiGenBat             *object,

                        GDBusMethodInvocation  *invocation,

                        GVariant               *force_in_i,

                        GVariant               *force_in_s,

                        GVariant               *force_in_ay,

                        GVariant               *force_in_struct,

                        gpointer                user_data)

{

  GVariant *ret_i;

  GVariant *ret_s;

  GVariant *ret_ay;

  GVariant *ret_struct;

  gint32 val;

  gchar *s;

  ret_i = g_variant_new_int32 (g_variant_get_int32 (force_in_i) + 10);

  s = g_strdup_printf ("%s_foo", g_variant_get_string (force_in_s, NULL));

  ret_s = g_variant_new_string (s);

  g_free (s);

  s = g_strdup_printf ("%s_foo\xff", g_variant_get_bytestring (force_in_ay));

  ret_ay = g_variant_new_bytestring (s);

  g_free (s);

  g_variant_get (force_in_struct, "(i)", &val;;

  ret_struct = g_variant_new ("(i)", val + 10);

  g_variant_ref_sink (ret_i);

  g_variant_ref_sink (ret_s);

  g_variant_ref_sink (ret_ay);

  g_variant_ref_sink (ret_struct);

  foo_igen_bat_emit_force_signal (object,

                                  ret_i,

                                  ret_s,

                                  ret_ay,

                                  ret_struct);

  foo_igen_bat_complete_force_method (object,

                                      invocation,

                                      ret_i,

                                      ret_s,

                                      ret_ay,

                                      ret_struct);

  g_variant_unref (ret_i);

  g_variant_unref (ret_s);

  g_variant_unref (ret_ay);

  g_variant_unref (ret_struct);

  return TRUE;

}

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

static gboolean

my_g_authorize_method_handler (GDBusInterfaceSkeleton *interface,

                               GDBusMethodInvocation  *invocation,

                               gpointer                user_data)

{

  const gchar *method_name;

  gboolean authorized;

  authorized = FALSE;

  method_name = g_dbus_method_invocation_get_method_name (invocation);

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

    {

      authorized = FALSE;

    }

  else if (g_strcmp0 (method_name, "CheckAuthorized") == 0)

    {

      authorized = TRUE;

    }

  else if (g_strcmp0 (method_name, "CheckNotAuthorizedFromObject") == 0)

    {

      authorized = TRUE;

    }

  else

    {

      g_assert_not_reached ();

    }

  if (!authorized)

    {

      g_dbus_method_invocation_return_error (invocation,

                                             G_IO_ERROR,

                                             G_IO_ERROR_PERMISSION_DENIED,

                                             "not authorized...");

    }

  return authorized;

}

static gboolean

my_object_authorize_method_handler (GDBusObjectSkeleton     *object,

                                    GDBusInterfaceSkeleton  *interface,

                                    GDBusMethodInvocation   *invocation,

                                    gpointer                 user_data)

{

  const gchar *method_name;

  gboolean authorized;

  authorized = FALSE;

  method_name = g_dbus_method_invocation_get_method_name (invocation);

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

    {

      authorized = TRUE;

    }

  else if (g_strcmp0 (method_name, "CheckAuthorized") == 0)

    {

      authorized = TRUE;

    }

  else if (g_strcmp0 (method_name, "CheckNotAuthorizedFromObject") == 0)

    {

      authorized = FALSE;

    }

  else

    {

      g_assert_not_reached ();

    }

  if (!authorized)

    {

      g_dbus_method_invocation_return_error (invocation,

                                             G_IO_ERROR,

                                             G_IO_ERROR_PENDING,

                                             "not authorized (from object)...");

    }

  return authorized;

}

static gboolean

on_handle_check_not_authorized (FooiGenAuthorize       *object,

                                GDBusMethodInvocation  *invocation,

                                gpointer                user_data)

{

  foo_igen_authorize_complete_check_not_authorized (object, invocation);

  return TRUE;

}

static gboolean

on_handle_check_authorized (FooiGenAuthorize       *object,

                            GDBusMethodInvocation  *invocation,

                            gpointer                user_data)

{

  foo_igen_authorize_complete_check_authorized (object, invocation);

  return TRUE;

}

static gboolean

on_handle_check_not_authorized_from_object (FooiGenAuthorize       *object,

                                            GDBusMethodInvocation  *invocation,

                                            gpointer                user_data)

{

  foo_igen_authorize_complete_check_not_authorized_from_object (object, invocation);

  return TRUE;

}

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

static gboolean

on_handle_get_self (FooiGenMethodThreads   *object,

                    GDBusMethodInvocation  *invocation,

                    gpointer                user_data)

{

  gchar *s;

  s = g_strdup_printf ("%p", (void *)g_thread_self ());

  foo_igen_method_threads_complete_get_self (object, invocation, s);

  g_free (s);

  return TRUE;

}

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

static GThread *method_handler_thread = NULL;

static FooiGenBar *exported_bar_object = NULL;

static FooiGenBat *exported_bat_object = NULL;

static FooiGenAuthorize *exported_authorize_object = NULL;

static GDBusObjectSkeleton *authorize_enclosing_object = NULL;

static FooiGenMethodThreads *exported_thread_object_1 = NULL;

static FooiGenMethodThreads *exported_thread_object_2 = NULL;

static void

unexport_objects (void)

{

  g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (exported_bar_object));

  g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (exported_bat_object));

  g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (exported_authorize_object));

  g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (exported_thread_object_1));

  g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (exported_thread_object_2));

}

static void

on_bus_acquired (GDBusConnection *connection,

                 const gchar     *name,

                 gpointer         user_data)

{

  GError *error;

  /* Test that we can export an object using the generated

   * FooiGenBarSkeleton subclass. Notes:

   *

   * 1. We handle methods by simply connecting to the appropriate

   * GObject signal.

   *

   * 2. Property storage is taken care of by the class; we can

   *    use g_object_get()/g_object_set() (and the generated

   *    C bindings at will)

   */

  error = NULL;

  exported_bar_object = foo_igen_bar_skeleton_new ();

  foo_igen_bar_set_ay (exported_bar_object, "ABCabc");

  foo_igen_bar_set_y (exported_bar_object, 42);

  foo_igen_bar_set_d (exported_bar_object, 43.0);

  foo_igen_bar_set_finally_normal_name (exported_bar_object, "There aint no place like home");

  foo_igen_bar_set_writeonly_property (exported_bar_object, "Mr. Burns");

  /* The following works because it's on the Skeleton object - it will

   * fail (at run-time) on a Proxy (see on_proxy_appeared() below)

   */

  foo_igen_bar_set_readonly_property (exported_bar_object, "blah");

  g_assert_cmpstr (foo_igen_bar_get_writeonly_property (exported_bar_object), ==, "Mr. Burns");

  g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (exported_bar_object),

                                    connection,

                                    "/bar",

                                    &error);

  g_assert_no_error (error);

  g_signal_connect (exported_bar_object,

                    "handle-hello-world",

                    G_CALLBACK (on_handle_hello_world),

                    NULL);

  g_signal_connect (exported_bar_object,

                    "handle-test-primitive-types",

                    G_CALLBACK (on_handle_test_primitive_types),

                    NULL);

  g_signal_connect (exported_bar_object,

                    "handle-test-non-primitive-types",

                    G_CALLBACK (on_handle_test_non_primitive_types),

                    NULL);

  g_signal_connect (exported_bar_object,

                    "handle-request-signal-emission",

                    G_CALLBACK (on_handle_request_signal_emission),

                    NULL);

  g_signal_connect (exported_bar_object,

                    "handle-request-multi-property-mods",

                    G_CALLBACK (on_handle_request_multi_property_mods),

                    NULL);

  g_signal_connect (exported_bar_object,

                    "handle-property-cancellation",

                    G_CALLBACK (on_handle_property_cancellation),

                    NULL);

  exported_bat_object = foo_igen_bat_skeleton_new ();

  g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (exported_bat_object),

                                    connection,

                                    "/bat",

                                    &error);

  g_assert_no_error (error);

  g_signal_connect (exported_bat_object,

                    "handle-force-method",

                    G_CALLBACK (on_handle_force_method),

                    NULL);

  g_object_set (exported_bat_object,

                "force-i", g_variant_new_int32 (43),

                "force-s", g_variant_new_string ("prop string"),

                "force-ay", g_variant_new_bytestring ("prop bytestring\xff"),

                "force-struct", g_variant_new ("(i)", 4300),

                NULL);

  authorize_enclosing_object = g_dbus_object_skeleton_new ("/authorize");

  g_signal_connect (authorize_enclosing_object,

                    "authorize-method",

                    G_CALLBACK (my_object_authorize_method_handler),

                    NULL);

  exported_authorize_object = foo_igen_authorize_skeleton_new ();

  g_dbus_object_skeleton_add_interface (authorize_enclosing_object,

                                        G_DBUS_INTERFACE_SKELETON (exported_authorize_object));

  g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (exported_authorize_object),

                                    connection,

                                    "/authorize",

                                    &error);

  g_assert_no_error (error);

  g_signal_connect (exported_authorize_object,

                    "g-authorize-method",

                    G_CALLBACK (my_g_authorize_method_handler),

                    NULL);

  g_signal_connect (exported_authorize_object,

                    "handle-check-not-authorized",

                    G_CALLBACK (on_handle_check_not_authorized),

                    NULL);

  g_signal_connect (exported_authorize_object,

                    "handle-check-authorized",

                    G_CALLBACK (on_handle_check_authorized),

                    NULL);

  g_signal_connect (exported_authorize_object,

                    "handle-check-not-authorized-from-object",

                    G_CALLBACK (on_handle_check_not_authorized_from_object),

                    NULL);

  /* only object 1 has the G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD flag set */

  exported_thread_object_1 = foo_igen_method_threads_skeleton_new ();

  g_dbus_interface_skeleton_set_flags (G_DBUS_INTERFACE_SKELETON (exported_thread_object_1),

                                       G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);

  g_assert (!g_dbus_interface_skeleton_has_connection (G_DBUS_INTERFACE_SKELETON (exported_thread_object_1), connection));

  g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (exported_thread_object_1),

                                    connection,

                                    "/method_threads_1",

                                    &error);

  g_assert_no_error (error);

  g_signal_connect (exported_thread_object_1,

                    "handle-get-self",

                    G_CALLBACK (on_handle_get_self),

                    NULL);

  g_assert_cmpint (g_dbus_interface_skeleton_get_flags (G_DBUS_INTERFACE_SKELETON (exported_thread_object_1)), ==, G_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_THREAD);

  exported_thread_object_2 = foo_igen_method_threads_skeleton_new ();

  g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (exported_thread_object_2),

                                    connection,

                                    "/method_threads_2",

                                    &error);

  g_assert_no_error (error);

  g_signal_connect (exported_thread_object_2,

                    "handle-get-self",

                    G_CALLBACK (on_handle_get_self),

                    NULL);

  g_assert_cmpint (g_dbus_interface_skeleton_get_flags (G_DBUS_INTERFACE_SKELETON (exported_thread_object_2)), ==, G_DBUS_INTERFACE_SKELETON_FLAGS_NONE);

  method_handler_thread = g_thread_self ();

}

static gpointer check_proxies_in_thread (gpointer user_data);

static void

on_name_acquired (GDBusConnection *connection,

                  const gchar     *name,

                  gpointer         user_data)

{

  GMainLoop *loop = user_data;

  g_thread_new ("check-proxies",

                check_proxies_in_thread,

                loop);

}

static void

on_name_lost (GDBusConnection *connection,

              const gchar     *name,

              gpointer         user_data)

{

  g_assert_not_reached ();

}

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

typedef struct

{

  GMainLoop *thread_loop;

  gint initial_y;

  gint initial_i;

  guint num_g_properties_changed;

  gboolean received_test_signal;

  guint num_notify_u;

  guint num_notify_n;

} ClientData;

static void

on_notify_u (GObject    *object,

           GParamSpec *pspec,

           gpointer    user_data)

{

  ClientData *data = user_data;

  g_assert_cmpstr (pspec->name, ==, "u");

  data->num_notify_u += 1;

}

static void

on_notify_n (GObject    *object,

             GParamSpec *pspec,

             gpointer    user_data)

{

  ClientData *data = user_data;

  g_assert_cmpstr (pspec->name, ==, "n");

  data->num_notify_n += 1;

}

static void

on_g_properties_changed (GDBusProxy          *_proxy,

                         GVariant            *changed_properties,

                         const gchar* const  *invalidated_properties,

                         gpointer             user_data)

{

  ClientData *data = user_data;

  FooiGenBar *proxy = FOO_IGEN_BAR (_proxy);

  g_assert_cmpint (g_variant_n_children (changed_properties), ==, 2);

  if (data->num_g_properties_changed == 0)

    {

      g_assert_cmpint (data->initial_y, ==, foo_igen_bar_get_y (proxy) - 2);

      g_assert_cmpint (data->initial_i, ==, foo_igen_bar_get_i (proxy) - 2);

    }

  else if (data->num_g_properties_changed == 1)

    {

      g_assert_cmpint (data->initial_y, ==, foo_igen_bar_get_y (proxy) - 3);

      g_assert_cmpint (data->initial_i, ==, foo_igen_bar_get_i (proxy) - 3);

    }

  else

    g_assert_not_reached ();

  data->num_g_properties_changed++;

  if (data->num_g_properties_changed == 2)

    g_main_loop_quit (data->thread_loop);

}

static void

on_test_signal (FooiGenBar          *proxy,

                gint                 val_int32,

                const gchar* const  *array_of_strings,

                const gchar* const  *array_of_bytestrings,

                GVariant            *dict_s_to_pairs,

                gpointer             user_data)

{

  ClientData *data = user_data;

  g_assert_cmpint (val_int32, ==, 43);

  g_assert_cmpstr (array_of_strings[0], ==, "foo");

  g_assert_cmpstr (array_of_strings[1], ==, "bar");

  g_assert (array_of_strings[2] == NULL);

  g_assert_cmpstr (array_of_bytestrings[0], ==, "foo\xff");

  g_assert_cmpstr (array_of_bytestrings[1], ==, "bar\xff");

  g_assert (array_of_bytestrings[2] == NULL);

  data->received_test_signal = TRUE;

  g_main_loop_quit (data->thread_loop);

}

static void

on_property_cancellation_cb (FooiGenBar    *proxy,

                             GAsyncResult  *res,

                             gpointer       user_data)

{

  ClientData *data = user_data;

  gboolean ret;

  GError *error = NULL;

  error = NULL;

  ret = foo_igen_bar_call_property_cancellation_finish (proxy, res, &error);

  g_assert_no_error (error);

  g_assert (ret);

  g_main_loop_quit (data->thread_loop);

}

static void

check_bar_proxy (FooiGenBar *proxy,

                 GMainLoop  *thread_loop)

{

  const gchar *array_of_strings[3] = {"one", "two", NULL};

  const gchar *array_of_strings_2[3] = {"one2", "two2", NULL};

  const gchar *array_of_objpaths[3] = {"/one", "/one/two", NULL};

  GVariant *array_of_signatures = NULL;

  const gchar *array_of_bytestrings[3] = {"one\xff", "two\xff", NULL};

  gchar **ret_array_of_strings = NULL;

  gchar **ret_array_of_objpaths = NULL;

  GVariant *ret_array_of_signatures = NULL;

  gchar **ret_array_of_bytestrings = NULL;

  guchar ret_val_byte;

  gboolean ret_val_boolean;

  gint16 ret_val_int16;

  guint16 ret_val_uint16;

  gint ret_val_int32;

  guint ret_val_uint32;

  gint64 ret_val_int64;

  guint64 ret_val_uint64;

  gdouble ret_val_double;

  gchar *ret_val_string;

  gchar *ret_val_objpath;

  gchar *ret_val_signature;

  gchar *ret_val_bytestring;

  gboolean ret;

  GError *error;

  ClientData *data;

  guchar val_y;

  gboolean val_b;

  gint val_n;

  guint val_q;

  gint val_i;

  guint val_u;

  gint64 val_x;

  guint64 val_t;

  gdouble val_d;

  gchar *val_s;

  gchar *val_o;

  gchar *val_g;

  gchar *val_ay;

  gchar **val_as;

  gchar **val_ao;

  GVariant *val_ag;

  gint32 val_unset_i;

  gdouble val_unset_d;

  gchar *val_unset_s;

  gchar *val_unset_o;

  gchar *val_unset_g;

  gchar *val_unset_ay;

  gchar **val_unset_as;

  gchar **val_unset_ao;

  GVariant *val_unset_ag;

  GVariant *val_unset_struct;

  gchar *val_finally_normal_name;

  GVariant *v;

  gchar *s;

  const gchar *const *read_as;

  const gchar *const *read_as2;

  const gchar *const *read_as3;

  data = g_new0 (ClientData, 1);

  data->thread_loop = thread_loop;

  v = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "y");

  g_assert (v != NULL);

  g_variant_unref (v);

  /* set empty values to non-empty */

  val_unset_i = 42;

  val_unset_d = 42.0;

  val_unset_s = "42";

  val_unset_o = "42";

  val_unset_g = "42";

  val_unset_ay = NULL;

  val_unset_as = NULL;

  val_unset_ao = NULL;

  val_unset_ag = NULL;

  val_unset_struct = NULL;

  /* check properties */

  g_object_get (proxy,

                "y", &val_y,

                "b", &val_b,

                "n", &val_n,

                "q", &val_q,

                "i", &val_i,

                "u", &val_u,

                "x", &val_x,

                "t", &val_t,

                "d", &val_d,

                "s", &val_s,

                "o", &val_o,

                "g", &val_g,

                "ay", &val_ay,

                "as", &val_as,

                "ao", &val_ao,

                "ag", &val_ag,

                "unset_i", &val_unset_i,

                "unset_d", &val_unset_d,

                "unset_s", &val_unset_s,

                "unset_o", &val_unset_o,

                "unset_g", &val_unset_g,

                "unset_ay", &val_unset_ay,

                "unset_as", &val_unset_as,

                "unset_ao", &val_unset_ao,

                "unset_ag", &val_unset_ag,

                "unset_struct", &val_unset_struct,

                "finally-normal-name", &val_finally_normal_name,

                NULL);

  g_assert_cmpint (val_y, ==, 42);

  g_assert_cmpstr (val_finally_normal_name, ==, "There aint no place like home");

  g_free (val_s);

  g_free (val_o);

  g_free (val_g);

  g_assert_cmpstr (val_ay, ==, "ABCabc");

  g_free (val_ay);

  g_strfreev (val_as);

  g_strfreev (val_ao);

  g_variant_unref (val_ag);

  g_free (val_finally_normal_name);

  /* check empty values */

  g_assert_cmpint (val_unset_i, ==, 0);

  g_assert_cmpfloat (val_unset_d, ==, 0.0);

  g_assert_cmpstr (val_unset_s, ==, "");

  g_assert_cmpstr (val_unset_o, ==, "/");

  g_assert_cmpstr (val_unset_g, ==, "");

  g_free (val_unset_s);

  g_free (val_unset_o);

  g_free (val_unset_g);

  g_assert_cmpstr (val_unset_ay, ==, "");

  g_assert (val_unset_as[0] == NULL);

  g_assert (val_unset_ao[0] == NULL);

  g_assert (g_variant_is_of_type (val_unset_ag, G_VARIANT_TYPE ("ag")));

  g_assert (g_variant_is_of_type (val_unset_struct, G_VARIANT_TYPE ("(idsogayasaoag)")));

  s = g_variant_print (val_unset_struct, TRUE);

  g_assert_cmpstr (s, ==, "(0, 0.0, '', objectpath '/', signature '', @ay [], @as [], @ao [], @ag [])");

  g_free (s);

  g_free (val_unset_ay);

  g_strfreev (val_unset_as);

  g_strfreev (val_unset_ao);

  g_variant_unref (val_unset_ag);

  g_variant_unref (val_unset_struct);

  /* Try setting a property. This causes the generated glue to invoke

   * the org.fd.DBus.Properties.Set() method asynchronously. So we

   * have to wait for properties-changed...

   */

  foo_igen_bar_set_finally_normal_name (proxy, "foo!");

  _g_assert_property_notify (proxy, "finally-normal-name");

  g_assert_cmpstr (foo_igen_bar_get_finally_normal_name (proxy), ==, "foo!");

  /* Try setting properties that requires memory management. This

   * is to exercise the paths that frees the references.

   */

  g_object_set (proxy,

                "s", "a string",

                "o", "/a/path",

                "g", "asig",

                "ay", g_variant_new_parsed ("[byte 0x65, 0x67]"),

                "as", array_of_strings,

                "ao", array_of_objpaths,

                "ag", g_variant_new_parsed ("[@g 'ass', 'git']"),

                NULL);

  error = NULL;

  ret = foo_igen_bar_call_test_primitive_types_sync (proxy,

                                                     10,

                                                     TRUE,

                                                     11,

                                                     12,

                                                     13,

                                                     14,

                                                     15,

                                                     16,

                                                     17,

                                                     "a string",

                                                     "/a/path",

                                                     "asig",