/* GLib testing framework examples and tests
 *
 * Copyright (C) 2008-2010 Red Hat, Inc.
 * Copyright (C) 2021 Frederic Martinsons
 *
 * 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>
 * Author: Frederic Martinsons <frederic.martinsons@gmail.com>
 */

#include <gio/gio.h>
#include <unistd.h>

#include "gdbus-tests.h"

/* all tests rely on a shared mainloop */
static GMainLoop *loop;

/* ---------------------------------------------------------------------------------------------------- */
/* Test that g_bus_own_name() works correctly */
/* ---------------------------------------------------------------------------------------------------- */

typedef struct
{
  gboolean expect_null_connection;
  guint num_bus_acquired;
  guint num_acquired;
  guint num_lost;
  guint num_free_func;
} OwnNameData;

static void
own_name_data_free_func (OwnNameData *data)
{
  data->num_free_func++;
  g_main_loop_quit (loop);
}

static void
bus_acquired_handler (GDBusConnection *connection,
                      const gchar     *name,
                      gpointer         user_data)
{
  OwnNameData *data = user_data;
  g_dbus_connection_set_exit_on_close (connection, FALSE);
  data->num_bus_acquired += 1;
  g_main_loop_quit (loop);
}

static void
name_acquired_handler (GDBusConnection *connection,
                       const gchar     *name,
                       gpointer         user_data)
{
  OwnNameData *data = user_data;
  data->num_acquired += 1;
  g_main_loop_quit (loop);
}

static void
name_lost_handler (GDBusConnection *connection,
                   const gchar     *name,
                   gpointer         user_data)
{
  OwnNameData *data = user_data;
  if (data->expect_null_connection)
    {
      g_assert (connection == NULL);
    }
  else
    {
      g_assert (connection != NULL);
      g_dbus_connection_set_exit_on_close (connection, FALSE);
    }
  data->num_lost += 1;
  g_main_loop_quit (loop);
}

