--- a/meson.build

+++ b/meson.build

@@ -75,6 +75,7 @@ gio_unix_req_version = '>= 2.25.7'

 glib_dep = dependency('glib-2.0', version: '>= 2.44.0')

 gio_unix_dep = dependency('gio-unix-2.0', version: gio_unix_req_version)

+dbus_1_dep = dependency('dbus-1')

 gio_querymodules = find_program('gio-querymodules', required: false)

 if gio_querymodules.found()

@@ -101,6 +102,7 @@ subdir('gvdb')

 subdir('common')

 subdir('engine')

 subdir('service')

+subdir('dbus-1')

 subdir('gdbus')

 subdir('gsettings')

 subdir('client')

--- /dev/null

+++ b/dbus-1/meson.build

@@ -0,0 +1,43 @@

+client_inc = include_directories('.')

+

+libdbus_1_sources = files('dconf-libdbus-1.c', 'dconf-libdbus-1.h')

+

+cflags = '-DG_LOG_DOMAIN="@0@"'.format(meson.project_name())

+

+libdconf_libdbus_1_shared = static_library(

+  meson.project_name() + '-libdbus-1-shared',

+  sources: libdbus_1_sources,

+  include_directories: top_inc,

+  dependencies: [gio_unix_dep, dbus_1_dep],

+  c_args: cflags,

+  pic: true

+)

+

+libdconf_libdbus_1 = static_library(

+  meson.project_name() + '-libdbus-1',

+  sources: libdbus_1_sources,

+  include_directories: top_inc,

+  dependencies: [gio_unix_dep, dbus_1_dep],

+  c_args: cflags,

+)

+

+dbus_1_sources = files('dconf-dbus-1.c')

+

+libdconf_dbus_1 = shared_library(

+  meson.project_name() + '-dbus-1',

+  sources: dbus_1_sources,

+  version: '0.0.0',

+  soversion: '0',

+  include_directories: top_inc,

+  dependencies: [gio_unix_dep, dbus_1_dep],

+  c_args: cflags,

+  link_with: [

+    libdconf_common_hidden,

+    libdconf_engine_shared,

+    libdconf_libdbus_1_shared,

+    libdconf_shm_shared,

+    libgvdb_shared

+  ],

+  install: true,

+  install_dir: dconf_libdir

+)

--- /dev/null

+++ b/dbus-1/dconf-dbus-1.c

@@ -0,0 +1,188 @@

+/**

+ * Copyright © 2010 Canonical Limited

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation, either version 3 of the licence, or (at

+ * your option) any later version.

+ *

+ * This program 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

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Author: Ryan Lortie <desrt@desrt.ca>

+ **/

+

+#include "config.h"

+

+#include "dconf-dbus-1.h"

+

+#include "../engine/dconf-engine.h"

+#include "dconf-libdbus-1.h"

+

+#include <string.h>

+

+struct _DConfDBusClient

+{

+  DConfEngine *engine;

+  GSList *watches;

+  gint ref_count;

+};

+

+typedef struct

+{

+  gchar           *path;

+  DConfDBusNotify  notify;

+  gpointer         user_data;

+} Watch;

+

+void

+dconf_engine_change_notify (DConfEngine         *engine,

+                            const gchar         *prefix,

+                            const gchar * const *changes,

+                            const gchar         *tag,

+                            gboolean             is_writability,

+                            gpointer             origin_tag,

+                            gpointer             user_data)

+{

+  DConfDBusClient *dcdbc = user_data;

+  gchar **my_changes;

+  gint n_changes;

+  GSList *iter;

+  gint i;

+

+  n_changes = g_strv_length ((gchar **) changes);

+  my_changes = g_new (gchar *, n_changes + 1);

+

+  for (i = 0; i < n_changes; i++)

+    my_changes[i] = g_strconcat (prefix, changes[i], NULL);

+  my_changes[i] = NULL;

+

+  for (iter = dcdbc->watches; iter; iter = iter->next)

+    {

+      Watch *watch = iter->data;

+

+      for (i = 0; i < n_changes; i++)

+        if (g_str_has_prefix (my_changes[i], watch->path))

+          watch->notify (dcdbc, my_changes[i], watch->user_data);

+    }

+

+  g_strfreev (my_changes);

+}

