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 "gdbus-tests.h"
29 /* all tests rely on a global connection */
30 static GDBusConnection *c = NULL;
32 /* ---------------------------------------------------------------------------------------------------- */
33 /* Ensure that signal and method replies are delivered in the right thread */
34 /* ---------------------------------------------------------------------------------------------------- */
38 GMainLoop *thread_loop;
43 msg_cb_expect_success (GDBusConnection *connection,
47 DeliveryData *data = user_data;
52 result = g_dbus_connection_call_finish (connection,
55 g_assert_no_error (error);
56 g_assert (result != NULL);
57 g_variant_unref (result);
59 g_assert (g_thread_self () == data->thread);
61 g_main_loop_quit (data->thread_loop);
65 msg_cb_expect_error_cancelled (GDBusConnection *connection,
69 DeliveryData *data = user_data;
74 result = g_dbus_connection_call_finish (connection,
77 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
78 g_assert (!g_dbus_error_is_remote_error (error));
80 g_assert (result == NULL);
82 g_assert (g_thread_self () == data->thread);
84 g_main_loop_quit (data->thread_loop);
88 signal_handler (GDBusConnection *connection,
89 const gchar *sender_name,
90 const gchar *object_path,
91 const gchar *interface_name,
92 const gchar *signal_name,
96 DeliveryData *data = user_data;
98 g_assert (g_thread_self () == data->thread);
100 data->signal_count++;
102 g_main_loop_quit (data->thread_loop);
106 test_delivery_in_thread_func (gpointer _data)
108 GMainLoop *thread_loop;
109 GMainContext *thread_context;
112 guint subscription_id;
113 GDBusConnection *priv_c;
118 thread_context = g_main_context_new ();
119 thread_loop = g_main_loop_new (thread_context, FALSE);
120 g_main_context_push_thread_default (thread_context);
122 data.thread = g_thread_self ();
123 data.thread_loop = thread_loop;
124 data.signal_count = 0;
126 /* ---------------------------------------------------------------------------------------------------- */
129 * Check that we get a reply to the GetId() method call.
131 g_dbus_connection_call (c,
132 "org.freedesktop.DBus", /* bus_name */
133 "/org/freedesktop/DBus", /* object path */
134 "org.freedesktop.DBus", /* interface name */
135 "GetId", /* method name */
137 G_DBUS_CALL_FLAGS_NONE,
140 (GAsyncReadyCallback) msg_cb_expect_success,
142 g_main_loop_run (thread_loop);
145 * Check that we never actually send a message if the GCancellable
146 * is already cancelled - i.e. we should get #G_IO_ERROR_CANCELLED
147 * when the actual connection is not up.
149 ca = g_cancellable_new ();
150 g_cancellable_cancel (ca);
151 g_dbus_connection_call (c,
152 "org.freedesktop.DBus", /* bus_name */
153 "/org/freedesktop/DBus", /* object path */
154 "org.freedesktop.DBus", /* interface name */
155 "GetId", /* method name */
157 G_DBUS_CALL_FLAGS_NONE,
160 (GAsyncReadyCallback) msg_cb_expect_error_cancelled,
162 g_main_loop_run (thread_loop);
166 * Check that cancellation works when the message is already in flight.
168 ca = g_cancellable_new ();
169 g_dbus_connection_call (c,
170 "org.freedesktop.DBus", /* bus_name */
171 "/org/freedesktop/DBus", /* object path */
172 "org.freedesktop.DBus", /* interface name */
173 "GetId", /* method name */
175 G_DBUS_CALL_FLAGS_NONE,
178 (GAsyncReadyCallback) msg_cb_expect_error_cancelled,
180 g_cancellable_cancel (ca);
181 g_main_loop_run (thread_loop);
185 * Check that signals are delivered to the correct thread.
187 * First we subscribe to the signal, then we create a a private
188 * connection. This should cause a NameOwnerChanged message from
191 subscription_id = g_dbus_connection_signal_subscribe (c,
192 "org.freedesktop.DBus", /* sender */
193 "org.freedesktop.DBus", /* interface */
194 "NameOwnerChanged", /* member */
195 "/org/freedesktop/DBus", /* path */
197 G_DBUS_SIGNAL_FLAGS_NONE,
201 g_assert (subscription_id != 0);
202 g_assert (data.signal_count == 0);
204 priv_c = _g_bus_get_priv (G_BUS_TYPE_SESSION, NULL, &error);
205 g_assert_no_error (error);
206 g_assert (priv_c != NULL);
208 g_main_loop_run (thread_loop);
209 g_assert (data.signal_count == 1);
211 g_object_unref (priv_c);
213 g_dbus_connection_signal_unsubscribe (c, subscription_id);
215 /* ---------------------------------------------------------------------------------------------------- */
217 g_main_context_pop_thread_default (thread_context);
218 g_main_loop_unref (thread_loop);
219 g_main_context_unref (thread_context);
225 test_delivery_in_thread (void)
229 thread = g_thread_new ("deliver",
230 test_delivery_in_thread_func,
233 g_thread_join (thread);
236 /* ---------------------------------------------------------------------------------------------------- */
244 GMainLoop *thread_loop;
249 sleep_cb (GDBusProxy *proxy,
253 SyncThreadData *data = user_data;
258 result = g_dbus_proxy_call_finish (proxy,
261 g_assert_no_error (error);
262 g_assert (result != NULL);
263 g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
264 g_variant_unref (result);
266 g_assert (data->thread == g_thread_self ());
268 g_main_loop_quit (data->thread_loop);
270 //g_debug ("async cb (%p)", g_thread_self ());
274 test_sleep_in_thread_func (gpointer _data)
276 SyncThreadData *data = _data;
277 GMainContext *thread_context;
280 thread_context = g_main_context_new ();
281 data->thread_loop = g_main_loop_new (thread_context, FALSE);
282 g_main_context_push_thread_default (thread_context);
284 data->thread = g_thread_self ();
286 for (n = 0; n < data->num; n++)
290 //g_debug ("invoking async (%p)", g_thread_self ());
291 g_dbus_proxy_call (data->proxy,
293 g_variant_new ("(i)", data->msec),
294 G_DBUS_CALL_FLAGS_NONE,
297 (GAsyncReadyCallback) sleep_cb,
299 g_main_loop_run (data->thread_loop);
301 //g_debug ("done invoking async (%p)", g_thread_self ());
309 //g_debug ("invoking sync (%p)", g_thread_self ());
310 result = g_dbus_proxy_call_sync (data->proxy,
312 g_variant_new ("(i)", data->msec),
313 G_DBUS_CALL_FLAGS_NONE,
318 //g_debug ("done invoking sync (%p)", g_thread_self ());
319 g_assert_no_error (error);
320 g_assert (result != NULL);
321 g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
322 g_variant_unref (result);
326 g_main_context_pop_thread_default (thread_context);
327 g_main_loop_unref (data->thread_loop);
328 g_main_context_unref (thread_context);
334 test_method_calls_on_proxy (GDBusProxy *proxy)
339 * Check that multiple threads can do calls without interferring with
340 * each other. We do this by creating three threads that call the
341 * Sleep() method on the server (which handles it asynchronously, e.g.
342 * it won't block other requests) with different sleep durations and
343 * a number of times. We do this so each set of calls add up to 4000
346 * The dbus test server that this code calls into uses glib timeouts
347 * to do the sleeping which have only a granularity of 1ms. It is
348 * therefore possible to lose as much as 40ms; the test could finish
349 * in slightly less than 4 seconds.
351 * We run this test twice - first with async calls in each thread, then
352 * again with sync calls
355 for (n = 0; n < 2; n++)
361 SyncThreadData data1;
362 SyncThreadData data2;
363 SyncThreadData data3;
370 g_get_current_time (&start_time);
375 data1.async = do_async;
376 thread1 = g_thread_new ("sleep",
377 test_sleep_in_thread_func,
383 data2.async = do_async;
384 thread2 = g_thread_new ("sleep2",
385 test_sleep_in_thread_func,
391 data3.async = do_async;
392 thread3 = g_thread_new ("sleep3",
393 test_sleep_in_thread_func,
396 g_thread_join (thread1);
397 g_thread_join (thread2);
398 g_thread_join (thread3);
400 g_get_current_time (&end_time);
402 elapsed_msec = ((end_time.tv_sec * G_USEC_PER_SEC + end_time.tv_usec) -
403 (start_time.tv_sec * G_USEC_PER_SEC + start_time.tv_usec)) / 1000;
405 //g_debug ("Elapsed time for %s = %d msec", n == 0 ? "async" : "sync", elapsed_msec);
407 /* elapsed_msec should be 4000 msec +/- change for overhead/inaccuracy */
408 g_assert_cmpint (elapsed_msec, >=, 3950);
409 g_assert_cmpint (elapsed_msec, <, 6000);
416 test_method_calls_in_thread (void)
419 GDBusConnection *connection;
424 connection = g_bus_get_sync (G_BUS_TYPE_SESSION,
427 g_assert_no_error (error);
429 proxy = g_dbus_proxy_new_sync (connection,
430 G_DBUS_PROXY_FLAGS_NONE,
431 NULL, /* GDBusInterfaceInfo */
432 "com.example.TestService", /* name */
433 "/com/example/TestObject", /* object path */
434 "com.example.Frob", /* interface */
435 NULL, /* GCancellable */
437 g_assert_no_error (error);
439 name_owner = g_dbus_proxy_get_name_owner (proxy);
440 g_assert_cmpstr (name_owner, !=, NULL);
443 test_method_calls_on_proxy (proxy);
445 g_object_unref (proxy);
446 g_object_unref (connection);
449 #define SLEEP_MIN_USEC 1
450 #define SLEEP_MAX_USEC 10
452 /* Can run in any thread */
454 ensure_connection_works (GDBusConnection *conn)
457 GError *error = NULL;
459 v = g_dbus_connection_call_sync (conn, "org.freedesktop.DBus",
460 "/org/freedesktop/DBus", "org.freedesktop.DBus", "GetId", NULL, NULL, 0, -1,
462 g_assert_no_error (error);
463 g_assert (v != NULL);
464 g_assert (g_variant_is_of_type (v, G_VARIANT_TYPE ("(s)")));
469 * get_sync_in_thread:
470 * @data: (type guint): delay in microseconds
472 * Sleep for a short time, then get a session bus connection and call
475 * Runs in a non-main thread.
477 * Returns: (transfer full): the connection
480 get_sync_in_thread (gpointer data)
482 guint delay = GPOINTER_TO_UINT (data);
483 GError *error = NULL;
484 GDBusConnection *conn;
488 conn = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
489 g_assert_no_error (error);
491 ensure_connection_works (conn);
497 test_threaded_singleton (void)
500 guint unref_wins = 0;
503 if (g_test_thorough ())
508 for (i = 0; i < n; i++)
512 guint unref_delay, get_delay;
513 GDBusConnection *new_conn;
515 /* We want to be the last ref, so let it finish setting up */
516 for (j = 0; j < 100; j++)
518 guint r = g_atomic_int_get (&G_OBJECT (c)->ref_count);
523 g_debug ("run %u: refcount is %u, sleeping", i, r);
528 g_error ("connection had too many refs");
530 if (g_test_verbose () && (i % (n/50)) == 0)
531 g_print ("%u%%\n", ((i * 100) / n));
533 /* Delay for a random time on each side of the race, to perturb the
534 * timing. Ideally, we want each side to win half the races; these
535 * timings are about right on smcv's laptop.
537 unref_delay = g_random_int_range (SLEEP_MIN_USEC, SLEEP_MAX_USEC);
538 get_delay = g_random_int_range (SLEEP_MIN_USEC / 2, SLEEP_MAX_USEC / 2);
540 /* One half of the race is to call g_bus_get_sync... */
541 thread = g_thread_new ("get_sync_in_thread", get_sync_in_thread,
542 GUINT_TO_POINTER (get_delay));
544 /* ... and the other half is to unref the shared connection, which must
545 * have exactly one ref at this point
547 g_usleep (unref_delay);
550 /* Wait for the thread to run; see what it got */
551 new_conn = g_thread_join (thread);
553 /* If the thread won the race, it will have kept the same connection,
554 * and it'll have one ref
563 /* c is invalid now, but new_conn is suitable for the
569 ensure_connection_works (c);
572 if (g_test_verbose ())
573 g_print ("Unref won %u races; Get won %u races\n", unref_wins, get_wins);
576 /* ---------------------------------------------------------------------------------------------------- */
586 g_test_init (&argc, &argv, NULL);
590 /* this is safe; testserver will exit once the bus goes away */
591 g_assert (g_spawn_command_line_async (SRCDIR "/gdbus-testserver.py", NULL));
593 /* wait for the service to come up */
596 /* Create the connection in the main thread */
598 c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
599 g_assert_no_error (error);
600 g_assert (c != NULL);
602 g_test_add_func ("/gdbus/delivery-in-thread", test_delivery_in_thread);
603 g_test_add_func ("/gdbus/method-calls-in-thread", test_method_calls_in_thread);
604 g_test_add_func ("/gdbus/threaded-singleton", test_threaded_singleton);