1 /* GLib testing framework examples and tests
3 * Copyright (C) 2008-2010 Red Hat, Inc.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18 * Boston, MA 02111-1307, USA.
20 * Author: David Zeuthen <davidz@redhat.com>
26 #include "gdbus-tests.h"
28 /* all tests rely on a shared mainloop */
29 static GMainLoop *loop;
31 /* ---------------------------------------------------------------------------------------------------- */
32 /* Test that g_bus_own_name() works correctly */
33 /* ---------------------------------------------------------------------------------------------------- */
38 gboolean expect_null_connection;
39 guint num_bus_acquired;
46 own_name_data_free_func (OwnNameData *data)
48 data->num_free_func++;
49 g_main_loop_quit (loop);
53 bus_acquired_handler (GDBusConnection *connection,
57 OwnNameData *data = user_data;
58 g_dbus_connection_set_exit_on_close (connection, FALSE);
59 data->num_bus_acquired += 1;
60 g_main_loop_quit (loop);
64 name_acquired_handler (GDBusConnection *connection,
68 OwnNameData *data = user_data;
69 data->num_acquired += 1;
70 g_main_loop_quit (loop);
74 name_lost_handler (GDBusConnection *connection,
78 OwnNameData *data = user_data;
79 if (data->expect_null_connection)
81 g_assert (connection == NULL);
85 g_assert (connection != NULL);
86 g_dbus_connection_set_exit_on_close (connection, FALSE);
89 g_main_loop_quit (loop);
93 test_bus_own_name (void)
102 gboolean name_has_owner_reply;
107 name = "org.gtk.GDBus.Name1";
110 * First check that name_lost_handler() is invoked if there is no bus.
112 * Also make sure name_lost_handler() isn't invoked when unowning the name.
114 data.num_bus_acquired = 0;
115 data.num_free_func = 0;
116 data.num_acquired = 0;
118 data.expect_null_connection = TRUE;
119 id = g_bus_own_name (G_BUS_TYPE_SESSION,
121 G_BUS_NAME_OWNER_FLAGS_NONE,
122 bus_acquired_handler,
123 name_acquired_handler,
126 (GDestroyNotify) own_name_data_free_func);
127 g_assert_cmpint (data.num_bus_acquired, ==, 0);
128 g_assert_cmpint (data.num_acquired, ==, 0);
129 g_assert_cmpint (data.num_lost, ==, 0);
130 g_main_loop_run (loop);
131 g_assert_cmpint (data.num_bus_acquired, ==, 0);
132 g_assert_cmpint (data.num_acquired, ==, 0);
133 g_assert_cmpint (data.num_lost, ==, 1);
134 g_bus_unown_name (id);
135 g_assert_cmpint (data.num_acquired, ==, 0);
136 g_assert_cmpint (data.num_lost, ==, 1);
137 g_assert_cmpint (data.num_free_func, ==, 1);
140 * Bring up a bus, then own a name and check bus_acquired_handler() then name_acquired_handler() is invoked.
143 data.num_bus_acquired = 0;
144 data.num_acquired = 0;
146 data.expect_null_connection = FALSE;
147 id = g_bus_own_name (G_BUS_TYPE_SESSION,
149 G_BUS_NAME_OWNER_FLAGS_NONE,
150 bus_acquired_handler,
151 name_acquired_handler,
154 (GDestroyNotify) own_name_data_free_func);
155 g_assert_cmpint (data.num_bus_acquired, ==, 0);
156 g_assert_cmpint (data.num_acquired, ==, 0);
157 g_assert_cmpint (data.num_lost, ==, 0);
158 g_main_loop_run (loop);
159 g_assert_cmpint (data.num_bus_acquired, ==, 1);
160 g_assert_cmpint (data.num_acquired, ==, 0);
161 g_assert_cmpint (data.num_lost, ==, 0);
162 g_main_loop_run (loop);
163 g_assert_cmpint (data.num_bus_acquired, ==, 1);
164 g_assert_cmpint (data.num_acquired, ==, 1);
165 g_assert_cmpint (data.num_lost, ==, 0);
168 * Check that the name was actually acquired.
170 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
171 g_assert (c != NULL);
172 g_assert (!g_dbus_connection_is_closed (c));
173 result = g_dbus_connection_call_sync (c,
174 "org.freedesktop.DBus", /* bus name */
175 "/org/freedesktop/DBus", /* object path */
176 "org.freedesktop.DBus", /* interface name */
177 "NameHasOwner", /* method name */
178 g_variant_new ("(s)", name),
179 G_VARIANT_TYPE ("(b)"),
180 G_DBUS_CALL_FLAGS_NONE,
184 g_assert_no_error (error);
185 g_assert (result != NULL);
186 g_variant_get (result, "(b)", &name_has_owner_reply);
187 g_assert (name_has_owner_reply);
188 g_variant_unref (result);
191 * Stop owning the name - this should invoke our free func
193 g_bus_unown_name (id);
194 g_assert_cmpint (data.num_free_func, ==, 2);
197 * Check that the name was actually released.
199 result = g_dbus_connection_call_sync (c,
200 "org.freedesktop.DBus", /* bus name */
201 "/org/freedesktop/DBus", /* object path */
202 "org.freedesktop.DBus", /* interface name */
203 "NameHasOwner", /* method name */
204 g_variant_new ("(s)", name),
205 G_VARIANT_TYPE ("(b)"),
206 G_DBUS_CALL_FLAGS_NONE,
210 g_assert_no_error (error);
211 g_assert (result != NULL);
212 g_variant_get (result, "(b)", &name_has_owner_reply);
213 g_assert (!name_has_owner_reply);
214 g_variant_unref (result);
217 * Own the name again.
219 data.num_bus_acquired = 0;
220 data.num_acquired = 0;
222 data.expect_null_connection = FALSE;
223 id = g_bus_own_name (G_BUS_TYPE_SESSION,
225 G_BUS_NAME_OWNER_FLAGS_NONE,
226 bus_acquired_handler,
227 name_acquired_handler,
230 (GDestroyNotify) own_name_data_free_func);
231 g_assert_cmpint (data.num_bus_acquired, ==, 0);
232 g_assert_cmpint (data.num_acquired, ==, 0);
233 g_assert_cmpint (data.num_lost, ==, 0);
234 g_main_loop_run (loop);
235 g_assert_cmpint (data.num_bus_acquired, ==, 1);
236 g_assert_cmpint (data.num_acquired, ==, 0);
237 g_assert_cmpint (data.num_lost, ==, 0);
238 g_main_loop_run (loop);
239 g_assert_cmpint (data.num_bus_acquired, ==, 1);
240 g_assert_cmpint (data.num_acquired, ==, 1);
241 g_assert_cmpint (data.num_lost, ==, 0);
244 * Try owning the name with another object on the same connection - this should
245 * fail because we already own the name.
247 data2.num_free_func = 0;
248 data2.num_bus_acquired = 0;
249 data2.num_acquired = 0;
251 data2.expect_null_connection = FALSE;
252 id2 = g_bus_own_name (G_BUS_TYPE_SESSION,
254 G_BUS_NAME_OWNER_FLAGS_NONE,
255 bus_acquired_handler,
256 name_acquired_handler,
259 (GDestroyNotify) own_name_data_free_func);
260 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
261 g_assert_cmpint (data2.num_acquired, ==, 0);
262 g_assert_cmpint (data2.num_lost, ==, 0);
263 g_main_loop_run (loop);
264 g_assert_cmpint (data2.num_bus_acquired, ==, 1);
265 g_assert_cmpint (data2.num_acquired, ==, 0);
266 g_assert_cmpint (data2.num_lost, ==, 0);
267 g_main_loop_run (loop);
268 g_assert_cmpint (data2.num_bus_acquired, ==, 1);
269 g_assert_cmpint (data2.num_acquired, ==, 0);
270 g_assert_cmpint (data2.num_lost, ==, 1);
271 g_bus_unown_name (id2);
272 g_assert_cmpint (data2.num_bus_acquired, ==, 1);
273 g_assert_cmpint (data2.num_acquired, ==, 0);
274 g_assert_cmpint (data2.num_lost, ==, 1);
275 g_assert_cmpint (data2.num_free_func, ==, 1);
278 * Create a secondary (e.g. private) connection and try owning the name on that
279 * connection. This should fail both with and without _REPLACE because we
280 * didn't specify ALLOW_REPLACEMENT.
282 c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, NULL);
283 g_assert (c2 != NULL);
284 g_assert (!g_dbus_connection_is_closed (c2));
285 /* first without _REPLACE */
286 data2.num_bus_acquired = 0;
287 data2.num_acquired = 0;
289 data2.expect_null_connection = FALSE;
290 data2.num_free_func = 0;
291 id2 = g_bus_own_name_on_connection (c2,
293 G_BUS_NAME_OWNER_FLAGS_NONE,
294 name_acquired_handler,
297 (GDestroyNotify) own_name_data_free_func);
298 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
299 g_assert_cmpint (data2.num_acquired, ==, 0);
300 g_assert_cmpint (data2.num_lost, ==, 0);
301 g_main_loop_run (loop);
302 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
303 g_assert_cmpint (data2.num_acquired, ==, 0);
304 g_assert_cmpint (data2.num_lost, ==, 1);
305 g_bus_unown_name (id2);
306 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
307 g_assert_cmpint (data2.num_acquired, ==, 0);
308 g_assert_cmpint (data2.num_lost, ==, 1);
309 g_assert_cmpint (data2.num_free_func, ==, 1);
310 /* then with _REPLACE */
311 data2.num_bus_acquired = 0;
312 data2.num_acquired = 0;
314 data2.expect_null_connection = FALSE;
315 data2.num_free_func = 0;
316 id2 = g_bus_own_name_on_connection (c2,
318 G_BUS_NAME_OWNER_FLAGS_REPLACE,
319 name_acquired_handler,
322 (GDestroyNotify) own_name_data_free_func);
323 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
324 g_assert_cmpint (data2.num_acquired, ==, 0);
325 g_assert_cmpint (data2.num_lost, ==, 0);
326 g_main_loop_run (loop);
327 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
328 g_assert_cmpint (data2.num_acquired, ==, 0);
329 g_assert_cmpint (data2.num_lost, ==, 1);
330 g_bus_unown_name (id2);
331 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
332 g_assert_cmpint (data2.num_acquired, ==, 0);
333 g_assert_cmpint (data2.num_lost, ==, 1);
334 g_assert_cmpint (data2.num_free_func, ==, 1);
337 * Stop owning the name and grab it again with _ALLOW_REPLACEMENT.
339 data.expect_null_connection = FALSE;
340 g_bus_unown_name (id);
341 g_assert_cmpint (data.num_bus_acquired, ==, 1);
342 g_assert_cmpint (data.num_acquired, ==, 1);
343 g_assert_cmpint (data.num_free_func, ==, 3);
345 data.num_bus_acquired = 0;
346 data.num_acquired = 0;
348 data.expect_null_connection = FALSE;
349 id = g_bus_own_name (G_BUS_TYPE_SESSION,
351 G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT,
352 bus_acquired_handler,
353 name_acquired_handler,
356 (GDestroyNotify) own_name_data_free_func);
357 g_assert_cmpint (data.num_bus_acquired, ==, 0);
358 g_assert_cmpint (data.num_acquired, ==, 0);
359 g_assert_cmpint (data.num_lost, ==, 0);
360 g_main_loop_run (loop);
361 g_assert_cmpint (data.num_bus_acquired, ==, 1);
362 g_assert_cmpint (data.num_acquired, ==, 0);
363 g_assert_cmpint (data.num_lost, ==, 0);
364 g_main_loop_run (loop);
365 g_assert_cmpint (data.num_bus_acquired, ==, 1);
366 g_assert_cmpint (data.num_acquired, ==, 1);
367 g_assert_cmpint (data.num_lost, ==, 0);
370 * Now try to grab the name from the secondary connection.
373 /* first without _REPLACE - this won't make us acquire the name */
374 data2.num_bus_acquired = 0;
375 data2.num_acquired = 0;
377 data2.expect_null_connection = FALSE;
378 data2.num_free_func = 0;
379 id2 = g_bus_own_name_on_connection (c2,
381 G_BUS_NAME_OWNER_FLAGS_NONE,
382 name_acquired_handler,
385 (GDestroyNotify) own_name_data_free_func);
386 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
387 g_assert_cmpint (data2.num_acquired, ==, 0);
388 g_assert_cmpint (data2.num_lost, ==, 0);
389 g_main_loop_run (loop);
390 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
391 g_assert_cmpint (data2.num_acquired, ==, 0);
392 g_assert_cmpint (data2.num_lost, ==, 1);
393 g_bus_unown_name (id2);
394 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
395 g_assert_cmpint (data2.num_acquired, ==, 0);
396 g_assert_cmpint (data2.num_lost, ==, 1);
397 g_assert_cmpint (data2.num_free_func, ==, 1);
398 /* then with _REPLACE - here we should acquire the name - e.g. owner should lose it
399 * and owner2 should acquire it */
400 data2.num_bus_acquired = 0;
401 data2.num_acquired = 0;
403 data2.expect_null_connection = FALSE;
404 data2.num_free_func = 0;
405 id2 = g_bus_own_name_on_connection (c2,
407 G_BUS_NAME_OWNER_FLAGS_REPLACE,
408 name_acquired_handler,
411 (GDestroyNotify) own_name_data_free_func);
412 g_assert_cmpint (data.num_acquired, ==, 1);
413 g_assert_cmpint (data.num_lost, ==, 0);
414 g_assert_cmpint (data2.num_acquired, ==, 0);
415 g_assert_cmpint (data2.num_lost, ==, 0);
416 /* wait for handlers for both owner and owner2 to fire */
417 while (data.num_lost == 0 || data2.num_acquired == 0)
418 g_main_loop_run (loop);
419 g_assert_cmpint (data.num_acquired, ==, 1);
420 g_assert_cmpint (data.num_lost, ==, 1);
421 g_assert_cmpint (data2.num_acquired, ==, 1);
422 g_assert_cmpint (data2.num_lost, ==, 0);
423 g_assert_cmpint (data2.num_bus_acquired, ==, 0);
424 /* ok, make owner2 release the name - then wait for owner to automagically reacquire it */
425 g_bus_unown_name (id2);
426 g_assert_cmpint (data2.num_free_func, ==, 1);
427 g_main_loop_run (loop);
428 g_assert_cmpint (data.num_acquired, ==, 2);
429 g_assert_cmpint (data.num_lost, ==, 1);
432 * Finally, nuke the bus and check name_lost_handler() is invoked.
435 data.expect_null_connection = TRUE;
437 while (data.num_lost != 2)
438 g_main_loop_run (loop);
439 g_assert_cmpint (data.num_acquired, ==, 2);
440 g_assert_cmpint (data.num_lost, ==, 2);
441 g_bus_unown_name (id);
442 g_assert_cmpint (data.num_free_func, ==, 4);
448 /* ---------------------------------------------------------------------------------------------------- */
449 /* Test that g_bus_watch_name() works correctly */
450 /* ---------------------------------------------------------------------------------------------------- */
454 gboolean expect_null_connection;
463 watch_name_data_free_func (WatchNameData *data)
465 data->num_free_func++;
466 g_main_loop_quit (loop);
470 w_bus_acquired_handler (GDBusConnection *connection,
477 w_name_acquired_handler (GDBusConnection *connection,
481 WatchNameData *data = user_data;
482 data->num_acquired += 1;
483 g_main_loop_quit (loop);
487 w_name_lost_handler (GDBusConnection *connection,
491 WatchNameData *data = user_data;
493 g_main_loop_quit (loop);
497 name_appeared_handler (GDBusConnection *connection,
499 const gchar *name_owner,
502 WatchNameData *data = user_data;
503 if (data->expect_null_connection)
505 g_assert (connection == NULL);
509 g_assert (connection != NULL);
510 g_dbus_connection_set_exit_on_close (connection, FALSE);
512 data->num_appeared += 1;
513 g_main_loop_quit (loop);
517 name_vanished_handler (GDBusConnection *connection,
521 WatchNameData *data = user_data;
522 if (data->expect_null_connection)
524 g_assert (connection == NULL);
528 g_assert (connection != NULL);
529 g_dbus_connection_set_exit_on_close (connection, FALSE);
531 data->num_vanished += 1;
532 g_main_loop_quit (loop);
536 test_bus_watch_name (void)
543 * First check that name_vanished_handler() is invoked if there is no bus.
545 * Also make sure name_vanished_handler() isn't invoked when unwatching the name.
547 data.num_free_func = 0;
548 data.num_appeared = 0;
549 data.num_vanished = 0;
550 data.expect_null_connection = TRUE;
551 id = g_bus_watch_name (G_BUS_TYPE_SESSION,
552 "org.gtk.GDBus.Name1",
553 G_BUS_NAME_WATCHER_FLAGS_NONE,
554 name_appeared_handler,
555 name_vanished_handler,
557 (GDestroyNotify) watch_name_data_free_func);
558 g_assert_cmpint (data.num_appeared, ==, 0);
559 g_assert_cmpint (data.num_vanished, ==, 0);
560 g_main_loop_run (loop);
561 g_assert_cmpint (data.num_appeared, ==, 0);
562 g_assert_cmpint (data.num_vanished, ==, 1);
563 g_bus_unwatch_name (id);
564 g_assert_cmpint (data.num_appeared, ==, 0);
565 g_assert_cmpint (data.num_vanished, ==, 1);
566 g_assert_cmpint (data.num_free_func, ==, 1);
569 * Now bring up a bus, own a name, and then start watching it.
573 data.num_free_func = 0;
574 data.num_acquired = 0;
576 data.expect_null_connection = FALSE;
577 owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
578 "org.gtk.GDBus.Name1",
579 G_BUS_NAME_OWNER_FLAGS_NONE,
580 w_bus_acquired_handler,
581 w_name_acquired_handler,
584 (GDestroyNotify) watch_name_data_free_func);
585 g_main_loop_run (loop);
586 g_assert_cmpint (data.num_acquired, ==, 1);
587 g_assert_cmpint (data.num_lost, ==, 0);
588 /* now watch the name */
589 data.num_appeared = 0;
590 data.num_vanished = 0;
591 id = g_bus_watch_name (G_BUS_TYPE_SESSION,
592 "org.gtk.GDBus.Name1",
593 G_BUS_NAME_WATCHER_FLAGS_NONE,
594 name_appeared_handler,
595 name_vanished_handler,
597 (GDestroyNotify) watch_name_data_free_func);
598 g_assert_cmpint (data.num_appeared, ==, 0);
599 g_assert_cmpint (data.num_vanished, ==, 0);
600 g_main_loop_run (loop);
601 g_assert_cmpint (data.num_appeared, ==, 1);
602 g_assert_cmpint (data.num_vanished, ==, 0);
607 g_bus_unwatch_name (id);
608 g_assert_cmpint (data.num_free_func, ==, 1);
611 g_bus_unown_name (owner_id);
612 g_assert_cmpint (data.num_acquired, ==, 1);
613 g_assert_cmpint (data.num_free_func, ==, 2);
616 * Create a watcher and then make a name be owned.
618 * This should trigger name_appeared_handler() ...
621 data.num_appeared = 0;
622 data.num_vanished = 0;
623 data.num_free_func = 0;
624 id = g_bus_watch_name (G_BUS_TYPE_SESSION,
625 "org.gtk.GDBus.Name1",
626 G_BUS_NAME_WATCHER_FLAGS_NONE,
627 name_appeared_handler,
628 name_vanished_handler,
630 (GDestroyNotify) watch_name_data_free_func);
631 g_assert_cmpint (data.num_appeared, ==, 0);
632 g_assert_cmpint (data.num_vanished, ==, 0);
633 g_main_loop_run (loop);
634 g_assert_cmpint (data.num_appeared, ==, 0);
635 g_assert_cmpint (data.num_vanished, ==, 1);
638 data.num_acquired = 0;
640 data.expect_null_connection = FALSE;
641 owner_id = g_bus_own_name (G_BUS_TYPE_SESSION,
642 "org.gtk.GDBus.Name1",
643 G_BUS_NAME_OWNER_FLAGS_NONE,
644 w_bus_acquired_handler,
645 w_name_acquired_handler,
648 (GDestroyNotify) watch_name_data_free_func);
649 while (data.num_acquired == 0 || data.num_appeared == 0)
650 g_main_loop_run (loop);
651 g_assert_cmpint (data.num_acquired, ==, 1);
652 g_assert_cmpint (data.num_lost, ==, 0);
653 g_assert_cmpint (data.num_appeared, ==, 1);
654 g_assert_cmpint (data.num_vanished, ==, 1);
657 * Nuke the bus and check that the name vanishes and is lost.
659 data.expect_null_connection = TRUE;
661 g_main_loop_run (loop);
662 g_assert_cmpint (data.num_lost, ==, 1);
663 g_assert_cmpint (data.num_vanished, ==, 2);
665 g_bus_unwatch_name (id);
666 g_assert_cmpint (data.num_free_func, ==, 1);
668 g_bus_unown_name (owner_id);
669 g_assert_cmpint (data.num_free_func, ==, 2);
673 /* ---------------------------------------------------------------------------------------------------- */
676 test_validate_names (void)
686 { 1, 0, 1, "valid.well_known.name"},
687 { 1, 0, 0, "valid.well-known.name"},
688 { 1, 1, 0, ":valid.unique.name"},
689 { 0, 0, 0, "invalid.5well_known.name"},
690 { 0, 0, 0, "4invalid.5well_known.name"},
691 { 1, 1, 0, ":4valid.5unique.name"},
693 { 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 */
694 { 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! */
695 { 0, 0, 0, ".starts.with.a.dot"},
696 { 0, 0, 0, "contains.invalid;.characters"},
697 { 0, 0, 0, "contains.inva/lid.characters"},
698 { 0, 0, 0, "contains.inva[lid.characters"},
699 { 0, 0, 0, "contains.inva]lid.characters"},
700 { 0, 0, 0, "contains.inva_æøå_lid.characters"},
704 for (n = 0; n < G_N_ELEMENTS (names); n++)
707 g_assert (g_dbus_is_name (names[n].string));
709 g_assert (!g_dbus_is_name (names[n].string));
712 g_assert (g_dbus_is_unique_name (names[n].string));
714 g_assert (!g_dbus_is_unique_name (names[n].string));
716 if (names[n].interface)
717 g_assert (g_dbus_is_interface_name (names[n].string));
719 g_assert (!g_dbus_is_interface_name (names[n].string));
723 /* ---------------------------------------------------------------------------------------------------- */
732 g_test_init (&argc, &argv, NULL);
734 loop = g_main_loop_new (NULL, FALSE);
736 /* all the tests use a session bus with a well-known address that we can bring up and down
737 * using session_bus_up() and session_bus_down().
739 g_unsetenv ("DISPLAY");
740 g_setenv ("DBUS_SESSION_BUS_ADDRESS", session_bus_get_temporary_address (), TRUE);
742 g_test_add_func ("/gdbus/validate-names", test_validate_names);
743 g_test_add_func ("/gdbus/bus-own-name", test_bus_own_name);
744 g_test_add_func ("/gdbus/bus-watch-name", test_bus_watch_name);
748 g_main_loop_unref (loop);