+

+GVariant *

+dconf_dbus_client_read (DConfDBusClient *dcdbc,

+                        const gchar     *key)

+{

+  return dconf_engine_read (dcdbc->engine, DCONF_READ_FLAGS_NONE, NULL, key);

+}

+

+gboolean

+dconf_dbus_client_write (DConfDBusClient *dcdbc,

+                         const gchar     *key,

+                         GVariant        *value)

+{

+  DConfChangeset *changeset;

+  gboolean success;

+

+  changeset = dconf_changeset_new_write (key, value);

+  success = dconf_engine_change_fast (dcdbc->engine, changeset, NULL, NULL);

+  dconf_changeset_unref (changeset);

+

+  return success;

+}

+

+void

+dconf_dbus_client_subscribe (DConfDBusClient *dcdbc,

+                             const gchar     *path,

+                             DConfDBusNotify  notify,

+                             gpointer         user_data)

+{

+  Watch *watch;

+

+  watch = g_slice_new (Watch);

+  watch->path = g_strdup (path);

+  watch->notify = notify;

+  watch->user_data = user_data;

+

+  dcdbc->watches = g_slist_prepend (dcdbc->watches, watch);

+

+  dconf_engine_watch_fast (dcdbc->engine, path);

+}

+

+void

+dconf_dbus_client_unsubscribe (DConfDBusClient *dcdbc,

+                               DConfDBusNotify  notify,

+                               gpointer         user_data)

+{

+  GSList **ptr;

+

+  for (ptr = &dcdbc->watches; *ptr; ptr = &(*ptr)->next)

+    {

+      Watch *watch = (*ptr)->data;

+

+      if (watch->notify == notify && watch->user_data == user_data)

+        {

+          *ptr = g_slist_remove_link (*ptr, *ptr);

+          dconf_engine_unwatch_fast (dcdbc->engine, watch->path);

+          g_free (watch->path);

+          g_slice_free (Watch, watch);

+          return;

+        }

+    }

+

+  g_warning ("No matching watch found to unsubscribe");

+}

+

+gboolean

+dconf_dbus_client_has_pending (DConfDBusClient *dcdbc)

+{

+  return dconf_engine_has_outstanding (dcdbc->engine);

+}

+

+DConfDBusClient *

+dconf_dbus_client_new (const gchar    *profile,

+                       DBusConnection *session,

+                       DBusConnection *system)

+{

+  DConfDBusClient *dcdbc;

+

+  if (session == NULL)

+    session = dbus_bus_get (DBUS_BUS_SESSION, NULL);

+

+  if (system == NULL)

+    system = dbus_bus_get (DBUS_BUS_SYSTEM, NULL);

+

+  dconf_libdbus_1_provide_bus (G_BUS_TYPE_SESSION, session);

+  dconf_libdbus_1_provide_bus (G_BUS_TYPE_SYSTEM, system);

+

+  dcdbc = g_slice_new (DConfDBusClient);

+  dcdbc->engine = dconf_engine_new (NULL, dcdbc, NULL);

+  dcdbc->watches = NULL;

+  dcdbc->ref_count = 1;

+

+  return dcdbc;

+}

+

+void

+dconf_dbus_client_unref (DConfDBusClient *dcdbc)

+{

+  if (--dcdbc->ref_count == 0)

+    {

+      g_return_if_fail (dcdbc->watches == NULL);

+

+      g_slice_free (DConfDBusClient, dcdbc);

+    }

+}

+

+DConfDBusClient *

+dconf_dbus_client_ref (DConfDBusClient *dcdbc)

+{

+  dcdbc->ref_count++;

+

+  return dcdbc;

+}

--- /dev/null

+++ b/dbus-1/dconf-dbus-1.h

@@ -0,0 +1,56 @@

+/**

+ * Copyright © 2010 Canonical Limited

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation, either version 3 of the licence, or (at

+ * your option) any later version.

+ *

+ * This program 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

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Author: Ryan Lortie <desrt@desrt.ca>

+ **/

