#undef G_DISABLE_ASSERT

#undef G_LOG_DOMAIN

#include "config.h"

#include <glib.h>

/* #define DEBUG 1 */

#ifdef DEBUG

# define DEBUG_MSG(args) g_printerr args ; g_printerr ("\n");

#else

# define DEBUG_MSG(x)

#endif

#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;

G_LOCK_DEFINE_STATIC (last_thread);

static guint last_thread_id = 0;

G_LOCK_DEFINE_STATIC (thread_counter_sort);

static gulong sort_thread_counter = 0;

static GThreadPool *idle_pool = NULL;

static GMainLoop *main_loop = NULL;

static void

test_thread_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;

  DEBUG_MSG (("[funcs] Setting max unused threads to %d",

	      max_unused_threads));

  g_thread_pool_set_max_unused_threads (max_unused_threads);

  DEBUG_MSG (("[funcs] Getting max unused threads = %d",

	     g_thread_pool_get_max_unused_threads ()));

  g_assert (g_thread_pool_get_max_unused_threads() == max_unused_threads);

  DEBUG_MSG (("[funcs] Getting num unused threads = %d",

	     g_thread_pool_get_num_unused_threads ()));

  g_assert (g_thread_pool_get_num_unused_threads () == 0);

  DEBUG_MSG (("[funcs] Stopping unused threads"));

  g_thread_pool_stop_unused_threads ();

  max_idle_time = 10 * G_USEC_PER_SEC;

  DEBUG_MSG (("[funcs] Setting max idle time to %d",

	      max_idle_time));

  g_thread_pool_set_max_idle_time (max_idle_time);

  DEBUG_MSG (("[funcs] Getting max idle time = %d",

	     g_thread_pool_get_max_idle_time ()));

  g_assert (g_thread_pool_get_max_idle_time () == max_idle_time);

  DEBUG_MSG (("[funcs] Setting max idle time to 0"));

  g_thread_pool_set_max_idle_time (0);

  DEBUG_MSG (("[funcs] Getting max idle time = %d",

	     g_thread_pool_get_max_idle_time ()));

  g_assert (g_thread_pool_get_max_idle_time () == 0);

}

static void

test_thread_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);

   DEBUG_MSG (("[unused] ===> pushed %d threads onto the idle pool",

	       limit));

   /* Wait for the threads to migrate. */

   g_usleep (G_USEC_PER_SEC);

   DEBUG_MSG (("[unused] stopping unused threads"));

   g_thread_pool_stop_unused_threads ();

   for (i = 0; i < 5; i++)

     {

       if (g_thread_pool_get_num_unused_threads () == 0)

         break;

       DEBUG_MSG (("[unused] waiting ONE second for threads to die"));

       /* Some time for threads to die. */

       g_usleep (G_USEC_PER_SEC);

     }

   DEBUG_MSG (("[unused] stopped idle threads, %d remain",

	       g_thread_pool_get_num_unused_threads ()));

   g_assert (g_thread_pool_get_num_unused_threads () == 0);

   g_thread_pool_set_max_unused_threads (MAX_THREADS);

   DEBUG_MSG (("[unused] cleaning up thread pool"));

   g_thread_pool_free (pool, FALSE, TRUE);

}

static void

test_thread_pools_entry_func (gpointer data, gpointer user_data)

{

#ifdef DEBUG

  guint id = 0;

  id = GPOINTER_TO_UINT (data);

#endif

  DEBUG_MSG (("[pool] ---> [%3.3d] entered thread.", id));

  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--;

  DEBUG_MSG (("[pool] ---> [%3.3d] exiting thread (abs count:%ld, "

	      "running count:%ld, left over:%ld)",

	      id, abs_thread_counter,

	      running_thread_counter, leftover_task_counter));

  G_UNLOCK (thread_counter_pools);

}

static void

test_thread_pools (void)

{

  GThreadPool *pool1, *pool2, *pool3;

  guint runs;

  guint i;

  pool1 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 3, FALSE, NULL);

  pool2 = g_thread_pool_new ((GFunc)test_thread_pools_entry_func, NULL, 5, TRUE, NULL);

  pool3 = g_thread_pool_new ((GFunc)test_thread_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 (runs * 3 == abs_thread_counter + leftover_task_counter);

  g_assert (running_thread_counter == 0);

}

static gint

test_thread_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_thread_sort_entry_func (gpointer data, gpointer user_data)

{

  guint thread_id;

  gboolean is_sorted;

  G_LOCK (last_thread);

  thread_id = GPOINTER_TO_UINT (data);

  is_sorted = GPOINTER_TO_INT (user_data);

  DEBUG_MSG (("%s ---> entered thread:%2.2d, last thread:%2.2d",

	      is_sorted ? "[  sorted]" : "[unsorted]",

	      thread_id, last_thread_id));

  if (is_sorted) {

    static gboolean last_failed = FALSE;

    if (last_thread_id > thread_id) {

      if (last_failed) {

	g_assert (last_thread_id <= thread_id);

      }

      /* Here we remember one fail and if it concurrently fails, it

       * can not be sorted. the last thread id might be < this thread

       * id if something is added to the queue since threads were

       * created

       */

      last_failed = TRUE;

    } else {

      last_failed = FALSE;

    }

    last_thread_id = thread_id;

  }

  G_UNLOCK (last_thread);

  g_usleep (WAIT * 1000);

}

