gio/gtestdbus.c

   1 /* GIO testing utilities
   2  *
   3  * Copyright (C) 2008-2010 Red Hat, Inc.
   4  * Copyright (C) 2012 Collabora Ltd. <http://www.collabora.co.uk/>
   5  *
   6  * SPDX-License-Identifier: LGPL-2.1-or-later
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General
  19  * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
  20  *
  21  * Authors: David Zeuthen <davidz@redhat.com>
  22  *          Xavier Claessens <xavier.claessens@collabora.co.uk>
  23  */
  24
  25 #include "config.h"
  26
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <errno.h>
  30 #include <string.h>
  31 #include <gstdio.h>
  32 #ifdef G_OS_UNIX
  33 #include <unistd.h>
  34 #endif
  35 #ifdef G_OS_WIN32
  36 #include <io.h>
  37 #include <fcntl.h>
  38 #include <windows.h>
  39 #endif
  40
  41 #include <glib.h>
  42
  43 #include "gdbusconnection.h"
  44 #include "gdbusprivate.h"
  45 #include "gfile.h"
  46 #include "gioenumtypes.h"
  47 #include "gtestdbus.h"
  48
  49 #include "glibintl.h"
  50
  51 #ifdef G_OS_UNIX
  52 #include "glib-unix.h"
  53 #include "glib-unixprivate.h"
  54 #endif
  55
  56 /* -------------------------------------------------------------------------- */
  57 /* Utility: Wait until object has a single ref  */
  58
  59 typedef struct
  60 {
  61   GMainLoop *loop;
  62   gboolean   timed_out;
  63 } WeakNotifyData;
  64
  65 static void
  66 on_weak_notify_timeout (gpointer user_data)
  67 {
  68   WeakNotifyData *data = user_data;
  69   data->timed_out = TRUE;
  70   g_main_loop_quit (data->loop);
  71 }
  72
  73 static gboolean
  74 unref_on_idle (gpointer object)
  75 {
  76   g_object_unref (object);
  77   return FALSE;
  78 }
  79
  80 static gboolean
  81 _g_object_unref_and_wait_weak_notify (gpointer object)
  82 {
  83   WeakNotifyData data;
  84   guint timeout_id;
  85
  86   data.loop = g_main_loop_new (NULL, FALSE);
  87   data.timed_out = FALSE;
  88
  89   g_object_weak_ref (object, (GWeakNotify) g_main_loop_quit, data.loop);
  90
  91   /* Drop the strong ref held by the caller in an idle callback. This is to
  92    * make sure the mainloop is already running when weak notify happens (when
  93    * all other strong ref holders have dropped theirs). */
  94   g_idle_add (unref_on_idle, object);
  95
  96   /* Make sure we don't block forever */
  97   timeout_id = g_timeout_add_seconds_once (30, on_weak_notify_timeout, &data);
  98
  99   g_main_loop_run (data.loop);
 100
 101   if (data.timed_out)
 102     {
 103       g_warning ("Weak notify timeout, object ref_count=%d",
 104           G_OBJECT (object)->ref_count);
 105     }
 106   else
 107     {
 108       g_source_remove (timeout_id);
 109     }
 110
 111   g_main_loop_unref (data.loop);
 112   return data.timed_out;
 113 }
 114
 115 /* -------------------------------------------------------------------------- */
 116 /* Utilities to cleanup the mess in the case unit test process crash */
 117
 118 #ifdef G_OS_WIN32
 119
 120 /* This could be interesting to expose in public API */
 121 static void
 122 _g_test_watcher_add_pid (GPid pid)
 123 {
 124   HANDLE job = NULL;
 125
 126   if (g_once_init_enter (&job))
 127     {
 128       JOBOBJECT_EXTENDED_LIMIT_INFORMATION info;
 129
 130       HANDLE tmp = CreateJobObjectW (NULL, NULL);
 131       memset (&info, 0, sizeof (info));
 132       info.BasicLimitInformation.LimitFlags = 0x2000 /* JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE */;
 133
 134       if (!SetInformationJobObject (tmp, JobObjectExtendedLimitInformation, &info, sizeof (info)))
 135         g_warning ("Can't enable JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE: %s", g_win32_error_message (GetLastError()));
 136
 137       g_once_init_leave_pointer (&job, tmp);
 138     }
 139
 140   if (!AssignProcessToJobObject(job, pid))
 141     g_warning ("Can't assign process to job: %s", g_win32_error_message (GetLastError()));
 142 }
 143
 144 static void
 145 _g_test_watcher_remove_pid (GPid pid)
 146 {
 147   /* No need to unassign the process from the job object as the process
 148      will be killed anyway */
 149 }
 150
 151 #else
 152
 153 #define ADD_PID_FORMAT "add pid %d\n"
 154 #define REMOVE_PID_FORMAT "remove pid %d\n"
 155
 156 static void
 157 watch_parent (gint fd)
 158 {
 159   GIOChannel *channel;
 160   GPollFD fds[1];
 161   GArray *pids_to_kill;
 162
 163   channel = g_io_channel_unix_new (fd);
 164
 165   fds[0].fd = fd;
 166   fds[0].events = G_IO_HUP | G_IO_IN;
 167   fds[0].revents = 0;
 168
 169   pids_to_kill = g_array_new (FALSE, FALSE, sizeof (guint));
 170
 171   do
 172     {
 173       gint num_events;
 174       gchar *command = NULL;
 175       guint pid;
 176       guint n;
 177       GError *error = NULL;
 178
 179       num_events = g_poll (fds, 1, -1);
 180       if (num_events == 0)
 181         continue;
 182
 183       if (fds[0].revents & G_IO_HUP)
 184         {
 185           /* Parent quit, cleanup the mess and exit */
 186           for (n = 0; n < pids_to_kill->len; n++)
 187             {
 188               pid = g_array_index (pids_to_kill, guint, n);
 189               g_printerr ("cleaning up pid %d\n", pid);
 190               kill (pid, SIGTERM);
 191             }
 192
 193           g_array_unref (pids_to_kill);
 194           g_io_channel_shutdown (channel, FALSE, &error);
 195           g_assert_no_error (error);
 196           g_io_channel_unref (channel);
 197
 198           exit (0);
 199         }
 200
 201       /* Read the command from the input */
 202       g_io_channel_read_line (channel, &command, NULL, NULL, &error);
 203       g_assert_no_error (error);
 204
 205       /* Check for known commands */
 206       if (sscanf (command, ADD_PID_FORMAT, &pid) == 1)
 207         {
 208           g_array_append_val (pids_to_kill, pid);
 209         }
 210       else if (sscanf (command, REMOVE_PID_FORMAT, &pid) == 1)
 211         {
 212           for (n = 0; n < pids_to_kill->len; n++)
 213             {
 214               if (g_array_index (pids_to_kill, guint, n) == pid)
 215                 {
 216                   g_array_remove_index (pids_to_kill, n);
 217                   pid = 0;
 218                   break;
 219                 }
 220             }
 221           if (pid != 0)
 222             {
 223               g_warning ("unknown pid %d to remove", pid);
 224             }
 225         }
 226       else
 227         {
 228           g_warning ("unknown command from parent '%s'", command);
 229         }
 230
 231       g_free (command);
 232     }
 233   while (TRUE);
 234 }
 235
 236 static GIOChannel *
 237 watcher_init (void)
 238 {
 239   static gsize started = 0;
 240   static GIOChannel *channel = NULL;
 241   int errsv;
 242
 243   if (g_once_init_enter (&started))
 244     {
 245       gint pipe_fds[2];
 246
 247       /* fork a child to clean up when we are killed */
 248       if (!g_unix_open_pipe_internal (pipe_fds, TRUE, FALSE))
 249         {
 250           errsv = errno;
 251           g_warning ("pipe() failed: %s", g_strerror (errsv));
 252           g_assert_not_reached ();
 253         }
 254
 255       /* flush streams to avoid buffers being duplicated in the child and
 256        * flushed by both the child and parent later
 257        *
 258        * FIXME: This is a workaround for the fact that watch_parent() uses
 259        * non-async-signal-safe API. See
 260        * https://gitlab.gnome.org/GNOME/glib/-/issues/2322#note_1034330
 261        */
 262       fflush (stdout);
 263       fflush (stderr);
 264
 265       switch (fork ())
 266         {
 267         case -1:
 268           errsv = errno;
 269           g_warning ("fork() failed: %s", g_strerror (errsv));
 270           g_assert_not_reached ();
 271           break;
 272
 273         case 0:
 274           /* child */
 275           close (pipe_fds[1]);
 276           watch_parent (pipe_fds[0]);
 277           break;
 278
 279         default:
 280           /* parent */
 281           close (pipe_fds[0]);
 282           channel = g_io_channel_unix_new (pipe_fds[1]);
 283         }
 284
 285       g_once_init_leave (&started, 1);
 286     }
 287
 288   return channel;
 289 }
 290
 291 static void
 292 watcher_send_command (const gchar *command)
 293 {
 294   GIOChannel *channel;
 295   GError *error = NULL;
 296   GIOStatus status;
 297
 298   channel = watcher_init ();
 299
 300   do
 301    status = g_io_channel_write_chars (channel, command, -1, NULL, &error);
 302   while (status == G_IO_STATUS_AGAIN);
 303   g_assert_no_error (error);
 304
 305   g_io_channel_flush (channel, &error);
 306   g_assert_no_error (error);
 307 }
 308
 309 /* This could be interesting to expose in public API */
 310 static void
 311 _g_test_watcher_add_pid (GPid pid)
 312 {
 313   gchar *command;
 314
 315   command = g_strdup_printf (ADD_PID_FORMAT, (guint) pid);
 316   watcher_send_command (command);
 317   g_free (command);
 318 }
 319
 320 static void
 321 _g_test_watcher_remove_pid (GPid pid)
 322 {
 323   gchar *command;
 324
 325   command = g_strdup_printf (REMOVE_PID_FORMAT, (guint) pid);
 326   watcher_send_command (command);
 327   g_free (command);
 328 }
 329
 330 #endif
 331
 332 /* -------------------------------------------------------------------------- */
 333 /* GTestDBus object implementation */
 334
 335 /**
 336  * GTestDBus:
 337  *
 338  * A helper class for testing code which uses D-Bus without touching the user’s
 339  * session bus.
 340  *
 341  * Note that `GTestDBus` modifies the user’s environment, calling
 342  * [`setenv()`](man:setenv(3)). This is not thread-safe, so all `GTestDBus`
 343  * calls should be completed before threads are spawned, or should have
 344  * appropriate locking to ensure no access conflicts to environment variables
 345  * shared between `GTestDBus` and other threads.
 346  *
 347  * ## Creating unit tests using `GTestDBus`
 348  *
 349  * Testing of D-Bus services can be tricky because normally we only ever run
 350  * D-Bus services over an existing instance of the D-Bus daemon thus we
 351  * usually don’t activate D-Bus services that are not yet installed into the
 352  * target system. The `GTestDBus` object makes this easier for us by taking care
 353  * of the lower level tasks such as running a private D-Bus daemon and looking
 354  * up uninstalled services in customizable locations, typically in your source
 355  * code tree.
 356  *
 357  * The first thing you will need is a separate service description file for the
 358  * D-Bus daemon. Typically a `services` subdirectory of your `tests` directory
 359  * is a good place to put this file.
 360  *
 361  * The service file should list your service along with an absolute path to the
 362  * uninstalled service executable in your source tree. Using autotools we would
 363  * achieve this by adding a file such as `my-server.service.in` in the services
 364  * directory and have it processed by configure.
 365  *
 366  * ```
 367  * [D-BUS Service]
 368  * Name=org.gtk.GDBus.Examples.ObjectManager
 369  * Exec=@abs_top_builddir@/gio/tests/gdbus-example-objectmanager-server
 370  * ```
 371  *
 372  * You will also need to indicate this service directory in your test
 373  * fixtures, so you will need to pass the path while compiling your
 374  * test cases. Typically this is done with autotools with an added
 375  * preprocessor flag specified to compile your tests such as:
 376  *
 377  * ```
 378  * -DTEST_SERVICES=\""$(abs_top_builddir)/tests/services"\"
 379  * ```
 380  *
 381  * Once you have a service definition file which is local to your source tree,
 382  * you can proceed to set up a GTest fixture using the `GTestDBus` scaffolding.
 383  *
 384  * An example of a test fixture for D-Bus services can be found
 385  * here:
 386  * [gdbus-test-fixture.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-test-fixture.c)
 387  *
 388  * Note that these examples only deal with isolating the D-Bus aspect of your
 389  * service. To successfully run isolated unit tests on your service you may need
 390  * some additional modifications to your test case fixture. For example; if your
 391  * service uses [class@Gio.Settings] and installs a schema then it is important
 392  * that your test service not load the schema in the ordinary installed location
 393  * (chances are that your service and schema files are not yet installed, or
 394  * worse; there is an older version of the schema file sitting in the install
 395  * location).
 396  *
 397  * Most of the time we can work around these obstacles using the
 398  * environment. Since the environment is inherited by the D-Bus daemon
 399  * created by `GTestDBus` and then in turn inherited by any services the
 400  * D-Bus daemon activates, using the setup routine for your fixture is
 401  * a practical place to help sandbox your runtime environment. For the
 402  * rather typical GSettings case we can work around this by setting
 403  * `GSETTINGS_SCHEMA_DIR` to the in tree directory holding your schemas
 404  * in the above `fixture_setup()` routine.
 405  *
 406  * The GSettings schemas need to be locally pre-compiled for this to work. This
 407  * can be achieved by compiling the schemas locally as a step before running
 408  * test cases, an autotools setup might do the following in the directory
 409  * holding schemas:
 410  *
 411  * ```
 412  *     all-am:
 413  *             $(GLIB_COMPILE_SCHEMAS) .
 414  *
 415  *     CLEANFILES += gschemas.compiled
 416  * ```
 417  *
 418  * Since: 2.34
 419  */
 420
 421 typedef struct _GTestDBusClass   GTestDBusClass;
 422 typedef struct _GTestDBusPrivate GTestDBusPrivate;
 423
 424 struct _GTestDBus {
 425   GObject parent;
 426
 427   GTestDBusPrivate *priv;
 428 };
 429
 430 struct _GTestDBusClass {
 431   GObjectClass parent_class;
 432 };
 433
 434 struct _GTestDBusPrivate
 435 {
 436   GTestDBusFlags flags;
 437   GPtrArray *service_dirs;
 438   GPid bus_pid;
 439   gchar *bus_address;
 440   gboolean up;
 441 };
 442
 443 enum
 444 {
 445   PROP_0,
 446   PROP_FLAGS,
 447 };
 448
 449 G_DEFINE_TYPE_WITH_PRIVATE (GTestDBus, g_test_dbus, G_TYPE_OBJECT)
 450
 451 static void
 452 g_test_dbus_init (GTestDBus *self)
 453 {
 454   self->priv = g_test_dbus_get_instance_private (self);
 455   self->priv->service_dirs = g_ptr_array_new_with_free_func (g_free);
 456 }
 457
 458 static void
 459 g_test_dbus_dispose (GObject *object)
 460 {
 461   GTestDBus *self = (GTestDBus *) object;
 462
 463   if (self->priv->up)
 464     g_test_dbus_down (self);
 465
 466   G_OBJECT_CLASS (g_test_dbus_parent_class)->dispose (object);
 467 }
 468
 469 static void
 470 g_test_dbus_finalize (GObject *object)
 471 {
 472   GTestDBus *self = (GTestDBus *) object;
 473
 474   g_ptr_array_unref (self->priv->service_dirs);
 475   g_free (self->priv->bus_address);
 476
 477   G_OBJECT_CLASS (g_test_dbus_parent_class)->finalize (object);
 478 }
 479
 480 static void
 481 g_test_dbus_get_property (GObject *object,
 482     guint property_id,
 483     GValue *value,
 484     GParamSpec *pspec)
 485 {
 486   GTestDBus *self = (GTestDBus *) object;
 487
 488   switch (property_id)
 489     {
 490       case PROP_FLAGS:
 491         g_value_set_flags (value, g_test_dbus_get_flags (self));
 492         break;
 493       default:
 494         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 495         break;
 496     }
 497 }
 498
 499 static void
 500 g_test_dbus_set_property (GObject *object,
 501     guint property_id,
 502     const GValue *value,
 503     GParamSpec *pspec)
 504 {
 505   GTestDBus *self = (GTestDBus *) object;
 506
 507   switch (property_id)
 508     {
 509       case PROP_FLAGS:
 510         self->priv->flags = g_value_get_flags (value);
 511         break;
 512       default:
 513         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 514         break;
 515     }
 516 }
 517
 518 static void
 519 g_test_dbus_class_init (GTestDBusClass *klass)
 520 {
 521   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 522
 523   object_class->dispose = g_test_dbus_dispose;
 524   object_class->finalize = g_test_dbus_finalize;
 525   object_class->get_property = g_test_dbus_get_property;
 526   object_class->set_property = g_test_dbus_set_property;
 527
 528   /**
 529    * GTestDBus:flags:
 530    *
 531    * #GTestDBusFlags specifying the behaviour of the D-Bus session.
 532    *
 533    * Since: 2.34
 534    */
 535   g_object_class_install_property (object_class, PROP_FLAGS,
 536     g_param_spec_flags ("flags", NULL, NULL,
 537                         G_TYPE_TEST_DBUS_FLAGS, G_TEST_DBUS_NONE,
 538                         G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
 539                         G_PARAM_STATIC_STRINGS));
 540
 541 }
 542
 543 static gchar *
 544 write_config_file (GTestDBus *self)
 545 {
 546   GString *contents;
 547   gint fd;
 548   guint i;
 549   GError *error = NULL;
 550   gchar *path = NULL;
 551
 552   fd = g_file_open_tmp ("g-test-dbus-XXXXXX", &path, &error);
 553   g_assert_no_error (error);
 554
 555   contents = g_string_new (NULL);
 556   g_string_append (contents,
 557       "<busconfig>\n"
 558       "  <type>session</type>\n"
 559 #ifdef G_OS_WIN32
 560       "  <listen>nonce-tcp:</listen>\n"
 561 #else
 562       "  <listen>unix:tmpdir=/tmp</listen>\n"
 563 #endif
 564                    );
 565
 566   for (i = 0; i < self->priv->service_dirs->len; i++)
 567     {
 568       const gchar *dir_path = g_ptr_array_index (self->priv->service_dirs, i);
 569
 570       g_string_append_printf (contents,
 571           "  <servicedir>%s</servicedir>\n", dir_path);
 572     }
 573
 574   g_string_append (contents,
 575       "  <policy context=\"default\">\n"
 576       "    <!-- Allow everything to be sent -->\n"
 577       "    <allow send_destination=\"*\" eavesdrop=\"true\"/>\n"
 578       "    <!-- Allow everything to be received -->\n"
 579       "    <allow eavesdrop=\"true\"/>\n"
 580       "    <!-- Allow anyone to own anything -->\n"
 581       "    <allow own=\"*\"/>\n"
 582       "  </policy>\n"
 583       "</busconfig>\n");
 584
 585   close (fd);
 586   g_file_set_contents_full (path, contents->str, contents->len,
 587                             G_FILE_SET_CONTENTS_NONE,
 588                             0600, &error);
 589   g_assert_no_error (error);
 590
 591   g_string_free (contents, TRUE);
 592
 593   return path;
 594 }
 595
 596 static gboolean
 597 make_pipe (gint     pipe_fds[2],
 598            GError **error)
 599 {
 600 #if defined(G_OS_UNIX)
 601   return g_unix_open_pipe (pipe_fds, O_CLOEXEC, error);
 602 #elif defined(G_OS_WIN32)
 603   if (_pipe (pipe_fds, 4096, _O_BINARY) < 0)
 604     {
 605       int errsv = errno;
 606
 607       g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 608                    _("Failed to create pipe for communicating with child process (%s)"),
 609                    g_strerror (errsv));
 610       return FALSE;
 611     }
 612   return TRUE;
 613 #else
 614   g_set_error (error, G_SPAWN_ERROR, G_SPAWN_ERROR_FAILED,
 615                _("Pipes are not supported in this platform"));
 616   return FALSE;
 617 #endif
 618 }
 619
 620 static void
 621 start_daemon (GTestDBus *self)
 622 {
 623   const gchar *argv[] = {"dbus-daemon", "--print-address", "--config-file=foo", NULL};
 624   gint pipe_fds[2] = {-1, -1};
 625   gchar *config_path;
 626   gchar *config_arg;
 627   gchar *print_address;
 628   GIOChannel *channel;
 629   gsize termpos;
 630   GError *error = NULL;
 631
 632   if (g_getenv ("G_TEST_DBUS_DAEMON") != NULL)
 633     argv[0] = (gchar *)g_getenv ("G_TEST_DBUS_DAEMON");
 634
 635   make_pipe (pipe_fds, &error);
 636   g_assert_no_error (error);
 637
 638   print_address = g_strdup_printf ("--print-address=%d", pipe_fds[1]);
 639   argv[1] = print_address;
 640   g_assert_no_error (error);
 641
 642   /* Write config file and set its path in argv */
 643   config_path = write_config_file (self);
 644   config_arg = g_strdup_printf ("--config-file=%s", config_path);
 645   argv[2] = config_arg;
 646
 647   /* Spawn dbus-daemon */
 648   g_spawn_async_with_pipes_and_fds (NULL,
 649                                     argv,
 650                                     NULL,
 651                                     /* We Need this to get the pid returned on win32 */
 652                                     G_SPAWN_DO_NOT_REAP_CHILD |
 653                                     G_SPAWN_SEARCH_PATH |
 654                                     /* dbus-daemon will not abuse our descriptors, and
 655                                      * passing this means we can use posix_spawn() for speed */
 656                                     G_SPAWN_LEAVE_DESCRIPTORS_OPEN,
 657                                     NULL, NULL,
 658                                     -1, -1, -1,
 659                                     &pipe_fds[1], &pipe_fds[1], 1,
 660                                     &self->priv->bus_pid,
 661                                     NULL, NULL, NULL,
 662                                     &error);
 663   g_assert_no_error (error);
 664
 665   _g_test_watcher_add_pid (self->priv->bus_pid);
 666
 667   /* Read bus address from pipe */
 668   channel = g_io_channel_unix_new (pipe_fds[0]);
 669   pipe_fds[0] = -1;
 670   g_io_channel_set_close_on_unref (channel, TRUE);
 671   g_io_channel_read_line (channel, &self->priv->bus_address, NULL,
 672       &termpos, &error);
 673   g_assert_no_error (error);
 674   self->priv->bus_address[termpos] = '\0';
 675   close (pipe_fds[1]);
 676   pipe_fds[1] = -1;
 677
 678   /* start dbus-monitor */
 679   if (g_getenv ("G_DBUS_MONITOR") != NULL)
 680     {
 681       gchar *command;
 682
 683       command = g_strdup_printf ("dbus-monitor --address %s",
 684           self->priv->bus_address);
 685       g_spawn_command_line_async (command, NULL);
 686       g_free (command);
 687
 688       g_usleep (500 * 1000);
 689     }
 690
 691   /* Cleanup */
 692   g_io_channel_shutdown (channel, FALSE, &error);
 693   g_assert_no_error (error);
 694   g_io_channel_unref (channel);
 695
 696   /* Don't use g_file_delete since it calls into gvfs */
 697   if (g_unlink (config_path) != 0)
 698     g_assert_not_reached ();
 699
 700   g_free (print_address);
 701   g_free (config_path);
 702   g_free (config_arg);
 703 }
 704
 705 static void
 706 stop_daemon (GTestDBus *self)
 707 {
 708 #ifdef G_OS_WIN32
 709   if (!TerminateProcess (self->priv->bus_pid, 0))
 710     g_warning ("Can't terminate process: %s", g_win32_error_message (GetLastError()));
 711 #else
 712   kill (self->priv->bus_pid, SIGTERM);
 713 #endif
 714   _g_test_watcher_remove_pid (self->priv->bus_pid);
 715   g_spawn_close_pid (self->priv->bus_pid);
 716   self->priv->bus_pid = 0;
 717
 718   g_free (self->priv->bus_address);
 719   self->priv->bus_address = NULL;
 720 }
 721
 722 /**
 723  * g_test_dbus_new:
 724  * @flags: a #GTestDBusFlags
 725  *
 726  * Create a new #GTestDBus object.
 727  *
 728  * Returns: (transfer full): a new #GTestDBus.
 729  */
 730 GTestDBus *
 731 g_test_dbus_new (GTestDBusFlags flags)
 732 {
 733   return g_object_new (G_TYPE_TEST_DBUS,
 734       "flags", flags,
 735       NULL);
 736 }
 737
 738 /**
 739  * g_test_dbus_get_flags:
 740  * @self: a #GTestDBus
 741  *
 742  * Get the flags of the #GTestDBus object.
 743  *
 744  * Returns: the value of #GTestDBus:flags property
 745  */
 746 GTestDBusFlags
 747 g_test_dbus_get_flags (GTestDBus *self)
 748 {
 749   g_return_val_if_fail (G_IS_TEST_DBUS (self), G_TEST_DBUS_NONE);
 750
 751   return self->priv->flags;
 752 }
 753
 754 /**
 755  * g_test_dbus_get_bus_address:
 756  * @self: a #GTestDBus
 757  *
 758  * Get the address on which dbus-daemon is running. If g_test_dbus_up() has not
 759  * been called yet, %NULL is returned. This can be used with
 760  * g_dbus_connection_new_for_address().
 761  *
 762  * Returns: (nullable): the address of the bus, or %NULL.
 763  */
 764 const gchar *
 765 g_test_dbus_get_bus_address (GTestDBus *self)
 766 {
 767   g_return_val_if_fail (G_IS_TEST_DBUS (self), NULL);
 768
 769   return self->priv->bus_address;
 770 }
 771
 772 /**
 773  * g_test_dbus_add_service_dir:
 774  * @self: a #GTestDBus
 775  * @path: path to a directory containing .service files
 776  *
 777  * Add a path where dbus-daemon will look up .service files. This can't be
 778  * called after g_test_dbus_up().
 779  */
 780 void
 781 g_test_dbus_add_service_dir (GTestDBus *self,
 782     const gchar *path)
 783 {
 784   g_return_if_fail (G_IS_TEST_DBUS (self));
 785   g_return_if_fail (self->priv->bus_address == NULL);
 786
 787   g_ptr_array_add (self->priv->service_dirs, g_strdup (path));
 788 }
 789
 790 /**
 791  * g_test_dbus_up:
 792  * @self: a #GTestDBus
 793  *
 794  * Start a dbus-daemon instance and set DBUS_SESSION_BUS_ADDRESS. After this
 795  * call, it is safe for unit tests to start sending messages on the session bus.
 796  *
 797  * If this function is called from setup callback of g_test_add(),
 798  * g_test_dbus_down() must be called in its teardown callback.
 799  *
 800  * If this function is called from unit test's main(), then g_test_dbus_down()
 801  * must be called after g_test_run().
 802  */
 803 void
 804 g_test_dbus_up (GTestDBus *self)
 805 {
 806   g_return_if_fail (G_IS_TEST_DBUS (self));
 807   g_return_if_fail (self->priv->bus_address == NULL);
 808   g_return_if_fail (!self->priv->up);
 809
 810   start_daemon (self);
 811
 812   g_test_dbus_unset ();
 813   g_setenv ("DBUS_SESSION_BUS_ADDRESS", self->priv->bus_address, TRUE);
 814   self->priv->up = TRUE;
 815 }
 816
 817
 818 /**
 819  * g_test_dbus_stop:
 820  * @self: a #GTestDBus
 821  *
 822  * Stop the session bus started by g_test_dbus_up().
 823  *
 824  * Unlike g_test_dbus_down(), this won't verify the #GDBusConnection
 825  * singleton returned by g_bus_get() or g_bus_get_sync() is destroyed. Unit
 826  * tests wanting to verify behaviour after the session bus has been stopped
 827  * can use this function but should still call g_test_dbus_down() when done.
 828  */
 829 void
 830 g_test_dbus_stop (GTestDBus *self)
 831 {
 832   g_return_if_fail (G_IS_TEST_DBUS (self));
 833   g_return_if_fail (self->priv->bus_address != NULL);
 834
 835   stop_daemon (self);
 836 }
 837
 838 /**
 839  * g_test_dbus_down:
 840  * @self: a #GTestDBus
 841  *
 842  * Stop the session bus started by g_test_dbus_up().
 843  *
 844  * This will wait for the singleton returned by g_bus_get() or g_bus_get_sync()
 845  * to be destroyed. This is done to ensure that the next unit test won't get a
 846  * leaked singleton from this test.
 847  */
 848 void
 849 g_test_dbus_down (GTestDBus *self)
 850 {
 851   GDBusConnection *connection;
 852
 853   g_return_if_fail (G_IS_TEST_DBUS (self));
 854   g_return_if_fail (self->priv->up);
 855
 856   connection = _g_bus_get_singleton_if_exists (G_BUS_TYPE_SESSION);
 857   if (connection != NULL)
 858     g_dbus_connection_set_exit_on_close (connection, FALSE);
 859
 860   if (self->priv->bus_address != NULL)
 861     stop_daemon (self);
 862
 863   if (connection != NULL)
 864     _g_object_unref_and_wait_weak_notify (connection);
 865
 866   g_test_dbus_unset ();
 867   _g_bus_forget_singleton (G_BUS_TYPE_SESSION);
 868   self->priv->up = FALSE;
 869 }
 870
 871 /**
 872  * g_test_dbus_unset:
 873  *
 874  * Unset DISPLAY and DBUS_SESSION_BUS_ADDRESS env variables to ensure the test
 875  * won't use user's session bus.
 876  *
 877  * This is useful for unit tests that want to verify behaviour when no session
 878  * bus is running. It is not necessary to call this if unit test already calls
 879  * g_test_dbus_up() before acquiring the session bus.
 880  */
 881 void
 882 g_test_dbus_unset (void)
 883 {
 884   g_unsetenv ("DISPLAY");
 885   g_unsetenv ("DBUS_SESSION_BUS_ADDRESS");
 886   g_unsetenv ("DBUS_STARTER_ADDRESS");
 887   g_unsetenv ("DBUS_STARTER_BUS_TYPE");
 888   /* avoid using XDG_RUNTIME_DIR/bus */
 889   g_unsetenv ("XDG_RUNTIME_DIR");
 890 }