glib/tests/thread-pool-slow.c - third_party/glib - Git at Google

 #include "config.h"

 #include <glib.h>

 #define WAIT                5    /* seconds */
 #define MAX_THREADS         10

 /* if > 0 the test will run continuously (since the test ends when
  * thread count is 0), if -1 it means no limit to unused threads
  * if 0 then no unused threads are possible */
 #define MAX_UNUSED_THREADS -1

 G_LOCK_DEFINE_STATIC (thread_counter_pools);

 static gulong abs_thread_counter = 0;
 static gulong running_thread_counter = 0;
 static gulong leftover_task_counter = 0;

 static GThreadPool *idle_pool = NULL;

 static void
 test_threadpool_functions (void)
 {
   gint max_unused_threads;
   guint max_idle_time;

   /* This function attempts to call functions which don't need a
    * threadpool to operate to make sure no uninitialised pointers
    * accessed and no errors occur.
    */

   max_unused_threads = 3;

   g_thread_pool_set_max_unused_threads (max_unused_threads);

   g_assert_cmpint (g_thread_pool_get_max_unused_threads (), ==,
                    max_unused_threads);

   g_assert_cmpint (g_thread_pool_get_num_unused_threads (), ==, 0);

   g_thread_pool_stop_unused_threads ();

   max_idle_time = 10 * G_USEC_PER_SEC;

   g_thread_pool_set_max_idle_time (max_idle_time);

   g_assert_cmpint (g_thread_pool_get_max_idle_time (), ==, max_idle_time);

   g_thread_pool_set_max_idle_time (0);

   g_assert_cmpint (g_thread_pool_get_max_idle_time (), ==, 0);
 }

 static void
 test_threadpool_stop_unused (void)
 {
   GThreadPool *pool;
   guint i;
   guint limit = 100;

   /* Spawn a few threads. */
   g_thread_pool_set_max_unused_threads (-1);
   pool = g_thread_pool_new ((GFunc) g_usleep, NULL, -1, FALSE, NULL);

   for (i = 0; i < limit; i++)
     g_thread_pool_push (pool, GUINT_TO_POINTER (1000), NULL);

   /* Wait for the threads to migrate. */
   while (g_thread_pool_get_num_threads (pool) != 0)
     g_usleep (100);

   g_assert_cmpuint (g_thread_pool_get_num_threads (pool), ==, 0);
   g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), >, 0);

   /* Wait for threads to die. */
   g_thread_pool_stop_unused_threads ();

   while (g_thread_pool_get_num_unused_threads () != 0)
     g_usleep (100);

   g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), ==, 0);

   g_thread_pool_set_max_unused_threads (MAX_THREADS);

   g_assert_cmpuint (g_thread_pool_get_num_threads (pool), ==, 0);
   g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), ==, 0);

   g_thread_pool_free (pool, FALSE, TRUE);
 }

 static void
 test_threadpool_stop_unused_multiple (void)
 {
   GThreadPool *pools[10];
   guint i, j;
   const guint limit = 10;
   gboolean all_stopped;

   /* Spawn a few threads. */
   g_thread_pool_set_max_unused_threads (-1);

   for (i = 0; i < G_N_ELEMENTS (pools); i++)
     {
       pools[i] = g_thread_pool_new ((GFunc) g_usleep, NULL, -1, FALSE, NULL);

       for (j = 0; j < limit; j++)
         g_thread_pool_push (pools[i], GUINT_TO_POINTER (100), NULL);
     }

   all_stopped = FALSE;
   while (!all_stopped)
     {
       all_stopped = TRUE;
       for (i = 0; i < G_N_ELEMENTS (pools); i++)
         all_stopped &= (g_thread_pool_get_num_threads (pools[i]) == 0);
     }

   for (i = 0; i < G_N_ELEMENTS (pools); i++)
     {
       g_assert_cmpuint (g_thread_pool_get_num_threads (pools[i]), ==, 0);
       g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), >, 0);
     }

   /* Wait for threads to die. */
   g_thread_pool_stop_unused_threads ();

   while (g_thread_pool_get_num_unused_threads () != 0)
     g_usleep (100);

   g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), ==, 0);

   for (i = 0; i < G_N_ELEMENTS (pools); i++)
     g_thread_pool_free (pools[i], FALSE, TRUE);
 }

 static void
 test_threadpool_pools_entry_func (gpointer data, gpointer user_data)
 {
   G_LOCK (thread_counter_pools);
   abs_thread_counter++;
   running_thread_counter++;
   G_UNLOCK (thread_counter_pools);

   g_usleep (g_random_int_range (0, 4000));

   G_LOCK (thread_counter_pools);
   running_thread_counter--;
   leftover_task_counter--;

   G_UNLOCK (thread_counter_pools);
 }

 static void
 test_threadpool_pools (void)
 {
   GThreadPool *pool1, *pool2, *pool3;
   guint runs;
   guint i;

   pool1 = g_thread_pool_new ((GFunc) test_threadpool_pools_entry_func, NULL, 3, FALSE, NULL);
   pool2 = g_thread_pool_new ((GFunc) test_threadpool_pools_entry_func, NULL, 5, TRUE, NULL);
   pool3 = g_thread_pool_new ((GFunc) test_threadpool_pools_entry_func, NULL, 7, TRUE, NULL);

   runs = 300;
   for (i = 0; i < runs; i++)
     {
       g_thread_pool_push (pool1, GUINT_TO_POINTER (i + 1), NULL);
       g_thread_pool_push (pool2, GUINT_TO_POINTER (i + 1), NULL);
       g_thread_pool_push (pool3, GUINT_TO_POINTER (i + 1), NULL);

       G_LOCK (thread_counter_pools);
       leftover_task_counter += 3;
       G_UNLOCK (thread_counter_pools);
     }

   g_thread_pool_free (pool1, TRUE, TRUE);
   g_thread_pool_free (pool2, FALSE, TRUE);
   g_thread_pool_free (pool3, FALSE, TRUE);

   g_assert_cmpint (runs * 3, ==, abs_thread_counter + leftover_task_counter);
   g_assert_cmpint (running_thread_counter, ==, 0);
 }

 static gint
 test_threadpool_sort_compare_func (gconstpointer a, gconstpointer b, gpointer user_data)
 {
   guint32 id1, id2;

   id1 = GPOINTER_TO_UINT (a);
   id2 = GPOINTER_TO_UINT (b);

   return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);
 }

 static void
 test_threadpool_sort_entry_func (gpointer data, gpointer user_data)
 {
   guint thread_id;
   gboolean is_sorted;
   static GMutex last_thread_mutex;
   static guint last_thread_id = 0;

   g_mutex_lock (&last_thread_mutex);

   thread_id = GPOINTER_TO_UINT (data);
   is_sorted = GPOINTER_TO_INT (user_data);

   if (is_sorted)
     {
       if (last_thread_id != 0)
         g_assert_cmpint (last_thread_id, <=, thread_id);

       last_thread_id = thread_id;
     }

   g_mutex_unlock (&last_thread_mutex);

   g_usleep (WAIT * 1000);
 }

 static void
 test_threadpool_sort (gconstpointer data)
 {
   gboolean sort = GPOINTER_TO_UINT (data);
   GThreadPool *pool;
   guint limit;
   guint max_threads;
   guint i;
   GError *local_error = NULL;

   limit = MAX_THREADS * 10;

   if (sort) {
     max_threads = 1;
   } else {
     max_threads = MAX_THREADS;
   }

   /* It is important that we only have a maximum of 1 thread for this
    * test since the results can not be guaranteed to be sorted if > 1.
    *
    * Threads are scheduled by the operating system and are executed at
    * random. It cannot be assumed that threads are executed in the
    * order they are created. This was discussed in bug #334943.
    *
    * However, if testing sorting, we start with max-threads=0 so that all the
    * work can be enqueued before starting the pool. This prevents a race between
    * new work being enqueued out of sorted order, and work being pulled off the
    * queue.
    */

   pool = g_thread_pool_new (test_threadpool_sort_entry_func,
 			    GINT_TO_POINTER (sort),
 			    sort ? 0 : max_threads,
 			    FALSE,
 			    NULL);

   g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);

   if (sort) {
     g_thread_pool_set_sort_function (pool,
 				     test_threadpool_sort_compare_func,
 				     NULL);
   }

   for (i = 0; i < limit; i++) {
     guint id;

     id = g_random_int_range (1, limit) + 1;
     g_thread_pool_push (pool, GUINT_TO_POINTER (id), NULL);
     g_test_message ("%s ===> pushed new thread with id:%d, number "
                     "of threads:%d, unprocessed:%d",
                     sort ? "[  sorted]" : "[unsorted]",
                     id,
                     g_thread_pool_get_num_threads (pool),
                     g_thread_pool_unprocessed (pool));
   }

   if (sort)
     {
       g_test_message ("Starting thread pool processing");
       g_thread_pool_set_max_threads (pool, max_threads, &local_error);
       g_assert_no_error (local_error);
     }

   g_assert_cmpint (g_thread_pool_get_max_threads (pool), ==, (gint) max_threads);
   g_assert_cmpuint (g_thread_pool_get_num_threads (pool), <=,
                     (guint) g_thread_pool_get_max_threads (pool));
   g_thread_pool_free (pool, TRUE, TRUE);
 }

 static void
 test_threadpool_idle_time_entry_func (gpointer data, gpointer user_data)
 {
   g_usleep (WAIT * 1000);
 }

 static gboolean
 test_threadpool_idle_timeout (gpointer data)
 {
   gboolean *idle_timeout_called = data;
   gint i;

   *idle_timeout_called = TRUE;

   for (i = 0; i < 2; i++) {
     g_thread_pool_push (idle_pool, GUINT_TO_POINTER (100 + i), NULL);
   }

   g_main_context_wakeup (NULL);

   return G_SOURCE_REMOVE;
 }

 static gboolean
 poll_cb (gpointer data)
 {
   g_main_context_wakeup (NULL);
   return G_SOURCE_CONTINUE;
 }

 static void
 test_threadpool_idle_time (void)
 {
   guint limit = 50;
   guint interval = 10000;
   guint i;
   guint idle;
   gboolean idle_timeout_called = FALSE;
   GSource *timeout_source = NULL;
   GSource *poll_source = NULL;

   idle_pool = g_thread_pool_new (test_threadpool_idle_time_entry_func,
 				 NULL,
 				 0,
 				 FALSE,
 				 NULL);

   g_thread_pool_set_max_threads (idle_pool, MAX_THREADS, NULL);
   g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
   g_thread_pool_set_max_idle_time (interval);

   g_assert_cmpint (g_thread_pool_get_max_threads (idle_pool), ==,
                    MAX_THREADS);
   g_assert_cmpint (g_thread_pool_get_max_unused_threads (), ==,
                    MAX_UNUSED_THREADS);
   g_assert_cmpint (g_thread_pool_get_max_idle_time (), ==, interval);

   for (i = 0; i < limit; i++) {
     g_thread_pool_push (idle_pool, GUINT_TO_POINTER (i + 1), NULL);
   }

   g_assert_cmpint (g_thread_pool_unprocessed (idle_pool), <=, limit);

   timeout_source = g_timeout_source_new (interval - 1000);
   g_source_set_callback (timeout_source, test_threadpool_idle_timeout, &idle_timeout_called, NULL);
   g_source_attach (timeout_source, NULL);

   /* Wait until the idle timeout has been called at least once and there are no
    * unused threads. We need a second timeout for this, to periodically wake
    * the main context up, as there’s no way to be notified of changes to `idle`.
    */
   poll_source = g_timeout_source_new (500);
   g_source_set_callback (poll_source, poll_cb, NULL, NULL);
   g_source_attach (poll_source, NULL);

   idle = g_thread_pool_get_num_unused_threads ();
   while (!idle_timeout_called || idle > 0)
     {
       g_test_message ("Pool idle thread count: %d, unprocessed jobs: %d",
                       idle, g_thread_pool_unprocessed (idle_pool));
       g_main_context_iteration (NULL, TRUE);
       idle = g_thread_pool_get_num_unused_threads ();
     }

   g_thread_pool_free (idle_pool, FALSE, TRUE);
   g_source_destroy (poll_source);
   g_source_unref (poll_source);
   g_source_destroy (timeout_source);
   g_source_unref (timeout_source);
 }

 int
 main (int argc, char *argv[])
 {
   g_test_init (&argc, &argv, NULL);

   g_test_add_func ("/threadpool/functions", test_threadpool_functions);
   g_test_add_func ("/threadpool/stop-unused", test_threadpool_stop_unused);
   g_test_add_func ("/threadpool/pools", test_threadpool_pools);
   g_test_add_data_func ("/threadpool/no-sort", GUINT_TO_POINTER (FALSE), test_threadpool_sort);
   g_test_add_data_func ("/threadpool/sort", GUINT_TO_POINTER (TRUE), test_threadpool_sort);
   g_test_add_func ("/threadpool/stop-unused-multiple", test_threadpool_stop_unused_multiple);
   g_test_add_func ("/threadpool/idle-time", test_threadpool_idle_time);

   return g_test_run ();
 }
	#include "config.h"

	#include <glib.h>

	#define WAIT 5 /* seconds */
	#define MAX_THREADS 10

	/* if > 0 the test will run continuously (since the test ends when
	* thread count is 0), if -1 it means no limit to unused threads
	* if 0 then no unused threads are possible */
	#define MAX_UNUSED_THREADS -1

	G_LOCK_DEFINE_STATIC (thread_counter_pools);

	static gulong abs_thread_counter = 0;
	static gulong running_thread_counter = 0;
	static gulong leftover_task_counter = 0;

	static GThreadPool *idle_pool = NULL;

	static void
	test_threadpool_functions (void)
	{
	gint max_unused_threads;
	guint max_idle_time;

	/* This function attempts to call functions which don't need a
	* threadpool to operate to make sure no uninitialised pointers
	* accessed and no errors occur.
	*/

	max_unused_threads = 3;

	g_thread_pool_set_max_unused_threads (max_unused_threads);

	g_assert_cmpint (g_thread_pool_get_max_unused_threads (), ==,
	max_unused_threads);

	g_assert_cmpint (g_thread_pool_get_num_unused_threads (), ==, 0);

	g_thread_pool_stop_unused_threads ();

	max_idle_time = 10 * G_USEC_PER_SEC;

	g_thread_pool_set_max_idle_time (max_idle_time);

	g_assert_cmpint (g_thread_pool_get_max_idle_time (), ==, max_idle_time);

	g_thread_pool_set_max_idle_time (0);

	g_assert_cmpint (g_thread_pool_get_max_idle_time (), ==, 0);
	}

	static void
	test_threadpool_stop_unused (void)
	{
	GThreadPool *pool;
	guint i;
	guint limit = 100;

	/* Spawn a few threads. */
	g_thread_pool_set_max_unused_threads (-1);
	pool = g_thread_pool_new ((GFunc) g_usleep, NULL, -1, FALSE, NULL);

	for (i = 0; i < limit; i++)
	g_thread_pool_push (pool, GUINT_TO_POINTER (1000), NULL);

	/* Wait for the threads to migrate. */
	while (g_thread_pool_get_num_threads (pool) != 0)
	g_usleep (100);

	g_assert_cmpuint (g_thread_pool_get_num_threads (pool), ==, 0);
	g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), >, 0);

	/* Wait for threads to die. */
	g_thread_pool_stop_unused_threads ();

	while (g_thread_pool_get_num_unused_threads () != 0)
	g_usleep (100);

	g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), ==, 0);

	g_thread_pool_set_max_unused_threads (MAX_THREADS);

	g_assert_cmpuint (g_thread_pool_get_num_threads (pool), ==, 0);
	g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), ==, 0);

	g_thread_pool_free (pool, FALSE, TRUE);
	}

	static void
	test_threadpool_stop_unused_multiple (void)
	{
	GThreadPool *pools[10];
	guint i, j;
	const guint limit = 10;
	gboolean all_stopped;

	/* Spawn a few threads. */
	g_thread_pool_set_max_unused_threads (-1);

	for (i = 0; i < G_N_ELEMENTS (pools); i++)
	{
	pools[i] = g_thread_pool_new ((GFunc) g_usleep, NULL, -1, FALSE, NULL);

	for (j = 0; j < limit; j++)
	g_thread_pool_push (pools[i], GUINT_TO_POINTER (100), NULL);
	}

	all_stopped = FALSE;
	while (!all_stopped)
	{
	all_stopped = TRUE;
	for (i = 0; i < G_N_ELEMENTS (pools); i++)
	all_stopped &= (g_thread_pool_get_num_threads (pools[i]) == 0);
	}

	for (i = 0; i < G_N_ELEMENTS (pools); i++)
	{
	g_assert_cmpuint (g_thread_pool_get_num_threads (pools[i]), ==, 0);
	g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), >, 0);
	}

	/* Wait for threads to die. */
	g_thread_pool_stop_unused_threads ();

	while (g_thread_pool_get_num_unused_threads () != 0)
	g_usleep (100);

	g_assert_cmpuint (g_thread_pool_get_num_unused_threads (), ==, 0);

	for (i = 0; i < G_N_ELEMENTS (pools); i++)
	g_thread_pool_free (pools[i], FALSE, TRUE);
	}

	static void
	test_threadpool_pools_entry_func (gpointer data, gpointer user_data)
	{
	G_LOCK (thread_counter_pools);
	abs_thread_counter++;
	running_thread_counter++;
	G_UNLOCK (thread_counter_pools);

	g_usleep (g_random_int_range (0, 4000));

	G_LOCK (thread_counter_pools);
	running_thread_counter--;
	leftover_task_counter--;

	G_UNLOCK (thread_counter_pools);
	}

	static void
	test_threadpool_pools (void)
	{
	GThreadPool pool1, pool2, *pool3;
	guint runs;
	guint i;

	pool1 = g_thread_pool_new ((GFunc) test_threadpool_pools_entry_func, NULL, 3, FALSE, NULL);
	pool2 = g_thread_pool_new ((GFunc) test_threadpool_pools_entry_func, NULL, 5, TRUE, NULL);
	pool3 = g_thread_pool_new ((GFunc) test_threadpool_pools_entry_func, NULL, 7, TRUE, NULL);

	runs = 300;
	for (i = 0; i < runs; i++)
	{
	g_thread_pool_push (pool1, GUINT_TO_POINTER (i + 1), NULL);
	g_thread_pool_push (pool2, GUINT_TO_POINTER (i + 1), NULL);
	g_thread_pool_push (pool3, GUINT_TO_POINTER (i + 1), NULL);

	G_LOCK (thread_counter_pools);
	leftover_task_counter += 3;
	G_UNLOCK (thread_counter_pools);
	}

	g_thread_pool_free (pool1, TRUE, TRUE);
	g_thread_pool_free (pool2, FALSE, TRUE);
	g_thread_pool_free (pool3, FALSE, TRUE);

	g_assert_cmpint (runs * 3, ==, abs_thread_counter + leftover_task_counter);
	g_assert_cmpint (running_thread_counter, ==, 0);
	}

	static gint
	test_threadpool_sort_compare_func (gconstpointer a, gconstpointer b, gpointer user_data)
	{
	guint32 id1, id2;

	id1 = GPOINTER_TO_UINT (a);
	id2 = GPOINTER_TO_UINT (b);

	return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);
	}

	static void
	test_threadpool_sort_entry_func (gpointer data, gpointer user_data)
	{
	guint thread_id;
	gboolean is_sorted;
	static GMutex last_thread_mutex;
	static guint last_thread_id = 0;

	g_mutex_lock (&last_thread_mutex);

	thread_id = GPOINTER_TO_UINT (data);
	is_sorted = GPOINTER_TO_INT (user_data);

	if (is_sorted)
	{
	if (last_thread_id != 0)
	g_assert_cmpint (last_thread_id, <=, thread_id);

	last_thread_id = thread_id;
	}

	g_mutex_unlock (&last_thread_mutex);

	g_usleep (WAIT * 1000);
	}

	static void
	test_threadpool_sort (gconstpointer data)
	{
	gboolean sort = GPOINTER_TO_UINT (data);
	GThreadPool *pool;
	guint limit;
	guint max_threads;
	guint i;
	GError *local_error = NULL;

	limit = MAX_THREADS * 10;

	if (sort) {
	max_threads = 1;
	} else {
	max_threads = MAX_THREADS;
	}

	/* It is important that we only have a maximum of 1 thread for this
	* test since the results can not be guaranteed to be sorted if > 1.
	*
	* Threads are scheduled by the operating system and are executed at
	* random. It cannot be assumed that threads are executed in the
	* order they are created. This was discussed in bug #334943.
	*
	* However, if testing sorting, we start with max-threads=0 so that all the
	* work can be enqueued before starting the pool. This prevents a race between
	* new work being enqueued out of sorted order, and work being pulled off the
	* queue.
	*/

	pool = g_thread_pool_new (test_threadpool_sort_entry_func,
	GINT_TO_POINTER (sort),
	sort ? 0 : max_threads,
	FALSE,
	NULL);

	g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);

	if (sort) {
	g_thread_pool_set_sort_function (pool,
	test_threadpool_sort_compare_func,
	NULL);
	}

	for (i = 0; i < limit; i++) {
	guint id;

	id = g_random_int_range (1, limit) + 1;
	g_thread_pool_push (pool, GUINT_TO_POINTER (id), NULL);
	g_test_message ("%s ===> pushed new thread with id:%d, number "
	"of threads:%d, unprocessed:%d",
	sort ? "[ sorted]" : "[unsorted]",
	id,
	g_thread_pool_get_num_threads (pool),
	g_thread_pool_unprocessed (pool));
	}

	if (sort)
	{
	g_test_message ("Starting thread pool processing");
	g_thread_pool_set_max_threads (pool, max_threads, &local_error);
	g_assert_no_error (local_error);
	}

	g_assert_cmpint (g_thread_pool_get_max_threads (pool), ==, (gint) max_threads);
	g_assert_cmpuint (g_thread_pool_get_num_threads (pool), <=,
	(guint) g_thread_pool_get_max_threads (pool));
	g_thread_pool_free (pool, TRUE, TRUE);
	}

	static void
	test_threadpool_idle_time_entry_func (gpointer data, gpointer user_data)
	{
	g_usleep (WAIT * 1000);
	}

	static gboolean
	test_threadpool_idle_timeout (gpointer data)
	{
	gboolean *idle_timeout_called = data;
	gint i;

	*idle_timeout_called = TRUE;

	for (i = 0; i < 2; i++) {
	g_thread_pool_push (idle_pool, GUINT_TO_POINTER (100 + i), NULL);
	}

	g_main_context_wakeup (NULL);

	return G_SOURCE_REMOVE;
	}

	static gboolean
	poll_cb (gpointer data)
	{
	g_main_context_wakeup (NULL);
	return G_SOURCE_CONTINUE;
	}

	static void
	test_threadpool_idle_time (void)
	{
	guint limit = 50;
	guint interval = 10000;
	guint i;
	guint idle;
	gboolean idle_timeout_called = FALSE;
	GSource *timeout_source = NULL;
	GSource *poll_source = NULL;

	idle_pool = g_thread_pool_new (test_threadpool_idle_time_entry_func,
	NULL,
	0,
	FALSE,
	NULL);

	g_thread_pool_set_max_threads (idle_pool, MAX_THREADS, NULL);
	g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);
	g_thread_pool_set_max_idle_time (interval);

	g_assert_cmpint (g_thread_pool_get_max_threads (idle_pool), ==,
	MAX_THREADS);
	g_assert_cmpint (g_thread_pool_get_max_unused_threads (), ==,
	MAX_UNUSED_THREADS);
	g_assert_cmpint (g_thread_pool_get_max_idle_time (), ==, interval);

	for (i = 0; i < limit; i++) {
	g_thread_pool_push (idle_pool, GUINT_TO_POINTER (i + 1), NULL);
	}

	g_assert_cmpint (g_thread_pool_unprocessed (idle_pool), <=, limit);

	timeout_source = g_timeout_source_new (interval - 1000);
	g_source_set_callback (timeout_source, test_threadpool_idle_timeout, &idle_timeout_called, NULL);
	g_source_attach (timeout_source, NULL);

	/* Wait until the idle timeout has been called at least once and there are no
	* unused threads. We need a second timeout for this, to periodically wake
	* the main context up, as there’s no way to be notified of changes to `idle`.
	*/
	poll_source = g_timeout_source_new (500);
	g_source_set_callback (poll_source, poll_cb, NULL, NULL);
	g_source_attach (poll_source, NULL);

	idle = g_thread_pool_get_num_unused_threads ();
	while (!idle_timeout_called \|\| idle > 0)
	{
	g_test_message ("Pool idle thread count: %d, unprocessed jobs: %d",
	idle, g_thread_pool_unprocessed (idle_pool));
	g_main_context_iteration (NULL, TRUE);
	idle = g_thread_pool_get_num_unused_threads ();
	}

	g_thread_pool_free (idle_pool, FALSE, TRUE);
	g_source_destroy (poll_source);
	g_source_unref (poll_source);
	g_source_destroy (timeout_source);
	g_source_unref (timeout_source);
	}

	int
	main (int argc, char *argv[])
	{
	g_test_init (&argc, &argv, NULL);

	g_test_add_func ("/threadpool/functions", test_threadpool_functions);
	g_test_add_func ("/threadpool/stop-unused", test_threadpool_stop_unused);
	g_test_add_func ("/threadpool/pools", test_threadpool_pools);
	g_test_add_data_func ("/threadpool/no-sort", GUINT_TO_POINTER (FALSE), test_threadpool_sort);
	g_test_add_data_func ("/threadpool/sort", GUINT_TO_POINTER (TRUE), test_threadpool_sort);
	g_test_add_func ("/threadpool/stop-unused-multiple", test_threadpool_stop_unused_multiple);
	g_test_add_func ("/threadpool/idle-time", test_threadpool_idle_time);

	return g_test_run ();
	}