static void
test_bus_own_name (void)
{
  guint id;
  guint id2;
  OwnNameData data;
  OwnNameData data2;
  const gchar *name;
  GDBusConnection *c;
  GError *error;
  gboolean name_has_owner_reply;
  GDBusConnection *c2;
  GVariant *result;

  error = NULL;
  name = "org.gtk.GDBus.Name1";

  /*
   * First check that name_lost_handler() is invoked if there is no bus.
   *
   * Also make sure name_lost_handler() isn't invoked when unowning the name.
   */
  data.num_bus_acquired = 0;
  data.num_free_func = 0;
  data.num_acquired = 0;
  data.num_lost = 0;
  data.expect_null_connection = TRUE;
  id = g_bus_own_name (G_BUS_TYPE_SESSION,
                       name,
                       G_BUS_NAME_OWNER_FLAGS_NONE,
                       bus_acquired_handler,
                       name_acquired_handler,
                       name_lost_handler,
                       &data,
                       (GDestroyNotify) own_name_data_free_func);
  g_assert_cmpint (data.num_bus_acquired, ==, 0);
  g_assert_cmpint (data.num_acquired, ==, 0);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_bus_acquired, ==, 0);
  g_assert_cmpint (data.num_acquired, ==, 0);
  g_assert_cmpint (data.num_lost,     ==, 1);
  g_bus_unown_name (id);
  g_assert_cmpint (data.num_acquired, ==, 0);
  g_assert_cmpint (data.num_lost,     ==, 1);
  g_assert_cmpint (data.num_free_func, ==, 1);

  /*
   * Bring up a bus, then own a name and check bus_acquired_handler() then name_acquired_handler() is invoked.
   */
  session_bus_up ();
  data.num_bus_acquired = 0;
  data.num_acquired = 0;
  data.num_lost = 0;
  data.expect_null_connection = FALSE;
  id = g_bus_own_name (G_BUS_TYPE_SESSION,
                       name,
                       G_BUS_NAME_OWNER_FLAGS_NONE,
                       bus_acquired_handler,
                       name_acquired_handler,
                       name_lost_handler,
                       &data,
                       (GDestroyNotify) own_name_data_free_func);
  g_assert_cmpint (data.num_bus_acquired, ==, 0);
  g_assert_cmpint (data.num_acquired, ==, 0);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 0);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 1);
  g_assert_cmpint (data.num_lost,     ==, 0);

  /*
   * Check that the name was actually acquired.
   */
  c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
  g_assert (c != NULL);
  g_assert (!g_dbus_connection_is_closed (c));
  result = g_dbus_connection_call_sync (c,
                                        "org.freedesktop.DBus",  /* bus name */
                                        "/org/freedesktop/DBus", /* object path */
                                        "org.freedesktop.DBus",  /* interface name */
                                        "NameHasOwner",          /* method name */
                                        g_variant_new ("(s)", name),
                                        G_VARIANT_TYPE ("(b)"),
                                        G_DBUS_CALL_FLAGS_NONE,
                                        -1,
                                        NULL,
                                        &error);
  g_assert_no_error (error);
  g_assert (result != NULL);
  g_variant_get (result, "(b)", &name_has_owner_reply);
  g_assert (name_has_owner_reply);
  g_variant_unref (result);

  /*
   * Stop owning the name - this should invoke our free func
   */
  g_bus_unown_name (id);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_free_func, ==, 2);

  /*
   * Check that the name was actually released.
   */
  result = g_dbus_connection_call_sync (c,
                                        "org.freedesktop.DBus",  /* bus name */
                                        "/org/freedesktop/DBus", /* object path */
                                        "org.freedesktop.DBus",  /* interface name */
                                        "NameHasOwner",          /* method name */
                                        g_variant_new ("(s)", name),
                                        G_VARIANT_TYPE ("(b)"),
                                        G_DBUS_CALL_FLAGS_NONE,
                                        -1,
                                        NULL,
                                        &error);
  g_assert_no_error (error);
  g_assert (result != NULL);
  g_variant_get (result, "(b)", &name_has_owner_reply);
  g_assert (!name_has_owner_reply);
  g_variant_unref (result);

  /* Now try owning the name and then immediately decide to unown the name */
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 1);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_assert_cmpint (data.num_free_func, ==, 2);
  id = g_bus_own_name (G_BUS_TYPE_SESSION,
                       name,
                       G_BUS_NAME_OWNER_FLAGS_NONE,
                       bus_acquired_handler,
                       name_acquired_handler,
                       name_lost_handler,
                       &data,
                       (GDestroyNotify) own_name_data_free_func);
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 1);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_assert_cmpint (data.num_free_func, ==, 2);
  g_bus_unown_name (id);
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 1);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_assert_cmpint (data.num_free_func, ==, 2);
  g_main_loop_run (loop); /* the GDestroyNotify is called in idle because the bus is acquired in idle */
  g_assert_cmpint (data.num_free_func, ==, 3);

  /*
   * Own the name again.
   */
  data.num_bus_acquired = 0;
  data.num_acquired = 0;
  data.num_lost = 0;
  data.expect_null_connection = FALSE;
  id = g_bus_own_name_with_closures (G_BUS_TYPE_SESSION,
                                     name,
                                     G_BUS_NAME_OWNER_FLAGS_NONE,
                                     g_cclosure_new (G_CALLBACK (bus_acquired_handler),
                                                     &data,
                                                     NULL),
                                     g_cclosure_new (G_CALLBACK (name_acquired_handler),
                                                     &data,
                                                     NULL),
                                     g_cclosure_new (G_CALLBACK (name_lost_handler),
                                                     &data,
                                                     (GClosureNotify) own_name_data_free_func));
  g_assert_cmpint (data.num_bus_acquired, ==, 0);
  g_assert_cmpint (data.num_acquired, ==, 0);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 0);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 1);
  g_assert_cmpint (data.num_lost,     ==, 0);

  /*
   * Try owning the name with another object on the same connection  - this should
   * fail because we already own the name.
   */
  data2.num_free_func = 0;
  data2.num_bus_acquired = 0;
  data2.num_acquired = 0;
  data2.num_lost = 0;
  data2.expect_null_connection = FALSE;
  id2 = g_bus_own_name (G_BUS_TYPE_SESSION,
                        name,
                        G_BUS_NAME_OWNER_FLAGS_NONE,
                        bus_acquired_handler,
                        name_acquired_handler,
                        name_lost_handler,
                        &data2,
                        (GDestroyNotify) own_name_data_free_func);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_bus_acquired, ==, 1);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_bus_acquired, ==, 1);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 1);
  g_bus_unown_name (id2);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_bus_acquired, ==, 1);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 1);
  g_assert_cmpint (data2.num_free_func, ==, 1);

  /*
   * Create a secondary (e.g. private) connection and try owning the name on that
   * connection. This should fail both with and without _REPLACE because we
   * didn't specify ALLOW_REPLACEMENT.
   */
  c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, NULL);
  g_assert (c2 != NULL);
  g_assert (!g_dbus_connection_is_closed (c2));
  /* first without _REPLACE */
  data2.num_bus_acquired = 0;
  data2.num_acquired = 0;
  data2.num_lost = 0;
  data2.expect_null_connection = FALSE;
  data2.num_free_func = 0;
  id2 = g_bus_own_name_on_connection (c2,
                                      name,
                                      G_BUS_NAME_OWNER_FLAGS_NONE,
                                      name_acquired_handler,
                                      name_lost_handler,
                                      &data2,
                                      (GDestroyNotify) own_name_data_free_func);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 1);
  g_bus_unown_name (id2);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 1);
  g_assert_cmpint (data2.num_free_func, ==, 1);
  /* then with _REPLACE */
  data2.num_bus_acquired = 0;
  data2.num_acquired = 0;
  data2.num_lost = 0;
  data2.expect_null_connection = FALSE;
  data2.num_free_func = 0;
  id2 = g_bus_own_name_on_connection (c2,
                                      name,
                                      G_BUS_NAME_OWNER_FLAGS_REPLACE,
                                      name_acquired_handler,
                                      name_lost_handler,
                                      &data2,
                                      (GDestroyNotify) own_name_data_free_func);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 1);
  g_bus_unown_name (id2);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 1);
  g_assert_cmpint (data2.num_free_func, ==, 1);

  /*
   * Stop owning the name and grab it again with _ALLOW_REPLACEMENT.
   */
  data.expect_null_connection = FALSE;
  g_bus_unown_name (id);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 1);
  g_assert_cmpint (data.num_free_func, ==, 4);
  /* grab it again */
  data.num_bus_acquired = 0;
  data.num_acquired = 0;
  data.num_lost = 0;
  data.expect_null_connection = FALSE;
  id = g_bus_own_name (G_BUS_TYPE_SESSION,
                       name,
                       G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT,
                       bus_acquired_handler,
                       name_acquired_handler,
                       name_lost_handler,
                       &data,
                       (GDestroyNotify) own_name_data_free_func);
  g_assert_cmpint (data.num_bus_acquired, ==, 0);
  g_assert_cmpint (data.num_acquired, ==, 0);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 0);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_bus_acquired, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 1);
  g_assert_cmpint (data.num_lost,     ==, 0);

  /*
   * Now try to grab the name from the secondary connection.
   *
   */
  /* first without _REPLACE - this won't make us acquire the name */
  data2.num_bus_acquired = 0;
  data2.num_acquired = 0;
  data2.num_lost = 0;
  data2.expect_null_connection = FALSE;
  data2.num_free_func = 0;
  id2 = g_bus_own_name_on_connection (c2,
                                      name,
                                      G_BUS_NAME_OWNER_FLAGS_NONE,
                                      name_acquired_handler,
                                      name_lost_handler,
                                      &data2,
                                      (GDestroyNotify) own_name_data_free_func);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 1);
  g_bus_unown_name (id2);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 1);
  g_assert_cmpint (data2.num_free_func, ==, 1);
  /* then with _REPLACE - here we should acquire the name - e.g. owner should lose it
   * and owner2 should acquire it  */
  data2.num_bus_acquired = 0;
  data2.num_acquired = 0;
  data2.num_lost = 0;
  data2.expect_null_connection = FALSE;
  data2.num_free_func = 0;
  id2 = g_bus_own_name_on_connection (c2,
                                      name,
                                      G_BUS_NAME_OWNER_FLAGS_REPLACE,
                                      name_acquired_handler,
                                      name_lost_handler,
                                      &data2,
                                      (GDestroyNotify) own_name_data_free_func);
  g_assert_cmpint (data.num_acquired, ==, 1);
  g_assert_cmpint (data.num_lost,     ==, 0);
  g_assert_cmpint (data2.num_acquired, ==, 0);
  g_assert_cmpint (data2.num_lost,     ==, 0);
  /* wait for handlers for both owner and owner2 to fire */
  while (data.num_lost == 0 || data2.num_acquired == 0)
    g_main_loop_run (loop);
  g_assert_cmpint (data.num_acquired, ==, 1);
  g_assert_cmpint (data.num_lost,     ==, 1);
  g_assert_cmpint (data2.num_acquired, ==, 1);
  g_assert_cmpint (data2.num_lost,     ==, 0);
  g_assert_cmpint (data2.num_bus_acquired, ==, 0);
  /* ok, make owner2 release the name - then wait for owner to automagically reacquire it */
  g_bus_unown_name (id2);
  g_main_loop_run (loop);
  g_main_loop_run (loop);
  g_assert_cmpint (data2.num_free_func, ==, 1);
  g_assert_cmpint (data.num_acquired, ==, 2);
  g_assert_cmpint (data.num_lost,     ==, 1);

  /*
   * Finally, nuke the bus and check name_lost_handler() is invoked.
   *
   */
  data.expect_null_connection = TRUE;
  session_bus_stop ();
  while (data.num_lost != 2)
    g_main_loop_run (loop);
  g_assert_cmpint (data.num_acquired, ==, 2);
  g_assert_cmpint (data.num_lost,     ==, 2);
  g_bus_unown_name (id);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_free_func, ==, 5);

  g_object_unref (c);
  g_object_unref (c2);

  session_bus_down ();
}

