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>
27 #include <sys/types.h>
30 #include "gdbus-tests.h"
32 /* all tests rely on a shared mainloop */
33 static GMainLoop *loop = NULL;
35 G_GNUC_UNUSED static void
36 _log (const gchar *format, ...)
45 va_start (var_args, format);
46 str = g_strdup_vprintf (format, var_args);
49 g_get_current_time (&now);
50 now_time = (time_t) now.tv_sec;
51 now_tm = localtime (&now_time);
52 strftime (time_buf, sizeof time_buf, "%H:%M:%S", now_tm);
54 g_print ("%s.%06d: %s\n",
55 time_buf, (gint) now.tv_usec / 1000,
61 test_connection_quit_mainloop (gpointer user_data)
63 volatile gboolean *quit_mainloop_fired = user_data;
64 //_log ("quit_mainloop_fired");
65 *quit_mainloop_fired = TRUE;
66 g_main_loop_quit (loop);
70 /* ---------------------------------------------------------------------------------------------------- */
71 /* Connection life-cycle testing */
72 /* ---------------------------------------------------------------------------------------------------- */
74 static const GDBusInterfaceInfo boo_interface_info =
78 (GDBusMethodInfo **) NULL,
79 (GDBusSignalInfo **) NULL,
80 (GDBusPropertyInfo **) NULL,
84 static const GDBusInterfaceVTable boo_vtable =
86 NULL, /* _method_call */
87 NULL, /* _get_property */
88 NULL /* _set_property */
92 some_filter_func (GDBusConnection *connection,
93 GDBusMessage *message,
101 on_name_owner_changed (GDBusConnection *connection,
102 const gchar *sender_name,
103 const gchar *object_path,
104 const gchar *interface_name,
105 const gchar *signal_name,
106 GVariant *parameters,
112 a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop (gpointer user_data)
114 volatile gboolean *val = user_data;
116 //_log ("destroynotify fired for %p", val);
117 g_main_loop_quit (loop);
121 test_connection_life_cycle (void)
127 volatile gboolean on_signal_registration_freed_called;
128 volatile gboolean on_filter_freed_called;
129 volatile gboolean on_register_object_freed_called;
130 volatile gboolean quit_mainloop_fired;
131 guint quit_mainloop_id;
132 guint registration_id;
137 * Check for correct behavior when no bus is present
140 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
141 _g_assert_error_domain (error, G_IO_ERROR);
142 g_assert (!g_dbus_error_is_remote_error (error));
143 g_assert (c == NULL);
144 g_error_free (error);
147 * Check for correct behavior when a bus is present
152 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
153 g_assert_no_error (error);
154 g_assert (c != NULL);
155 g_assert (!g_dbus_connection_is_closed (c));
158 * Check that singleton handling work
161 c2 = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
162 g_assert_no_error (error);
163 g_assert (c2 != NULL);
168 * Check that private connections work
170 c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, &error);
171 g_assert_no_error (error);
172 g_assert (c2 != NULL);
176 c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, &error);
177 g_assert_no_error (error);
178 g_assert (c2 != NULL);
179 g_assert (!g_dbus_connection_is_closed (c2));
180 ret = g_dbus_connection_close_sync (c2, NULL, &error);
181 g_assert_no_error (error);
183 _g_assert_signal_received (c2, "closed");
184 g_assert (g_dbus_connection_is_closed (c2));
185 ret = g_dbus_connection_close_sync (c2, NULL, &error);
186 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED);
187 g_error_free (error);
192 * Check that the finalization code works
194 * (and that the GDestroyNotify for filters and objects and signal
195 * registrations are run as expected)
198 c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, &error);
199 g_assert_no_error (error);
200 g_assert (c2 != NULL);
201 /* signal registration */
202 on_signal_registration_freed_called = FALSE;
203 g_dbus_connection_signal_subscribe (c2,
204 "org.freedesktop.DBus", /* bus name */
205 "org.freedesktop.DBus", /* interface */
206 "NameOwnerChanged", /* member */
207 "/org/freesktop/DBus", /* path */
209 G_DBUS_SIGNAL_FLAGS_NONE,
210 on_name_owner_changed,
211 (gpointer) &on_signal_registration_freed_called,
212 a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop);
214 on_filter_freed_called = FALSE;
215 g_dbus_connection_add_filter (c2,
217 (gpointer) &on_filter_freed_called,
218 a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop);
219 /* object registration */
220 on_register_object_freed_called = FALSE;
222 registration_id = g_dbus_connection_register_object (c2,
224 (GDBusInterfaceInfo *) &boo_interface_info,
226 (gpointer) &on_register_object_freed_called,
227 a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop,
229 g_assert_no_error (error);
230 g_assert (registration_id > 0);
231 /* ok, finalize the connection and check that all the GDestroyNotify functions are invoked as expected */
233 quit_mainloop_fired = FALSE;
234 quit_mainloop_id = g_timeout_add (30000, test_connection_quit_mainloop, (gpointer) &quit_mainloop_fired);
235 //_log ("destroynotifies for\n"
236 // " register_object %p\n"
239 // &on_register_object_freed_called,
240 // &on_filter_freed_called,
241 // &on_signal_registration_freed_called);
244 if (on_signal_registration_freed_called &&
245 on_filter_freed_called &&
246 on_register_object_freed_called)
248 if (quit_mainloop_fired)
250 //_log ("entering loop");
251 g_main_loop_run (loop);
252 //_log ("exiting loop");
254 g_source_remove (quit_mainloop_id);
255 g_assert (on_signal_registration_freed_called);
256 g_assert (on_filter_freed_called);
257 g_assert (on_register_object_freed_called);
258 g_assert (!quit_mainloop_fired);
261 * Check for correct behavior when the bus goes away
264 g_assert (!g_dbus_connection_is_closed (c));
265 g_dbus_connection_set_exit_on_close (c, FALSE);
267 _g_assert_signal_received (c, "closed");
268 g_assert (g_dbus_connection_is_closed (c));
270 _g_object_wait_for_single_ref (c);
274 /* ---------------------------------------------------------------------------------------------------- */
275 /* Test that sending and receiving messages work as expected */
276 /* ---------------------------------------------------------------------------------------------------- */
279 msg_cb_expect_error_disconnected (GDBusConnection *connection,
287 result = g_dbus_connection_call_finish (connection,
290 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED);
291 g_assert (!g_dbus_error_is_remote_error (error));
292 g_error_free (error);
293 g_assert (result == NULL);
295 g_main_loop_quit (loop);
299 msg_cb_expect_error_unknown_method (GDBusConnection *connection,
307 result = g_dbus_connection_call_finish (connection,
310 g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD);
311 g_assert (g_dbus_error_is_remote_error (error));
312 g_error_free (error);
313 g_assert (result == NULL);
315 g_main_loop_quit (loop);
319 msg_cb_expect_success (GDBusConnection *connection,
327 result = g_dbus_connection_call_finish (connection,
330 g_assert_no_error (error);
331 g_assert (result != NULL);
332 g_variant_unref (result);
334 g_main_loop_quit (loop);
338 msg_cb_expect_error_cancelled (GDBusConnection *connection,
346 result = g_dbus_connection_call_finish (connection,
349 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
350 g_assert (!g_dbus_error_is_remote_error (error));
351 g_error_free (error);
352 g_assert (result == NULL);
354 g_main_loop_quit (loop);
358 msg_cb_expect_error_cancelled_2 (GDBusConnection *connection,
366 result = g_dbus_connection_call_finish (connection,
369 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
370 g_assert (!g_dbus_error_is_remote_error (error));
371 g_error_free (error);
372 g_assert (result == NULL);
374 g_main_loop_quit (loop);
377 /* ---------------------------------------------------------------------------------------------------- */
380 test_connection_send (void)
387 /* First, get an unopened connection */
388 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
389 g_assert (c != NULL);
390 g_assert (!g_dbus_connection_is_closed (c));
393 * Check that we never actually send a message if the GCancellable
394 * is already cancelled - i.e. we should get #G_IO_ERROR_CANCELLED
395 * when the actual connection is not up.
397 ca = g_cancellable_new ();
398 g_cancellable_cancel (ca);
399 g_dbus_connection_call (c,
400 "org.freedesktop.DBus", /* bus_name */
401 "/org/freedesktop/DBus", /* object path */
402 "org.freedesktop.DBus", /* interface name */
403 "GetId", /* method name */
405 G_DBUS_CALL_FLAGS_NONE,
408 (GAsyncReadyCallback) msg_cb_expect_error_cancelled,
410 g_main_loop_run (loop);
414 * Check that we get a reply to the GetId() method call.
416 g_dbus_connection_call (c,
417 "org.freedesktop.DBus", /* bus_name */
418 "/org/freedesktop/DBus", /* object path */
419 "org.freedesktop.DBus", /* interface name */
420 "GetId", /* method name */
422 G_DBUS_CALL_FLAGS_NONE,
425 (GAsyncReadyCallback) msg_cb_expect_success,
427 g_main_loop_run (loop);
430 * Check that we get an error reply to the NonExistantMethod() method call.
432 g_dbus_connection_call (c,
433 "org.freedesktop.DBus", /* bus_name */
434 "/org/freedesktop/DBus", /* object path */
435 "org.freedesktop.DBus", /* interface name */
436 "NonExistantMethod", /* method name */
438 G_DBUS_CALL_FLAGS_NONE,
441 (GAsyncReadyCallback) msg_cb_expect_error_unknown_method,
443 g_main_loop_run (loop);
446 * Check that cancellation works when the message is already in flight.
448 ca = g_cancellable_new ();
449 g_dbus_connection_call (c,
450 "org.freedesktop.DBus", /* bus_name */
451 "/org/freedesktop/DBus", /* object path */
452 "org.freedesktop.DBus", /* interface name */
453 "GetId", /* method name */
455 G_DBUS_CALL_FLAGS_NONE,
458 (GAsyncReadyCallback) msg_cb_expect_error_cancelled_2,
460 g_cancellable_cancel (ca);
461 g_main_loop_run (loop);
465 * Check that we get an error when sending to a connection that is disconnected.
467 g_dbus_connection_set_exit_on_close (c, FALSE);
469 _g_assert_signal_received (c, "closed");
470 g_assert (g_dbus_connection_is_closed (c));
472 g_dbus_connection_call (c,
473 "org.freedesktop.DBus", /* bus_name */
474 "/org/freedesktop/DBus", /* object path */
475 "org.freedesktop.DBus", /* interface name */
476 "GetId", /* method name */
478 G_DBUS_CALL_FLAGS_NONE,
481 (GAsyncReadyCallback) msg_cb_expect_error_disconnected,
483 g_main_loop_run (loop);
485 _g_object_wait_for_single_ref (c);
489 /* ---------------------------------------------------------------------------------------------------- */
490 /* Connection signal tests */
491 /* ---------------------------------------------------------------------------------------------------- */
494 test_connection_signal_handler (GDBusConnection *connection,
495 const gchar *sender_name,
496 const gchar *object_path,
497 const gchar *interface_name,
498 const gchar *signal_name,
499 GVariant *parameters,
502 gint *counter = user_data;
505 /*g_debug ("in test_connection_signal_handler (sender=%s path=%s interface=%s member=%s)",
511 g_main_loop_quit (loop);
515 test_connection_signals (void)
527 gint count_name_owner_changed;
531 gboolean quit_mainloop_fired;
532 guint quit_mainloop_id;
537 * Bring up first separate connections
540 /* if running with dbus-monitor, it claims the name :1.0 - so if we don't run with the monitor
543 if (g_getenv ("G_DBUS_MONITOR") == NULL)
545 c1 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, NULL);
546 g_assert (c1 != NULL);
547 g_assert (!g_dbus_connection_is_closed (c1));
550 c1 = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
551 g_assert (c1 != NULL);
552 g_assert (!g_dbus_connection_is_closed (c1));
553 g_assert_cmpstr (g_dbus_connection_get_unique_name (c1), ==, ":1.1");
556 * Install two signal handlers for the first connection
558 * - Listen to the signal "Foo" from :1.2 (e.g. c2)
559 * - Listen to the signal "Foo" from anyone (e.g. both c2 and c3)
561 * and then count how many times this signal handler was invoked.
563 s1 = g_dbus_connection_signal_subscribe (c1,
565 "org.gtk.GDBus.ExampleInterface",
567 "/org/gtk/GDBus/ExampleInterface",
569 G_DBUS_SIGNAL_FLAGS_NONE,
570 test_connection_signal_handler,
573 s2 = g_dbus_connection_signal_subscribe (c1,
574 NULL, /* match any sender */
575 "org.gtk.GDBus.ExampleInterface",
577 "/org/gtk/GDBus/ExampleInterface",
579 G_DBUS_SIGNAL_FLAGS_NONE,
580 test_connection_signal_handler,
583 s3 = g_dbus_connection_signal_subscribe (c1,
584 "org.freedesktop.DBus", /* sender */
585 "org.freedesktop.DBus", /* interface */
586 "NameOwnerChanged", /* member */
587 "/org/freedesktop/DBus", /* path */
589 G_DBUS_SIGNAL_FLAGS_NONE,
590 test_connection_signal_handler,
591 &count_name_owner_changed,
593 /* Note that s1b is *just like* s1 - this is to catch a bug where N
594 * subscriptions of the same rule causes N calls to each of the N
595 * subscriptions instead of just 1 call to each of the N subscriptions.
597 s1b = g_dbus_connection_signal_subscribe (c1,
599 "org.gtk.GDBus.ExampleInterface",
601 "/org/gtk/GDBus/ExampleInterface",
603 G_DBUS_SIGNAL_FLAGS_NONE,
604 test_connection_signal_handler,
615 count_name_owner_changed = 0;
618 * Bring up two other connections
620 c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, NULL);
621 g_assert (c2 != NULL);
622 g_assert (!g_dbus_connection_is_closed (c2));
623 g_assert_cmpstr (g_dbus_connection_get_unique_name (c2), ==, ":1.2");
624 c3 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, NULL);
625 g_assert (c3 != NULL);
626 g_assert (!g_dbus_connection_is_closed (c3));
627 g_assert_cmpstr (g_dbus_connection_get_unique_name (c3), ==, ":1.3");
630 * Make c2 emit "Foo" - we should catch it twice
632 * Note that there is no way to be sure that the signal subscriptions
633 * on c1 are effective yet - for all we know, the AddMatch() messages
634 * could sit waiting in a buffer somewhere between this process and
635 * the message bus. And emitting signals on c2 (a completely other
636 * socket!) will not necessarily change this.
638 * To ensure this is not the case, do a synchronous call on c1.
640 result = g_dbus_connection_call_sync (c1,
641 "org.freedesktop.DBus", /* bus name */
642 "/org/freedesktop/DBus", /* object path */
643 "org.freedesktop.DBus", /* interface name */
644 "GetId", /* method name */
645 NULL, /* parameters */
646 NULL, /* return type */
647 G_DBUS_CALL_FLAGS_NONE,
651 g_assert_no_error (error);
652 g_assert (result != NULL);
653 g_variant_unref (result);
654 /* now, emit the signal on c2 */
655 ret = g_dbus_connection_emit_signal (c2,
656 NULL, /* destination bus name */
657 "/org/gtk/GDBus/ExampleInterface",
658 "org.gtk.GDBus.ExampleInterface",
662 g_assert_no_error (error);
664 while (!(count_s1 >= 1 && count_s2 >= 1))
665 g_main_loop_run (loop);
666 g_assert_cmpint (count_s1, ==, 1);
667 g_assert_cmpint (count_s2, ==, 1);
670 * Make c3 emit "Foo" - we should catch it only once
672 ret = g_dbus_connection_emit_signal (c3,
673 NULL, /* destination bus name */
674 "/org/gtk/GDBus/ExampleInterface",
675 "org.gtk.GDBus.ExampleInterface",
679 g_assert_no_error (error);
681 while (!(count_s1 == 1 && count_s2 == 2))
682 g_main_loop_run (loop);
683 g_assert_cmpint (count_s1, ==, 1);
684 g_assert_cmpint (count_s2, ==, 2);
687 * Also to check the total amount of NameOwnerChanged signals - use a 5 second ceiling
688 * to avoid spinning forever
690 quit_mainloop_fired = FALSE;
691 quit_mainloop_id = g_timeout_add (30000, test_connection_quit_mainloop, &quit_mainloop_fired);
692 while (count_name_owner_changed < 2 && !quit_mainloop_fired)
693 g_main_loop_run (loop);
694 g_source_remove (quit_mainloop_id);
695 g_assert_cmpint (count_s1, ==, 1);
696 g_assert_cmpint (count_s2, ==, 2);
697 g_assert_cmpint (count_name_owner_changed, ==, 2);
699 g_dbus_connection_signal_unsubscribe (c1, s1);
700 g_dbus_connection_signal_unsubscribe (c1, s2);
701 g_dbus_connection_signal_unsubscribe (c1, s3);
702 g_dbus_connection_signal_unsubscribe (c1, s1b);
704 _g_object_wait_for_single_ref (c1);
705 _g_object_wait_for_single_ref (c2);
706 _g_object_wait_for_single_ref (c3);
715 /* ---------------------------------------------------------------------------------------------------- */
724 static GDBusMessage *
725 filter_func (GDBusConnection *connection,
726 GDBusMessage *message,
730 FilterData *data = user_data;
731 guint32 reply_serial;
735 reply_serial = g_dbus_message_get_reply_serial (message);
736 if (reply_serial == data->serial)
737 data->num_handled += 1;
741 data->num_outgoing += 1;
750 gboolean alter_incoming;
751 gboolean alter_outgoing;
754 static GDBusMessage *
755 other_filter_func (GDBusConnection *connection,
756 GDBusMessage *message,
760 FilterEffects *effects = user_data;
765 alter = effects->alter_incoming;
767 alter = effects->alter_outgoing;
776 copy = g_dbus_message_copy (message, NULL);
777 g_object_unref (message);
779 body = g_dbus_message_get_body (copy);
780 g_variant_get (body, "(s)", &s);
781 s2 = g_strdup_printf ("MOD: %s", s);
782 g_dbus_message_set_body (copy, g_variant_new ("(s)", s2));
797 test_connection_filter_name_owner_changed_signal_handler (GDBusConnection *connection,
798 const gchar *sender_name,
799 const gchar *object_path,
800 const gchar *interface_name,
801 const gchar *signal_name,
802 GVariant *parameters,
806 const gchar *old_owner;
807 const gchar *new_owner;
809 g_variant_get (parameters,
815 if (g_strcmp0 (name, "com.example.TestService") == 0 && strlen (new_owner) > 0)
817 g_main_loop_quit (loop);
822 test_connection_filter_on_timeout (gpointer user_data)
824 g_printerr ("Timeout waiting 30 sec on service\n");
825 g_assert_not_reached ();
830 test_connection_filter (void)
839 guint timeout_mainloop_id;
840 guint signal_handler_id;
841 FilterEffects effects;
845 memset (&data, '\0', sizeof (FilterData));
850 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
851 g_assert_no_error (error);
852 g_assert (c != NULL);
854 filter_id = g_dbus_connection_add_filter (c,
859 m = g_dbus_message_new_method_call ("org.freedesktop.DBus", /* name */
860 "/org/freedesktop/DBus", /* path */
861 "org.freedesktop.DBus", /* interface */
863 g_dbus_message_set_body (m, g_variant_new ("(s)", "org.freedesktop.DBus"));
865 g_dbus_connection_send_message (c, m, G_DBUS_SEND_MESSAGE_FLAGS_NONE, &data.serial, &error);
866 g_assert_no_error (error);
868 while (data.num_handled == 0)
871 m2 = g_dbus_message_copy (m, &error);
872 g_assert_no_error (error);
873 g_dbus_connection_send_message (c, m2, G_DBUS_SEND_MESSAGE_FLAGS_NONE, &data.serial, &error);
875 g_assert_no_error (error);
877 while (data.num_handled == 1)
880 m2 = g_dbus_message_copy (m, &error);
881 g_assert_no_error (error);
882 g_dbus_message_set_serial (m2, data.serial);
883 /* lock the message to test PRESERVE_SERIAL flag. */
884 g_dbus_message_lock (m2);
885 g_dbus_connection_send_message (c, m2, G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL, &data.serial, &error);
887 g_assert_no_error (error);
889 while (data.num_handled == 2)
892 m2 = g_dbus_message_copy (m, &error);
893 g_assert_no_error (error);
894 r = g_dbus_connection_send_message_with_reply_sync (c,
896 G_DBUS_SEND_MESSAGE_FLAGS_NONE,
899 NULL, /* GCancellable */
902 g_assert_no_error (error);
903 g_assert (r != NULL);
905 g_assert_cmpint (data.num_handled, ==, 4);
907 g_dbus_connection_remove_filter (c, filter_id);
909 m2 = g_dbus_message_copy (m, &error);
910 g_assert_no_error (error);
911 r = g_dbus_connection_send_message_with_reply_sync (c,
913 G_DBUS_SEND_MESSAGE_FLAGS_NONE,
916 NULL, /* GCancellable */
919 g_assert_no_error (error);
920 g_assert (r != NULL);
922 g_assert_cmpint (data.num_handled, ==, 4);
923 g_assert_cmpint (data.num_outgoing, ==, 4);
925 /* this is safe; testserver will exit once the bus goes away */
926 g_assert (g_spawn_command_line_async (SRCDIR "/gdbus-testserver.py", NULL));
927 /* wait for service to be available */
928 signal_handler_id = g_dbus_connection_signal_subscribe (c,
929 "org.freedesktop.DBus", /* sender */
930 "org.freedesktop.DBus",
932 "/org/freedesktop/DBus",
934 G_DBUS_SIGNAL_FLAGS_NONE,
935 test_connection_filter_name_owner_changed_signal_handler,
938 g_assert_cmpint (signal_handler_id, !=, 0);
939 timeout_mainloop_id = g_timeout_add (30000, test_connection_filter_on_timeout, NULL);
940 g_main_loop_run (loop);
941 g_source_remove (timeout_mainloop_id);
942 g_dbus_connection_signal_unsubscribe (c, signal_handler_id);
944 /* now test some combinations... */
945 filter_id = g_dbus_connection_add_filter (c,
950 effects.alter_incoming = FALSE;
951 effects.alter_outgoing = FALSE;
953 result = g_dbus_connection_call_sync (c,
954 "com.example.TestService", /* bus name */
955 "/com/example/TestObject", /* object path */
956 "com.example.Frob", /* interface name */
957 "HelloWorld", /* method name */
958 g_variant_new ("(s)", "Cat"), /* parameters */
959 G_VARIANT_TYPE ("(s)"), /* return type */
960 G_DBUS_CALL_FLAGS_NONE,
964 g_assert_no_error (error);
965 g_variant_get (result, "(&s)", &s);
966 g_assert_cmpstr (s, ==, "You greeted me with 'Cat'. Thanks!");
967 g_variant_unref (result);
969 effects.alter_incoming = TRUE;
970 effects.alter_outgoing = TRUE;
972 result = g_dbus_connection_call_sync (c,
973 "com.example.TestService", /* bus name */
974 "/com/example/TestObject", /* object path */
975 "com.example.Frob", /* interface name */
976 "HelloWorld", /* method name */
977 g_variant_new ("(s)", "Cat"), /* parameters */
978 G_VARIANT_TYPE ("(s)"), /* return type */
979 G_DBUS_CALL_FLAGS_NONE,
983 g_assert_no_error (error);
984 g_variant_get (result, "(&s)", &s);
985 g_assert_cmpstr (s, ==, "MOD: You greeted me with 'MOD: Cat'. Thanks!");
986 g_variant_unref (result);
989 g_dbus_connection_remove_filter (c, filter_id);
991 _g_object_wait_for_single_ref (c);
999 test_connection_basic (void)
1001 GDBusConnection *connection;
1003 GDBusCapabilityFlags flags;
1007 gboolean exit_on_close;
1009 GCredentials *credentials;
1014 connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
1015 g_assert_no_error (error);
1016 g_assert (connection != NULL);
1018 flags = g_dbus_connection_get_capabilities (connection);
1019 g_assert (flags == G_DBUS_CAPABILITY_FLAGS_NONE ||
1020 flags == G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
1022 credentials = g_dbus_connection_get_peer_credentials (connection);
1023 g_assert (credentials == NULL);
1025 g_object_get (connection,
1028 "unique-name", &name,
1030 "exit-on-close", &exit_on_close,
1031 "capabilities", &flags,
1034 g_assert (G_IS_IO_STREAM (stream));
1035 g_assert (g_dbus_is_guid (guid));
1036 g_assert (g_dbus_is_unique_name (name));
1038 g_assert (exit_on_close);
1039 g_assert (flags == G_DBUS_CAPABILITY_FLAGS_NONE ||
1040 flags == G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
1041 g_object_unref (stream);
1045 _g_object_wait_for_single_ref (connection);
1046 g_object_unref (connection);
1048 session_bus_down ();
1051 /* ---------------------------------------------------------------------------------------------------- */
1058 g_test_init (&argc, &argv, NULL);
1060 /* all the tests rely on a shared main loop */
1061 loop = g_main_loop_new (NULL, FALSE);
1063 /* all the tests use a session bus with a well-known address that we can bring up and down
1064 * using session_bus_up() and session_bus_down().
1066 g_unsetenv ("DISPLAY");
1067 g_setenv ("DBUS_SESSION_BUS_ADDRESS", session_bus_get_temporary_address (), TRUE);
1069 g_test_add_func ("/gdbus/connection/basic", test_connection_basic);
1070 g_test_add_func ("/gdbus/connection/life-cycle", test_connection_life_cycle);
1071 g_test_add_func ("/gdbus/connection/send", test_connection_send);
1072 g_test_add_func ("/gdbus/connection/signals", test_connection_signals);
1073 g_test_add_func ("/gdbus/connection/filter", test_connection_filter);
1074 return g_test_run();