+

+#ifndef _dconf_dbus_1_h_

+#define _dconf_dbus_1_h_

+

+#include <dbus/dbus.h>

+#include <glib.h>

+

+G_BEGIN_DECLS

+

+typedef struct _DConfDBusClient DConfDBusClient;

+

+typedef void         (* DConfDBusNotify)                                (DConfDBusClient *dcdbc,

+                                                                         const gchar     *key,

+                                                                         gpointer         user_data);

+

+DConfDBusClient *       dconf_dbus_client_new                           (const gchar     *profile,

+                                                                         DBusConnection  *session,

+                                                                         DBusConnection  *system);

+void                    dconf_dbus_client_unref                         (DConfDBusClient *dcdbc);

+DConfDBusClient *       dconf_dbus_client_ref                           (DConfDBusClient *dcdbc);

+

+GVariant *              dconf_dbus_client_read                          (DConfDBusClient *dcdbc,

+                                                                         const gchar     *key);

+gboolean                dconf_dbus_client_write                         (DConfDBusClient *dcdbc,

+                                                                         const gchar     *key,

+                                                                         GVariant        *value);

+void                    dconf_dbus_client_subscribe                     (DConfDBusClient *dcdbc,

+                                                                         const gchar     *name,

+                                                                         DConfDBusNotify  notify,

+                                                                         gpointer         user_data);

+void                    dconf_dbus_client_unsubscribe                   (DConfDBusClient *dcdbc,

+                                                                         DConfDBusNotify  notify,

+                                                                         gpointer         user_data);

+gboolean                dconf_dbus_client_has_pending                   (DConfDBusClient *dcdbc);

+

+G_END_DECLS

+

+#endif /* _dconf_dbus_1_h_ */

--- /dev/null

+++ b/dbus-1/dconf-libdbus-1.c

@@ -0,0 +1,365 @@

+/**

+ * Copyright © 2010 Canonical Limited

+ *

+ * This program is free software: you can redistribute it and/or modify

+ * it under the terms of the GNU General Public License as published by

+ * the Free Software Foundation, either version 3 of the licence, or (at

+ * your option) any later version.

+ *

+ * This program 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

+ * General Public License for more details.

+ *

+ * You should have received a copy of the GNU General Public License

+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.

+ *

+ * Author: Ryan Lortie <desrt@desrt.ca>

+ **/

+

+#include "config.h"

+

+#include "dconf-libdbus-1.h"

+

+#include "../engine/dconf-engine.h"

+

+#include <string.h>

+

+static DBusConnection *dconf_libdbus_1_buses[5];

+

+struct _DConfDBusClient

+{

+  DConfEngine *engine;

+  GSList *watches;

+  gint ref_count;

+};

+

+#define DCONF_LIBDBUS_1_ERROR (g_quark_from_static_string("DCONF_LIBDBUS_1_ERROR"))

+#define DCONF_LIBDBUS_1_ERROR_FAILED 0

+

+static DBusMessage *

+dconf_libdbus_1_new_method_call (const gchar *bus_name,

+                                 const gchar *object_path,

+                                 const gchar *interface_name,

+                                 const gchar *method_name,

+                                 GVariant    *parameters)