/* ---------------------------------------------------------------------------------------------------- */
/* Test that g_bus_watch_name() works correctly */
/* ---------------------------------------------------------------------------------------------------- */

typedef struct
{
  gboolean expect_null_connection;
  guint num_acquired;
  guint num_lost;
  guint num_appeared;
  guint num_vanished;
  guint num_free_func;
} WatchNameData;

typedef struct
{
  WatchNameData data;
  GDBusConnection *connection;
  GMutex cond_mutex;
  GCond cond;
  gboolean started;
  gboolean name_acquired;
  gboolean ended;
  gboolean unwatch_early;
  GMutex mutex;
  guint watch_id;
} WatchNameThreadData;

static void
watch_name_data_free_func (WatchNameData *data)
{
  data->num_free_func++;
  g_main_loop_quit (loop);
}

static void
w_bus_acquired_handler (GDBusConnection *connection,
                        const gchar     *name,
                        gpointer         user_data)
{
}

static void
w_name_acquired_handler (GDBusConnection *connection,
                         const gchar     *name,
                         gpointer         user_data)
{
  OwnNameData *data = user_data;
  data->num_acquired += 1;
  g_main_loop_quit (loop);
}

static void
w_name_lost_handler (GDBusConnection *connection,
                     const gchar     *name,
                     gpointer         user_data)
{
  OwnNameData *data = user_data;
  data->num_lost += 1;
  g_main_loop_quit (loop);
}

