2010-05-06 20:13:59 +02:00
|
|
|
|
/* GLib testing framework examples and tests
|
|
|
|
|
*
|
2010-05-10 14:07:28 +02:00
|
|
|
|
* Copyright (C) 2008-2010 Red Hat, Inc.
|
2010-05-06 20:13:59 +02:00
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
|
* License as published by the Free Software Foundation; either
|
2017-05-27 17:19:21 +02:00
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
2010-05-06 20:13:59 +02:00
|
|
|
|
*
|
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Lesser General
|
2014-01-23 12:58:29 +01:00
|
|
|
|
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
2010-05-06 20:13:59 +02:00
|
|
|
|
*
|
|
|
|
|
* Author: David Zeuthen <davidz@redhat.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <gio/gio.h>
|
|
|
|
|
#include <unistd.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
|
|
#include "gdbus-tests.h"
|
|
|
|
|
|
|
|
|
|
/* all tests rely on a global connection */
|
|
|
|
|
static GDBusConnection *c = NULL;
|
|
|
|
|
|
2020-02-21 13:18:29 +01:00
|
|
|
|
typedef struct
|
|
|
|
|
{
|
|
|
|
|
GMainContext *context;
|
|
|
|
|
gboolean timed_out;
|
|
|
|
|
} TimeoutData;
|
|
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
|
timeout_cb (gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
TimeoutData *data = user_data;
|
|
|
|
|
|
|
|
|
|
data->timed_out = TRUE;
|
|
|
|
|
g_main_context_wakeup (data->context);
|
|
|
|
|
|
|
|
|
|
return G_SOURCE_REMOVE;
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-12 14:20:29 +01:00
|
|
|
|
/* Check that the given @connection has only one ref, waiting to let any pending
|
|
|
|
|
* unrefs complete first. This is typically used on the shared connection, to
|
|
|
|
|
* ensure it’s in a correct state before beginning the next test. */
|
|
|
|
|
static void
|
2020-02-21 13:18:29 +01:00
|
|
|
|
assert_connection_has_one_ref (GDBusConnection *connection,
|
|
|
|
|
GMainContext *context)
|
2018-11-12 14:20:29 +01:00
|
|
|
|
{
|
2020-02-21 13:18:29 +01:00
|
|
|
|
GSource *timeout_source = NULL;
|
|
|
|
|
TimeoutData data = { context, FALSE };
|
2018-11-12 14:20:29 +01:00
|
|
|
|
|
2020-02-21 13:18:29 +01:00
|
|
|
|
if (g_atomic_int_get (&G_OBJECT (connection)->ref_count) == 1)
|
|
|
|
|
return;
|
2018-11-12 14:20:29 +01:00
|
|
|
|
|
2020-02-24 11:50:35 +01:00
|
|
|
|
timeout_source = g_timeout_source_new_seconds (3);
|
2020-02-21 13:18:29 +01:00
|
|
|
|
g_source_set_callback (timeout_source, timeout_cb, &data, NULL);
|
|
|
|
|
g_source_attach (timeout_source, context);
|
2018-11-12 14:20:29 +01:00
|
|
|
|
|
2020-02-21 13:18:29 +01:00
|
|
|
|
while (g_atomic_int_get (&G_OBJECT (connection)->ref_count) != 1 && !data.timed_out)
|
|
|
|
|
{
|
|
|
|
|
g_debug ("refcount of %p is not right, sleeping", connection);
|
|
|
|
|
g_main_context_iteration (NULL, TRUE);
|
2018-11-12 14:20:29 +01:00
|
|
|
|
}
|
|
|
|
|
|
2020-02-21 13:18:29 +01:00
|
|
|
|
g_source_destroy (timeout_source);
|
|
|
|
|
g_source_unref (timeout_source);
|
|
|
|
|
|
|
|
|
|
if (g_atomic_int_get (&G_OBJECT (connection)->ref_count) != 1)
|
2018-11-12 14:20:29 +01:00
|
|
|
|
g_error ("connection %p had too many refs", connection);
|
|
|
|
|
}
|
|
|
|
|
|
2010-05-06 20:13:59 +02:00
|
|
|
|
/* ---------------------------------------------------------------------------------------------------- */
|
|
|
|
|
/* Ensure that signal and method replies are delivered in the right thread */
|
|
|
|
|
/* ---------------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
GThread *thread;
|
2020-02-21 15:12:52 +01:00
|
|
|
|
GMainContext *context;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
guint signal_count;
|
2020-02-21 13:08:57 +01:00
|
|
|
|
gboolean unsubscribe_complete;
|
2020-02-21 15:12:52 +01:00
|
|
|
|
GAsyncResult *async_result;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
} DeliveryData;
|
|
|
|
|
|
|
|
|
|
static void
|
2020-02-21 15:12:52 +01:00
|
|
|
|
async_result_cb (GDBusConnection *connection,
|
|
|
|
|
GAsyncResult *res,
|
|
|
|
|
gpointer user_data)
|
2010-05-06 20:13:59 +02:00
|
|
|
|
{
|
|
|
|
|
DeliveryData *data = user_data;
|
|
|
|
|
|
2020-02-21 15:12:52 +01:00
|
|
|
|
data->async_result = g_object_ref (res);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_true (g_thread_self () == data->thread);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
2020-02-21 15:12:52 +01:00
|
|
|
|
g_main_context_wakeup (data->context);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
signal_handler (GDBusConnection *connection,
|
|
|
|
|
const gchar *sender_name,
|
|
|
|
|
const gchar *object_path,
|
|
|
|
|
const gchar *interface_name,
|
|
|
|
|
const gchar *signal_name,
|
|
|
|
|
GVariant *parameters,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
DeliveryData *data = user_data;
|
|
|
|
|
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_true (g_thread_self () == data->thread);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
data->signal_count++;
|
|
|
|
|
|
2020-02-21 15:12:52 +01:00
|
|
|
|
g_main_context_wakeup (data->context);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
}
|
|
|
|
|
|
2020-02-21 13:08:57 +01:00
|
|
|
|
static void
|
|
|
|
|
signal_data_free_cb (gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
DeliveryData *data = user_data;
|
|
|
|
|
|
|
|
|
|
g_assert_true (g_thread_self () == data->thread);
|
|
|
|
|
|
|
|
|
|
data->unsubscribe_complete = TRUE;
|
|
|
|
|
|
2020-02-21 15:12:52 +01:00
|
|
|
|
g_main_context_wakeup (data->context);
|
2020-02-21 13:08:57 +01:00
|
|
|
|
}
|
|
|
|
|
|
2010-05-06 20:13:59 +02:00
|
|
|
|
static gpointer
|
|
|
|
|
test_delivery_in_thread_func (gpointer _data)
|
|
|
|
|
{
|
|
|
|
|
GMainContext *thread_context;
|
|
|
|
|
DeliveryData data;
|
|
|
|
|
GCancellable *ca;
|
|
|
|
|
guint subscription_id;
|
2020-02-21 15:12:52 +01:00
|
|
|
|
GError *error = NULL;
|
|
|
|
|
GVariant *result_variant = NULL;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
thread_context = g_main_context_new ();
|
|
|
|
|
g_main_context_push_thread_default (thread_context);
|
|
|
|
|
|
|
|
|
|
data.thread = g_thread_self ();
|
2020-02-21 15:12:52 +01:00
|
|
|
|
data.context = thread_context;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
data.signal_count = 0;
|
2020-02-21 13:08:57 +01:00
|
|
|
|
data.unsubscribe_complete = FALSE;
|
2020-02-21 15:12:52 +01:00
|
|
|
|
data.async_result = NULL;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check that we get a reply to the GetId() method call.
|
|
|
|
|
*/
|
2010-05-10 17:47:08 +02:00
|
|
|
|
g_dbus_connection_call (c,
|
|
|
|
|
"org.freedesktop.DBus", /* bus_name */
|
|
|
|
|
"/org/freedesktop/DBus", /* object path */
|
|
|
|
|
"org.freedesktop.DBus", /* interface name */
|
|
|
|
|
"GetId", /* method name */
|
2010-05-24 22:46:24 +02:00
|
|
|
|
NULL, NULL,
|
2010-05-10 17:47:08 +02:00
|
|
|
|
G_DBUS_CALL_FLAGS_NONE,
|
|
|
|
|
-1,
|
|
|
|
|
NULL,
|
2020-02-21 15:12:52 +01:00
|
|
|
|
(GAsyncReadyCallback) async_result_cb,
|
2010-05-10 17:47:08 +02:00
|
|
|
|
&data);
|
2020-02-21 15:12:52 +01:00
|
|
|
|
while (data.async_result == NULL)
|
|
|
|
|
g_main_context_iteration (thread_context, TRUE);
|
|
|
|
|
|
|
|
|
|
result_variant = g_dbus_connection_call_finish (c, data.async_result, &error);
|
|
|
|
|
g_assert_no_error (error);
|
|
|
|
|
g_assert_nonnull (result_variant);
|
|
|
|
|
g_clear_pointer (&result_variant, g_variant_unref);
|
|
|
|
|
g_clear_object (&data.async_result);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check that we never actually send a message if the GCancellable
|
2022-03-04 17:21:55 +01:00
|
|
|
|
* is already cancelled - i.e. we should get G_IO_ERROR_CANCELLED
|
2010-05-06 20:13:59 +02:00
|
|
|
|
* when the actual connection is not up.
|
|
|
|
|
*/
|
|
|
|
|
ca = g_cancellable_new ();
|
|
|
|
|
g_cancellable_cancel (ca);
|
2010-05-10 17:47:08 +02:00
|
|
|
|
g_dbus_connection_call (c,
|
|
|
|
|
"org.freedesktop.DBus", /* bus_name */
|
|
|
|
|
"/org/freedesktop/DBus", /* object path */
|
|
|
|
|
"org.freedesktop.DBus", /* interface name */
|
|
|
|
|
"GetId", /* method name */
|
2010-05-24 22:46:24 +02:00
|
|
|
|
NULL, NULL,
|
2010-05-10 17:47:08 +02:00
|
|
|
|
G_DBUS_CALL_FLAGS_NONE,
|
|
|
|
|
-1,
|
|
|
|
|
ca,
|
2020-02-21 15:12:52 +01:00
|
|
|
|
(GAsyncReadyCallback) async_result_cb,
|
2010-05-10 17:47:08 +02:00
|
|
|
|
&data);
|
2020-02-21 15:12:52 +01:00
|
|
|
|
while (data.async_result == NULL)
|
|
|
|
|
g_main_context_iteration (thread_context, TRUE);
|
|
|
|
|
|
|
|
|
|
result_variant = g_dbus_connection_call_finish (c, data.async_result, &error);
|
|
|
|
|
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
|
|
|
|
|
g_assert_false (g_dbus_error_is_remote_error (error));
|
|
|
|
|
g_clear_error (&error);
|
|
|
|
|
g_assert_null (result_variant);
|
|
|
|
|
g_clear_object (&data.async_result);
|
|
|
|
|
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_object_unref (ca);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check that cancellation works when the message is already in flight.
|
|
|
|
|
*/
|
|
|
|
|
ca = g_cancellable_new ();
|
2010-05-10 17:47:08 +02:00
|
|
|
|
g_dbus_connection_call (c,
|
|
|
|
|
"org.freedesktop.DBus", /* bus_name */
|
|
|
|
|
"/org/freedesktop/DBus", /* object path */
|
|
|
|
|
"org.freedesktop.DBus", /* interface name */
|
|
|
|
|
"GetId", /* method name */
|
2010-05-24 22:46:24 +02:00
|
|
|
|
NULL, NULL,
|
2010-05-10 17:47:08 +02:00
|
|
|
|
G_DBUS_CALL_FLAGS_NONE,
|
|
|
|
|
-1,
|
|
|
|
|
ca,
|
2020-02-21 15:12:52 +01:00
|
|
|
|
(GAsyncReadyCallback) async_result_cb,
|
2010-05-10 17:47:08 +02:00
|
|
|
|
&data);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_cancellable_cancel (ca);
|
2020-02-21 15:12:52 +01:00
|
|
|
|
|
|
|
|
|
while (data.async_result == NULL)
|
|
|
|
|
g_main_context_iteration (thread_context, TRUE);
|
|
|
|
|
|
|
|
|
|
result_variant = g_dbus_connection_call_finish (c, data.async_result, &error);
|
|
|
|
|
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
|
|
|
|
|
g_assert_false (g_dbus_error_is_remote_error (error));
|
|
|
|
|
g_clear_error (&error);
|
|
|
|
|
g_assert_null (result_variant);
|
|
|
|
|
g_clear_object (&data.async_result);
|
|
|
|
|
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_object_unref (ca);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check that signals are delivered to the correct thread.
|
|
|
|
|
*
|
2020-02-21 15:14:57 +01:00
|
|
|
|
* First we subscribe to the signal, then we call EmitSignal(). This should
|
|
|
|
|
* cause a TestSignal emission from the testserver.
|
2010-05-06 20:13:59 +02:00
|
|
|
|
*/
|
|
|
|
|
subscription_id = g_dbus_connection_signal_subscribe (c,
|
2020-02-21 15:14:57 +01:00
|
|
|
|
"com.example.TestService", /* sender */
|
|
|
|
|
"com.example.Frob", /* interface */
|
|
|
|
|
"TestSignal", /* member */
|
|
|
|
|
"/com/example/TestObject", /* path */
|
2010-05-06 20:13:59 +02:00
|
|
|
|
NULL,
|
2010-07-19 21:03:00 +02:00
|
|
|
|
G_DBUS_SIGNAL_FLAGS_NONE,
|
2010-05-06 20:13:59 +02:00
|
|
|
|
signal_handler,
|
|
|
|
|
&data,
|
2020-02-21 13:08:57 +01:00
|
|
|
|
signal_data_free_cb);
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_cmpuint (subscription_id, !=, 0);
|
|
|
|
|
g_assert_cmpuint (data.signal_count, ==, 0);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
2020-02-21 15:14:57 +01:00
|
|
|
|
g_dbus_connection_call (c,
|
|
|
|
|
"com.example.TestService", /* bus_name */
|
|
|
|
|
"/com/example/TestObject", /* object path */
|
|
|
|
|
"com.example.Frob", /* interface name */
|
|
|
|
|
"EmitSignal", /* method name */
|
|
|
|
|
g_variant_new_parsed ("('hello', @o '/com/example/TestObject')"),
|
|
|
|
|
NULL,
|
|
|
|
|
G_DBUS_CALL_FLAGS_NONE,
|
|
|
|
|
-1,
|
|
|
|
|
NULL,
|
|
|
|
|
(GAsyncReadyCallback) async_result_cb,
|
|
|
|
|
&data);
|
|
|
|
|
while (data.async_result == NULL || data.signal_count < 1)
|
|
|
|
|
g_main_context_iteration (thread_context, TRUE);
|
|
|
|
|
|
|
|
|
|
result_variant = g_dbus_connection_call_finish (c, data.async_result, &error);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_assert_no_error (error);
|
2020-02-21 15:14:57 +01:00
|
|
|
|
g_assert_nonnull (result_variant);
|
|
|
|
|
g_clear_pointer (&result_variant, g_variant_unref);
|
|
|
|
|
g_clear_object (&data.async_result);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_cmpuint (data.signal_count, ==, 1);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
g_dbus_connection_signal_unsubscribe (c, subscription_id);
|
2020-02-21 13:08:57 +01:00
|
|
|
|
subscription_id = 0;
|
|
|
|
|
|
2020-02-21 15:12:52 +01:00
|
|
|
|
while (!data.unsubscribe_complete)
|
|
|
|
|
g_main_context_iteration (thread_context, TRUE);
|
2020-02-21 13:08:57 +01:00
|
|
|
|
g_assert_true (data.unsubscribe_complete);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
|
|
g_main_context_pop_thread_default (thread_context);
|
|
|
|
|
g_main_context_unref (thread_context);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
test_delivery_in_thread (void)
|
|
|
|
|
{
|
|
|
|
|
GThread *thread;
|
|
|
|
|
|
2011-10-10 15:49:50 +02:00
|
|
|
|
thread = g_thread_new ("deliver",
|
|
|
|
|
test_delivery_in_thread_func,
|
2011-10-13 07:00:57 +02:00
|
|
|
|
NULL);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
g_thread_join (thread);
|
2018-11-12 14:20:29 +01:00
|
|
|
|
|
2020-02-21 13:18:29 +01:00
|
|
|
|
assert_connection_has_one_ref (c, NULL);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
|
GDBusProxy *proxy;
|
|
|
|
|
gint msec;
|
|
|
|
|
guint num;
|
|
|
|
|
gboolean async;
|
|
|
|
|
|
|
|
|
|
GMainLoop *thread_loop;
|
|
|
|
|
GThread *thread;
|
|
|
|
|
} SyncThreadData;
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
sleep_cb (GDBusProxy *proxy,
|
|
|
|
|
GAsyncResult *res,
|
|
|
|
|
gpointer user_data)
|
|
|
|
|
{
|
|
|
|
|
SyncThreadData *data = user_data;
|
|
|
|
|
GError *error;
|
|
|
|
|
GVariant *result;
|
|
|
|
|
|
|
|
|
|
error = NULL;
|
2010-05-10 17:47:08 +02:00
|
|
|
|
result = g_dbus_proxy_call_finish (proxy,
|
|
|
|
|
res,
|
|
|
|
|
&error);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_assert_no_error (error);
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_nonnull (result);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
|
|
|
|
|
g_variant_unref (result);
|
|
|
|
|
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_true (data->thread == g_thread_self ());
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
g_main_loop_quit (data->thread_loop);
|
|
|
|
|
|
|
|
|
|
//g_debug ("async cb (%p)", g_thread_self ());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static gpointer
|
|
|
|
|
test_sleep_in_thread_func (gpointer _data)
|
|
|
|
|
{
|
|
|
|
|
SyncThreadData *data = _data;
|
|
|
|
|
GMainContext *thread_context;
|
|
|
|
|
guint n;
|
|
|
|
|
|
|
|
|
|
thread_context = g_main_context_new ();
|
|
|
|
|
data->thread_loop = g_main_loop_new (thread_context, FALSE);
|
|
|
|
|
g_main_context_push_thread_default (thread_context);
|
|
|
|
|
|
|
|
|
|
data->thread = g_thread_self ();
|
|
|
|
|
|
|
|
|
|
for (n = 0; n < data->num; n++)
|
|
|
|
|
{
|
|
|
|
|
if (data->async)
|
|
|
|
|
{
|
|
|
|
|
//g_debug ("invoking async (%p)", g_thread_self ());
|
2010-05-10 17:47:08 +02:00
|
|
|
|
g_dbus_proxy_call (data->proxy,
|
|
|
|
|
"Sleep",
|
|
|
|
|
g_variant_new ("(i)", data->msec),
|
|
|
|
|
G_DBUS_CALL_FLAGS_NONE,
|
|
|
|
|
-1,
|
|
|
|
|
NULL,
|
|
|
|
|
(GAsyncReadyCallback) sleep_cb,
|
|
|
|
|
data);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_main_loop_run (data->thread_loop);
|
2015-05-07 18:36:01 +02:00
|
|
|
|
if (g_test_verbose ())
|
2015-05-11 18:03:00 +02:00
|
|
|
|
g_printerr ("A");
|
2010-05-06 20:13:59 +02:00
|
|
|
|
//g_debug ("done invoking async (%p)", g_thread_self ());
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
GError *error;
|
|
|
|
|
GVariant *result;
|
|
|
|
|
|
|
|
|
|
error = NULL;
|
|
|
|
|
//g_debug ("invoking sync (%p)", g_thread_self ());
|
2010-05-10 17:47:08 +02:00
|
|
|
|
result = g_dbus_proxy_call_sync (data->proxy,
|
|
|
|
|
"Sleep",
|
|
|
|
|
g_variant_new ("(i)", data->msec),
|
|
|
|
|
G_DBUS_CALL_FLAGS_NONE,
|
|
|
|
|
-1,
|
|
|
|
|
NULL,
|
|
|
|
|
&error);
|
2015-05-07 18:36:01 +02:00
|
|
|
|
if (g_test_verbose ())
|
2015-05-11 18:03:00 +02:00
|
|
|
|
g_printerr ("S");
|
2010-05-06 20:13:59 +02:00
|
|
|
|
//g_debug ("done invoking sync (%p)", g_thread_self ());
|
|
|
|
|
g_assert_no_error (error);
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_nonnull (result);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_assert_cmpstr (g_variant_get_type_string (result), ==, "()");
|
|
|
|
|
g_variant_unref (result);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
g_main_context_pop_thread_default (thread_context);
|
|
|
|
|
g_main_loop_unref (data->thread_loop);
|
|
|
|
|
g_main_context_unref (thread_context);
|
|
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2010-06-11 21:45:18 +02:00
|
|
|
|
test_method_calls_on_proxy (GDBusProxy *proxy)
|
2010-05-06 20:13:59 +02:00
|
|
|
|
{
|
2020-02-24 13:19:52 +01:00
|
|
|
|
guint n, divisor;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
/*
|
2020-06-12 15:02:30 +02:00
|
|
|
|
* Check that multiple threads can do calls without interfering with
|
2010-05-06 20:13:59 +02:00
|
|
|
|
* each other. We do this by creating three threads that call the
|
|
|
|
|
* Sleep() method on the server (which handles it asynchronously, e.g.
|
|
|
|
|
* it won't block other requests) with different sleep durations and
|
|
|
|
|
* a number of times. We do this so each set of calls add up to 4000
|
|
|
|
|
* milliseconds.
|
|
|
|
|
*
|
2010-05-18 23:25:43 +02:00
|
|
|
|
* The dbus test server that this code calls into uses glib timeouts
|
|
|
|
|
* to do the sleeping which have only a granularity of 1ms. It is
|
|
|
|
|
* therefore possible to lose as much as 40ms; the test could finish
|
|
|
|
|
* in slightly less than 4 seconds.
|
|
|
|
|
*
|
2010-05-06 20:13:59 +02:00
|
|
|
|
* We run this test twice - first with async calls in each thread, then
|
|
|
|
|
* again with sync calls
|
|
|
|
|
*/
|
|
|
|
|
|
2020-02-24 13:19:52 +01:00
|
|
|
|
if (g_test_thorough ())
|
|
|
|
|
divisor = 1;
|
|
|
|
|
else
|
|
|
|
|
divisor = 10;
|
|
|
|
|
|
2010-05-06 20:13:59 +02:00
|
|
|
|
for (n = 0; n < 2; n++)
|
|
|
|
|
{
|
|
|
|
|
gboolean do_async;
|
|
|
|
|
GThread *thread1;
|
|
|
|
|
GThread *thread2;
|
|
|
|
|
GThread *thread3;
|
|
|
|
|
SyncThreadData data1;
|
|
|
|
|
SyncThreadData data2;
|
|
|
|
|
SyncThreadData data3;
|
2019-07-24 15:10:05 +02:00
|
|
|
|
gint64 start_time, end_time;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
guint elapsed_msec;
|
|
|
|
|
|
|
|
|
|
do_async = (n == 0);
|
|
|
|
|
|
2019-07-24 15:10:05 +02:00
|
|
|
|
start_time = g_get_real_time ();
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
data1.proxy = proxy;
|
|
|
|
|
data1.msec = 40;
|
2020-02-24 13:19:52 +01:00
|
|
|
|
data1.num = 100 / divisor;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
data1.async = do_async;
|
2011-10-10 15:49:50 +02:00
|
|
|
|
thread1 = g_thread_new ("sleep",
|
|
|
|
|
test_sleep_in_thread_func,
|
2011-10-13 07:00:57 +02:00
|
|
|
|
&data1);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
data2.proxy = proxy;
|
|
|
|
|
data2.msec = 20;
|
2020-02-24 13:19:52 +01:00
|
|
|
|
data2.num = 200 / divisor;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
data2.async = do_async;
|
2011-10-10 15:49:50 +02:00
|
|
|
|
thread2 = g_thread_new ("sleep2",
|
|
|
|
|
test_sleep_in_thread_func,
|
2011-10-13 07:00:57 +02:00
|
|
|
|
&data2);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
data3.proxy = proxy;
|
|
|
|
|
data3.msec = 100;
|
2020-02-24 13:19:52 +01:00
|
|
|
|
data3.num = 40 / divisor;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
data3.async = do_async;
|
2011-10-10 15:49:50 +02:00
|
|
|
|
thread3 = g_thread_new ("sleep3",
|
|
|
|
|
test_sleep_in_thread_func,
|
2011-10-13 07:00:57 +02:00
|
|
|
|
&data3);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
g_thread_join (thread1);
|
|
|
|
|
g_thread_join (thread2);
|
|
|
|
|
g_thread_join (thread3);
|
|
|
|
|
|
2019-07-24 15:10:05 +02:00
|
|
|
|
end_time = g_get_real_time ();
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
2019-07-24 15:10:05 +02:00
|
|
|
|
elapsed_msec = (end_time - start_time) / 1000;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
//g_debug ("Elapsed time for %s = %d msec", n == 0 ? "async" : "sync", elapsed_msec);
|
|
|
|
|
|
2010-05-18 23:25:43 +02:00
|
|
|
|
/* elapsed_msec should be 4000 msec +/- change for overhead/inaccuracy */
|
2020-02-24 13:19:52 +01:00
|
|
|
|
g_assert_cmpint (elapsed_msec, >=, 3950 / divisor);
|
|
|
|
|
g_assert_cmpint (elapsed_msec, <, 30000 / divisor);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
2015-05-07 18:36:01 +02:00
|
|
|
|
if (g_test_verbose ())
|
2015-05-11 18:03:00 +02:00
|
|
|
|
g_printerr (" ");
|
2010-05-06 20:13:59 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
test_method_calls_in_thread (void)
|
|
|
|
|
{
|
2010-06-11 21:45:18 +02:00
|
|
|
|
GDBusProxy *proxy;
|
|
|
|
|
GDBusConnection *connection;
|
|
|
|
|
GError *error;
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
2010-06-11 21:45:18 +02:00
|
|
|
|
error = NULL;
|
|
|
|
|
connection = g_bus_get_sync (G_BUS_TYPE_SESSION,
|
|
|
|
|
NULL,
|
|
|
|
|
&error);
|
|
|
|
|
g_assert_no_error (error);
|
|
|
|
|
error = NULL;
|
|
|
|
|
proxy = g_dbus_proxy_new_sync (connection,
|
|
|
|
|
G_DBUS_PROXY_FLAGS_NONE,
|
|
|
|
|
NULL, /* GDBusInterfaceInfo */
|
|
|
|
|
"com.example.TestService", /* name */
|
|
|
|
|
"/com/example/TestObject", /* object path */
|
|
|
|
|
"com.example.Frob", /* interface */
|
|
|
|
|
NULL, /* GCancellable */
|
|
|
|
|
&error);
|
|
|
|
|
g_assert_no_error (error);
|
|
|
|
|
|
|
|
|
|
test_method_calls_on_proxy (proxy);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
2010-06-11 21:45:18 +02:00
|
|
|
|
g_object_unref (proxy);
|
|
|
|
|
g_object_unref (connection);
|
2013-11-10 19:26:01 +01:00
|
|
|
|
|
2015-05-07 18:36:01 +02:00
|
|
|
|
if (g_test_verbose ())
|
2015-05-11 18:03:00 +02:00
|
|
|
|
g_printerr ("\n");
|
2018-11-12 14:20:29 +01:00
|
|
|
|
|
2020-02-21 13:18:29 +01:00
|
|
|
|
assert_connection_has_one_ref (c, NULL);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
}
|
|
|
|
|
|
2011-12-07 16:04:59 +01:00
|
|
|
|
#define SLEEP_MIN_USEC 1
|
|
|
|
|
#define SLEEP_MAX_USEC 10
|
|
|
|
|
|
|
|
|
|
/* Can run in any thread */
|
|
|
|
|
static void
|
|
|
|
|
ensure_connection_works (GDBusConnection *conn)
|
|
|
|
|
{
|
|
|
|
|
GVariant *v;
|
|
|
|
|
GError *error = NULL;
|
|
|
|
|
|
|
|
|
|
v = g_dbus_connection_call_sync (conn, "org.freedesktop.DBus",
|
|
|
|
|
"/org/freedesktop/DBus", "org.freedesktop.DBus", "GetId", NULL, NULL, 0, -1,
|
|
|
|
|
NULL, &error);
|
|
|
|
|
g_assert_no_error (error);
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_nonnull (v);
|
|
|
|
|
g_assert_true (g_variant_is_of_type (v, G_VARIANT_TYPE ("(s)")));
|
2011-12-07 16:04:59 +01:00
|
|
|
|
g_variant_unref (v);
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-18 14:08:41 +02:00
|
|
|
|
/**
|
2011-12-07 16:04:59 +01:00
|
|
|
|
* get_sync_in_thread:
|
|
|
|
|
* @data: (type guint): delay in microseconds
|
|
|
|
|
*
|
|
|
|
|
* Sleep for a short time, then get a session bus connection and call
|
|
|
|
|
* a method on it.
|
|
|
|
|
*
|
|
|
|
|
* Runs in a non-main thread.
|
|
|
|
|
*
|
|
|
|
|
* Returns: (transfer full): the connection
|
|
|
|
|
*/
|
|
|
|
|
static gpointer
|
|
|
|
|
get_sync_in_thread (gpointer data)
|
|
|
|
|
{
|
|
|
|
|
guint delay = GPOINTER_TO_UINT (data);
|
|
|
|
|
GError *error = NULL;
|
|
|
|
|
GDBusConnection *conn;
|
|
|
|
|
|
|
|
|
|
g_usleep (delay);
|
|
|
|
|
|
|
|
|
|
conn = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
|
|
|
|
|
g_assert_no_error (error);
|
|
|
|
|
|
|
|
|
|
ensure_connection_works (conn);
|
|
|
|
|
|
|
|
|
|
return conn;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
test_threaded_singleton (void)
|
|
|
|
|
{
|
|
|
|
|
guint i, n;
|
|
|
|
|
guint unref_wins = 0;
|
|
|
|
|
guint get_wins = 0;
|
|
|
|
|
|
|
|
|
|
if (g_test_thorough ())
|
|
|
|
|
n = 100000;
|
|
|
|
|
else
|
2020-02-24 13:19:52 +01:00
|
|
|
|
n = 1000;
|
2011-12-07 16:04:59 +01:00
|
|
|
|
|
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
|
{
|
|
|
|
|
GThread *thread;
|
|
|
|
|
guint unref_delay, get_delay;
|
|
|
|
|
GDBusConnection *new_conn;
|
|
|
|
|
|
|
|
|
|
/* We want to be the last ref, so let it finish setting up */
|
2020-02-21 13:18:29 +01:00
|
|
|
|
assert_connection_has_one_ref (c, NULL);
|
2011-12-07 16:04:59 +01:00
|
|
|
|
|
|
|
|
|
if (g_test_verbose () && (i % (n/50)) == 0)
|
2015-05-11 18:03:00 +02:00
|
|
|
|
g_printerr ("%u%%\n", ((i * 100) / n));
|
2011-12-07 16:04:59 +01:00
|
|
|
|
|
|
|
|
|
/* Delay for a random time on each side of the race, to perturb the
|
|
|
|
|
* timing. Ideally, we want each side to win half the races; these
|
|
|
|
|
* timings are about right on smcv's laptop.
|
|
|
|
|
*/
|
|
|
|
|
unref_delay = g_random_int_range (SLEEP_MIN_USEC, SLEEP_MAX_USEC);
|
|
|
|
|
get_delay = g_random_int_range (SLEEP_MIN_USEC / 2, SLEEP_MAX_USEC / 2);
|
|
|
|
|
|
|
|
|
|
/* One half of the race is to call g_bus_get_sync... */
|
|
|
|
|
thread = g_thread_new ("get_sync_in_thread", get_sync_in_thread,
|
|
|
|
|
GUINT_TO_POINTER (get_delay));
|
|
|
|
|
|
|
|
|
|
/* ... and the other half is to unref the shared connection, which must
|
|
|
|
|
* have exactly one ref at this point
|
|
|
|
|
*/
|
|
|
|
|
g_usleep (unref_delay);
|
|
|
|
|
g_object_unref (c);
|
|
|
|
|
|
|
|
|
|
/* Wait for the thread to run; see what it got */
|
|
|
|
|
new_conn = g_thread_join (thread);
|
|
|
|
|
|
|
|
|
|
/* If the thread won the race, it will have kept the same connection,
|
|
|
|
|
* and it'll have one ref
|
|
|
|
|
*/
|
|
|
|
|
if (new_conn == c)
|
|
|
|
|
{
|
|
|
|
|
get_wins++;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
unref_wins++;
|
|
|
|
|
/* c is invalid now, but new_conn is suitable for the
|
|
|
|
|
* next round
|
|
|
|
|
*/
|
|
|
|
|
c = new_conn;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ensure_connection_works (c);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (g_test_verbose ())
|
2015-05-11 18:03:00 +02:00
|
|
|
|
g_printerr ("Unref won %u races; Get won %u races\n", unref_wins, get_wins);
|
2011-12-07 16:04:59 +01:00
|
|
|
|
}
|
|
|
|
|
|
2010-05-06 20:13:59 +02:00
|
|
|
|
/* ---------------------------------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
main (int argc,
|
|
|
|
|
char *argv[])
|
|
|
|
|
{
|
|
|
|
|
GError *error;
|
|
|
|
|
gint ret;
|
2013-05-20 14:46:21 +02:00
|
|
|
|
gchar *path;
|
|
|
|
|
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_test_init (&argc, &argv, NULL);
|
|
|
|
|
|
|
|
|
|
session_bus_up ();
|
|
|
|
|
|
|
|
|
|
/* this is safe; testserver will exit once the bus goes away */
|
2013-05-28 18:48:37 +02:00
|
|
|
|
path = g_test_build_filename (G_TEST_BUILT, "gdbus-testserver", NULL);
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_true (g_spawn_command_line_async (path, NULL));
|
2013-05-20 14:46:21 +02:00
|
|
|
|
g_free (path);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
/* Create the connection in the main thread */
|
|
|
|
|
error = NULL;
|
|
|
|
|
c = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
|
|
|
|
|
g_assert_no_error (error);
|
2018-11-12 13:51:16 +01:00
|
|
|
|
g_assert_nonnull (c);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
2020-02-20 12:49:12 +01:00
|
|
|
|
ensure_gdbus_testserver_up (c, NULL);
|
|
|
|
|
|
2010-05-06 20:13:59 +02:00
|
|
|
|
g_test_add_func ("/gdbus/delivery-in-thread", test_delivery_in_thread);
|
|
|
|
|
g_test_add_func ("/gdbus/method-calls-in-thread", test_method_calls_in_thread);
|
2011-12-07 16:04:59 +01:00
|
|
|
|
g_test_add_func ("/gdbus/threaded-singleton", test_threaded_singleton);
|
2010-05-06 20:13:59 +02:00
|
|
|
|
|
|
|
|
|
ret = g_test_run();
|
|
|
|
|
|
|
|
|
|
g_object_unref (c);
|
|
|
|
|
|
|
|
|
|
/* tear down bus */
|
|
|
|
|
session_bus_down ();
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|