?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add Friulian translation
[glib.git] / gio / tests / gdbus-connection.c
blob488f213ac1e71a67e95e7bf81a86e1209a6096b8
1 /* GLib testing framework examples and tests
2 *
3 * Copyright (C) 2008-2010 Red Hat, Inc.
4 *
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.
9 *
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.
14 *
15 * You should have received a copy of the GNU Lesser General
16 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
17 *
18 * Author: David Zeuthen <davidz@redhat.com>
19 */
20
21 #include <gio/gio.h>
22 #include <unistd.h>
23 #include <string.h>
24
25 #include <sys/types.h>
26
27 #include "gdbus-tests.h"
28
29 /* all tests rely on a shared mainloop */
30 static GMainLoop *loop = NULL;
31
32 #if 0
33 G_GNUC_UNUSED static void
34 _log (const gchar *format, ...)
35 {
36 GTimeVal now;
37 time_t now_time;
38 struct tm *now_tm;
39 gchar time_buf[128];
40 gchar *str;
41 va_list var_args;
42
43 va_start (var_args, format);
44 str = g_strdup_vprintf (format, var_args);
45 va_end (var_args);
46
47 g_get_current_time (&now);
48 now_time = (time_t) now.tv_sec;
49 now_tm = localtime (&now_time);
50 strftime (time_buf, sizeof time_buf, "%H:%M:%S", now_tm);
51
52 g_printerr ("%s.%06d: %s\n",
53 time_buf, (gint) now.tv_usec / 1000,
54 str);
55 g_free (str);
56 }
57 #else
58 #define _log(...)
59 #endif
60
61 static gboolean
62 test_connection_quit_mainloop (gpointer user_data)
63 {
64 volatile gboolean *quit_mainloop_fired = user_data;
65 _log ("quit_mainloop_fired");
66 *quit_mainloop_fired = TRUE;
67 g_main_loop_quit (loop);
68 return TRUE;
69 }
70
71 /* ---------------------------------------------------------------------------------------------------- */
72 /* Connection life-cycle testing */
73 /* ---------------------------------------------------------------------------------------------------- */
74
75 static const GDBusInterfaceInfo boo_interface_info =
76 {
77 -1,
78 "org.example.Boo",
79 (GDBusMethodInfo **) NULL,
80 (GDBusSignalInfo **) NULL,
81 (GDBusPropertyInfo **) NULL,
82 NULL,
83 };
84
85 static const GDBusInterfaceVTable boo_vtable =
86 {
87 NULL, /* _method_call */
88 NULL, /* _get_property */
89 NULL /* _set_property */
90 };
91
92 static GDBusMessage *
93 some_filter_func (GDBusConnection *connection,
94 GDBusMessage *message,
95 gboolean incoming,
96 gpointer user_data)
97 {
98 return message;
99 }
100
101 static void
102 on_name_owner_changed (GDBusConnection *connection,
103 const gchar *sender_name,
104 const gchar *object_path,
105 const gchar *interface_name,
106 const gchar *signal_name,
107 GVariant *parameters,
108 gpointer user_data)
109 {
110 }
111
112 static void
113 a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop (gpointer user_data)
114 {
115 volatile gboolean *val = user_data;
116 *val = TRUE;
117 _log ("destroynotify fired for %p", val);
118 g_main_loop_quit (loop);
119 }
120
121 static void
122 test_connection_bus_failure (void)
123 {
124 GDBusConnection *c;
125 GError *error = NULL;
126
127 /*
128 * Check for correct behavior when no bus is present
129 *
130 */
131 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
132 g_assert (error != NULL);
133 g_assert (!g_dbus_error_is_remote_error (error));
134 g_assert (c == NULL);
135 g_error_free (error);
136 }
137
138 static void
139 test_connection_life_cycle (void)
140 {
141 gboolean ret;
142 GDBusConnection *c;
143 GDBusConnection *c2;
144 GError *error;
145 volatile gboolean on_signal_registration_freed_called;
146 volatile gboolean on_filter_freed_called;
147 volatile gboolean on_register_object_freed_called;
148 volatile gboolean quit_mainloop_fired;
149 guint quit_mainloop_id;
150 guint registration_id;
151
152 error = NULL;
153
154 /*
155 * Check for correct behavior when a bus is present
156 */
157 session_bus_up ();
158 /* case 1 */
159 error = NULL;
160 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
161 g_assert_no_error (error);
162 g_assert (c != NULL);
163 g_assert (!g_dbus_connection_is_closed (c));
164
165 /*
166 * Check that singleton handling work
167 */
168 error = NULL;
169 c2 = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
170 g_assert_no_error (error);
171 g_assert (c2 != NULL);
172 g_assert (c == c2);
173 g_object_unref (c2);
174
175 /*
176 * Check that private connections work
177 */
178 c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, &error);
179 g_assert_no_error (error);
180 g_assert (c2 != NULL);
181 g_assert (c != c2);
182 g_object_unref (c2);
183
184 c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, &error);
185 g_assert_no_error (error);
186 g_assert (c2 != NULL);
187 g_assert (!g_dbus_connection_is_closed (c2));
188 ret = g_dbus_connection_close_sync (c2, NULL, &error);
189 g_assert_no_error (error);
190 g_assert (ret);
191 _g_assert_signal_received (c2, "closed");
192 g_assert (g_dbus_connection_is_closed (c2));
193 ret = g_dbus_connection_close_sync (c2, NULL, &error);
194 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED);
195 g_error_free (error);
196 g_assert (!ret);
197 g_object_unref (c2);
198
199 /*
200 * Check that the finalization code works
201 *
202 * (and that the GDestroyNotify for filters and objects and signal
203 * registrations are run as expected)
204 */
205 error = NULL;
206 c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, &error);
207 g_assert_no_error (error);
208 g_assert (c2 != NULL);
209 /* signal registration */
210 on_signal_registration_freed_called = FALSE;
211 g_dbus_connection_signal_subscribe (c2,
212 "org.freedesktop.DBus", /* bus name */
213 "org.freedesktop.DBus", /* interface */
214 "NameOwnerChanged", /* member */
215 "/org/freesktop/DBus", /* path */
216 NULL, /* arg0 */
217 G_DBUS_SIGNAL_FLAGS_NONE,
218 on_name_owner_changed,
219 (gpointer) &on_signal_registration_freed_called,
220 a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop);
221 /* filter func */
222 on_filter_freed_called = FALSE;
223 g_dbus_connection_add_filter (c2,
224 some_filter_func,
225 (gpointer) &on_filter_freed_called,
226 a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop);
227 /* object registration */
228 on_register_object_freed_called = FALSE;
229 error = NULL;
230 registration_id = g_dbus_connection_register_object (c2,
231 "/foo",
232 (GDBusInterfaceInfo *) &boo_interface_info,
233 &boo_vtable,
234 (gpointer) &on_register_object_freed_called,
235 a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop,
236 &error);
237 g_assert_no_error (error);
238 g_assert (registration_id > 0);
239 /* ok, finalize the connection and check that all the GDestroyNotify functions are invoked as expected */
240 g_object_unref (c2);
241 quit_mainloop_fired = FALSE;
242 quit_mainloop_id = g_timeout_add (30000, test_connection_quit_mainloop, (gpointer) &quit_mainloop_fired);
243 _log ("destroynotifies for\n"
244 " register_object %p\n"
245 " filter %p\n"
246 " signal %p",
247 &on_register_object_freed_called,
248 &on_filter_freed_called,
249 &on_signal_registration_freed_called);
250 while (TRUE)
251 {
252 if (on_signal_registration_freed_called &&
253 on_filter_freed_called &&
254 on_register_object_freed_called)
255 break;
256 if (quit_mainloop_fired)
257 break;
258 _log ("entering loop");
259 g_main_loop_run (loop);
260 _log ("exiting loop");
261 }
262 g_source_remove (quit_mainloop_id);
263 g_assert (on_signal_registration_freed_called);
264 g_assert (on_filter_freed_called);
265 g_assert (on_register_object_freed_called);
266 g_assert (!quit_mainloop_fired);
267
268 /*
269 * Check for correct behavior when the bus goes away
270 *
271 */
272 g_assert (!g_dbus_connection_is_closed (c));
273 g_dbus_connection_set_exit_on_close (c, FALSE);
274 session_bus_stop ();
275 _g_assert_signal_received (c, "closed");
276 g_assert (g_dbus_connection_is_closed (c));
277 g_object_unref (c);
278
279 session_bus_down ();
280 }
281
282 /* ---------------------------------------------------------------------------------------------------- */
283 /* Test that sending and receiving messages work as expected */
284 /* ---------------------------------------------------------------------------------------------------- */
285
286 static void
287 msg_cb_expect_error_disconnected (GDBusConnection *connection,
288 GAsyncResult *res,
289 gpointer user_data)
290 {
291 GError *error;
292 GVariant *result;
293
294 /* Make sure gdbusconnection isn't holding @connection's lock. (#747349) */
295 g_dbus_connection_get_last_serial (connection);
296
297 error = NULL;
298 result = g_dbus_connection_call_finish (connection,
299 res,
300 &error);
301 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CLOSED);
302 g_assert (!g_dbus_error_is_remote_error (error));
303 g_error_free (error);
304 g_assert (result == NULL);
305
306 g_main_loop_quit (loop);
307 }
308
309 static void
310 msg_cb_expect_error_unknown_method (GDBusConnection *connection,
311 GAsyncResult *res,
312 gpointer user_data)
313 {
314 GError *error;
315 GVariant *result;
316
317 /* Make sure gdbusconnection isn't holding @connection's lock. (#747349) */
318 g_dbus_connection_get_last_serial (connection);
319
320 error = NULL;
321 result = g_dbus_connection_call_finish (connection,
322 res,
323 &error);
324 g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD);
325 g_assert (g_dbus_error_is_remote_error (error));
326 g_error_free (error);
327 g_assert (result == NULL);
328
329 g_main_loop_quit (loop);
330 }
331
332 static void
333 msg_cb_expect_success (GDBusConnection *connection,
334 GAsyncResult *res,
335 gpointer user_data)
336 {
337 GError *error;
338 GVariant *result;
339
340 /* Make sure gdbusconnection isn't holding @connection's lock. (#747349) */
341 g_dbus_connection_get_last_serial (connection);
342
343 error = NULL;
344 result = g_dbus_connection_call_finish (connection,
345 res,
346 &error);
347 g_assert_no_error (error);
348 g_assert (result != NULL);
349 g_variant_unref (result);
350
351 g_main_loop_quit (loop);
352 }
353
354 static void
355 msg_cb_expect_error_cancelled (GDBusConnection *connection,
356 GAsyncResult *res,
357 gpointer user_data)
358 {
359 GError *error;
360 GVariant *result;
361
362 /* Make sure gdbusconnection isn't holding @connection's lock. (#747349) */
363 g_dbus_connection_get_last_serial (connection);
364
365 error = NULL;
366 result = g_dbus_connection_call_finish (connection,
367 res,
368 &error);
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);
373
374 g_main_loop_quit (loop);
375 }
376
377 static void
378 msg_cb_expect_error_cancelled_2 (GDBusConnection *connection,
379 GAsyncResult *res,
380 gpointer user_data)
381 {
382 GError *error;
383 GVariant *result;
384
385 /* Make sure gdbusconnection isn't holding @connection's lock. (#747349) */
386 g_dbus_connection_get_last_serial (connection);
387
388 error = NULL;
389 result = g_dbus_connection_call_finish (connection,
390 res,
391 &error);
392 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
393 g_assert (!g_dbus_error_is_remote_error (error));
394 g_error_free (error);
395 g_assert (result == NULL);
396
397 g_main_loop_quit (loop);
398 }
399
400 /* ---------------------------------------------------------------------------------------------------- */
401
402 static void
403 test_connection_send (void)
404 {
405 GDBusConnection *c;
406 GCancellable *ca;
407
408 session_bus_up ();
409
410 /* First, get an unopened connection */
411 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
412 g_assert (c != NULL);
413 g_assert (!g_dbus_connection_is_closed (c));
414
415 /*
416 * Check that we never actually send a message if the GCancellable
417 * is already cancelled - i.e. we should get #G_IO_ERROR_CANCELLED
418 * when the actual connection is not up.
419 */
420 ca = g_cancellable_new ();
421 g_cancellable_cancel (ca);
422 g_dbus_connection_call (c,
423 "org.freedesktop.DBus", /* bus_name */
424 "/org/freedesktop/DBus", /* object path */
425 "org.freedesktop.DBus", /* interface name */
426 "GetId", /* method name */
427 NULL, NULL,
428 G_DBUS_CALL_FLAGS_NONE,
429 -1,
430 ca,
431 (GAsyncReadyCallback) msg_cb_expect_error_cancelled,
432 NULL);
433 g_main_loop_run (loop);
434 g_object_unref (ca);
435
436 /*
437 * Check that we get a reply to the GetId() method call.
438 */
439 g_dbus_connection_call (c,
440 "org.freedesktop.DBus", /* bus_name */
441 "/org/freedesktop/DBus", /* object path */
442 "org.freedesktop.DBus", /* interface name */
443 "GetId", /* method name */
444 NULL, NULL,
445 G_DBUS_CALL_FLAGS_NONE,
446 -1,
447 NULL,
448 (GAsyncReadyCallback) msg_cb_expect_success,
449 NULL);
450 g_main_loop_run (loop);
451
452 /*
453 * Check that we get an error reply to the NonExistantMethod() method call.
454 */
455 g_dbus_connection_call (c,
456 "org.freedesktop.DBus", /* bus_name */
457 "/org/freedesktop/DBus", /* object path */
458 "org.freedesktop.DBus", /* interface name */
459 "NonExistantMethod", /* method name */
460 NULL, NULL,
461 G_DBUS_CALL_FLAGS_NONE,
462 -1,
463 NULL,
464 (GAsyncReadyCallback) msg_cb_expect_error_unknown_method,
465 NULL);
466 g_main_loop_run (loop);
467
468 /*
469 * Check that cancellation works when the message is already in flight.
470 */
471 ca = g_cancellable_new ();
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 */
477 NULL, NULL,
478 G_DBUS_CALL_FLAGS_NONE,
479 -1,
480 ca,
481 (GAsyncReadyCallback) msg_cb_expect_error_cancelled_2,
482 NULL);
483 g_cancellable_cancel (ca);
484 g_main_loop_run (loop);
485 g_object_unref (ca);
486
487 /*
488 * Check that we get an error when sending to a connection that is disconnected.
489 */
490 g_dbus_connection_set_exit_on_close (c, FALSE);
491 session_bus_stop ();
492 _g_assert_signal_received (c, "closed");
493 g_assert (g_dbus_connection_is_closed (c));
494
495 g_dbus_connection_call (c,
496 "org.freedesktop.DBus", /* bus_name */
497 "/org/freedesktop/DBus", /* object path */
498 "org.freedesktop.DBus", /* interface name */
499 "GetId", /* method name */
500 NULL, NULL,
501 G_DBUS_CALL_FLAGS_NONE,
502 -1,
503 NULL,
504 (GAsyncReadyCallback) msg_cb_expect_error_disconnected,
505 NULL);
506 g_main_loop_run (loop);
507
508 g_object_unref (c);
509
510 session_bus_down ();
511 }
512
513 /* ---------------------------------------------------------------------------------------------------- */
514 /* Connection signal tests */
515 /* ---------------------------------------------------------------------------------------------------- */
516
517 static void
518 test_connection_signal_handler (GDBusConnection *connection,
519 const gchar *sender_name,
520 const gchar *object_path,
521 const gchar *interface_name,
522 const gchar *signal_name,
523 GVariant *parameters,
524 gpointer user_data)
525 {
526 gint *counter = user_data;
527 *counter += 1;
528
529 /*g_debug ("in test_connection_signal_handler (sender=%s path=%s interface=%s member=%s)",
530 sender_name,
531 object_path,
532 interface_name,
533 signal_name);*/
534
535 g_main_loop_quit (loop);
536 }
537
538 static void
539 test_connection_signals (void)
540 {
541 GDBusConnection *c1;
542 GDBusConnection *c2;
543 GDBusConnection *c3;
544 guint s1;
545 guint s1b;
546 guint s2;
547 guint s3;
548 gint count_s1;
549 gint count_s1b;
550 gint count_s2;
551 gint count_name_owner_changed;
552 GError *error;
553 gboolean ret;
554 GVariant *result;
555 gboolean quit_mainloop_fired;
556 guint quit_mainloop_id;
557
558 error = NULL;
559
560 /*
561 * Bring up first separate connections
562 */
563 session_bus_up ();
564 /* if running with dbus-monitor, it claims the name :1.0 - so if we don't run with the monitor
565 * emulate this
566 */
567 if (g_getenv ("G_DBUS_MONITOR") == NULL)
568 {
569 c1 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, NULL);
570 g_assert (c1 != NULL);
571 g_assert (!g_dbus_connection_is_closed (c1));
572 g_object_unref (c1);
573 }
574 c1 = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
575 g_assert (c1 != NULL);
576 g_assert (!g_dbus_connection_is_closed (c1));
577 g_assert_cmpstr (g_dbus_connection_get_unique_name (c1), ==, ":1.1");
578
579 /*
580 * Install two signal handlers for the first connection
581 *
582 * - Listen to the signal "Foo" from :1.2 (e.g. c2)
583 * - Listen to the signal "Foo" from anyone (e.g. both c2 and c3)
584 *
585 * and then count how many times this signal handler was invoked.
586 */
587 s1 = g_dbus_connection_signal_subscribe (c1,
588 ":1.2",
589 "org.gtk.GDBus.ExampleInterface",
590 "Foo",
591 "/org/gtk/GDBus/ExampleInterface",
592 NULL,
593 G_DBUS_SIGNAL_FLAGS_NONE,
594 test_connection_signal_handler,
595 &count_s1,
596 NULL);
597 s2 = g_dbus_connection_signal_subscribe (c1,
598 NULL, /* match any sender */
599 "org.gtk.GDBus.ExampleInterface",
600 "Foo",
601 "/org/gtk/GDBus/ExampleInterface",
602 NULL,
603 G_DBUS_SIGNAL_FLAGS_NONE,
604 test_connection_signal_handler,
605 &count_s2,
606 NULL);
607 s3 = g_dbus_connection_signal_subscribe (c1,
608 "org.freedesktop.DBus", /* sender */
609 "org.freedesktop.DBus", /* interface */
610 "NameOwnerChanged", /* member */
611 "/org/freedesktop/DBus", /* path */
612 NULL,
613 G_DBUS_SIGNAL_FLAGS_NONE,
614 test_connection_signal_handler,
615 &count_name_owner_changed,
616 NULL);
617 /* Note that s1b is *just like* s1 - this is to catch a bug where N
618 * subscriptions of the same rule causes N calls to each of the N
619 * subscriptions instead of just 1 call to each of the N subscriptions.
620 */
621 s1b = g_dbus_connection_signal_subscribe (c1,
622 ":1.2",
623 "org.gtk.GDBus.ExampleInterface",
624 "Foo",
625 "/org/gtk/GDBus/ExampleInterface",
626 NULL,
627 G_DBUS_SIGNAL_FLAGS_NONE,
628 test_connection_signal_handler,
629 &count_s1b,
630 NULL);
631 g_assert (s1 != 0);
632 g_assert (s1b != 0);
633 g_assert (s2 != 0);
634 g_assert (s3 != 0);
635
636 count_s1 = 0;
637 count_s1b = 0;
638 count_s2 = 0;
639 count_name_owner_changed = 0;
640
641 /*
642 * Make c2 emit "Foo" - we should catch it twice
643 *
644 * Note that there is no way to be sure that the signal subscriptions
645 * on c1 are effective yet - for all we know, the AddMatch() messages
646 * could sit waiting in a buffer somewhere between this process and
647 * the message bus. And emitting signals on c2 (a completely other
648 * socket!) will not necessarily change this.
649 *
650 * To ensure this is not the case, do a synchronous call on c1.
651 */
652 result = g_dbus_connection_call_sync (c1,
653 "org.freedesktop.DBus", /* bus name */
654 "/org/freedesktop/DBus", /* object path */
655 "org.freedesktop.DBus", /* interface name */
656 "GetId", /* method name */
657 NULL, /* parameters */
658 NULL, /* return type */
659 G_DBUS_CALL_FLAGS_NONE,
660 -1,
661 NULL,
662 &error);
663 g_assert_no_error (error);
664 g_assert (result != NULL);
665 g_variant_unref (result);
666
667 /*
668 * Bring up two other connections
669 */
670 c2 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, NULL);
671 g_assert (c2 != NULL);
672 g_assert (!g_dbus_connection_is_closed (c2));
673 g_assert_cmpstr (g_dbus_connection_get_unique_name (c2), ==, ":1.2");
674 c3 = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, NULL);
675 g_assert (c3 != NULL);
676 g_assert (!g_dbus_connection_is_closed (c3));
677 g_assert_cmpstr (g_dbus_connection_get_unique_name (c3), ==, ":1.3");
678
679 /* now, emit the signal on c2 */
680 ret = g_dbus_connection_emit_signal (c2,
681 NULL, /* destination bus name */
682 "/org/gtk/GDBus/ExampleInterface",
683 "org.gtk.GDBus.ExampleInterface",
684 "Foo",
685 NULL,
686 &error);
687 g_assert_no_error (error);
688 g_assert (ret);
689 while (!(count_s1 >= 1 && count_s2 >= 1))
690 g_main_loop_run (loop);
691 g_assert_cmpint (count_s1, ==, 1);
692 g_assert_cmpint (count_s2, ==, 1);
693
694 /*
695 * Make c3 emit "Foo" - we should catch it only once
696 */
697 ret = g_dbus_connection_emit_signal (c3,
698 NULL, /* destination bus name */
699 "/org/gtk/GDBus/ExampleInterface",
700 "org.gtk.GDBus.ExampleInterface",
701 "Foo",
702 NULL,
703 &error);
704 g_assert_no_error (error);
705 g_assert (ret);
706 while (!(count_s1 == 1 && count_s2 == 2))
707 g_main_loop_run (loop);
708 g_assert_cmpint (count_s1, ==, 1);
709 g_assert_cmpint (count_s2, ==, 2);
710
711 /*
712 * Also to check the total amount of NameOwnerChanged signals - use a 5 second ceiling
713 * to avoid spinning forever
714 */
715 quit_mainloop_fired = FALSE;
716 quit_mainloop_id = g_timeout_add (30000, test_connection_quit_mainloop, &quit_mainloop_fired);
717 while (count_name_owner_changed < 2 && !quit_mainloop_fired)
718 g_main_loop_run (loop);
719 g_source_remove (quit_mainloop_id);
720 g_assert_cmpint (count_s1, ==, 1);
721 g_assert_cmpint (count_s2, ==, 2);
722 g_assert_cmpint (count_name_owner_changed, ==, 2);
723
724 g_dbus_connection_signal_unsubscribe (c1, s1);
725 g_dbus_connection_signal_unsubscribe (c1, s2);
726 g_dbus_connection_signal_unsubscribe (c1, s3);
727 g_dbus_connection_signal_unsubscribe (c1, s1b);
728
729 g_object_unref (c1);
730 g_object_unref (c2);
731 g_object_unref (c3);
732
733 session_bus_down ();
734 }
735
736 static void
737 test_match_rule (GDBusConnection *connection,
738 GDBusSignalFlags flags,
739 gchar *arg0_rule,
740 gchar *arg0,
741 gboolean should_match)
742 {
743 guint subscription_ids[2];
744 gint emissions = 0;
745 gint matches = 0;
746 GError *error = NULL;
747
748 subscription_ids[0] = g_dbus_connection_signal_subscribe (connection,
749 NULL, "org.gtk.ExampleInterface", "Foo", "/",
750 NULL,
751 G_DBUS_SIGNAL_FLAGS_NONE,
752 test_connection_signal_handler,
753 &emissions, NULL);
754 subscription_ids[1] = g_dbus_connection_signal_subscribe (connection,
755 NULL, "org.gtk.ExampleInterface", "Foo", "/",
756 arg0_rule,
757 flags,
758 test_connection_signal_handler,
759 &matches, NULL);
760 g_assert_cmpint (subscription_ids[0], !=, 0);
761 g_assert_cmpint (subscription_ids[1], !=, 0);
762
763 g_dbus_connection_emit_signal (connection,
764 NULL, "/", "org.gtk.ExampleInterface",
765 "Foo", g_variant_new ("(s)", arg0),
766 &error);
767 g_assert_no_error (error);
768
769 /* synchronously ping a non-existent method to make sure the signals are dispatched */
770 g_dbus_connection_call_sync (connection, "org.gtk.ExampleInterface", "/", "org.gtk.ExampleInterface",
771 "Bar", g_variant_new ("()"), G_VARIANT_TYPE_UNIT, G_DBUS_CALL_FLAGS_NONE,
772 -1, NULL, NULL);
773
774 while (g_main_context_iteration (NULL, FALSE))
775 ;
776
777 g_assert_cmpint (emissions, ==, 1);
778 g_assert_cmpint (matches, ==, should_match ? 1 : 0);
779
780 g_dbus_connection_signal_unsubscribe (connection, subscription_ids[0]);
781 g_dbus_connection_signal_unsubscribe (connection, subscription_ids[1]);
782 }
783
784 static void
785 test_connection_signal_match_rules (void)
786 {
787 GDBusConnection *con;
788
789 session_bus_up ();
790 con = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
791
792 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_NONE, "foo", "foo", TRUE);
793 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_NONE, "foo", "bar", FALSE);
794
795 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE, "org.gtk", "", FALSE);
796 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE, "org.gtk", "org", FALSE);
797 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE, "org.gtk", "org.gtk", TRUE);
798 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE, "org.gtk", "org.gtk.Example", TRUE);
799 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE, "org.gtk", "org.gtk+", FALSE);
800
801 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH, "/", "/", TRUE);
802 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH, "/", "", FALSE);
803 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH, "/org/gtk/Example", "/org/gtk/Example", TRUE);
804 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH, "/org/gtk/", "/org/gtk/Example", TRUE);
805 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH, "/org/gtk/Example", "/org/gtk/", TRUE);
806 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH, "/org/gtk/Example", "/org/gtk", FALSE);
807 test_match_rule (con, G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH, "/org/gtk+", "/org/gtk", FALSE);
808
809 g_object_unref (con);
810 session_bus_down ();
811 }
812
813 /* ---------------------------------------------------------------------------------------------------- */
814
815 typedef struct
816 {
817 guint num_handled;
818 guint num_outgoing;
819 guint32 serial;
820 } FilterData;
821
822 static GDBusMessage *
823 filter_func (GDBusConnection *connection,
824 GDBusMessage *message,
825 gboolean incoming,
826 gpointer user_data)
827 {
828 FilterData *data = user_data;
829 guint32 reply_serial;
830
831 if (incoming)
832 {
833 reply_serial = g_dbus_message_get_reply_serial (message);
834 if (reply_serial == data->serial)
835 data->num_handled += 1;
836 }
837 else
838 {
839 data->num_outgoing += 1;
840 }
841
842 return message;
843 }
844
845
846 typedef struct
847 {
848 gboolean alter_incoming;
849 gboolean alter_outgoing;
850 } FilterEffects;
851
852 static GDBusMessage *
853 other_filter_func (GDBusConnection *connection,
854 GDBusMessage *message,
855 gboolean incoming,
856 gpointer user_data)
857 {
858 FilterEffects *effects = user_data;
859 GDBusMessage *ret;
860 gboolean alter;
861
862 if (incoming)
863 alter = effects->alter_incoming;
864 else
865 alter = effects->alter_outgoing;
866
867 if (alter)
868 {
869 GDBusMessage *copy;
870 GVariant *body;
871 gchar *s;
872 gchar *s2;
873
874 copy = g_dbus_message_copy (message, NULL);
875 g_object_unref (message);
876
877 body = g_dbus_message_get_body (copy);
878 g_variant_get (body, "(s)", &s);
879 s2 = g_strdup_printf ("MOD: %s", s);
880 g_dbus_message_set_body (copy, g_variant_new ("(s)", s2));
881 g_free (s2);
882 g_free (s);
883
884 ret = copy;
885 }
886 else
887 {
888 ret = message;
889 }
890
891 return ret;
892 }
893
894 static void
895 test_connection_filter_name_owner_changed_signal_handler (GDBusConnection *connection,
896 const gchar *sender_name,
897 const gchar *object_path,
898 const gchar *interface_name,
899 const gchar *signal_name,
900 GVariant *parameters,
901 gpointer user_data)
902 {
903 const gchar *name;
904 const gchar *old_owner;
905 const gchar *new_owner;
906
907 g_variant_get (parameters,
908 "(&s&s&s)",
909 &name,
910 &old_owner,
911 &new_owner);
912
913 if (g_strcmp0 (name, "com.example.TestService") == 0 && strlen (new_owner) > 0)
914 {
915 g_main_loop_quit (loop);
916 }
917 }
918
919 static gboolean
920 test_connection_filter_on_timeout (gpointer user_data)
921 {
922 g_printerr ("Timeout waiting 30 sec on service\n");
923 g_assert_not_reached ();
924 return FALSE;
925 }
926
927 static void
928 test_connection_filter (void)
929 {
930 GDBusConnection *c;
931 FilterData data;
932 GDBusMessage *m;
933 GDBusMessage *m2;
934 GDBusMessage *r;
935 GError *error;
936 guint filter_id;
937 guint timeout_mainloop_id;
938 guint signal_handler_id;
939 FilterEffects effects;
940 GVariant *result;
941 const gchar *s;
942
943 memset (&data, '\0', sizeof (FilterData));
944
945 session_bus_up ();
946
947 error = NULL;
948 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
949 g_assert_no_error (error);
950 g_assert (c != NULL);
951
952 filter_id = g_dbus_connection_add_filter (c,
953 filter_func,
954 &data,
955 NULL);
956
957 m = g_dbus_message_new_method_call ("org.freedesktop.DBus", /* name */
958 "/org/freedesktop/DBus", /* path */
959 "org.freedesktop.DBus", /* interface */
960 "GetNameOwner");
961 g_dbus_message_set_body (m, g_variant_new ("(s)", "org.freedesktop.DBus"));
962 error = NULL;
963 g_dbus_connection_send_message (c, m, G_DBUS_SEND_MESSAGE_FLAGS_NONE, &data.serial, &error);
964 g_assert_no_error (error);
965
966 while (data.num_handled == 0)
967 g_thread_yield ();
968
969 m2 = g_dbus_message_copy (m, &error);
970 g_assert_no_error (error);
971 g_dbus_connection_send_message (c, m2, G_DBUS_SEND_MESSAGE_FLAGS_NONE, &data.serial, &error);
972 g_object_unref (m2);
973 g_assert_no_error (error);
974
975 while (data.num_handled == 1)
976 g_thread_yield ();
977
978 m2 = g_dbus_message_copy (m, &error);
979 g_assert_no_error (error);
980 g_dbus_message_set_serial (m2, data.serial);
981 /* lock the message to test PRESERVE_SERIAL flag. */
982 g_dbus_message_lock (m2);
983 g_dbus_connection_send_message (c, m2, G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL, &data.serial, &error);
984 g_object_unref (m2);
985 g_assert_no_error (error);
986
987 while (data.num_handled == 2)
988 g_thread_yield ();
989
990 m2 = g_dbus_message_copy (m, &error);
991 g_assert_no_error (error);
992 r = g_dbus_connection_send_message_with_reply_sync (c,
993 m2,
994 G_DBUS_SEND_MESSAGE_FLAGS_NONE,
995 -1,
996 &data.serial,
997 NULL, /* GCancellable */
998 &error);
999 g_object_unref (m2);
1000 g_assert_no_error (error);
1001 g_assert (r != NULL);
1002 g_object_unref (r);
1003 g_assert_cmpint (data.num_handled, ==, 4);
1004
1005 g_dbus_connection_remove_filter (c, filter_id);
1006
1007 m2 = g_dbus_message_copy (m, &error);
1008 g_assert_no_error (error);
1009 r = g_dbus_connection_send_message_with_reply_sync (c,
1010 m2,
1011 G_DBUS_SEND_MESSAGE_FLAGS_NONE,
1012 -1,
1013 &data.serial,
1014 NULL, /* GCancellable */
1015 &error);
1016 g_object_unref (m2);
1017 g_assert_no_error (error);
1018 g_assert (r != NULL);
1019 g_object_unref (r);
1020 g_assert_cmpint (data.num_handled, ==, 4);
1021 g_assert_cmpint (data.num_outgoing, ==, 4);
1022
1023 /* wait for service to be available */
1024 signal_handler_id = g_dbus_connection_signal_subscribe (c,
1025 "org.freedesktop.DBus", /* sender */
1026 "org.freedesktop.DBus",
1027 "NameOwnerChanged",
1028 "/org/freedesktop/DBus",
1029 NULL, /* arg0 */
1030 G_DBUS_SIGNAL_FLAGS_NONE,
1031 test_connection_filter_name_owner_changed_signal_handler,
1032 NULL,
1033 NULL);
1034 g_assert_cmpint (signal_handler_id, !=, 0);
1035
1036 /* this is safe; testserver will exit once the bus goes away */
1037 g_assert (g_spawn_command_line_async (g_test_get_filename (G_TEST_BUILT, "gdbus-testserver", NULL), NULL));
1038
1039 timeout_mainloop_id = g_timeout_add (30000, test_connection_filter_on_timeout, NULL);
1040 g_main_loop_run (loop);
1041 g_source_remove (timeout_mainloop_id);
1042 g_dbus_connection_signal_unsubscribe (c, signal_handler_id);
1043
1044 /* now test some combinations... */
1045 filter_id = g_dbus_connection_add_filter (c,
1046 other_filter_func,
1047 &effects,
1048 NULL);
1049 /* -- */
1050 effects.alter_incoming = FALSE;
1051 effects.alter_outgoing = FALSE;
1052 error = NULL;
1053 result = g_dbus_connection_call_sync (c,
1054 "com.example.TestService", /* bus name */
1055 "/com/example/TestObject", /* object path */
1056 "com.example.Frob", /* interface name */
1057 "HelloWorld", /* method name */
1058 g_variant_new ("(s)", "Cat"), /* parameters */
1059 G_VARIANT_TYPE ("(s)"), /* return type */
1060 G_DBUS_CALL_FLAGS_NONE,
1061 -1,
1062 NULL,
1063 &error);
1064 g_assert_no_error (error);
1065 g_variant_get (result, "(&s)", &s);
1066 g_assert_cmpstr (s, ==, "You greeted me with 'Cat'. Thanks!");
1067 g_variant_unref (result);
1068 /* -- */
1069 effects.alter_incoming = TRUE;
1070 effects.alter_outgoing = TRUE;
1071 error = NULL;
1072 result = g_dbus_connection_call_sync (c,
1073 "com.example.TestService", /* bus name */
1074 "/com/example/TestObject", /* object path */
1075 "com.example.Frob", /* interface name */
1076 "HelloWorld", /* method name */
1077 g_variant_new ("(s)", "Cat"), /* parameters */
1078 G_VARIANT_TYPE ("(s)"), /* return type */
1079 G_DBUS_CALL_FLAGS_NONE,
1080 -1,
1081 NULL,
1082 &error);
1083 g_assert_no_error (error);
1084 g_variant_get (result, "(&s)", &s);
1085 g_assert_cmpstr (s, ==, "MOD: You greeted me with 'MOD: Cat'. Thanks!");
1086 g_variant_unref (result);
1087
1088
1089 g_dbus_connection_remove_filter (c, filter_id);
1090
1091 g_object_unref (c);
1092 g_object_unref (m);
1093
1094 session_bus_down ();
1095 }
1096
1097 /* ---------------------------------------------------------------------------------------------------- */
1098
1099 #define NUM_THREADS 50
1100
1101 static void
1102 send_bogus_message (GDBusConnection *c, guint32 *out_serial)
1103 {
1104 GDBusMessage *m;
1105 GError *error;
1106
1107 m = g_dbus_message_new_method_call ("org.freedesktop.DBus", /* name */
1108 "/org/freedesktop/DBus", /* path */
1109 "org.freedesktop.DBus", /* interface */
1110 "GetNameOwner");
1111 g_dbus_message_set_body (m, g_variant_new ("(s)", "org.freedesktop.DBus"));
1112 error = NULL;
1113 g_dbus_connection_send_message (c, m, G_DBUS_SEND_MESSAGE_FLAGS_NONE, out_serial, &error);
1114 g_assert_no_error (error);
1115 g_object_unref (m);
1116 }
1117
1118 #define SLEEP_USEC (100 * 1000)
1119
1120 static gpointer
1121 serials_thread_func (GDBusConnection *c)
1122 {
1123 guint32 message_serial;
1124 guint i;
1125
1126 /* No calls on this thread yet */
1127 g_assert_cmpint (g_dbus_connection_get_last_serial(c), ==, 0);
1128
1129 /* Send a bogus message and store its serial */
1130 message_serial = 0;
1131 send_bogus_message (c, &message_serial);
1132
1133 /* Give it some time to actually send the message out. 10 seconds
1134 * should be plenty, even on slow machines. */
1135 for (i = 0; i < 10 * G_USEC_PER_SEC / SLEEP_USEC; i++)
1136 {
1137 if (g_dbus_connection_get_last_serial(c) != 0)
1138 break;
1139
1140 g_usleep (SLEEP_USEC);
1141 }
1142
1143 g_assert_cmpint (g_dbus_connection_get_last_serial(c), !=, 0);
1144 g_assert_cmpint (g_dbus_connection_get_last_serial(c), ==, message_serial);
1145
1146 return NULL;
1147 }
1148
1149 static void
1150 test_connection_serials (void)
1151 {
1152 GDBusConnection *c;
1153 GError *error;
1154 GThread *pool[NUM_THREADS];
1155 int i;
1156
1157 session_bus_up ();
1158
1159 error = NULL;
1160 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
1161 g_assert_no_error (error);
1162 g_assert (c != NULL);
1163
1164 /* Status after initialization */
1165 g_assert_cmpint (g_dbus_connection_get_last_serial (c), ==, 1);
1166
1167 /* Send a bogus message */
1168 send_bogus_message (c, NULL);
1169 g_assert_cmpint (g_dbus_connection_get_last_serial (c), ==, 2);
1170
1171 /* Start the threads */
1172 for (i = 0; i < NUM_THREADS; i++)
1173 pool[i] = g_thread_new (NULL, (GThreadFunc) serials_thread_func, c);
1174
1175 /* Wait until threads are finished */
1176 for (i = 0; i < NUM_THREADS; i++)
1177 g_thread_join (pool[i]);
1178
1179 /* No calls in between on this thread, should be the last value */
1180 g_assert_cmpint (g_dbus_connection_get_last_serial (c), ==, 2);
1181
1182 send_bogus_message (c, NULL);
1183
1184 /* All above calls + calls in threads */
1185 g_assert_cmpint (g_dbus_connection_get_last_serial (c), ==, 3 + NUM_THREADS);
1186
1187 g_object_unref (c);
1188
1189 session_bus_down ();
1190 }
1191
1192 /* ---------------------------------------------------------------------------------------------------- */
1193
1194 static void
1195 test_connection_basic (void)
1196 {
1197 GDBusConnection *connection;
1198 GError *error;
1199 GDBusCapabilityFlags flags;
1200 gchar *guid;
1201 gchar *name;
1202 gboolean closed;
1203 gboolean exit_on_close;
1204 GIOStream *stream;
1205 GCredentials *credentials;
1206
1207 session_bus_up ();
1208
1209 error = NULL;
1210 connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
1211 g_assert_no_error (error);
1212 g_assert (connection != NULL);
1213
1214 flags = g_dbus_connection_get_capabilities (connection);
1215 g_assert (flags == G_DBUS_CAPABILITY_FLAGS_NONE ||
1216 flags == G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
1217
1218 credentials = g_dbus_connection_get_peer_credentials (connection);
1219 g_assert (credentials == NULL);
1220
1221 g_object_get (connection,
1222 "stream", &stream,
1223 "guid", &guid,
1224 "unique-name", &name,
1225 "closed", &closed,
1226 "exit-on-close", &exit_on_close,
1227 "capabilities", &flags,
1228 NULL);
1229
1230 g_assert (G_IS_IO_STREAM (stream));
1231 g_assert (g_dbus_is_guid (guid));
1232 g_assert (g_dbus_is_unique_name (name));
1233 g_assert (!closed);
1234 g_assert (exit_on_close);
1235 g_assert (flags == G_DBUS_CAPABILITY_FLAGS_NONE ||
1236 flags == G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING);
1237 g_object_unref (stream);
1238 g_free (name);
1239 g_free (guid);
1240
1241 g_object_unref (connection);
1242
1243 session_bus_down ();
1244 }
1245
1246 /* ---------------------------------------------------------------------------------------------------- */
1247
1248 int
1249 main (int argc,
1250 char *argv[])
1251 {
1252 int ret;
1253 g_test_init (&argc, &argv, NULL);
1254
1255 /* all the tests rely on a shared main loop */
1256 loop = g_main_loop_new (NULL, FALSE);
1257
1258 g_test_dbus_unset ();
1259
1260 /* gdbus cleanup is pretty racy due to worker threads, so always do this test first */
1261 g_test_add_func ("/gdbus/connection/bus-failure", test_connection_bus_failure);
1262
1263 g_test_add_func ("/gdbus/connection/basic", test_connection_basic);
1264 g_test_add_func ("/gdbus/connection/life-cycle", test_connection_life_cycle);
1265 g_test_add_func ("/gdbus/connection/send", test_connection_send);
1266 g_test_add_func ("/gdbus/connection/signals", test_connection_signals);
1267 g_test_add_func ("/gdbus/connection/signal-match-rules", test_connection_signal_match_rules);
1268 g_test_add_func ("/gdbus/connection/filter", test_connection_filter);
1269 g_test_add_func ("/gdbus/connection/serials", test_connection_serials);
1270 ret = g_test_run();
1271
1272 g_main_loop_unref (loop);
1273 return ret;
1274 }
glib mirror