static void
name_appeared_handler (GDBusConnection *connection,
                       const gchar     *name,
                       const gchar     *name_owner,
                       gpointer         user_data)
{
  WatchNameData *data = user_data;

  if (data->expect_null_connection)
    {
      g_assert (connection == NULL);
    }
  else
    {
      g_assert (connection != NULL);
      g_dbus_connection_set_exit_on_close (connection, FALSE);
    }
  data->num_appeared += 1;
  g_main_loop_quit (loop);
}

static void
name_vanished_handler (GDBusConnection *connection,
                       const gchar     *name,
                       gpointer         user_data)
{
  WatchNameData *data = user_data;

  if (data->expect_null_connection)
    {
      g_assert (connection == NULL);
    }
  else
    {
      g_assert (connection != NULL);
      g_dbus_connection_set_exit_on_close (connection, FALSE);
    }
  data->num_vanished += 1;
  g_main_loop_quit (loop);
}

typedef struct
{
  guint watcher_flags;
  gboolean watch_with_closures;
  gboolean existing_service;
} WatchNameTest;

static const WatchNameTest watch_no_closures_no_flags = {
  .watcher_flags = G_BUS_NAME_WATCHER_FLAGS_NONE,
  .watch_with_closures = FALSE,
  .existing_service = FALSE
};

static const WatchNameTest watch_no_closures_flags_auto_start = {
  .watcher_flags = G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
  .watch_with_closures = FALSE,
  .existing_service = FALSE
};

static const WatchNameTest watch_no_closures_flags_auto_start_service_exist = {
  .watcher_flags = G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
  .watch_with_closures = FALSE,
  .existing_service = TRUE
};

static const WatchNameTest watch_closures_no_flags = {
  .watcher_flags = G_BUS_NAME_WATCHER_FLAGS_NONE,
  .watch_with_closures = TRUE,
  .existing_service = FALSE
};

static const WatchNameTest watch_closures_flags_auto_start = {
  .watcher_flags = G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
  .watch_with_closures = TRUE,
  .existing_service = FALSE
};

static void
stop_service (GDBusConnection *connection,
              WatchNameData   *data)
{
  GError *error = NULL;
  GDBusProxy *proxy = NULL;
  GVariant *result = NULL;

  data->num_vanished = 0;

  proxy = g_dbus_proxy_new_sync (connection,
                                 G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START,
                                 NULL,
                                 "org.gtk.GDBus.FakeService",
                                 "/org/gtk/GDBus/FakeService",
                                 "org.gtk.GDBus.FakeService",
                                 NULL,
                                 &error);
  g_assert_no_error (error);

  result = g_dbus_proxy_call_sync (proxy,
                                   "Quit",
                                   NULL,
                                   G_DBUS_CALL_FLAGS_NO_AUTO_START,
                                   100,
                                   NULL,
                                   &error);
  g_assert_no_error (error);
  g_object_unref (proxy);
  if (result)
    g_variant_unref (result);
  while (data->num_vanished == 0)
    g_main_loop_run (loop);
}