+{

+  DBusMessageIter dbus_iter;

+  DBusMessage *message;

+  GVariantIter iter;

+  GVariant *child;

+

+  g_variant_ref_sink (parameters);

+

+  message = dbus_message_new_method_call (bus_name, object_path, interface_name, method_name);

+  dbus_message_iter_init_append (message, &dbus_iter);

+  g_variant_iter_init (&iter, parameters);

+

+  while ((child = g_variant_iter_next_value (&iter)))

+    {

+      if (g_variant_is_of_type (child, G_VARIANT_TYPE_STRING))

+        {

+          const gchar *str;

+

+          str = g_variant_get_string (child, NULL);

+          dbus_message_iter_append_basic (&dbus_iter, DBUS_TYPE_STRING, &str);

+        }

+

+      else if (g_variant_is_of_type (child, G_VARIANT_TYPE_UINT32))

+        {

+          guint32 uint;

+

+          uint = g_variant_get_uint32 (child);

+          dbus_message_iter_append_basic (&dbus_iter, DBUS_TYPE_UINT32, &uint);

+        }

+

+      else

+        {

+          DBusMessageIter subiter;

+          const guint8 *bytes;

+          gsize n_elements;

+

+          g_assert (g_variant_is_of_type (child, G_VARIANT_TYPE_BYTESTRING));

+

+          bytes = g_variant_get_fixed_array (child, &n_elements, sizeof (guint8));

+          dbus_message_iter_open_container (&dbus_iter, DBUS_TYPE_ARRAY, "y", &subiter);

+          dbus_message_iter_append_fixed_array (&subiter, DBUS_TYPE_BYTE, &bytes, n_elements);

+          dbus_message_iter_close_container (&dbus_iter, &subiter);

+        }

+

+      g_variant_unref (child);

+    }

+

+  g_variant_unref (parameters);

+

+  return message;

+}

+

+static GVariant *

+dconf_libdbus_1_get_message_body (DBusMessage  *message,

+                                  GError      **error)

+{

+  GVariantBuilder builder;

+  const gchar *signature;

+  DBusMessageIter iter;

+

+  /* We support two types: strings and arrays of strings.

+   *

+   * It's very simple to detect if the message contains only these

+   * types: check that the signature contains only the letters "a" and

+   * "s" and that it does not contain "aa".

+   */

+  signature = dbus_message_get_signature (message);

+  if (signature[strspn(signature, "as")] != '\0' || strstr (signature, "aa"))

+    {

+      g_set_error (error, DCONF_LIBDBUS_1_ERROR, DCONF_LIBDBUS_1_ERROR_FAILED,

+                   "unable to handle message type '(%s)'", signature);

+      return NULL;

+    }

+

+  g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE);

+  dbus_message_iter_init (message, &iter);

+  while (dbus_message_iter_get_arg_type (&iter))

+    {

+      const gchar *string;

+

+      if (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_STRING)

+        {

+          dbus_message_iter_get_basic (&iter, &string);

+          g_variant_builder_add (&builder, "s", string);

+        }

+      else

+        {

+          DBusMessageIter sub;

+

+          g_assert (dbus_message_iter_get_arg_type (&iter) == DBUS_TYPE_ARRAY &&

+                    dbus_message_iter_get_element_type (&iter) == DBUS_TYPE_STRING);

+

+          g_variant_builder_open (&builder, G_VARIANT_TYPE_STRING_ARRAY);

+          dbus_message_iter_recurse (&iter, &sub);

+

+          while (dbus_message_iter_get_arg_type (&sub))

+            {

+              const gchar *string;

+              dbus_message_iter_get_basic (&sub, &string);

+              g_variant_builder_add (&builder, "s", string);

+              dbus_message_iter_next (&sub);

+            }

+

+          g_variant_builder_close (&builder);

+        }

+      dbus_message_iter_next (&iter);

+    }

+

+  return g_variant_ref_sink (g_variant_builder_end (&builder));

+}

+

+static GVariant *

+dconf_libdbus_1_interpret_result (DBusMessage         *result,

+                                  const GVariantType  *expected_type,

+                                  GError             **error)

+{

+  GVariant *reply;

+

+  if (dbus_message_get_type (result) == DBUS_MESSAGE_TYPE_ERROR)

+    {

+      const gchar *errstr = "(no message)";

+

+      dbus_message_get_args (result, NULL, DBUS_TYPE_STRING, &errstr, DBUS_TYPE_INVALID);

+      g_set_error (error, DCONF_LIBDBUS_1_ERROR, DCONF_LIBDBUS_1_ERROR_FAILED,

+                   "%s: %s", dbus_message_get_error_name (result), errstr);

+      return NULL;

+    }

+

+  reply = dconf_libdbus_1_get_message_body (result, error);

+

+  if (reply && expected_type && !g_variant_is_of_type (reply, expected_type))

+    {

+      gchar *expected_string;

+

+      expected_string = g_variant_type_dup_string (expected_type);

+      g_set_error (error, DCONF_LIBDBUS_1_ERROR, DCONF_LIBDBUS_1_ERROR_FAILED,

+                   "received reply '%s' is not of the expected type %s",

+                   g_variant_get_type_string (reply), expected_string);

+      g_free (expected_string);

+

+      g_variant_unref (reply);

+      reply = NULL;

+    }

+

+  return reply;

+}

