/* test-dbus.c * * 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 version 2.1 of the * License, or (at your option) any later version. * * 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 General Public License along * with this program. If not, see . * * SPDX-License-Identifier: LGPL-2.1-or-later */ #include "config.h" #include #include #include "dex-fiber-private.h" #include "dex-test-dbus-foo.h" struct _DexTestFoo { DexTestDbusFooSkeleton parent_instance; }; struct _DexTestFooClass { DexTestDbusFooSkeletonClass parent_class; }; static void dex_test_dbus_foo_iface_init (DexTestDbusFooIface *iface); #define DEX_TEST_TYPE_FOO (dex_test_foo_get_type ()) G_DECLARE_FINAL_TYPE (DexTestFoo, dex_test_foo, DEX_TEST, FOO, DexTestDbusFooSkeleton) G_DEFINE_TYPE_WITH_CODE (DexTestFoo, dex_test_foo, DEX_TEST_DBUS_TYPE_FOO_SKELETON, G_IMPLEMENT_INTERFACE (DEX_TEST_DBUS_TYPE_FOO, dex_test_dbus_foo_iface_init)); static GDBusConnection * get_new_session_connection_sync (void) { GDBusConnection *connection; char *session_address; GError *error = NULL; session_address = g_dbus_address_get_for_bus_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (session_address); connection = g_dbus_connection_new_for_address_sync (session_address, G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, NULL, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); g_free (session_address); return connection; } static gboolean handle_foo (DexTestDbusFoo *object, GDBusMethodInvocation *invocation) { g_usleep (G_USEC_PER_SEC / 10); dex_test_dbus_foo_complete_foo (object, invocation); return G_DBUS_METHOD_INVOCATION_HANDLED; } static gboolean handle_bar (DexTestDbusFoo *object, GDBusMethodInvocation *invocation, const char * const *i1, uint32_t i2) { GVariantBuilder builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); g_usleep (G_USEC_PER_SEC / 10); g_variant_builder_add (&builder, "{sv}", "foo", g_variant_new_uint32 (3)); g_variant_builder_add (&builder, "{sv}", "bar", g_variant_new_boolean (FALSE)); dex_test_dbus_foo_complete_bar (object, invocation, 42, g_variant_builder_end (&builder)); return G_DBUS_METHOD_INVOCATION_HANDLED; } static gboolean handle_emit_foo_bar (DexTestDbusFoo *object, GDBusMethodInvocation *invocation) { dex_test_dbus_foo_emit_foo_bar (object); dex_test_dbus_foo_complete_emit_foo_bar (object, invocation); return G_DBUS_METHOD_INVOCATION_HANDLED; } static gboolean handle_fiber (DexTestDbusFoo *object, GDBusMethodInvocation *invocation) { dex_await (dex_timeout_new_msec (100), NULL); dex_test_dbus_foo_complete_fiber (object, invocation); return G_DBUS_METHOD_INVOCATION_HANDLED; } static void dex_test_dbus_foo_iface_init (DexTestDbusFooIface *iface) { iface->handle_foo = handle_foo; iface->handle_bar = handle_bar; iface->handle_emit_foo_bar = handle_emit_foo_bar; iface->handle_fiber = handle_fiber; } static void dex_test_foo_init (DexTestFoo *foo G_GNUC_UNUSED) { } static void dex_test_foo_class_init (DexTestFooClass *klass G_GNUC_UNUSED) { } typedef struct _FooServiceData { GMainLoop *main_loop; DexTestFoo *foo; guint own_name_id; guint timeout_id; gboolean acquired; } FooServiceData; static gboolean send_signal_cb (gpointer user_data) { FooServiceData *data = user_data; GVariantBuilder builder = G_VARIANT_BUILDER_INIT (G_VARIANT_TYPE_VARDICT); g_variant_builder_add (&builder, "{sv}", "foo", g_variant_new_uint32 (3)); g_variant_builder_add (&builder, "{sv}", "bar", g_variant_new_boolean (FALSE)); dex_test_dbus_foo_emit_baz (DEX_TEST_DBUS_FOO (data->foo), 11, g_variant_builder_end (&builder)); return G_SOURCE_CONTINUE; } static void bus_name_acquired_cb (GDBusConnection *connection, const gchar *name, gpointer user_data) { FooServiceData *data = user_data; DexTestFoo *foo = data->foo; GError *error = NULL; g_assert_true (g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (foo), connection, "/org/example/foo", &error)); g_assert_no_error (error); data->timeout_id = g_timeout_add (100, send_signal_cb, data); data->acquired = TRUE; } static void bus_name_lost_cb (GDBusConnection *connection, const gchar *name, gpointer user_data) { FooServiceData *data = user_data; g_main_loop_quit (data->main_loop); } static void foo_service_cancelled_cb (GCancellable *cancellable, gpointer user_data) { FooServiceData *data = user_data; g_clear_handle_id (&data->own_name_id, g_bus_unown_name); g_main_loop_quit (data->main_loop); } static void run_foo_service_in_thread (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { FooServiceData data; GMainLoop *main_loop; GMainContext *main_context; GDBusConnection *connection; DexTestFoo *foo; GError *error = NULL; main_context = g_main_context_new (); main_loop = g_main_loop_new (main_context, FALSE); g_assert_nonnull (main_loop); foo = g_object_new (DEX_TEST_TYPE_FOO, NULL); g_assert_nonnull (foo); data.main_loop = main_loop; data.foo = foo; data.acquired = FALSE; data.own_name_id = 0; data.timeout_id = 0; connection = get_new_session_connection_sync (); g_assert_no_error (error); g_assert_nonnull (connection); data.own_name_id = g_bus_own_name_on_connection (connection, "org.example.Foo", G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE, bus_name_acquired_cb, bus_name_lost_cb, &data, NULL); g_cancellable_connect (cancellable, G_CALLBACK (foo_service_cancelled_cb), &data, NULL); if (!g_cancellable_is_cancelled (cancellable)) g_main_loop_run (main_loop); if (data.acquired) g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (data.foo)); g_clear_handle_id (&data.timeout_id, g_source_remove); g_main_loop_unref (main_loop); g_main_context_unref (main_context); g_clear_object (&foo); g_clear_object (&connection); g_task_return_boolean (task, TRUE); } static void run_foo_service_cancelled_cb (GObject *source_object, GAsyncResult *res, gpointer data) { GTask *task = G_TASK (res); GCancellable *cancellable; cancellable = g_task_get_task_data (task); g_task_set_task_data (task, NULL, NULL); g_clear_object (&cancellable); } static GTask * run_foo_service (void) { GTask *task = NULL; GCancellable *cancellable = g_cancellable_new (); task = g_task_new (NULL, cancellable, run_foo_service_cancelled_cb, NULL); g_task_set_task_data (task, cancellable, NULL); g_task_run_in_thread (task, run_foo_service_in_thread); return task; } static void stop_foo_service (GTask *task) { GCancellable *cancellable; cancellable = g_task_get_task_data (task); g_cancellable_cancel (cancellable); while (g_task_get_task_data (task) != NULL) g_main_context_iteration (NULL, TRUE); g_clear_object (&task); } static void test_gdbus_proxy_create (void) { GDBusConnection *connection; DexFuture *future; const GValue *value; DexTestDbusFoo *proxy; GError *error = NULL; connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); future = dex_test_dbus_foo_proxy_new_future (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo"); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_no_error (error); g_assert_nonnull (value); g_assert_true (G_VALUE_HOLDS_OBJECT (value)); proxy = g_value_get_object (value); g_assert_true (DEX_TEST_DBUS_IS_FOO (proxy)); g_clear_error (&error); dex_clear (&future); g_clear_object (&connection); } static void test_gdbus_method_call_simple (void) { GDBusConnection *connection; DexFuture *future; const GValue *value; DexTestDbusFoo *proxy; GError *error = NULL; connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_test_dbus_foo_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo", NULL, &error); g_assert_no_error (error); g_assert_nonnull (proxy); future = dex_test_dbus_foo_call_foo_future (proxy); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_error (error, G_DBUS_ERROR, G_DBUS_ERROR_SERVICE_UNKNOWN); g_assert_null (value); g_clear_error (&error); dex_clear (&future); g_clear_object (&proxy); g_clear_object (&connection); } static void test_gdbus_method_call_result (void) { GDBusConnection *connection; DexFuture *future; const GValue *value; DexTestDbusFoo *proxy; GTask *foo_service; GError *error = NULL; char *name; foo_service = run_foo_service (); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_test_dbus_foo_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo", NULL, &error); g_assert_no_error (error); g_assert_nonnull (proxy); while (!(name = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy)))) g_main_context_iteration (NULL, TRUE); g_free (name); future = dex_test_dbus_foo_call_foo_future (proxy); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_no_error (error); g_assert_nonnull (value); g_assert_true (G_VALUE_HOLDS_BOOLEAN (value)); g_assert_true (g_value_get_boolean (value)); g_clear_error (&error); dex_clear (&future); g_clear_object (&proxy); g_clear_object (&connection); stop_foo_service (foo_service); } static void test_gdbus_method_call_cancel (void) { GDBusConnection *connection; DexFuture *future; DexPromise *promise; const GValue *value; DexTestDbusFoo *proxy; GTask *foo_service; GError *error = NULL; char *name; foo_service = run_foo_service (); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_test_dbus_foo_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo", NULL, &error); g_assert_no_error (error); g_assert_nonnull (proxy); while (!(name = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy)))) g_main_context_iteration (NULL, TRUE); g_free (name); promise = dex_promise_new (); future = dex_future_first (DEX_FUTURE (promise), dex_test_dbus_foo_call_foo_future (proxy), NULL); dex_promise_reject (promise, g_error_new_literal (G_IO_ERROR, G_IO_ERROR_CANCELLED, "Cancelled")); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED); g_assert_null (value); g_clear_error (&error); dex_clear (&future); g_clear_object (&proxy); g_clear_object (&connection); stop_foo_service (foo_service); } static void test_gdbus_method_call_complex (void) { GTask *foo_service; GDBusConnection *connection; DexTestDbusFoo *proxy; DexFuture *future; const GValue *value; DexTestDbusFooBarResult *result; GError *error = NULL; char *name; foo_service = run_foo_service (); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_test_dbus_foo_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo", NULL, &error); g_assert_no_error (error); g_assert_nonnull (proxy); while (!(name = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy)))) g_main_context_iteration (NULL, TRUE); g_free (name); future = dex_test_dbus_foo_call_bar_future (proxy, (const gchar * []) { "foo", "bar", NULL, }, 42); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_no_error (error); g_assert_nonnull (value); g_assert_true (G_VALUE_HOLDS_BOXED (value)); result = g_value_get_boxed (value); { uint32_t foo; gboolean bar; g_assert_nonnull (result); g_assert_cmpint (result->o1, == , 42); g_assert_nonnull (result->o2); g_assert_true (g_variant_lookup (result->o2, "foo", "u", &foo)); g_assert_cmpint (foo, == , 3); g_assert_true (g_variant_lookup (result->o2, "bar", "b", &bar)); g_assert_true (!bar); } g_clear_error (&error); dex_clear (&future); g_clear_object (&proxy); g_clear_object (&connection); stop_foo_service (foo_service); } static void test_gdbus_signal_wait_simple (void) { GTask *foo_service; GDBusConnection *connection; DexTestDbusFoo *proxy; DexFuture *future; const GValue *value; DexTestDbusFooBazSignal *result; GError *error = NULL; char *name; foo_service = run_foo_service (); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_test_dbus_foo_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo", NULL, &error); g_assert_no_error (error); g_assert_nonnull (proxy); while (!(name = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy)))) g_main_context_iteration (NULL, TRUE); g_free (name); future = dex_test_dbus_foo_wait_baz_future (proxy); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_no_error (error); g_assert_nonnull (value); g_assert_true (G_VALUE_HOLDS_BOXED (value)); result = g_value_get_boxed (value); { uint32_t foo; gboolean bar; g_assert_nonnull (result); g_assert_cmpint (result->s1, == , 11); g_assert_nonnull (result->s2); g_assert_true (g_variant_lookup (result->s2, "foo", "u", &foo)); g_assert_cmpint (foo, == , 3); g_assert_true (g_variant_lookup (result->s2, "bar", "b", &bar)); g_assert_true (!bar); } g_clear_error (&error); dex_clear (&future); g_clear_object (&proxy); g_clear_object (&connection); stop_foo_service (foo_service); } static void test_gdbus_signal_wait_cancel (void) { GTask *foo_service; GDBusConnection *connection; DexTestDbusFoo *proxy; DexPromise *promise; DexFuture *future; const GValue *value; GError *error = NULL; char *name; foo_service = run_foo_service (); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_test_dbus_foo_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo", NULL, &error); g_assert_no_error (error); g_assert_nonnull (proxy); while (!(name = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy)))) g_main_context_iteration (NULL, TRUE); g_free (name); promise = dex_promise_new (); future = dex_future_first (DEX_FUTURE (promise), dex_test_dbus_foo_wait_baz_future (proxy), NULL); dex_promise_reject (promise, g_error_new_literal (G_IO_ERROR, G_IO_ERROR_CANCELLED, "Cancelled")); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED); g_assert_null (value); g_clear_error (&error); dex_clear (&future); g_clear_object (&proxy); g_clear_object (&connection); stop_foo_service (foo_service); } static void test_gdbus_signal_monitor_basic (void) { GTask *foo_service; GDBusConnection *connection; DexTestDbusFoo *proxy; DexFuture *future; const GValue *value; DexTestDbusFooSignalMonitor *signal_monitor; GError *error = NULL; char *name; foo_service = run_foo_service (); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_test_dbus_foo_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo", NULL, &error); g_assert_no_error (error); g_assert_nonnull (proxy); while (!(name = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy)))) g_main_context_iteration (NULL, TRUE); g_free (name); signal_monitor = dex_test_dbus_foo_signal_monitor_new (proxy, DEX_TEST_DBUS_FOO_SIGNAL_FOO_BAR); future = dex_test_dbus_foo_call_emit_foo_bar_future (proxy); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); dex_clear (&future); future = dex_test_dbus_foo_signal_monitor_next_foo_bar (signal_monitor); g_assert_true (dex_future_get_status (future) == DEX_FUTURE_STATUS_RESOLVED); value = dex_future_get_value (future, &error); g_assert_no_error (error); g_assert_nonnull (value); g_assert_true (G_VALUE_HOLDS_BOOLEAN (value)); g_assert_true (g_value_get_boolean (value)); dex_clear (&future); future = dex_test_dbus_foo_signal_monitor_next_foo_bar (signal_monitor); g_assert_true (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING); g_clear_error (&error); dex_clear (&future); g_clear_object (&signal_monitor); g_clear_object (&proxy); g_clear_object (&connection); stop_foo_service (foo_service); } static void test_gdbus_signal_monitor_cancel (void) { GTask *foo_service; GDBusConnection *connection; DexTestDbusFoo *proxy; DexFuture *future; DexPromise *promise; const GValue *value; DexTestDbusFooSignalMonitor *signal_monitor; GError *error = NULL; char *name; foo_service = run_foo_service (); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_test_dbus_foo_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo", NULL, &error); g_assert_no_error (error); g_assert_nonnull (proxy); while (!(name = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy)))) g_main_context_iteration (NULL, TRUE); g_free (name); signal_monitor = dex_test_dbus_foo_signal_monitor_new (proxy, DEX_TEST_DBUS_FOO_SIGNAL_FOO_BAR); promise = dex_promise_new (); future = dex_future_first (DEX_FUTURE (promise), dex_test_dbus_foo_signal_monitor_next_foo_bar (signal_monitor), NULL); dex_promise_reject (promise, g_error_new_literal (G_IO_ERROR, G_IO_ERROR_CANCELLED, "Cancelled")); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED); g_assert_null (value); g_clear_error (&error); dex_clear (&future); g_clear_object (&signal_monitor); g_clear_object (&proxy); g_clear_object (&connection); stop_foo_service (foo_service); } static DexFuture * fiber_basic (gpointer user_data) { GDBusConnection *connection = NULL; DexTestDbusFoo *proxy = NULL; GError *error = NULL; connection = dex_await_object (dex_bus_get (G_BUS_TYPE_SESSION), &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_await_object (dex_test_dbus_foo_proxy_new_future (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo"), &error); g_assert_no_error (error); g_assert_nonnull (proxy); { gboolean foo_result; foo_result = dex_await_boolean (dex_test_dbus_foo_call_foo_future (proxy), &error); g_assert_no_error (error); g_assert_true (foo_result); } { DexTestDbusFooBazSignal *baz_result; uint32_t foo; gboolean bar; baz_result = dex_await_boxed (dex_test_dbus_foo_wait_baz_future (proxy), &error); g_assert_no_error (error); g_assert_nonnull (baz_result); g_assert_cmpint (baz_result->s1, == , 11); g_assert_nonnull (baz_result->s2); g_assert_true (g_variant_lookup (baz_result->s2, "foo", "u", &foo)); g_assert_cmpint (foo, == , 3); g_assert_true (g_variant_lookup (baz_result->s2, "bar", "b", &bar)); g_assert_true (!bar); g_clear_pointer (&baz_result, dex_test_dbus_foo_baz_signal_free); } { DexTestDbusFooSignalMonitor *signal_monitor; gboolean result; signal_monitor = dex_test_dbus_foo_signal_monitor_new (proxy, DEX_TEST_DBUS_FOO_SIGNAL_FOO_BAR); result = dex_await_boolean (dex_test_dbus_foo_call_emit_foo_bar_future (proxy), &error); g_assert_no_error (error); g_assert_true (result); result = dex_await_boolean (dex_test_dbus_foo_signal_monitor_next_foo_bar (signal_monitor), &error); g_assert_no_error (error); g_assert_true (result); g_clear_object (&signal_monitor); } return dex_future_new_true (); } static void test_gdbus_fiber_basic (void) { GTask *foo_service; DexFuture *future; const GValue *value; GError *error = NULL; foo_service = run_foo_service (); future = dex_scheduler_spawn (NULL, 0, fiber_basic, NULL, NULL); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_no_error (error); g_assert_nonnull (value); g_assert_true (G_VALUE_HOLDS_BOOLEAN (value)); g_assert_true (g_value_get_boolean (value)); g_clear_error (&error); dex_clear (&future); stop_foo_service (foo_service); } static DexFuture * fiber_service (gpointer user_data) { GDBusConnection *connection = NULL; DexTestFoo *foo = NULL; DexFuture *name_acquired = NULL; DexFuture *name_lost = NULL; GError *error = NULL; connection = dex_await_object (dex_bus_get (G_BUS_TYPE_SESSION), &error); g_assert_no_error (error); g_assert_nonnull (connection); dex_bus_own_name_on_connection (connection, "org.example.Foo", G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT | G_BUS_NAME_OWNER_FLAGS_REPLACE, &name_acquired, &name_lost); dex_await (g_steal_pointer (&name_acquired), &error); g_assert_no_error (error); foo = g_object_new (DEX_TEST_TYPE_FOO, NULL); dex_dbus_interface_skeleton_set_flags (DEX_DBUS_INTERFACE_SKELETON (foo), DEX_DBUS_INTERFACE_SKELETON_FLAGS_HANDLE_METHOD_INVOCATIONS_IN_FIBER); g_assert_true (g_dbus_interface_skeleton_export (G_DBUS_INTERFACE_SKELETON (foo), connection, "/org/example/foo", &error)); g_assert_no_error (error); dex_await (g_steal_pointer (&name_lost), &error); g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED); g_dbus_interface_skeleton_unexport (G_DBUS_INTERFACE_SKELETON (foo)); dex_dbus_interface_skeleton_cancel (DEX_DBUS_INTERFACE_SKELETON (foo)); return dex_future_new_true (); } static void call_fiber_cb (GObject *source_object, GAsyncResult *res, gpointer data) { gboolean *done = data; GError *error = NULL; g_assert_true (dex_test_dbus_foo_call_fiber_finish (DEX_TEST_DBUS_FOO (source_object), res, &error)); g_assert_no_error (error); *done = TRUE; } static void test_gdbus_fiber_service (void) { GTask *foo_service; GDBusConnection *connection; DexTestDbusFoo *proxy; DexFuture *future; const GValue *value; GError *error = NULL; char *name; future = dex_scheduler_spawn (NULL, 0, fiber_service, NULL, NULL); connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert_nonnull (connection); proxy = dex_test_dbus_foo_proxy_new_sync (connection, G_DBUS_PROXY_FLAGS_NONE, "org.example.Foo", "/org/example/foo", NULL, &error); g_assert_no_error (error); g_assert_nonnull (proxy); while (!(name = g_dbus_proxy_get_name_owner (G_DBUS_PROXY (proxy)))) g_main_context_iteration (NULL, TRUE); g_free (name); { gboolean done = FALSE; dex_test_dbus_foo_call_fiber (proxy, NULL, call_fiber_cb, &done); while (!done) g_main_context_iteration (NULL, TRUE); } /* kick the fiber service off the bus */ foo_service = run_foo_service (); while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING) g_main_context_iteration (NULL, TRUE); value = dex_future_get_value (future, &error); g_assert_no_error (error); g_assert_nonnull (value); g_assert_true (G_VALUE_HOLDS_BOOLEAN (value)); g_assert_true (g_value_get_boolean (value)); g_clear_error (&error); dex_clear (&future); stop_foo_service (foo_service); } int main (int argc, char *argv[]) { dex_init (); g_test_init (&argc, &argv, NULL); g_test_add_func ("/Dex/TestSuite/GDBus/proxy/create", test_gdbus_proxy_create); g_test_add_func ("/Dex/TestSuite/GDBus/method_call/simple", test_gdbus_method_call_simple); g_test_add_func ("/Dex/TestSuite/GDBus/method_call/result", test_gdbus_method_call_result); g_test_add_func ("/Dex/TestSuite/GDBus/method_call/cancel", test_gdbus_method_call_cancel); g_test_add_func ("/Dex/TestSuite/GDBus/method_call/complex", test_gdbus_method_call_complex); g_test_add_func ("/Dex/TestSuite/GDBus/signal_wait/simple", test_gdbus_signal_wait_simple); g_test_add_func ("/Dex/TestSuite/GDBus/signal_wait/cancel", test_gdbus_signal_wait_cancel); g_test_add_func ("/Dex/TestSuite/GDBus/signal_monitor/basic", test_gdbus_signal_monitor_basic); g_test_add_func ("/Dex/TestSuite/GDBus/signal_monitor/cancel", test_gdbus_signal_monitor_cancel); g_test_add_func ("/Dex/TestSuite/GDBus/fiber/basic", test_gdbus_fiber_basic); g_test_add_func ("/Dex/TestSuite/GDBus/fiber/service", test_gdbus_fiber_service); return g_test_run (); }