static void
test_bus_watch_name (gconstpointer d)
{
  WatchNameData data;
  OwnNameData own_data;
  guint id;
  guint owner_id;
  GDBusConnection *connection;
  const WatchNameTest *watch_name_test;
  const gchar *name;

  watch_name_test = (WatchNameTest *) d;

  if (watch_name_test->existing_service)
    {
      name = "org.gtk.GDBus.FakeService";
    }
  else
    {
      name = "org.gtk.GDBus.Name1";
    }

  /*
   * First check that name_vanished_handler() is invoked if there is no bus.
   *
   * Also make sure name_vanished_handler() isn't invoked when unwatching the name.
   */
  data.num_free_func = 0;
  data.num_appeared = 0;
  data.num_vanished = 0;
  data.expect_null_connection = TRUE;
  id = g_bus_watch_name (G_BUS_TYPE_SESSION,
                         name,
                         watch_name_test->watcher_flags,
                         name_appeared_handler,
                         name_vanished_handler,
                         &data,
                         (GDestroyNotify) watch_name_data_free_func);
  g_assert_cmpint (data.num_appeared, ==, 0);
  g_assert_cmpint (data.num_vanished, ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_appeared, ==, 0);
  g_assert_cmpint (data.num_vanished, ==, 1);
  g_bus_unwatch_name (id);
  g_assert_cmpint (data.num_appeared, ==, 0);
  g_assert_cmpint (data.num_vanished, ==, 1);
  g_assert_cmpint (data.num_free_func, ==, 1);
  data.num_free_func = 0;

  /*
   * Now bring up a bus, own a name, and then start watching it.
   */
  session_bus_up ();
  /* own the name */
  own_data.num_free_func = 0;
  own_data.num_acquired = 0;
  own_data.num_lost = 0;
  data.expect_null_connection = FALSE;
  owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
                             name,
                             G_BUS_NAME_OWNER_FLAGS_NONE,
                             w_bus_acquired_handler,
                             w_name_acquired_handler,
                             w_name_lost_handler,
                             &own_data,
                             (GDestroyNotify) own_name_data_free_func);
  g_main_loop_run (loop);
  g_assert_cmpint (own_data.num_acquired, ==, 1);
  g_assert_cmpint (own_data.num_lost, ==, 0);

  connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
  g_assert (connection != NULL);

  /* now watch the name */
  data.num_appeared = 0;
  data.num_vanished = 0;
  if (watch_name_test->watch_with_closures)
    {
      id = g_bus_watch_name_on_connection_with_closures (connection,
                                                         name,
                                                         watch_name_test->watcher_flags,
                                                         g_cclosure_new (G_CALLBACK (name_appeared_handler),
                                                                         &data,
                                                                         NULL),
                                                         g_cclosure_new (G_CALLBACK (name_vanished_handler),
                                                                         &data,
                                                                         (GClosureNotify) watch_name_data_free_func));
    }
  else
    {
      id = g_bus_watch_name_on_connection (connection,
                                           name,
                                           watch_name_test->watcher_flags,
                                           name_appeared_handler,
                                           name_vanished_handler,
                                           &data,
                                           (GDestroyNotify) watch_name_data_free_func);
    }
  g_assert_cmpint (data.num_appeared, ==, 0);
  g_assert_cmpint (data.num_vanished, ==, 0);
  g_main_loop_run (loop);
  g_assert_cmpint (data.num_appeared, ==, 1);
  g_assert_cmpint (data.num_vanished, ==, 0);

  /*
   * Unwatch the name.
   */
  g_bus_unwatch_name (id);
  g_assert_cmpint (data.num_free_func, ==, 1);

  /* unown the name */
  g_bus_unown_name (owner_id);
  g_main_loop_run (loop);
  g_assert_cmpint (own_data.num_acquired, ==, 1);
  g_assert_cmpint (own_data.num_free_func, ==, 1);
  own_data.num_free_func = 0;
  /*
   * Create a watcher and then make a name be owned.
   *
   * This should trigger name_appeared_handler() ...
   */
  /* watch the name */
  data.num_appeared = 0;
  data.num_vanished = 0;
  data.num_free_func = 0;
  if (watch_name_test->watch_with_closures)
    {
      id = g_bus_watch_name_with_closures (G_BUS_TYPE_SESSION,
                                           name,
                                           watch_name_test->watcher_flags,
                                           g_cclosure_new (G_CALLBACK (name_appeared_handler),
                                                           &data,
                                                           NULL),
                                           g_cclosure_new (G_CALLBACK (name_vanished_handler),
                                                           &data,
                                                           (GClosureNotify) watch_name_data_free_func));
    }
  else
    {
      id = g_bus_watch_name (G_BUS_TYPE_SESSION,
                             name,
                             watch_name_test->watcher_flags,
                             name_appeared_handler,
                             name_vanished_handler,
                             &data,
                             (GDestroyNotify) watch_name_data_free_func);
    }

  g_assert_cmpint (data.num_appeared, ==, 0);
  g_assert_cmpint (data.num_vanished, ==, 0);
  g_main_loop_run (loop);
  if (watch_name_test->existing_service)
    {
      g_assert_cmpint (data.num_appeared, ==, 1);
      g_assert_cmpint (data.num_vanished, ==, 0);
    }
  else
    {
      g_assert_cmpint (data.num_appeared, ==, 0);
      g_assert_cmpint (data.num_vanished, ==, 1);
    }

  if (!watch_name_test->existing_service)
    {
      /* own the name */
      own_data.num_acquired = 0;
      own_data.num_lost = 0;
      own_data.expect_null_connection = FALSE;
      owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
                                 name,
                                 G_BUS_NAME_OWNER_FLAGS_NONE,
                                 w_bus_acquired_handler,
                                 w_name_acquired_handler,
                                 w_name_lost_handler,
                                 &own_data,
                                 (GDestroyNotify) own_name_data_free_func);
      while (own_data.num_acquired == 0 || data.num_appeared == 0)
        g_main_loop_run (loop);
      g_assert_cmpint (own_data.num_acquired, ==, 1);
      g_assert_cmpint (own_data.num_lost, ==, 0);
      g_assert_cmpint (data.num_appeared, ==, 1);
      g_assert_cmpint (data.num_vanished, ==, 1);
    }

  data.expect_null_connection = TRUE;
  if (watch_name_test->existing_service)
    {
      data.expect_null_connection = FALSE;
      stop_service (connection, &data);
    }
  g_object_unref (connection);
  /*
   * Nuke the bus and check that the name vanishes and is lost.
   */
  session_bus_stop ();
  if (!watch_name_test->existing_service)
    {
      g_main_loop_run (loop);
      g_assert_cmpint (own_data.num_lost, ==, 1);
      g_assert_cmpint (data.num_vanished, ==, 2);
    }
  else
    {
      g_assert_cmpint (own_data.num_lost, ==, 0);
      g_assert_cmpint (data.num_vanished, ==, 1);
    }
  g_bus_unwatch_name (id);
  g_assert_cmpint (data.num_free_func, ==, 1);

  if (!watch_name_test->existing_service)
    {
      g_bus_unown_name (owner_id);
      g_main_loop_run (loop);
      g_assert_cmpint (own_data.num_free_func, ==, 1);
    }
  session_bus_down ();
}

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