+

+static void

+dconf_libdbus_1_method_call_done (DBusPendingCall *pending,

+                                  gpointer         user_data)

+{

+  DConfEngineCallHandle *handle = user_data;

+  const GVariantType *expected_type;

+  DBusMessage *message;

+  GError *error = NULL;

+  GVariant *reply;

+

+  if (pending == NULL)

+    return;

+

+  message = dbus_pending_call_steal_reply (pending);

+  dbus_pending_call_unref (pending);

+

+  expected_type = dconf_engine_call_handle_get_expected_type (handle);

+  reply = dconf_libdbus_1_interpret_result (message, expected_type, &error);

+  dbus_message_unref (message);

+

+  dconf_engine_call_handle_reply (handle, reply, error);

+

+  if (reply)

+    g_variant_unref (reply);

+  if (error)

+    g_error_free (error);

+}

+

+gboolean

+dconf_engine_dbus_call_async_func (GBusType                bus_type,

+                                   const gchar            *bus_name,

+                                   const gchar            *object_path,

+                                   const gchar            *interface_name,

+                                   const gchar            *method_name,

+                                   GVariant               *parameters,

+                                   DConfEngineCallHandle  *handle,

+                                   GError                **error)

+{

+  DBusConnection *connection;

+  DBusPendingCall *pending;

+  DBusMessage *message;

+

+  g_assert_cmpint (bus_type, <, G_N_ELEMENTS (dconf_libdbus_1_buses));

+  connection = dconf_libdbus_1_buses[bus_type];

+  g_assert (connection != NULL);

+

+  message = dconf_libdbus_1_new_method_call (bus_name, object_path, interface_name, method_name, parameters);

+  dbus_connection_send_with_reply (connection, message, &pending, -1);

+  dbus_pending_call_set_notify (pending, dconf_libdbus_1_method_call_done, handle, NULL);

+  dbus_message_unref (message);

+

+  return TRUE;

+}

+

+static void

+dconf_libdbus_1_convert_error (DBusError  *dbus_error,

+                               GError    **error)

+{

+  g_set_error (error, DCONF_LIBDBUS_1_ERROR, DCONF_LIBDBUS_1_ERROR_FAILED,

+               "%s: %s", dbus_error->name, dbus_error->message);

+}

+

+GVariant *

+dconf_engine_dbus_call_sync_func (GBusType             bus_type,

+                                  const gchar         *bus_name,

+                                  const gchar         *object_path,

+                                  const gchar         *interface_name,

+                                  const gchar         *method_name,

+                                  GVariant            *parameters,

+                                  const GVariantType  *expected_type,

+                                  GError             **error)

+{

+  DBusConnection *connection;

+  DBusMessage *message;

+  DBusError dbus_error;

+  DBusMessage *result;

+  GVariant *reply;

+

+  g_assert_cmpint (bus_type, <, G_N_ELEMENTS (dconf_libdbus_1_buses));

+  connection = dconf_libdbus_1_buses[bus_type];

+  g_assert (connection != NULL);

+

+  dbus_error_init (&dbus_error);

+  message = dconf_libdbus_1_new_method_call (bus_name, object_path, interface_name, method_name, parameters);

+  result = dbus_connection_send_with_reply_and_block (connection, message, -1, &dbus_error);

+  dbus_message_unref (message);

+

+  if (result == NULL)

+    {

+      dconf_libdbus_1_convert_error (&dbus_error, error);

+      dbus_error_free (&dbus_error);

+      return NULL;

+    }

+

+  reply = dconf_libdbus_1_interpret_result (result, expected_type, error);

+  dbus_message_unref (result);

+

+  return reply;

+}

+

+static DBusHandlerResult

+dconf_libdbus_1_filter (DBusConnection *connection,

+                        DBusMessage    *message,

+                        gpointer        user_data)

