luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-10 03:16:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

tests: Fix non-atomic access to some shared variables

Browse Source 
And drop the `volatile` qualifier from the variables, as that doesn’t
help with thread safety.

Signed-off-by: Philip Withnall <pwithnall@endlessos.org>

Helps: #600
This commit is contained in:
Philip Withnall 2020-11-11 18:21:00 +00:00
parent 3dda662beb
commit 7f905ff1fa
5 changed files with 111 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gio/tests/gdbus-connection-flush.c
View File

@ -43,9 +43,9 @@ G_LOCK_DEFINE_STATIC (write);
typedef struct {
GFilterOutputStream parent;
volatile gint started;
volatile gint finished;
volatile gint flushed;
gint started; /* (atomic) */
gint finished; /* (atomic) */
gint flushed; /* (atomic) */
GOutputStream *real_output;
} MyOutputStream;

40
gio/tests/gdbus-connection.c
View File

@ -61,9 +61,9 @@ _log (const gchar *format, ...)
static gboolean
test_connection_quit_mainloop (gpointer user_data)
{
volatile gboolean *quit_mainloop_fired = user_data;
gboolean *quit_mainloop_fired = user_data; /* (atomic) */
_log ("quit_mainloop_fired");
*quit_mainloop_fired = TRUE;
g_atomic_int_set (quit_mainloop_fired, TRUE);
g_main_loop_quit (loop);
return G_SOURCE_CONTINUE;
}
@ -113,8 +113,8 @@ on_name_owner_changed (GDBusConnection *connection,
static void
a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop (gpointer user_data)
{
volatile gboolean *val = user_data;
*val = TRUE;
gboolean *val = user_data; /* (atomic) */
g_atomic_int_set (val, TRUE);
_log ("destroynotify fired for %p", val);
g_main_loop_quit (loop);
}
@ -143,10 +143,10 @@ test_connection_life_cycle (void)
GDBusConnection *c;
GDBusConnection *c2;
GError *error;
volatile gboolean on_signal_registration_freed_called;
volatile gboolean on_filter_freed_called;
volatile gboolean on_register_object_freed_called;
volatile gboolean quit_mainloop_fired;
gboolean on_signal_registration_freed_called; /* (atomic) */
gboolean on_filter_freed_called; /* (atomic) */
gboolean on_register_object_freed_called; /* (atomic) */
gboolean quit_mainloop_fired; /* (atomic) */
guint quit_mainloop_id;
guint registration_id;
@ -208,7 +208,7 @@ test_connection_life_cycle (void)
g_assert_no_error (error);
g_assert_nonnull (c2);
/* signal registration */
on_signal_registration_freed_called = FALSE;
g_atomic_int_set (&on_signal_registration_freed_called, FALSE);
g_dbus_connection_signal_subscribe (c2,
"org.freedesktop.DBus", /* bus name */
"org.freedesktop.DBus", /* interface */
@ -220,13 +220,13 @@ test_connection_life_cycle (void)
(gpointer) &on_signal_registration_freed_called,
a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop);
/* filter func */
on_filter_freed_called = FALSE;
g_atomic_int_set (&on_filter_freed_called, FALSE);
g_dbus_connection_add_filter (c2,
some_filter_func,
(gpointer) &on_filter_freed_called,
a_gdestroynotify_that_sets_a_gboolean_to_true_and_quits_loop);
/* object registration */
on_register_object_freed_called = FALSE;
g_atomic_int_set (&on_register_object_freed_called, FALSE);
error = NULL;
registration_id = g_dbus_connection_register_object (c2,
"/foo",
@ -239,7 +239,7 @@ test_connection_life_cycle (void)
g_assert_cmpuint (registration_id, >, 0);
/* ok, finalize the connection and check that all the GDestroyNotify functions are invoked as expected */
g_object_unref (c2);
quit_mainloop_fired = FALSE;
g_atomic_int_set (&quit_mainloop_fired, FALSE);
quit_mainloop_id = g_timeout_add (30000, test_connection_quit_mainloop, (gpointer) &quit_mainloop_fired);
_log ("destroynotifies for\n"
" register_object %p\n"
@ -250,21 +250,21 @@ test_connection_life_cycle (void)
&on_signal_registration_freed_called);
while (TRUE)
{
if (on_signal_registration_freed_called &&
on_filter_freed_called &&
on_register_object_freed_called)
if (g_atomic_int_get (&on_signal_registration_freed_called) &&
g_atomic_int_get (&on_filter_freed_called) &&
g_atomic_int_get (&on_register_object_freed_called))
break;
if (quit_mainloop_fired)
if (g_atomic_int_get (&quit_mainloop_fired))
break;
_log ("entering loop");
g_main_loop_run (loop);
_log ("exiting loop");
}
g_source_remove (quit_mainloop_id);
g_assert_true (on_signal_registration_freed_called);
g_assert_true (on_filter_freed_called);
g_assert_true (on_register_object_freed_called);
g_assert_false (quit_mainloop_fired);
g_assert_true (g_atomic_int_get (&on_signal_registration_freed_called));
g_assert_true (g_atomic_int_get (&on_filter_freed_called));
g_assert_true (g_atomic_int_get (&on_register_object_freed_called));
g_assert_false (g_atomic_int_get (&quit_mainloop_fired));
/*
* Check for correct behavior when the bus goes away

20
gio/tests/gdbus-overflow.c
View File

@ -86,8 +86,8 @@ overflow_filter_func (GDBusConnection *connection,
gboolean incoming,
gpointer user_data)
{
volatile gint *counter = user_data;
*counter += 1;
gint *counter = user_data; /* (atomic) */
g_atomic_int_inc (counter);
return message;
}
@ -108,8 +108,8 @@ test_overflow (void)
GDBusConnection *producer, *consumer;
GError *error;
GTimer *timer;
volatile gint n_messages_received;
volatile gint n_messages_sent;
gint n_messages_received; /* (atomic) */
gint n_messages_sent; /* (atomic) */
g_assert_cmpint (socketpair (AF_UNIX, SOCK_STREAM, 0, sv), ==, 0);
@ -129,7 +129,7 @@ test_overflow (void)
g_dbus_connection_set_exit_on_close (producer, TRUE);
g_assert_no_error (error);
g_object_unref (socket_connection);
n_messages_sent = 0;
g_atomic_int_set (&n_messages_sent, 0);
g_dbus_connection_add_filter (producer, overflow_filter_func, (gpointer) &n_messages_sent, NULL);
/* send enough data that we get an EAGAIN */
@ -155,7 +155,7 @@ test_overflow (void)
*/
g_timeout_add (500, overflow_on_500ms_later_func, NULL);
g_main_loop_run (loop);
g_assert_cmpint (n_messages_sent, <, OVERFLOW_NUM_SIGNALS);
g_assert_cmpint (g_atomic_int_get (&n_messages_sent), <, OVERFLOW_NUM_SIGNALS);
/* now suck it all out as a client, and add it up */
socket = g_socket_new_from_fd (sv[1], &error);
@ -171,18 +171,18 @@ test_overflow (void)
&error);
g_assert_no_error (error);
g_object_unref (socket_connection);
n_messages_received = 0;
g_atomic_int_set (&n_messages_received, 0);
g_dbus_connection_add_filter (consumer, overflow_filter_func, (gpointer) &n_messages_received, NULL);
g_dbus_connection_start_message_processing (consumer);
timer = g_timer_new ();
g_timer_start (timer);
while (n_messages_received < OVERFLOW_NUM_SIGNALS && g_timer_elapsed (timer, NULL) < OVERFLOW_TIMEOUT_SEC)
while (g_atomic_int_get (&n_messages_received) < OVERFLOW_NUM_SIGNALS && g_timer_elapsed (timer, NULL) < OVERFLOW_TIMEOUT_SEC)
g_main_context_iteration (NULL, FALSE);
g_assert_cmpint (n_messages_sent, ==, OVERFLOW_NUM_SIGNALS);
g_assert_cmpint (n_messages_received, ==, OVERFLOW_NUM_SIGNALS);
g_assert_cmpint (g_atomic_int_get (&n_messages_sent), ==, OVERFLOW_NUM_SIGNALS);
g_assert_cmpint (g_atomic_int_get (&n_messages_received), ==, OVERFLOW_NUM_SIGNALS);
g_timer_destroy (timer);
g_object_unref (consumer);