/* Called in the same thread as watcher_thread() */
static void
t_watch_name_data_free_func (WatchNameThreadData *thread_data)
{
  thread_data->data.num_free_func++;
}

/* Called in the same thread as watcher_thread() */
static void
t_name_appeared_handler (GDBusConnection *connection,
                         const gchar     *name,
                         const gchar     *name_owner,
                         gpointer         user_data)
{
  WatchNameThreadData *thread_data = user_data;
  thread_data->data.num_appeared += 1;
}

/* Called in the same thread as watcher_thread() */
static void
t_name_vanished_handler (GDBusConnection *connection,
                         const gchar     *name,
                         gpointer         user_data)
{
  WatchNameThreadData *thread_data = user_data;
  thread_data->data.num_vanished += 1;
}

/* Called in the thread which constructed the GDBusConnection */
static void
connection_closed_cb (GDBusConnection *connection,
                      gboolean         remote_peer_vanished,
                      GError          *error,
                      gpointer         user_data)
{
  WatchNameThreadData *thread_data = (WatchNameThreadData *) user_data;
  if (thread_data->unwatch_early)
    {
      g_mutex_lock (&thread_data->mutex);
      g_bus_unwatch_name (g_atomic_int_get (&thread_data->watch_id));
      g_atomic_int_set (&thread_data->watch_id, 0);
      g_cond_signal (&thread_data->cond);
      g_mutex_unlock (&thread_data->mutex);
    }
}

static gpointer
watcher_thread (gpointer user_data)
{
  WatchNameThreadData *thread_data = user_data;
  GMainContext *thread_context;

  thread_context = g_main_context_new ();
  g_main_context_push_thread_default (thread_context);

  // Notify that the thread has started
  g_mutex_lock (&thread_data->cond_mutex);
  g_atomic_int_set (&thread_data->started, TRUE);
  g_cond_signal (&thread_data->cond);
  g_mutex_unlock (&thread_data->cond_mutex);

  // Wait for the main thread to own the name before watching it
  g_mutex_lock (&thread_data->cond_mutex);
  while (!g_atomic_int_get (&thread_data->name_acquired))
    g_cond_wait (&thread_data->cond, &thread_data->cond_mutex);
  g_mutex_unlock (&thread_data->cond_mutex);

  thread_data->data.num_appeared = 0;
  thread_data->data.num_vanished = 0;
  thread_data->data.num_free_func = 0;
  // g_signal_connect_after is important to have default handler be called before our code
  g_signal_connect_after (thread_data->connection, "closed", G_CALLBACK (connection_closed_cb), thread_data);

  g_mutex_lock (&thread_data->mutex);
  thread_data->watch_id = g_bus_watch_name_on_connection (thread_data->connection,
                                                          "org.gtk.GDBus.Name1",
                                                          G_BUS_NAME_WATCHER_FLAGS_NONE,
                                                          t_name_appeared_handler,
                                                          t_name_vanished_handler,
                                                          thread_data,
                                                          (GDestroyNotify) t_watch_name_data_free_func);
  g_mutex_unlock (&thread_data->mutex);

  g_assert_cmpint (thread_data->data.num_appeared, ==, 0);
  g_assert_cmpint (thread_data->data.num_vanished, ==, 0);
  while (thread_data->data.num_appeared == 0)
    g_main_context_iteration (thread_context, TRUE);
  g_assert_cmpint (thread_data->data.num_appeared, ==, 1);
  g_assert_cmpint (thread_data->data.num_vanished, ==, 0);
  thread_data->data.num_appeared = 0;

  /* Close the connection and:
   *  - check that we had received a vanished event even begin in different thread
   *  - or check that unwatching the bus when a vanished had been scheduled
   *    make it correctly unscheduled (unwatch_early condition)
   */
  g_dbus_connection_close_sync (thread_data->connection, NULL, NULL);
  if (thread_data->unwatch_early)
    {
      // Wait for the main thread to iterate in order to have close connection handled
      g_mutex_lock (&thread_data->mutex);
      while (g_atomic_int_get (&thread_data->watch_id) != 0)
        g_cond_wait (&thread_data->cond, &thread_data->mutex);
      g_mutex_unlock (&thread_data->mutex);

      while (thread_data->data.num_free_func == 0)
        g_main_context_iteration (thread_context, TRUE);
      g_assert_cmpint (thread_data->data.num_vanished, ==, 0);
      g_assert_cmpint (thread_data->data.num_appeared, ==, 0);
      g_assert_cmpint (thread_data->data.num_free_func, ==, 1);
    }
  else
    {
      while (thread_data->data.num_vanished == 0)
        {
          /*
           * Close of connection is treated in the context of the thread which
           * creates the connection. We must run iteration on it (to have the 'closed'
           * signal handled) and also run current thread loop to have name_vanished
           * callback handled.
           */
          g_main_context_iteration (thread_context, TRUE);
        }
      g_assert_cmpint (thread_data->data.num_vanished, ==, 1);
      g_assert_cmpint (thread_data->data.num_appeared, ==, 0);
      g_mutex_lock (&thread_data->mutex);
      g_bus_unwatch_name (g_atomic_int_get (&thread_data->watch_id));
      g_atomic_int_set (&thread_data->watch_id, 0);
      g_mutex_unlock (&thread_data->mutex);
      while (thread_data->data.num_free_func == 0)
        g_main_context_iteration (thread_context, TRUE);
      g_assert_cmpint (thread_data->data.num_free_func, ==, 1);
    }

  g_mutex_lock (&thread_data->cond_mutex);
  thread_data->ended = TRUE;
  g_main_context_wakeup (NULL);
  g_cond_signal (&thread_data->cond);
  g_mutex_unlock (&thread_data->cond_mutex);

  g_signal_handlers_disconnect_by_func (thread_data->connection, connection_closed_cb, thread_data);
  g_object_unref (thread_data->connection);
  g_main_context_pop_thread_default (thread_context);
  g_main_context_unref (thread_context);

  g_mutex_lock (&thread_data->mutex);
  g_assert_cmpint (thread_data->watch_id, ==, 0);
  g_mutex_unlock (&thread_data->mutex);
  return NULL;
}