+{

+  GBusType bus_type = GPOINTER_TO_INT (user_data);

+

+  if (dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_SIGNAL)

+    {

+      const gchar *interface;

+

+      interface = dbus_message_get_interface (message);

+

+      if (interface && g_str_equal (interface, "ca.desrt.dconf.Writer"))

+        {

+          GVariant *parameters;

+

+          parameters = dconf_libdbus_1_get_message_body (message, NULL);

+

+          if (parameters != NULL)

+            {

+              dconf_engine_handle_dbus_signal (bus_type,

+                                               dbus_message_get_sender (message),

+                                               dbus_message_get_path (message),

+                                               dbus_message_get_member (message),

+                                               parameters);

+              g_variant_unref (parameters);

+            }

+        }

+    }

+

+  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;

+}

+

+void

+dconf_libdbus_1_provide_bus (GBusType        bus_type,

+                             DBusConnection *connection)

+{

+  g_assert_cmpint (bus_type, <, G_N_ELEMENTS (dconf_libdbus_1_buses));

+

+  if (!dconf_libdbus_1_buses[bus_type])

+    {

+      dconf_libdbus_1_buses[bus_type] = dbus_connection_ref (connection);

+      dbus_connection_add_filter (connection, dconf_libdbus_1_filter, GINT_TO_POINTER (bus_type), NULL);

+    }

+}

+

+#ifndef PIC

+static gboolean

+dconf_libdbus_1_check_connection (gpointer user_data)

+{

+  DBusConnection *connection = user_data;

+

+  dbus_connection_read_write (connection, 0);

+  dbus_connection_dispatch (connection);

+

+  return G_SOURCE_CONTINUE;

+}

+

+void

+dconf_engine_dbus_init_for_testing (void)

+{

+  DBusConnection *session;

+  DBusConnection *system;

+

+  dconf_libdbus_1_provide_bus (G_BUS_TYPE_SESSION, session = dbus_bus_get (DBUS_BUS_SESSION, NULL));

+  dconf_libdbus_1_provide_bus (G_BUS_TYPE_SYSTEM, system = dbus_bus_get (DBUS_BUS_SYSTEM, NULL));

+

+  /* "mainloop integration" */

+  g_timeout_add (1, dconf_libdbus_1_check_connection, session);

+  g_timeout_add (1, dconf_libdbus_1_check_connection, system);

+}

+#endif

--- /dev/null

+++ b/dbus-1/dconf-libdbus-1.h

@@ -0,0 +1,11 @@

+#ifndef __dconf_libdbus_1_h__

+#define __dconf_libdbus_1_h__

+

+#include <dbus/dbus.h>

+#include <gio/gio.h>

+

+G_GNUC_INTERNAL

+void                    dconf_libdbus_1_provide_bus                     (GBusType        bus_type,

+                                                                         DBusConnection *connection);

+

+#endif /* __dconf_libdbus_1_h__ */

--- a/tests/meson.build

+++ b/tests/meson.build

@@ -23,6 +23,7 @@ unit_tests = [

   ['gvdb', 'gvdb.c', '-DSRCDIR="@0@"'.format(test_dir), glib_dep, libgvdb],

   ['gdbus-thread', 'dbus.c', '-DDBUS_BACKEND="/gdbus/thread"', gio_unix_dep, libdconf_gdbus_thread],

   ['gdbus-filter', 'dbus.c', '-DDBUS_BACKEND="/gdbus/filter"', gio_unix_dep, libdconf_gdbus_filter],

+  ['libdbus-1', 'dbus.c', '-DDBUS_BACKEND="/libdbus-1"', gio_unix_dep, libdconf_libdbus_1],

   ['engine', 'engine.c', '-DSRCDIR="@0@"'.format(test_dir), [glib_dep, dl_dep, m_dep], [libdconf_engine, libdconf_common, libdconf_mock]],

   ['client', 'client.c', '-DSRCDIR="@0@"'.format(test_dir), gio_unix_dep, [libdconf_client, libdconf_engine, libdconf_common, libdconf_mock]]

 ]