static void

test_thread_sort (gboolean sort)

{

  GThreadPool *pool;

  guint limit;

  guint max_threads;

  gint i;

  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.

   */

  pool = g_thread_pool_new (test_thread_sort_entry_func,

			    GINT_TO_POINTER (sort),

			    max_threads,

			    FALSE,

			    NULL);

  g_thread_pool_set_max_unused_threads (MAX_UNUSED_THREADS);

  if (sort) {

    g_thread_pool_set_sort_function (pool,

				     test_thread_sort_compare_func,

				     GUINT_TO_POINTER (69));

  }

  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);

    DEBUG_MSG (("%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)));

  }

  g_assert (g_thread_pool_get_max_threads (pool) == max_threads);

  g_assert (g_thread_pool_get_num_threads (pool) == g_thread_pool_get_max_threads (pool));

}

static void

test_thread_idle_time_entry_func (gpointer data, gpointer user_data)

{

#ifdef DEBUG

  guint thread_id;

  thread_id = GPOINTER_TO_UINT (data);

#endif

  DEBUG_MSG (("[idle] ---> entered thread:%2.2d", thread_id));

  g_usleep (WAIT * 1000);

  DEBUG_MSG (("[idle] <--- exiting thread:%2.2d", thread_id));

}

static gboolean

test_thread_idle_timeout (gpointer data)

{

  gint i;

  for (i = 0; i < 2; i++) {

    g_thread_pool_push (idle_pool, GUINT_TO_POINTER (100 + i), NULL);

    DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, number "

		"of threads:%d, unprocessed:%d",

		100 + i,

		g_thread_pool_get_num_threads (idle_pool),

		g_thread_pool_unprocessed (idle_pool)));

  }

  return FALSE;

}

static void

test_thread_idle_time (void)

{

  guint limit = 50;

  guint interval = 10000;

  gint i;

  idle_pool = g_thread_pool_new (test_thread_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 (g_thread_pool_get_max_threads (idle_pool) == MAX_THREADS);

  g_assert (g_thread_pool_get_max_unused_threads () == MAX_UNUSED_THREADS);

  g_assert (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);

    DEBUG_MSG (("[idle] ===> pushed new thread with id:%d, "

		"number of threads:%d, unprocessed:%d",

		i,

		g_thread_pool_get_num_threads (idle_pool),

		g_thread_pool_unprocessed (idle_pool)));

  }

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

  g_timeout_add ((interval - 1000),

		 test_thread_idle_timeout,

		 GUINT_TO_POINTER (interval));

}

static gboolean

test_check_start_and_stop (gpointer user_data)

{

  static guint test_number = 0;

  static gboolean run_next = FALSE;

  gboolean continue_timeout = TRUE;

  gboolean quit = TRUE;

  if (test_number == 0) {

    run_next = TRUE;

    DEBUG_MSG (("***** RUNNING TEST %2.2d *****", test_number));

  }

  if (run_next) {

    test_number++;

    switch (test_number) {

    case 1:

      test_thread_functions ();

      break;

    case 2:

      test_thread_stop_unused ();

      break;

    case 3:

      test_thread_pools ();

      break;

    case 4:

      test_thread_sort (FALSE);

      break;

    case 5:

      test_thread_sort (TRUE);

      break;

    case 6:

      test_thread_stop_unused ();

      break;

    case 7:

      test_thread_idle_time ();

      break;

    default:

      DEBUG_MSG (("***** END OF TESTS *****"));

      g_main_loop_quit (main_loop);

      continue_timeout = FALSE;

      break;

    }

    run_next = FALSE;

    return TRUE;

  }

  if (test_number == 3) {

    G_LOCK (thread_counter_pools);

    quit &= running_thread_counter <= 0;

    DEBUG_MSG (("***** POOL RUNNING THREAD COUNT:%ld",

		running_thread_counter));

    G_UNLOCK (thread_counter_pools);

  }

  if (test_number == 4 || test_number == 5) {

    G_LOCK (thread_counter_sort);

    quit &= sort_thread_counter <= 0;

    DEBUG_MSG (("***** POOL SORT THREAD COUNT:%ld",

		sort_thread_counter));

    G_UNLOCK (thread_counter_sort);

  }

  if (test_number == 7) {

    guint idle;

    idle = g_thread_pool_get_num_unused_threads ();

    quit &= idle < 1;

    DEBUG_MSG (("***** POOL IDLE THREAD COUNT:%d, UNPROCESSED JOBS:%d",

		idle, g_thread_pool_unprocessed (idle_pool)));

  }

  if (quit) {

    run_next = TRUE;

  }

  return continue_timeout;

}

int

main (int argc, char *argv[])

{

  DEBUG_MSG (("Starting... (in one second)"));

  g_timeout_add (1000, test_check_start_and_stop, NULL);

  main_loop = g_main_loop_new (NULL, FALSE);

  g_main_loop_run (main_loop);

  g_main_loop_unref (main_loop);

  g_thread_pool_free (idle_pool, FALSE, TRUE);

  return 0;

}