static void
watch_with_different_context (gboolean unwatch_early)
{
  OwnNameData own_data;
  WatchNameThreadData thread_data;
  GDBusConnection *connection;
  GThread *watcher;
  guint id;

  session_bus_up ();

  connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
  g_assert (connection != NULL);

  g_mutex_init (&thread_data.mutex);
  g_mutex_init (&thread_data.cond_mutex);
  g_cond_init (&thread_data.cond);
  thread_data.started = FALSE;
  thread_data.name_acquired = FALSE;
  thread_data.ended = FALSE;
  thread_data.connection = g_object_ref (connection);
  thread_data.unwatch_early = unwatch_early;

  // Create a thread which will watch a name and wait for it to be ready
  g_mutex_lock (&thread_data.cond_mutex);
  watcher = g_thread_new ("watcher", watcher_thread, &thread_data);
  while (!g_atomic_int_get (&thread_data.started))
    g_cond_wait (&thread_data.cond, &thread_data.cond_mutex);
  g_mutex_unlock (&thread_data.cond_mutex);

  own_data.num_acquired = 0;
  own_data.num_lost = 0;
  own_data.num_free_func = 0;
  own_data.expect_null_connection = FALSE;
  // Own the name to avoid direct name vanished in watcher thread
  id = g_bus_own_name_on_connection (connection,
                                     "org.gtk.GDBus.Name1",
                                     G_BUS_NAME_OWNER_FLAGS_REPLACE,
                                     w_name_acquired_handler,
                                     w_name_lost_handler,
                                     &own_data,
                                     (GDestroyNotify) own_name_data_free_func);
  while (own_data.num_acquired == 0)
    g_main_context_iteration (NULL, TRUE);
  g_assert_cmpint (own_data.num_acquired, ==, 1);
  g_assert_cmpint (own_data.num_lost, ==, 0);

  // Wake the thread for it to begin watch
  g_mutex_lock (&thread_data.cond_mutex);
  g_atomic_int_set (&thread_data.name_acquired, TRUE);
  g_cond_signal (&thread_data.cond);
  g_mutex_unlock (&thread_data.cond_mutex);

  // Iterate the loop until thread is waking us up
  while (!thread_data.ended)
    g_main_context_iteration (NULL, TRUE);

  g_thread_join (watcher);

  g_bus_unown_name (id);
  while (own_data.num_free_func == 0)
    g_main_context_iteration (NULL, TRUE);
  g_assert_cmpint (own_data.num_free_func, ==, 1);

  g_mutex_clear (&thread_data.mutex);
  g_mutex_clear (&thread_data.cond_mutex);
  g_cond_clear (&thread_data.cond);

  session_bus_stop ();
  g_assert_true (g_dbus_connection_is_closed (connection));
  g_object_unref (connection);
  session_bus_down ();
}

static void
test_bus_watch_different_context (void)
{
  watch_with_different_context (FALSE);
}

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

static void
test_bus_unwatch_early (void)
{
  g_test_bug ("https://gitlab.gnome.org/GNOME/glib/-/issues/604");
  watch_with_different_context (TRUE);
}

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

