/* Unit tests for GMainLoop * Copyright (C) 2011 Red Hat, Inc * Author: Matthias Clasen * * This work is provided "as is"; redistribution and modification * in whole or in part, in any medium, physical or electronic is * permitted without restriction. * * This work 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. * * In no event shall the authors or contributors be liable for any * direct, indirect, incidental, special, exemplary, or consequential * damages (including, but not limited to, procurement of substitute * goods or services; loss of use, data, or profits; or business * interruption) however caused and on any theory of liability, whether * in contract, strict liability, or tort (including negligence or * otherwise) arising in any way out of the use of this software, even * if advised of the possibility of such damage. */ #include #include "glib-private.h" #include #include static gboolean cb (gpointer data) { return FALSE; } static gboolean prepare (GSource *source, gint *time) { return FALSE; } static gboolean check (GSource *source) { return FALSE; } static gboolean dispatch (GSource *source, GSourceFunc cb, gpointer date) { return FALSE; } GSourceFuncs funcs = { prepare, check, dispatch, NULL }; static void test_maincontext_basic (void) { GMainContext *ctx; GSource *source; guint id; gpointer data = &funcs; ctx = g_main_context_new (); g_assert (!g_main_context_pending (ctx)); g_assert (!g_main_context_iteration (ctx, FALSE)); source = g_source_new (&funcs, sizeof (GSource)); g_assert_cmpint (g_source_get_priority (source), ==, G_PRIORITY_DEFAULT); g_assert (!g_source_is_destroyed (source)); g_assert (!g_source_get_can_recurse (source)); g_assert (g_source_get_name (source) == NULL); g_source_set_can_recurse (source, TRUE); g_source_set_name (source, "d"); g_assert (g_source_get_can_recurse (source)); g_assert_cmpstr (g_source_get_name (source), ==, "d"); g_assert (g_main_context_find_source_by_user_data (ctx, NULL) == NULL); g_assert (g_main_context_find_source_by_funcs_user_data (ctx, &funcs, NULL) == NULL); id = g_source_attach (source, ctx); g_assert_cmpint (g_source_get_id (source), ==, id); g_assert (g_main_context_find_source_by_id (ctx, id) == source); g_source_set_priority (source, G_PRIORITY_HIGH); g_assert_cmpint (g_source_get_priority (source), ==, G_PRIORITY_HIGH); g_source_destroy (source); g_assert (g_source_get_context (source) == ctx); g_assert (g_main_context_find_source_by_id (ctx, id) == NULL); g_main_context_unref (ctx); if (g_test_undefined ()) { g_test_expect_message (G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL, "*assertion*source->context != NULL*failed*"); g_assert (g_source_get_context (source) == NULL); g_test_assert_expected_messages (); } g_source_unref (source); ctx = g_main_context_default (); source = g_source_new (&funcs, sizeof (GSource)); g_source_set_funcs (source, &funcs); g_source_set_callback (source, cb, data, NULL); id = g_source_attach (source, ctx); g_source_unref (source); g_source_set_name_by_id (id, "e"); g_assert_cmpstr (g_source_get_name (source), ==, "e"); g_assert (g_source_get_context (source) == ctx); g_assert (g_source_remove_by_funcs_user_data (&funcs, data)); source = g_source_new (&funcs, sizeof (GSource)); g_source_set_funcs (source, &funcs); g_source_set_callback (source, cb, data, NULL); id = g_source_attach (source, ctx); g_source_unref (source); g_assert (g_source_remove_by_user_data (data)); g_assert (!g_source_remove_by_user_data ((gpointer)0x1234)); g_idle_add (cb, data); g_assert (g_idle_remove_by_data (data)); } static void test_mainloop_basic (void) { GMainLoop *loop; GMainContext *ctx; loop = g_main_loop_new (NULL, FALSE); g_assert (!g_main_loop_is_running (loop)); g_main_loop_ref (loop); ctx = g_main_loop_get_context (loop); g_assert (ctx == g_main_context_default ()); g_main_loop_unref (loop); g_assert_cmpint (g_main_depth (), ==, 0); g_main_loop_unref (loop); } static gint a; static gint b; static gint c; static gboolean count_calls (gpointer data) { gint *i = data; (*i)++; return TRUE; } static void test_timeouts (void) { GMainContext *ctx; GMainLoop *loop; GSource *source; a = b = c = 0; ctx = g_main_context_new (); loop = g_main_loop_new (ctx, FALSE); source = g_timeout_source_new (100); g_source_set_callback (source, count_calls, &a, NULL); g_source_attach (source, ctx); g_source_unref (source); source = g_timeout_source_new (250); g_source_set_callback (source, count_calls, &b, NULL); g_source_attach (source, ctx); g_source_unref (source); source = g_timeout_source_new (330); g_source_set_callback (source, count_calls, &c, NULL); g_source_attach (source, ctx); g_source_unref (source); source = g_timeout_source_new (1050); g_source_set_callback (source, (GSourceFunc)g_main_loop_quit, loop, NULL); g_source_attach (source, ctx); g_source_unref (source); g_main_loop_run (loop); /* We may be delayed for an arbitrary amount of time - for example, * it's possible for all timeouts to fire exactly once. */ g_assert_cmpint (a, >, 0); g_assert_cmpint (a, >=, b); g_assert_cmpint (b, >=, c); g_assert_cmpint (a, <=, 10); g_assert_cmpint (b, <=, 4); g_assert_cmpint (c, <=, 3); g_main_loop_unref (loop); g_main_context_unref (ctx); } static void test_priorities (void) { GMainContext *ctx; GSource *sourcea; GSource *sourceb; a = b = c = 0; ctx = g_main_context_new (); sourcea = g_idle_source_new (); g_source_set_callback (sourcea, count_calls, &a, NULL); g_source_set_priority (sourcea, 1); g_source_attach (sourcea, ctx); g_source_unref (sourcea); sourceb = g_idle_source_new (); g_source_set_callback (sourceb, count_calls, &b, NULL); g_source_set_priority (sourceb, 0); g_source_attach (sourceb, ctx); g_source_unref (sourceb); g_assert (g_main_context_pending (ctx)); g_assert (g_main_context_iteration (ctx, FALSE)); g_assert_cmpint (a, ==, 0); g_assert_cmpint (b, ==, 1); g_assert (g_main_context_iteration (ctx, FALSE)); g_assert_cmpint (a, ==, 0); g_assert_cmpint (b, ==, 2); g_source_destroy (sourceb); g_assert (g_main_context_iteration (ctx, FALSE)); g_assert_cmpint (a, ==, 1); g_assert_cmpint (b, ==, 2); g_assert (g_main_context_pending (ctx)); g_source_destroy (sourcea); g_assert (!g_main_context_pending (ctx)); g_main_context_unref (ctx); } static gboolean quit_loop (gpointer data) { GMainLoop *loop = data; g_main_loop_quit (loop); return G_SOURCE_REMOVE; } static gint count; static gboolean func (gpointer data) { if (data != NULL) g_assert (data == g_thread_self ()); count++; return FALSE; } static gboolean call_func (gpointer data) { func (g_thread_self ()); return G_SOURCE_REMOVE; } static GMutex mutex; static GCond cond; static gboolean thread_ready; static gpointer thread_func (gpointer data) { GMainContext *ctx = data; GMainLoop *loop; GSource *source; g_main_context_push_thread_default (ctx); loop = g_main_loop_new (ctx, FALSE); g_mutex_lock (&mutex); thread_ready = TRUE; g_cond_signal (&cond); g_mutex_unlock (&mutex); source = g_timeout_source_new (500); g_source_set_callback (source, quit_loop, loop, NULL); g_source_attach (source, ctx); g_source_unref (source); g_main_loop_run (loop); g_main_context_pop_thread_default (ctx); g_main_loop_unref (loop); return NULL; } static void test_invoke (void) { GMainContext *ctx; GThread *thread; count = 0; /* this one gets invoked directly */ g_main_context_invoke (NULL, func, g_thread_self ()); g_assert_cmpint (count, ==, 1); /* invoking out of an idle works too */ g_idle_add (call_func, NULL); g_main_context_iteration (g_main_context_default (), FALSE); g_assert_cmpint (count, ==, 2); /* test thread-default forcing the invocation to go * to another thread */ ctx = g_main_context_new (); thread = g_thread_new ("worker", thread_func, ctx); g_mutex_lock (&mutex); while (!thread_ready) g_cond_wait (&cond, &mutex); g_mutex_unlock (&mutex); g_main_context_invoke (ctx, func, thread); g_thread_join (thread); g_assert_cmpint (count, ==, 3); g_main_context_unref (ctx); } /* We can't use timeout sources here because on slow or heavily-loaded * machines, the test program might not get enough cycles to hit the * timeouts at the expected times. So instead we define a source that * is based on the number of GMainContext iterations. */ static gint counter; static gint64 last_counter_update; typedef struct { GSource source; gint interval; gint timeout; } CounterSource; static gboolean counter_source_prepare (GSource *source, gint *timeout) { CounterSource *csource = (CounterSource *)source; gint64 now; now = g_source_get_time (source); if (now != last_counter_update) { last_counter_update = now; counter++; } *timeout = 1; return counter >= csource->timeout; } static gboolean counter_source_dispatch (GSource *source, GSourceFunc callback, gpointer user_data) { CounterSource *csource = (CounterSource *) source; gboolean again; again = callback (user_data); if (again) csource->timeout = counter + csource->interval; return again; } static GSourceFuncs counter_source_funcs = { counter_source_prepare, NULL, counter_source_dispatch, NULL, }; static GSource * counter_source_new (gint interval) { GSource *source = g_source_new (&counter_source_funcs, sizeof (CounterSource)); CounterSource *csource = (CounterSource *) source; csource->interval = interval; csource->timeout = counter + interval; return source; } static gboolean run_inner_loop (gpointer user_data) { GMainContext *ctx = user_data; GMainLoop *inner; GSource *timeout; a++; inner = g_main_loop_new (ctx, FALSE); timeout = counter_source_new (100); g_source_set_callback (timeout, quit_loop, inner, NULL); g_source_attach (timeout, ctx); g_source_unref (timeout); g_main_loop_run (inner); g_main_loop_unref (inner); return G_SOURCE_CONTINUE; } static void test_child_sources (void) { GMainContext *ctx; GMainLoop *loop; GSource *parent, *child_b, *child_c, *end; ctx = g_main_context_new (); loop = g_main_loop_new (ctx, FALSE); a = b = c = 0; parent = counter_source_new (2000); g_source_set_callback (parent, run_inner_loop, ctx, NULL); g_source_set_priority (parent, G_PRIORITY_LOW); g_source_attach (parent, ctx); child_b = counter_source_new (250); g_source_set_callback (child_b, count_calls, &b, NULL); g_source_add_child_source (parent, child_b); child_c = counter_source_new (330); g_source_set_callback (child_c, count_calls, &c, NULL); g_source_set_priority (child_c, G_PRIORITY_HIGH); g_source_add_child_source (parent, child_c); /* Child sources always have the priority of the parent */ g_assert_cmpint (g_source_get_priority (parent), ==, G_PRIORITY_LOW); g_assert_cmpint (g_source_get_priority (child_b), ==, G_PRIORITY_LOW); g_assert_cmpint (g_source_get_priority (child_c), ==, G_PRIORITY_LOW); g_source_set_priority (parent, G_PRIORITY_DEFAULT); g_assert_cmpint (g_source_get_priority (parent), ==, G_PRIORITY_DEFAULT); g_assert_cmpint (g_source_get_priority (child_b), ==, G_PRIORITY_DEFAULT); g_assert_cmpint (g_source_get_priority (child_c), ==, G_PRIORITY_DEFAULT); end = counter_source_new (1050); g_source_set_callback (end, quit_loop, loop, NULL); g_source_attach (end, ctx); g_source_unref (end); g_main_loop_run (loop); /* The parent source's own timeout will never trigger, so "a" will * only get incremented when "b" or "c" does. And when timeouts get * blocked, they still wait the full interval next time rather than * "catching up". So the timing is: * * 250 - b++ -> a++, run_inner_loop * 330 - (c is blocked) * 350 - inner_loop ends * 350 - c++ belatedly -> a++, run_inner_loop * 450 - inner loop ends * 500 - b++ -> a++, run_inner_loop * 600 - inner_loop ends * 680 - c++ -> a++, run_inner_loop * 750 - (b is blocked) * 780 - inner loop ends * 780 - b++ belatedly -> a++, run_inner_loop * 880 - inner loop ends * 1010 - c++ -> a++, run_inner_loop * 1030 - (b is blocked) * 1050 - end runs, quits outer loop, which has no effect yet * 1110 - inner loop ends, a returns, outer loop exits */ g_assert_cmpint (a, ==, 6); g_assert_cmpint (b, ==, 3); g_assert_cmpint (c, ==, 3); g_source_destroy (parent); g_source_unref (parent); g_source_unref (child_b); g_source_unref (child_c); g_main_loop_unref (loop); g_main_context_unref (ctx); } static void test_recursive_child_sources (void) { GMainContext *ctx; GMainLoop *loop; GSource *parent, *child_b, *child_c, *end; ctx = g_main_context_new (); loop = g_main_loop_new (ctx, FALSE); a = b = c = 0; parent = counter_source_new (500); g_source_set_callback (parent, count_calls, &a, NULL); child_b = counter_source_new (220); g_source_set_callback (child_b, count_calls, &b, NULL); g_source_add_child_source (parent, child_b); child_c = counter_source_new (430); g_source_set_callback (child_c, count_calls, &c, NULL); g_source_add_child_source (child_b, child_c); g_source_attach (parent, ctx); end = counter_source_new (2010); g_source_set_callback (end, (GSourceFunc)g_main_loop_quit, loop, NULL); g_source_attach (end, ctx); g_source_unref (end); g_main_loop_run (loop); /* Sequence of events: * 220 b (b -> 440, a -> 720) * 430 c (c -> 860, b -> 650, a -> 930) * 650 b (b -> 870, a -> 1150) * 860 c (c -> 1290, b -> 1080, a -> 1360) * 1080 b (b -> 1300, a -> 1580) * 1290 c (c -> 1720, b -> 1510, a -> 1790) * 1510 b (b -> 1730, a -> 2010) * 1720 c (c -> 2150, b -> 1940, a -> 2220) * 1940 b (b -> 2160, a -> 2440) */ g_assert_cmpint (a, ==, 9); g_assert_cmpint (b, ==, 9); g_assert_cmpint (c, ==, 4); g_source_destroy (parent); g_source_unref (parent); g_source_unref (child_b); g_source_unref (child_c); g_main_loop_unref (loop); g_main_context_unref (ctx); } typedef struct { GSource *parent, *old_child, *new_child; GMainLoop *loop; } SwappingTestData; static gboolean swap_sources (gpointer user_data) { SwappingTestData *data = user_data; if (data->old_child) { g_source_remove_child_source (data->parent, data->old_child); g_clear_pointer (&data->old_child, g_source_unref); } if (!data->new_child) { data->new_child = g_timeout_source_new (0); g_source_set_callback (data->new_child, quit_loop, data->loop, NULL); g_source_add_child_source (data->parent, data->new_child); } return G_SOURCE_CONTINUE; } static gboolean assert_not_reached_callback (gpointer user_data) { g_assert_not_reached (); return G_SOURCE_REMOVE; } static void test_swapping_child_sources (void) { GMainContext *ctx; GMainLoop *loop; SwappingTestData data; ctx = g_main_context_new (); loop = g_main_loop_new (ctx, FALSE); data.parent = counter_source_new (50); data.loop = loop; g_source_set_callback (data.parent, swap_sources, &data, NULL); g_source_attach (data.parent, ctx); data.old_child = counter_source_new (100); g_source_add_child_source (data.parent, data.old_child); g_source_set_callback (data.old_child, assert_not_reached_callback, NULL, NULL); data.new_child = NULL; g_main_loop_run (loop); g_source_destroy (data.parent); g_source_unref (data.parent); g_source_unref (data.new_child); g_main_loop_unref (loop); g_main_context_unref (ctx); } static gboolean add_source_callback (gpointer user_data) { GMainLoop *loop = user_data; GSource *self = g_main_current_source (), *child; GIOChannel *io; /* It doesn't matter whether this is a valid fd or not; it never * actually gets polled; the test is just checking that * g_source_add_child_source() doesn't crash. */ io = g_io_channel_unix_new (0); child = g_io_create_watch (io, G_IO_IN); g_source_add_child_source (self, child); g_source_unref (child); g_io_channel_unref (io); g_main_loop_quit (loop); return FALSE; } static void test_blocked_child_sources (void) { GMainContext *ctx; GMainLoop *loop; GSource *source; g_test_bug ("701283"); ctx = g_main_context_new (); loop = g_main_loop_new (ctx, FALSE); source = g_idle_source_new (); g_source_set_callback (source, add_source_callback, loop, NULL); g_source_attach (source, ctx); g_main_loop_run (loop); g_source_destroy (source); g_source_unref (source); g_main_loop_unref (loop); g_main_context_unref (ctx); } typedef struct { GMainContext *ctx; GMainLoop *loop; GSource *timeout1, *timeout2; gint64 time1; GTimeVal tv; } TimeTestData; static gboolean timeout1_callback (gpointer user_data) { TimeTestData *data = user_data; GSource *source; gint64 mtime1, mtime2, time2; source = g_main_current_source (); g_assert (source == data->timeout1); if (data->time1 == -1) { /* First iteration */ g_assert (!g_source_is_destroyed (data->timeout2)); mtime1 = g_get_monotonic_time (); data->time1 = g_source_get_time (source); G_GNUC_BEGIN_IGNORE_DEPRECATIONS g_source_get_current_time (source, &data->tv); G_GNUC_END_IGNORE_DEPRECATIONS /* g_source_get_time() does not change during a single callback */ g_usleep (1000000); mtime2 = g_get_monotonic_time (); time2 = g_source_get_time (source); g_assert_cmpint (mtime1, <, mtime2); g_assert_cmpint (data->time1, ==, time2); } else { GTimeVal tv; /* Second iteration */ g_assert (g_source_is_destroyed (data->timeout2)); /* g_source_get_time() MAY change between iterations; in this * case we know for sure that it did because of the g_usleep() * last time. */ time2 = g_source_get_time (source); g_assert_cmpint (data->time1, <, time2); G_GNUC_BEGIN_IGNORE_DEPRECATIONS g_source_get_current_time (source, &tv); G_GNUC_END_IGNORE_DEPRECATIONS g_assert (tv.tv_sec > data->tv.tv_sec || (tv.tv_sec == data->tv.tv_sec && tv.tv_usec > data->tv.tv_usec)); g_main_loop_quit (data->loop); } return TRUE; } static gboolean timeout2_callback (gpointer user_data) { TimeTestData *data = user_data; GSource *source; gint64 time2, time3; source = g_main_current_source (); g_assert (source == data->timeout2); g_assert (!g_source_is_destroyed (data->timeout1)); /* g_source_get_time() does not change between different sources in * a single iteration of the mainloop. */ time2 = g_source_get_time (source); g_assert_cmpint (data->time1, ==, time2); /* The source should still have a valid time even after being * destroyed, since it's currently running. */ g_source_destroy (source); time3 = g_source_get_time (source); g_assert_cmpint (time2, ==, time3); return FALSE; } static void test_source_time (void) { TimeTestData data; data.ctx = g_main_context_new (); data.loop = g_main_loop_new (data.ctx, FALSE); data.timeout1 = g_timeout_source_new (0); g_source_set_callback (data.timeout1, timeout1_callback, &data, NULL); g_source_attach (data.timeout1, data.ctx); data.timeout2 = g_timeout_source_new (0); g_source_set_callback (data.timeout2, timeout2_callback, &data, NULL); g_source_attach (data.timeout2, data.ctx); data.time1 = -1; g_main_loop_run (data.loop); g_assert (!g_source_is_destroyed (data.timeout1)); g_assert (g_source_is_destroyed (data.timeout2)); g_source_destroy (data.timeout1); g_source_unref (data.timeout1); g_source_unref (data.timeout2); g_main_loop_unref (data.loop); g_main_context_unref (data.ctx); } typedef struct { guint outstanding_ops; GMainLoop *loop; } TestOverflowData; static gboolean on_source_fired_cb (gpointer user_data) { TestOverflowData *data = user_data; GSource *current_source; GMainContext *current_context; guint source_id; data->outstanding_ops--; current_source = g_main_current_source (); current_context = g_source_get_context (current_source); source_id = g_source_get_id (current_source); g_assert (g_main_context_find_source_by_id (current_context, source_id) != NULL); g_source_destroy (current_source); g_assert (g_main_context_find_source_by_id (current_context, source_id) == NULL); if (data->outstanding_ops == 0) g_main_loop_quit (data->loop); return FALSE; } static GSource * add_idle_source (GMainContext *ctx, TestOverflowData *data) { GSource *source; source = g_idle_source_new (); g_source_set_callback (source, on_source_fired_cb, data, NULL); g_source_attach (source, ctx); g_source_unref (source); data->outstanding_ops++; return source; } static void test_mainloop_overflow (void) { GMainContext *ctx; GMainLoop *loop; GSource *source; TestOverflowData data; guint i; g_test_bug ("687098"); memset (&data, 0, sizeof (data)); ctx = GLIB_PRIVATE_CALL (g_main_context_new_with_next_id) (G_MAXUINT-1); loop = g_main_loop_new (ctx, TRUE); data.outstanding_ops = 0; data.loop = loop; source = add_idle_source (ctx, &data); g_assert_cmpint (source->source_id, ==, G_MAXUINT-1); source = add_idle_source (ctx, &data); g_assert_cmpint (source->source_id, ==, G_MAXUINT); source = add_idle_source (ctx, &data); g_assert_cmpint (source->source_id, !=, 0); /* Now, a lot more sources */ for (i = 0; i < 50; i++) { source = add_idle_source (ctx, &data); g_assert_cmpint (source->source_id, !=, 0); } g_main_loop_run (loop); g_assert_cmpint (data.outstanding_ops, ==, 0); g_main_loop_unref (loop); g_main_context_unref (ctx); } static volatile gint ready_time_dispatched; static gboolean ready_time_dispatch (GSource *source, GSourceFunc callback, gpointer user_data) { g_atomic_int_set (&ready_time_dispatched, TRUE); g_source_set_ready_time (source, -1); return TRUE; } static gpointer run_context (gpointer user_data) { g_main_loop_run (user_data); return NULL; } static void test_ready_time (void) { GThread *thread; GSource *source; GSourceFuncs source_funcs = { NULL, NULL, ready_time_dispatch }; GMainLoop *loop; source = g_source_new (&source_funcs, sizeof (GSource)); g_source_attach (source, NULL); g_source_unref (source); /* Unfortunately we can't do too many things with respect to timing * without getting into trouble on slow systems or heavily loaded * builders. * * We can test that the basics are working, though. */ /* A source with no ready time set should not fire */ g_assert_cmpint (g_source_get_ready_time (source), ==, -1); while (g_main_context_iteration (NULL, FALSE)); g_assert (!ready_time_dispatched); /* The ready time should not have been changed */ g_assert_cmpint (g_source_get_ready_time (source), ==, -1); /* Of course this shouldn't change anything either */ g_source_set_ready_time (source, -1); g_assert_cmpint (g_source_get_ready_time (source), ==, -1); /* A source with a ready time set to tomorrow should not fire on any * builder, no matter how badly loaded... */ g_source_set_ready_time (source, g_get_monotonic_time () + G_TIME_SPAN_DAY); while (g_main_context_iteration (NULL, FALSE)); g_assert (!ready_time_dispatched); /* Make sure it didn't get reset */ g_assert_cmpint (g_source_get_ready_time (source), !=, -1); /* Ready time of -1 -> don't fire */ g_source_set_ready_time (source, -1); while (g_main_context_iteration (NULL, FALSE)); g_assert (!ready_time_dispatched); /* Not reset, but should still be -1 from above */ g_assert_cmpint (g_source_get_ready_time (source), ==, -1); /* A ready time of the current time should fire immediately */ g_source_set_ready_time (source, g_get_monotonic_time ()); while (g_main_context_iteration (NULL, FALSE)); g_assert (ready_time_dispatched); ready_time_dispatched = FALSE; /* Should have gotten reset by the handler function */ g_assert_cmpint (g_source_get_ready_time (source), ==, -1); /* As well as one in the recent past... */ g_source_set_ready_time (source, g_get_monotonic_time () - G_TIME_SPAN_SECOND); while (g_main_context_iteration (NULL, FALSE)); g_assert (ready_time_dispatched); ready_time_dispatched = FALSE; g_assert_cmpint (g_source_get_ready_time (source), ==, -1); /* Zero is the 'official' way to get a source to fire immediately */ g_source_set_ready_time (source, 0); while (g_main_context_iteration (NULL, FALSE)); g_assert (ready_time_dispatched); ready_time_dispatched = FALSE; g_assert_cmpint (g_source_get_ready_time (source), ==, -1); /* Now do some tests of cross-thread wakeups. * * Make sure it wakes up right away from the start. */ g_source_set_ready_time (source, 0); loop = g_main_loop_new (NULL, FALSE); thread = g_thread_new ("context thread", run_context, loop); while (!g_atomic_int_get (&ready_time_dispatched)); /* Now let's see if it can wake up from sleeping. */ g_usleep (G_TIME_SPAN_SECOND / 2); g_atomic_int_set (&ready_time_dispatched, FALSE); g_source_set_ready_time (source, 0); while (!g_atomic_int_get (&ready_time_dispatched)); /* kill the thread */ g_main_loop_quit (loop); g_thread_join (thread); g_main_loop_unref (loop); g_source_destroy (source); } static void test_wakeup(void) { GMainContext *ctx; int i; ctx = g_main_context_new (); /* run a random large enough number of times because * main contexts tend to wake up a few times after creation. */ for (i = 0; i < 100; i++) { /* This is the invariant we care about: * g_main_context_wakeup(ctx,) ensures that the next call to * g_main_context_iteration (ctx, TRUE) returns and doesn't * block. * This is important in threaded apps where we might not know * if the thread calls g_main_context_wakeup() before or after * we enter g_main_context_iteration(). */ g_main_context_wakeup (ctx); g_main_context_iteration (ctx, TRUE); } g_main_context_unref (ctx); } static void test_remove_invalid (void) { g_test_expect_message ("GLib", G_LOG_LEVEL_CRITICAL, "Source ID 3000000000 was not found*"); g_source_remove (3000000000u); g_test_assert_expected_messages (); } static gboolean trivial_prepare (GSource *source, gint *timeout) { *timeout = 0; return TRUE; } static gint n_finalized; static void trivial_finalize (GSource *source) { n_finalized++; } static void test_unref_while_pending (void) { static GSourceFuncs funcs = { trivial_prepare, NULL, NULL, trivial_finalize }; GMainContext *context; GSource *source; context = g_main_context_new (); source = g_source_new (&funcs, sizeof (GSource)); g_source_attach (source, context); g_source_unref (source); /* Do incomplete main iteration -- get a pending source but don't dispatch it. */ g_main_context_prepare (context, NULL); g_main_context_query (context, 0, NULL, NULL, 0); g_main_context_check (context, 1000, NULL, 0); /* Destroy the context */ g_main_context_unref (context); /* Make sure we didn't leak the source */ g_assert_cmpint (n_finalized, ==, 1); } #ifdef G_OS_UNIX #include #include static gchar zeros[1024]; static gsize fill_a_pipe (gint fd) { gsize written = 0; GPollFD pfd; pfd.fd = fd; pfd.events = G_IO_OUT; while (g_poll (&pfd, 1, 0) == 1) /* we should never see -1 here */ written += write (fd, zeros, sizeof zeros); return written; } static gboolean write_bytes (gint fd, GIOCondition condition, gpointer user_data) { gssize *to_write = user_data; gint limit; if (*to_write == 0) return FALSE; /* Detect if we run before we should */ g_assert (*to_write >= 0); limit = MIN (*to_write, sizeof zeros); *to_write -= write (fd, zeros, limit); return TRUE; } static gboolean read_bytes (gint fd, GIOCondition condition, gpointer user_data) { static gchar buffer[1024]; gssize *to_read = user_data; *to_read -= read (fd, buffer, sizeof buffer); /* The loop will exit when there is nothing else to read, then we will * use g_source_remove() to destroy this source. */ return TRUE; } static void test_unix_fd (void) { gssize to_write = -1; gssize to_read; gint fds[2]; gint a, b; gint s; GSource *source_a; GSource *source_b; s = pipe (fds); g_assert (s == 0); to_read = fill_a_pipe (fds[1]); /* write at higher priority to keep the pipe full... */ a = g_unix_fd_add_full (G_PRIORITY_HIGH, fds[1], G_IO_OUT, write_bytes, &to_write, NULL); source_a = g_source_ref (g_main_context_find_source_by_id (NULL, a)); /* make sure no 'writes' get dispatched yet */ while (g_main_context_iteration (NULL, FALSE)); to_read += 128 * 1024 * 1024; to_write = 128 * 1024 * 1024; b = g_unix_fd_add (fds[0], G_IO_IN, read_bytes, &to_read); source_b = g_source_ref (g_main_context_find_source_by_id (NULL, b)); /* Assuming the kernel isn't internally 'laggy' then there will always * be either data to read or room in which to write. That will keep * the loop running until all data has been read and written. */ while (TRUE) { gssize to_write_was = to_write; gssize to_read_was = to_read; if (!g_main_context_iteration (NULL, FALSE)) break; /* Since the sources are at different priority, only one of them * should possibly have run. */ g_assert (to_write == to_write_was || to_read == to_read_was); } g_assert (to_write == 0); g_assert (to_read == 0); /* 'a' is already removed by itself */ g_assert (g_source_is_destroyed (source_a)); g_source_unref (source_a); g_source_remove (b); g_assert (g_source_is_destroyed (source_b)); g_source_unref (source_b); close (fds[1]); close (fds[0]); } static void assert_main_context_state (gint n_to_poll, ...) { GMainContext *context; gboolean consumed[10] = { }; GPollFD poll_fds[10]; gboolean acquired; gboolean immediate; gint max_priority; gint timeout; gint n; gint i, j; va_list ap; context = g_main_context_default (); acquired = g_main_context_acquire (context); g_assert (acquired); immediate = g_main_context_prepare (context, &max_priority); g_assert (!immediate); n = g_main_context_query (context, max_priority, &timeout, poll_fds, 10); g_assert_cmpint (n, ==, n_to_poll + 1); /* one will be the gwakeup */ va_start (ap, n_to_poll); for (i = 0; i < n_to_poll; i++) { gint expected_fd = va_arg (ap, gint); GIOCondition expected_events = va_arg (ap, GIOCondition); GIOCondition report_events = va_arg (ap, GIOCondition); for (j = 0; j < n; j++) if (!consumed[j] && poll_fds[j].fd == expected_fd && poll_fds[j].events == expected_events) { poll_fds[j].revents = report_events; consumed[j] = TRUE; break; } if (j == n) g_error ("Unable to find fd %d (index %d) with events 0x%x\n", expected_fd, i, (guint) expected_events); } va_end (ap); /* find the gwakeup, flag as non-ready */ for (i = 0; i < n; i++) if (!consumed[i]) poll_fds[i].revents = 0; if (g_main_context_check (context, max_priority, poll_fds, n)) g_main_context_dispatch (context); g_main_context_release (context); } static gboolean flag_bool (gint fd, GIOCondition condition, gpointer user_data) { gboolean *flag = user_data; *flag = TRUE; return TRUE; } static void test_unix_fd_source (void) { GSource *out_source; GSource *in_source; GSource *source; gboolean out, in; gint fds[2]; gint s; assert_main_context_state (0); s = pipe (fds); g_assert (s == 0); source = g_unix_fd_source_new (fds[1], G_IO_OUT); g_source_attach (source, NULL); /* Check that a source with no callback gets successfully detached * with a warning printed. */ g_test_expect_message ("GLib", G_LOG_LEVEL_WARNING, "*GUnixFDSource dispatched without callback*"); while (g_main_context_iteration (NULL, FALSE)); g_test_assert_expected_messages (); g_assert (g_source_is_destroyed (source)); g_source_unref (source); out = in = FALSE; out_source = g_unix_fd_source_new (fds[1], G_IO_OUT); g_source_set_callback (out_source, (GSourceFunc) flag_bool, &out, NULL); g_source_attach (out_source, NULL); assert_main_context_state (1, fds[1], G_IO_OUT, 0); g_assert (!in && !out); in_source = g_unix_fd_source_new (fds[0], G_IO_IN); g_source_set_callback (in_source, (GSourceFunc) flag_bool, &in, NULL); g_source_set_priority (in_source, G_PRIORITY_DEFAULT_IDLE); g_source_attach (in_source, NULL); assert_main_context_state (2, fds[0], G_IO_IN, G_IO_IN, fds[1], G_IO_OUT, G_IO_OUT); /* out is higher priority so only it should fire */ g_assert (!in && out); /* raise the priority of the in source to higher than out*/ in = out = FALSE; g_source_set_priority (in_source, G_PRIORITY_HIGH); assert_main_context_state (2, fds[0], G_IO_IN, G_IO_IN, fds[1], G_IO_OUT, G_IO_OUT); g_assert (in && !out); /* now, let them be equal */ in = out = FALSE; g_source_set_priority (in_source, G_PRIORITY_DEFAULT); assert_main_context_state (2, fds[0], G_IO_IN, G_IO_IN, fds[1], G_IO_OUT, G_IO_OUT); g_assert (in && out); g_source_destroy (out_source); g_source_unref (out_source); g_source_destroy (in_source); g_source_unref (in_source); close (fds[1]); close (fds[0]); } typedef struct { GSource parent; gboolean flagged; } FlagSource; static gboolean return_true (GSource *source, GSourceFunc callback, gpointer user_data) { FlagSource *flag_source = (FlagSource *) source; flag_source->flagged = TRUE; return TRUE; } #define assert_flagged(s) g_assert (((FlagSource *) (s))->flagged); #define assert_not_flagged(s) g_assert (!((FlagSource *) (s))->flagged); #define clear_flag(s) ((FlagSource *) (s))->flagged = 0 static void test_source_unix_fd_api (void) { GSourceFuncs no_funcs = { NULL, NULL, return_true }; GSource *source_a; GSource *source_b; gpointer tag1, tag2; gint fds_a[2]; gint fds_b[2]; pipe (fds_a); pipe (fds_b); source_a = g_source_new (&no_funcs, sizeof (FlagSource)); source_b = g_source_new (&no_funcs, sizeof (FlagSource)); /* attach a source with more than one fd */ g_source_add_unix_fd (source_a, fds_a[0], G_IO_IN); g_source_add_unix_fd (source_a, fds_a[1], G_IO_OUT); g_source_attach (source_a, NULL); assert_main_context_state (2, fds_a[0], G_IO_IN, 0, fds_a[1], G_IO_OUT, 0); assert_not_flagged (source_a); /* attach a higher priority source with no fds */ g_source_set_priority (source_b, G_PRIORITY_HIGH); g_source_attach (source_b, NULL); assert_main_context_state (2, fds_a[0], G_IO_IN, G_IO_IN, fds_a[1], G_IO_OUT, 0); assert_flagged (source_a); assert_not_flagged (source_b); clear_flag (source_a); /* add some fds to the second source, while attached */ tag1 = g_source_add_unix_fd (source_b, fds_b[0], G_IO_IN); tag2 = g_source_add_unix_fd (source_b, fds_b[1], G_IO_OUT); assert_main_context_state (4, fds_a[0], G_IO_IN, 0, fds_a[1], G_IO_OUT, G_IO_OUT, fds_b[0], G_IO_IN, 0, fds_b[1], G_IO_OUT, G_IO_OUT); /* only 'b' (higher priority) should have dispatched */ assert_not_flagged (source_a); assert_flagged (source_b); clear_flag (source_b); /* change our events on b to the same as they were before */ g_source_modify_unix_fd (source_b, tag1, G_IO_IN); g_source_modify_unix_fd (source_b, tag2, G_IO_OUT); assert_main_context_state (4, fds_a[0], G_IO_IN, 0, fds_a[1], G_IO_OUT, G_IO_OUT, fds_b[0], G_IO_IN, 0, fds_b[1], G_IO_OUT, G_IO_OUT); assert_not_flagged (source_a); assert_flagged (source_b); clear_flag (source_b); /* now reverse them */ g_source_modify_unix_fd (source_b, tag1, G_IO_OUT); g_source_modify_unix_fd (source_b, tag2, G_IO_IN); assert_main_context_state (4, fds_a[0], G_IO_IN, 0, fds_a[1], G_IO_OUT, G_IO_OUT, fds_b[0], G_IO_OUT, 0, fds_b[1], G_IO_IN, 0); /* 'b' had no events, so 'a' can go this time */ assert_flagged (source_a); assert_not_flagged (source_b); clear_flag (source_a); /* remove one of the fds from 'b' */ g_source_remove_unix_fd (source_b, tag1); assert_main_context_state (3, fds_a[0], G_IO_IN, 0, fds_a[1], G_IO_OUT, 0, fds_b[1], G_IO_IN, 0); assert_not_flagged (source_a); assert_not_flagged (source_b); /* remove the other */ g_source_remove_unix_fd (source_b, tag2); assert_main_context_state (2, fds_a[0], G_IO_IN, 0, fds_a[1], G_IO_OUT, 0); assert_not_flagged (source_a); assert_not_flagged (source_b); /* destroy the sources */ g_source_destroy (source_a); g_source_destroy (source_b); assert_main_context_state (0); g_source_unref (source_a); g_source_unref (source_b); close (fds_a[0]); close (fds_a[1]); close (fds_b[0]); close (fds_b[1]); } static gboolean unixfd_quit_loop (gint fd, GIOCondition condition, gpointer user_data) { GMainLoop *loop = user_data; g_main_loop_quit (loop); return FALSE; } static void test_unix_file_poll (void) { gint fd; GSource *source; GMainLoop *loop; fd = open ("/dev/null", O_RDONLY); g_assert (fd >= 0); loop = g_main_loop_new (NULL, FALSE); source = g_unix_fd_source_new (fd, G_IO_IN); g_source_set_callback (source, (GSourceFunc) unixfd_quit_loop, loop, NULL); g_source_attach (source, NULL); /* Should not block */ g_main_loop_run (loop); g_source_destroy (source); assert_main_context_state (0); g_source_unref (source); g_main_loop_unref (loop); close (fd); } #endif static gboolean timeout_cb (gpointer data) { GMainLoop *loop = data; GMainContext *context; context = g_main_loop_get_context (loop); g_assert (g_main_loop_is_running (loop)); g_assert (g_main_context_is_owner (context)); g_main_loop_quit (loop); return G_SOURCE_REMOVE; } static gpointer threadf (gpointer data) { GMainContext *context = data; GMainLoop *loop; GSource *source; loop = g_main_loop_new (context, FALSE); source = g_timeout_source_new (250); g_source_set_callback (source, timeout_cb, loop, NULL); g_source_attach (source, context); g_source_unref (source); g_main_loop_run (loop); g_main_loop_unref (loop); return NULL; } static void test_mainloop_wait (void) { GMainContext *context; GThread *t1, *t2; context = g_main_context_new (); t1 = g_thread_new ("t1", threadf, context); t2 = g_thread_new ("t2", threadf, context); g_thread_join (t1); g_thread_join (t2); g_main_context_unref (context); } static gboolean nfds_in_cb (GIOChannel *io, GIOCondition condition, gpointer user_data) { gboolean *in_cb_ran = user_data; *in_cb_ran = TRUE; g_assert_cmpint (condition, ==, G_IO_IN); return FALSE; } static gboolean nfds_out_cb (GIOChannel *io, GIOCondition condition, gpointer user_data) { gboolean *out_cb_ran = user_data; *out_cb_ran = TRUE; g_assert_cmpint (condition, ==, G_IO_OUT); return FALSE; } static gboolean nfds_out_low_cb (GIOChannel *io, GIOCondition condition, gpointer user_data) { g_assert_not_reached (); return FALSE; } static void test_nfds (void) { GMainContext *ctx; GPollFD out_fds[3]; gint fd, nfds; GIOChannel *io; GSource *source1, *source2, *source3; gboolean source1_ran = FALSE, source3_ran = FALSE; gchar *tmpfile; GError *error = NULL; ctx = g_main_context_new (); nfds = g_main_context_query (ctx, G_MAXINT, NULL, out_fds, G_N_ELEMENTS (out_fds)); /* An "empty" GMainContext will have a single GPollFD, for its * internal GWakeup. */ g_assert_cmpint (nfds, ==, 1); fd = g_file_open_tmp (NULL, &tmpfile, &error); g_assert_no_error (error); io = g_io_channel_unix_new (fd); #ifdef G_OS_WIN32 /* The fd in the pollfds won't be the same fd we passed in */ g_io_channel_win32_make_pollfd (io, G_IO_IN, out_fds); fd = out_fds[0].fd; #endif /* Add our first pollfd */ source1 = g_io_create_watch (io, G_IO_IN); g_source_set_priority (source1, G_PRIORITY_DEFAULT); g_source_set_callback (source1, (GSourceFunc) nfds_in_cb, &source1_ran, NULL); g_source_attach (source1, ctx); nfds = g_main_context_query (ctx, G_MAXINT, NULL, out_fds, G_N_ELEMENTS (out_fds)); g_assert_cmpint (nfds, ==, 2); if (out_fds[0].fd == fd) g_assert_cmpint (out_fds[0].events, ==, G_IO_IN); else if (out_fds[1].fd == fd) g_assert_cmpint (out_fds[1].events, ==, G_IO_IN); else g_assert_not_reached (); /* Add a second pollfd with the same fd but different event, and * lower priority. */ source2 = g_io_create_watch (io, G_IO_OUT); g_source_set_priority (source2, G_PRIORITY_LOW); g_source_set_callback (source2, (GSourceFunc) nfds_out_low_cb, NULL, NULL); g_source_attach (source2, ctx); /* g_main_context_query() should still return only 2 pollfds, * one of which has our fd, and a combined events field. */ nfds = g_main_context_query (ctx, G_MAXINT, NULL, out_fds, G_N_ELEMENTS (out_fds)); g_assert_cmpint (nfds, ==, 2); if (out_fds[0].fd == fd) g_assert_cmpint (out_fds[0].events, ==, G_IO_IN | G_IO_OUT); else if (out_fds[1].fd == fd) g_assert_cmpint (out_fds[1].events, ==, G_IO_IN | G_IO_OUT); else g_assert_not_reached (); /* But if we query with a max priority, we won't see the * lower-priority one. */ nfds = g_main_context_query (ctx, G_PRIORITY_DEFAULT, NULL, out_fds, G_N_ELEMENTS (out_fds)); g_assert_cmpint (nfds, ==, 2); if (out_fds[0].fd == fd) g_assert_cmpint (out_fds[0].events, ==, G_IO_IN); else if (out_fds[1].fd == fd) g_assert_cmpint (out_fds[1].events, ==, G_IO_IN); else g_assert_not_reached (); /* Third pollfd */ source3 = g_io_create_watch (io, G_IO_OUT); g_source_set_priority (source3, G_PRIORITY_DEFAULT); g_source_set_callback (source3, (GSourceFunc) nfds_out_cb, &source3_ran, NULL); g_source_attach (source3, ctx); nfds = g_main_context_query (ctx, G_MAXINT, NULL, out_fds, G_N_ELEMENTS (out_fds)); g_assert_cmpint (nfds, ==, 2); if (out_fds[0].fd == fd) g_assert_cmpint (out_fds[0].events, ==, G_IO_IN | G_IO_OUT); else if (out_fds[1].fd == fd) g_assert_cmpint (out_fds[1].events, ==, G_IO_IN | G_IO_OUT); else g_assert_not_reached (); /* Now actually iterate the loop; the fd should be readable and * writable, so source1 and source3 should be triggered, but *not* * source2, since it's lower priority than them. (Though on * G_OS_WIN32, source3 doesn't get triggered, probably because of * giowin32 weirdness...) */ g_main_context_iteration (ctx, FALSE); g_assert (source1_ran); #ifndef G_OS_WIN32 g_assert (source3_ran); #endif g_source_destroy (source1); g_source_unref (source1); g_source_destroy (source2); g_source_unref (source2); g_source_destroy (source3); g_source_unref (source3); g_io_channel_unref (io); remove (tmpfile); g_free (tmpfile); g_main_context_unref (ctx); } int main (int argc, char *argv[]) { g_test_init (&argc, &argv, NULL); g_test_bug_base ("http://bugzilla.gnome.org/"); g_test_add_func ("/maincontext/basic", test_maincontext_basic); g_test_add_func ("/mainloop/basic", test_mainloop_basic); g_test_add_func ("/mainloop/timeouts", test_timeouts); g_test_add_func ("/mainloop/priorities", test_priorities); g_test_add_func ("/mainloop/invoke", test_invoke); g_test_add_func ("/mainloop/child_sources", test_child_sources); g_test_add_func ("/mainloop/recursive_child_sources", test_recursive_child_sources); g_test_add_func ("/mainloop/swapping_child_sources", test_swapping_child_sources); g_test_add_func ("/mainloop/blocked_child_sources", test_blocked_child_sources); g_test_add_func ("/mainloop/source_time", test_source_time); g_test_add_func ("/mainloop/overflow", test_mainloop_overflow); g_test_add_func ("/mainloop/ready-time", test_ready_time); g_test_add_func ("/mainloop/wakeup", test_wakeup); g_test_add_func ("/mainloop/remove-invalid", test_remove_invalid); g_test_add_func ("/mainloop/unref-while-pending", test_unref_while_pending); #ifdef G_OS_UNIX g_test_add_func ("/mainloop/unix-fd", test_unix_fd); g_test_add_func ("/mainloop/unix-fd-source", test_unix_fd_source); g_test_add_func ("/mainloop/source-unix-fd-api", test_source_unix_fd_api); g_test_add_func ("/mainloop/wait", test_mainloop_wait); g_test_add_func ("/mainloop/unix-file-poll", test_unix_file_poll); #endif g_test_add_func ("/mainloop/nfds", test_nfds); return g_test_run (); }