6
gio/tests/socket-service.c
View File

@ -99,7 +99,7 @@ test_start_stop (void)
GMutex mutex_712570;
GCond cond_712570;
volatile gboolean finalized;
gboolean finalized; /* (atomic) */
GType test_threaded_socket_service_get_type (void);
typedef GThreadedSocketService TestThreadedSocketService;
@ -120,7 +120,7 @@ test_threaded_socket_service_finalize (GObject *object)
/* Signal the main thread that finalization completed successfully
* rather than hanging.
*/
finalized = TRUE;
g_atomic_int_set (&finalized, TRUE);
g_cond_signal (&cond_712570);
g_mutex_unlock (&mutex_712570);
}
@ -235,7 +235,7 @@ test_threaded_712570 (void)
*/
g_object_unref (service);
while (!finalized)
while (!g_atomic_int_get (&finalized))
g_cond_wait (&cond_712570, &mutex_712570);
g_mutex_unlock (&mutex_712570);
}

150
gio/tests/task.c
View File

@ -957,7 +957,7 @@ task_weak_notify (gpointer user_data,
gboolean *weak_notify_ran = user_data;
g_mutex_lock (&run_in_thread_mutex);
*weak_notify_ran = TRUE;
g_atomic_int_set (weak_notify_ran, TRUE);
g_cond_signal (&run_in_thread_cond);
g_mutex_unlock (&run_in_thread_mutex);
}
@ -1007,7 +1007,7 @@ run_in_thread_thread (GTask *task,
g_assert (g_thread_self () != main_thread);
g_mutex_lock (&run_in_thread_mutex);
*thread_ran = TRUE;
g_atomic_int_set (thread_ran, TRUE);
g_cond_signal (&run_in_thread_cond);
g_mutex_unlock (&run_in_thread_mutex);
@ -1018,8 +1018,8 @@ static void
test_run_in_thread (void)
{
GTask *task;
volatile gboolean thread_ran = FALSE;
volatile gboolean weak_notify_ran = FALSE;
gboolean thread_ran = FALSE; /* (atomic) */
gboolean weak_notify_ran = FALSE; /* (atomic) */
gboolean notification_emitted = FALSE;
gboolean done = FALSE;
@ -1033,12 +1033,12 @@ test_run_in_thread (void)
g_task_run_in_thread (task, run_in_thread_thread);
g_mutex_lock (&run_in_thread_mutex);
while (!thread_ran)
while (!g_atomic_int_get (&thread_ran))
g_cond_wait (&run_in_thread_cond, &run_in_thread_mutex);
g_mutex_unlock (&run_in_thread_mutex);
g_assert (done == FALSE);
g_assert (weak_notify_ran == FALSE);
g_assert_false (g_atomic_int_get (&weak_notify_ran));
g_main_loop_run (loop);
@ -1050,7 +1050,7 @@ test_run_in_thread (void)
g_object_unref (task);
g_mutex_lock (&run_in_thread_mutex);
while (!weak_notify_ran)
while (!g_atomic_int_get (&weak_notify_ran))
g_cond_wait (&run_in_thread_cond, &run_in_thread_mutex);
g_mutex_unlock (&run_in_thread_mutex);
}
@ -1081,7 +1081,7 @@ run_in_thread_sync_thread (GTask *task,
g_assert (g_thread_self () != main_thread);
*thread_ran = TRUE;
g_atomic_int_set (thread_ran, TRUE);
g_task_return_int (task, magic);
}
@ -1102,7 +1102,7 @@ test_run_in_thread_sync (void)
g_task_set_task_data (task, &thread_ran, NULL);
g_task_run_in_thread_sync (task, run_in_thread_sync_thread);
g_assert (thread_ran == TRUE);
g_assert_true (g_atomic_int_get (&thread_ran));
g_assert (task != NULL);
g_assert (!g_task_had_error (task));
g_assert_true (g_task_get_completed (task));
@ -1487,8 +1487,8 @@ test_return_on_cancel (void)
{
GTask *task;
GCancellable *cancellable;
volatile ThreadState thread_state;
volatile gboolean weak_notify_ran = FALSE;
ThreadState thread_state; /* (atomic) */
gboolean weak_notify_ran = FALSE; /* (atomic) */
gboolean callback_ran;
gboolean notification_emitted = FALSE;
@ -1498,7 +1498,7 @@ test_return_on_cancel (void)
* early.
*/
callback_ran = FALSE;
thread_state = THREAD_STARTING;
g_atomic_int_set (&thread_state, THREAD_STARTING);
task = g_task_new (NULL, cancellable, return_on_cancel_callback, &callback_ran);
g_signal_connect (task, "notify::completed",
(GCallback) completed_cb, &notification_emitted);
@ -1509,18 +1509,18 @@ test_return_on_cancel (void)
g_task_run_in_thread (task, return_on_cancel_thread);
g_object_unref (task);
while (thread_state == THREAD_STARTING)
while (g_atomic_int_get (&thread_state) == THREAD_STARTING)
g_cond_wait (&roc_init_cond, &roc_init_mutex);
g_mutex_unlock (&roc_init_mutex);
g_assert (thread_state == THREAD_RUNNING);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_RUNNING);
g_assert (callback_ran == FALSE);
g_cancellable_cancel (cancellable);
g_mutex_unlock (&roc_finish_mutex);
g_main_loop_run (loop);
g_assert (thread_state == THREAD_COMPLETED);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_COMPLETED);
g_assert (callback_ran == TRUE);
g_assert_true (notification_emitted);
@ -1529,7 +1529,7 @@ test_return_on_cancel (void)
/* If return-on-cancel is TRUE, it does return early */
callback_ran = FALSE;
notification_emitted = FALSE;
thread_state = THREAD_STARTING;
g_atomic_int_set (&thread_state, THREAD_STARTING);
task = g_task_new (NULL, cancellable, return_on_cancel_callback, &callback_ran);
g_object_weak_ref (G_OBJECT (task), task_weak_notify, (gpointer)&weak_notify_ran);
g_signal_connect (task, "notify::completed",
@ -1542,27 +1542,27 @@ test_return_on_cancel (void)
g_task_run_in_thread (task, return_on_cancel_thread);
g_object_unref (task);
while (thread_state == THREAD_STARTING)
while (g_atomic_int_get (&thread_state) == THREAD_STARTING)
g_cond_wait (&roc_init_cond, &roc_init_mutex);
g_mutex_unlock (&roc_init_mutex);
g_assert (thread_state == THREAD_RUNNING);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_RUNNING);
g_assert (callback_ran == FALSE);
g_cancellable_cancel (cancellable);
g_main_loop_run (loop);
g_assert (thread_state == THREAD_RUNNING);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_RUNNING);
g_assert (callback_ran == TRUE);
g_assert (weak_notify_ran == FALSE);
g_assert_false (g_atomic_int_get (&weak_notify_ran));
while (thread_state == THREAD_RUNNING)
while (g_atomic_int_get (&thread_state) == THREAD_RUNNING)
g_cond_wait (&roc_finish_cond, &roc_finish_mutex);
g_mutex_unlock (&roc_finish_mutex);
g_assert (thread_state == THREAD_CANCELLED);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_CANCELLED);
g_mutex_lock (&run_in_thread_mutex);
while (!weak_notify_ran)
while (!g_atomic_int_get (&weak_notify_ran))
g_cond_wait (&run_in_thread_cond, &run_in_thread_mutex);
g_mutex_unlock (&run_in_thread_mutex);
@ -1574,7 +1574,7 @@ test_return_on_cancel (void)
*/
callback_ran = FALSE;
notification_emitted = FALSE;
thread_state = THREAD_STARTING;
g_atomic_int_set (&thread_state, THREAD_STARTING);
task = g_task_new (NULL, cancellable, return_on_cancel_callback, &callback_ran);
g_signal_connect (task, "notify::completed",
(GCallback) completed_cb, &notification_emitted);
@ -1591,17 +1591,17 @@ test_return_on_cancel (void)
g_main_loop_run (loop);
g_assert (callback_ran == TRUE);
while (thread_state == THREAD_STARTING)
while (g_atomic_int_get (&thread_state) == THREAD_STARTING)
g_cond_wait (&roc_init_cond, &roc_init_mutex);
g_mutex_unlock (&roc_init_mutex);
g_assert (thread_state == THREAD_RUNNING);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_RUNNING);
while (thread_state == THREAD_RUNNING)
while (g_atomic_int_get (&thread_state) == THREAD_RUNNING)
g_cond_wait (&roc_finish_cond, &roc_finish_mutex);
g_mutex_unlock (&roc_finish_mutex);
g_assert (thread_state == THREAD_CANCELLED);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_CANCELLED);
g_assert_true (notification_emitted);
g_object_unref (cancellable);
@ -1621,7 +1621,7 @@ test_return_on_cancel_sync (void)
{
GTask *task;
GCancellable *cancellable;
volatile ThreadState thread_state;
ThreadState thread_state; /* (atomic) */
GThread *runner_thread;
gssize ret;
GError *error = NULL;
@ -1630,7 +1630,7 @@ test_return_on_cancel_sync (void)
/* If return-on-cancel is FALSE, the task does not return early.
*/
thread_state = THREAD_STARTING;
g_atomic_int_set (&thread_state, THREAD_STARTING);
task = g_task_new (NULL, cancellable, run_in_thread_sync_callback, NULL);
g_task_set_task_data (task, (gpointer)&thread_state, NULL);
@ -1639,16 +1639,16 @@ test_return_on_cancel_sync (void)
runner_thread = g_thread_new ("return-on-cancel-sync runner thread",
cancel_sync_runner_thread, task);
while (thread_state == THREAD_STARTING)
while (g_atomic_int_get (&thread_state) == THREAD_STARTING)
g_cond_wait (&roc_init_cond, &roc_init_mutex);
g_mutex_unlock (&roc_init_mutex);
g_assert (thread_state == THREAD_RUNNING);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_RUNNING);
g_cancellable_cancel (cancellable);
g_mutex_unlock (&roc_finish_mutex);
g_thread_join (runner_thread);
g_assert (thread_state == THREAD_COMPLETED);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_COMPLETED);
ret = g_task_propagate_int (task, &error);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
@ -1660,7 +1660,7 @@ test_return_on_cancel_sync (void)
g_cancellable_reset (cancellable);
/* If return-on-cancel is TRUE, it does return early */
thread_state = THREAD_STARTING;
g_atomic_int_set (&thread_state, THREAD_STARTING);
task = g_task_new (NULL, cancellable, run_in_thread_sync_callback, NULL);
g_task_set_return_on_cancel (task, TRUE);
@ -1670,15 +1670,15 @@ test_return_on_cancel_sync (void)
runner_thread = g_thread_new ("return-on-cancel-sync runner thread",
cancel_sync_runner_thread, task);
while (thread_state == THREAD_STARTING)
while (g_atomic_int_get (&thread_state) == THREAD_STARTING)
g_cond_wait (&roc_init_cond, &roc_init_mutex);
g_mutex_unlock (&roc_init_mutex);
g_assert (thread_state == THREAD_RUNNING);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_RUNNING);
g_cancellable_cancel (cancellable);
g_thread_join (runner_thread);
g_assert (thread_state == THREAD_RUNNING);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_RUNNING);
ret = g_task_propagate_int (task, &error);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
@ -1687,18 +1687,18 @@ test_return_on_cancel_sync (void)
g_object_unref (task);
while (thread_state == THREAD_RUNNING)
while (g_atomic_int_get (&thread_state) == THREAD_RUNNING)
g_cond_wait (&roc_finish_cond, &roc_finish_mutex);
g_mutex_unlock (&roc_finish_mutex);
g_assert (thread_state == THREAD_CANCELLED);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_CANCELLED);
g_cancellable_reset (cancellable);
/* If the task is already cancelled before it starts, it returns
* immediately, but the thread func still runs.
*/
thread_state = THREAD_STARTING;
g_atomic_int_set (&thread_state, THREAD_STARTING);
task = g_task_new (NULL, cancellable, run_in_thread_sync_callback, NULL);
g_task_set_return_on_cancel (task, TRUE);
@ -1711,7 +1711,7 @@ test_return_on_cancel_sync (void)
cancel_sync_runner_thread, task);
g_thread_join (runner_thread);
g_assert (thread_state == THREAD_STARTING);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_STARTING);
ret = g_task_propagate_int (task, &error);
g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
@ -1720,17 +1720,17 @@ test_return_on_cancel_sync (void)
g_object_unref (task);
while (thread_state == THREAD_STARTING)
while (g_atomic_int_get (&thread_state) == THREAD_STARTING)
g_cond_wait (&roc_init_cond, &roc_init_mutex);
g_mutex_unlock (&roc_init_mutex);
g_assert (thread_state == THREAD_RUNNING);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_RUNNING);
while (thread_state == THREAD_RUNNING)
while (g_atomic_int_get (&thread_state) == THREAD_RUNNING)
g_cond_wait (&roc_finish_cond, &roc_finish_mutex);
g_mutex_unlock (&roc_finish_mutex);
g_assert (thread_state == THREAD_CANCELLED);
g_assert_cmpint (g_atomic_int_get (&thread_state), ==, THREAD_CANCELLED);
g_object_unref (cancellable);
}
@ -1776,7 +1776,7 @@ return_on_cancel_atomic_thread (GTask *task,
gpointer task_data,
GCancellable *cancellable)
{
gint *state = task_data;
gint *state = task_data; /* (atomic) */
g_assert (source_object == g_task_get_source_object (task));
g_assert (task_data == g_task_get_task_data (task));
@ -1784,34 +1784,34 @@ return_on_cancel_atomic_thread (GTask *task,
g_assert_false (g_task_get_completed (task));
g_assert (g_thread_self () != main_thread);
g_assert_cmpint (*state, ==, 0);
g_assert_cmpint (g_atomic_int_get (state), ==, 0);
g_mutex_lock (&roca_mutex_1);
*state = 1;
g_atomic_int_set (state, 1);
g_cond_signal (&roca_cond_1);
g_mutex_unlock (&roca_mutex_1);
g_mutex_lock (&roca_mutex_2);
if (g_task_set_return_on_cancel (task, FALSE))
*state = 2;
g_atomic_int_set (state, 2);
else
*state = 3;
g_atomic_int_set (state, 3);
g_cond_signal (&roca_cond_2);
g_mutex_unlock (&roca_mutex_2);
g_mutex_lock (&roca_mutex_1);
if (g_task_set_return_on_cancel (task, TRUE))
*state = 4;
g_atomic_int_set (state, 4);
else
*state = 5;
g_atomic_int_set (state, 5);
g_cond_signal (&roca_cond_1);
g_mutex_unlock (&roca_mutex_1);
g_mutex_lock (&roca_mutex_2);
if (g_task_set_return_on_cancel (task, TRUE))
*state = 6;
g_atomic_int_set (state, 6);
else
*state = 7;
g_atomic_int_set (state, 7);
g_cond_signal (&roca_cond_2);
g_mutex_unlock (&roca_mutex_2);
@ -1823,7 +1823,7 @@ test_return_on_cancel_atomic (void)
{
GTask *task;
GCancellable *cancellable;
volatile gint state;
gint state; /* (atomic) */
gboolean notification_emitted = FALSE;
gboolean callback_ran;
@ -1832,7 +1832,7 @@ test_return_on_cancel_atomic (void)
g_mutex_lock (&roca_mutex_2);
/* If we don't cancel it, each set_return_on_cancel() call will succeed */
state = 0;
g_atomic_int_set (&state, 0);
callback_ran = FALSE;
task = g_task_new (NULL, cancellable, return_on_cancel_atomic_callback, &callback_ran);
g_task_set_return_on_cancel (task, TRUE);
@ -1843,23 +1843,23 @@ test_return_on_cancel_atomic (void)
g_task_run_in_thread (task, return_on_cancel_atomic_thread);
g_object_unref (task);
g_assert_cmpint (state, ==, 0);
g_assert_cmpint (g_atomic_int_get (&state), ==, 0);
while (state == 0)
while (g_atomic_int_get (&state) == 0)
g_cond_wait (&roca_cond_1, &roca_mutex_1);
g_assert (state == 1);
g_assert_cmpint (g_atomic_int_get (&state), ==, 1);
while (state == 1)
while (g_atomic_int_get (&state) == 1)
g_cond_wait (&roca_cond_2, &roca_mutex_2);
g_assert (state == 2);
g_assert_cmpint (g_atomic_int_get (&state), ==, 2);
while (state == 2)
while (g_atomic_int_get (&state) == 2)
g_cond_wait (&roca_cond_1, &roca_mutex_1);
g_assert (state == 4);
g_assert_cmpint (g_atomic_int_get (&state), ==, 4);
while (state == 4)
while (g_atomic_int_get (&state) == 4)
g_cond_wait (&roca_cond_2, &roca_mutex_2);
g_assert (state == 6);
g_assert_cmpint (g_atomic_int_get (&state), ==, 6);
/* callback assumes there'll be a cancelled error */
g_cancellable_cancel (cancellable);
@ -1876,7 +1876,7 @@ test_return_on_cancel_atomic (void)
* task won't complete right away, and further
* g_task_set_return_on_cancel() calls will return FALSE.
*/
state = 0;
g_atomic_int_set (&state, 0);
callback_ran = FALSE;
notification_emitted = FALSE;
task = g_task_new (NULL, cancellable, return_on_cancel_atomic_callback, &callback_ran);
@ -1887,16 +1887,16 @@ test_return_on_cancel_atomic (void)
g_task_set_task_data (task, (gpointer)&state, NULL);
g_task_run_in_thread (task, return_on_cancel_atomic_thread);
g_assert_cmpint (state, ==, 0);
g_assert_cmpint (g_atomic_int_get (&state), ==, 0);
while (state == 0)
while (g_atomic_int_get (&state) == 0)
g_cond_wait (&roca_cond_1, &roca_mutex_1);
g_assert (state == 1);
g_assert_cmpint (g_atomic_int_get (&state), ==, 1);
g_assert (g_task_get_return_on_cancel (task));
while (state == 1)
while (g_atomic_int_get (&state) == 1)
g_cond_wait (&roca_cond_2, &roca_mutex_2);
g_assert (state == 2);
g_assert_cmpint (g_atomic_int_get (&state), ==, 2);
g_assert (!g_task_get_return_on_cancel (task));
g_cancellable_cancel (cancellable);
@ -1904,18 +1904,18 @@ test_return_on_cancel_atomic (void)
g_main_loop_run (loop);
g_assert (callback_ran == FALSE);
while (state == 2)
while (g_atomic_int_get (&state) == 2)
g_cond_wait (&roca_cond_1, &roca_mutex_1);
g_assert (state == 5);
g_assert_cmpint (g_atomic_int_get (&state), ==, 5);
g_assert (!g_task_get_return_on_cancel (task));
g_main_loop_run (loop);
g_assert (callback_ran == TRUE);
g_assert_true (notification_emitted);
while (state == 5)
while (g_atomic_int_get (&state) == 5)
g_cond_wait (&roca_cond_2, &roca_mutex_2);
g_assert (state == 7);
g_assert_cmpint (g_atomic_int_get (&state), ==, 7);
g_object_unref (cancellable);
g_mutex_unlock (&roca_mutex_1);