static void
test_validate_names (void)
{
  guint n;
  static const struct
  {
    gboolean name;
    gboolean unique;
    gboolean interface;
    const gchar *string;
  } names[] = {
    { 1, 0, 1, "valid.well_known.name"},
    { 1, 0, 0, "valid.well-known.name"},
    { 1, 1, 0, ":valid.unique.name"},
    { 0, 0, 0, "invalid.5well_known.name"},
    { 0, 0, 0, "4invalid.5well_known.name"},
    { 1, 1, 0, ":4valid.5unique.name"},
    { 0, 0, 0, ""},
    { 1, 0, 1, "very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.name1"}, /* 255 */
    { 0, 0, 0, "very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.very.long.name12"}, /* 256 - too long! */
    { 0, 0, 0, ".starts.with.a.dot"},
    { 0, 0, 0, "contains.invalid;.characters"},
    { 0, 0, 0, "contains.inva/lid.characters"},
    { 0, 0, 0, "contains.inva[lid.characters"},
    { 0, 0, 0, "contains.inva]lid.characters"},
    { 0, 0, 0, "contains.inva_æøå_lid.characters"},
    { 1, 1, 0, ":1.1"},
  };

  for (n = 0; n < G_N_ELEMENTS (names); n++)
    {
      if (names[n].name)
        g_assert (g_dbus_is_name (names[n].string));
      else
        g_assert (!g_dbus_is_name (names[n].string));

      if (names[n].unique)
        g_assert (g_dbus_is_unique_name (names[n].string));
      else
        g_assert (!g_dbus_is_unique_name (names[n].string));

      if (names[n].interface)
        {
          g_assert (g_dbus_is_interface_name (names[n].string));
          g_assert (g_dbus_is_error_name (names[n].string)); 
        }
      else
        {
          g_assert (!g_dbus_is_interface_name (names[n].string));
          g_assert (!g_dbus_is_error_name (names[n].string));
        }        
    }
}

static void
assert_cmp_escaped_object_path (const gchar *s,
                                const gchar *correct_escaped)
{
  gchar *escaped;
  guint8 *unescaped;

  escaped = g_dbus_escape_object_path (s);
  g_assert_cmpstr (escaped, ==, correct_escaped);

  g_free (escaped);
  escaped = g_dbus_escape_object_path_bytestring ((const guint8 *) s);
  g_assert_cmpstr (escaped, ==, correct_escaped);

  unescaped = g_dbus_unescape_object_path (escaped);
  g_assert_cmpstr ((const gchar *) unescaped, ==, s);

  g_free (escaped);
  g_free (unescaped);
}

static void
test_escape_object_path (void)
{
  assert_cmp_escaped_object_path ("Foo42", "Foo42");
  assert_cmp_escaped_object_path ("foo.bar.baz", "foo_2ebar_2ebaz");
  assert_cmp_escaped_object_path ("foo_bar_baz", "foo_5fbar_5fbaz");
  assert_cmp_escaped_object_path ("_", "_5f");
  assert_cmp_escaped_object_path ("__", "_5f_5f");
  assert_cmp_escaped_object_path ("", "_");
  assert_cmp_escaped_object_path (":1.42", "_3a1_2e42");
  assert_cmp_escaped_object_path ("a/b", "a_2fb");
  assert_cmp_escaped_object_path (" ", "_20");
  assert_cmp_escaped_object_path ("\n", "_0a");

  g_assert_null (g_dbus_unescape_object_path ("_ii"));
  g_assert_null (g_dbus_unescape_object_path ("döner"));
  g_assert_null (g_dbus_unescape_object_path ("_00"));
  g_assert_null (g_dbus_unescape_object_path ("_61"));
  g_assert_null (g_dbus_unescape_object_path ("_ga"));
  g_assert_null (g_dbus_unescape_object_path ("_ag"));
}

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

int
main (int   argc,
      char *argv[])
{
  gint ret;

  g_test_init (&argc, &argv, NULL);

  loop = g_main_loop_new (NULL, FALSE);

  g_test_dbus_unset ();

  g_test_add_func ("/gdbus/validate-names", test_validate_names);
  g_test_add_func ("/gdbus/bus-own-name", test_bus_own_name);
  g_test_add_data_func ("/gdbus/bus-watch-name",
                        &watch_no_closures_no_flags,
                        test_bus_watch_name);
  g_test_add_data_func ("/gdbus/bus-watch-name-auto-start",
                        &watch_no_closures_flags_auto_start,
                        test_bus_watch_name);
  g_test_add_data_func ("/gdbus/bus-watch-name-auto-start-service-exist",
                        &watch_no_closures_flags_auto_start_service_exist,
                        test_bus_watch_name);
  g_test_add_data_func ("/gdbus/bus-watch-name-closures",
                        &watch_closures_no_flags,
                        test_bus_watch_name);
  g_test_add_data_func ("/gdbus/bus-watch-name-closures-auto-start",
                        &watch_closures_flags_auto_start,
                        test_bus_watch_name);
  g_test_add_func ("/gdbus/bus-watch-different-context", test_bus_watch_different_context);
  g_test_add_func ("/gdbus/bus-unwatch-early", test_bus_unwatch_early);
  g_test_add_func ("/gdbus/escape-object-path", test_escape_object_path);
  ret = g_test_run();

  g_main_loop_unref (loop);

  return ret;
}