#include <glib-object.h>

#ifdef G_OS_UNIX

#include <glib-unix.h>

#include <fcntl.h>

#include <signal.h>

#include <unistd.h>

#endif

static void

test_source (GSource *one, GCallback quit_callback)

{

  GClosure *closure;

  GMainLoop *loop;

  /* Callback with GMainLoop user_data */

  loop = g_main_loop_new (NULL, FALSE);

  closure = g_cclosure_new (quit_callback, loop, NULL);

  g_source_set_closure (one, closure);

  g_source_attach (one, NULL);

  g_main_loop_run (loop);

  g_source_destroy (one);

  g_main_loop_unref (loop);

}

static gboolean

simple_quit_callback (gpointer user_data)

{

  GMainLoop *loop = user_data;

  g_main_loop_quit (loop);

  return TRUE;

}

static void

test_closure_idle (void)

{

  GSource *source;

  source = g_idle_source_new ();

  test_source (source, G_CALLBACK (simple_quit_callback));

  g_source_unref (source);

}

static void

test_closure_timeout (void)

{

  GSource *source;

  source = g_timeout_source_new (10);

  test_source (source, G_CALLBACK (simple_quit_callback));

  g_source_unref (source);

}

static gboolean

iochannel_quit_callback (GIOChannel   *channel,

                         GIOCondition  cond,

                         gpointer      user_data)

{

  GMainLoop *loop = user_data;

  g_main_loop_quit (loop);

  return TRUE;

}

static void

test_closure_iochannel (void)

{

  GIOChannel *chan;

  GSource *source;

  char *path;

  GError *error = NULL;

  if (g_path_is_absolute (g_get_prgname ()))

    path = g_strdup (g_get_prgname ());

  else

    {

      path = g_test_build_filename (G_TEST_BUILT,

                                    g_get_prgname (),

                                    NULL);

    }

  chan = g_io_channel_new_file (path, "r", &error);

  g_assert_no_error (error);

  g_free (path);

  source = g_io_create_watch (chan, G_IO_IN);

  test_source (source, G_CALLBACK (iochannel_quit_callback));

  g_source_unref (source);

  g_io_channel_unref (chan);

}

static void

test_closure_child (void)

{

  GSource *source;

  GPid pid;

  GError *error = NULL;

  gchar *argv[3];

  g_assert (g_getenv ("DO_NOT_ACCIDENTALLY_RECURSE") == NULL);

  g_setenv ("DO_NOT_ACCIDENTALLY_RECURSE", "1", TRUE);

  if (g_path_is_absolute (g_get_prgname ()))

    argv[0] = g_strdup (g_get_prgname ());

  else

    {

      argv[0] = g_test_build_filename (G_TEST_BUILT,

                                       g_get_prgname (),

                                       NULL);

    }

  argv[1] = "-l";

  argv[2] = NULL;

  g_spawn_async (NULL, argv, NULL,

                 G_SPAWN_STDOUT_TO_DEV_NULL |

                 G_SPAWN_STDERR_TO_DEV_NULL |

                 G_SPAWN_DO_NOT_REAP_CHILD,

                 NULL, NULL,

                 &pid, &error);

  g_assert_no_error (error);

  g_free (argv[0]);

  source = g_child_watch_source_new (pid);

  test_source (source, G_CALLBACK (iochannel_quit_callback));

  g_source_unref (source);

}

#ifdef G_OS_UNIX

static gboolean

fd_quit_callback (gint         fd,

                  GIOCondition condition,

                  gpointer     user_data)

{

  GMainLoop *loop = user_data;

  g_main_loop_quit (loop);

  return TRUE;

}

static void

test_closure_fd (void)

{

  gint fd;

  GSource *source;

  fd = open ("/dev/null", O_RDONLY);

  g_assert (fd != -1);

  source = g_unix_fd_source_new (fd, G_IO_IN);

  test_source (source, G_CALLBACK (fd_quit_callback));

  g_source_unref (source);

  close (fd);

}

static gboolean

send_usr1 (gpointer user_data)

{

  kill (getpid (), SIGUSR1);

  return FALSE;

}

static gboolean

closure_quit_callback (gpointer     user_data)

{

  GMainLoop *loop = user_data;

  g_main_loop_quit (loop);

  return TRUE;

}

static void

test_closure_signal (void)

{

  GSource *source;

  g_idle_add_full (G_PRIORITY_LOW, send_usr1, NULL, NULL);

  source = g_unix_signal_source_new (SIGUSR1);

  test_source (source, G_CALLBACK (closure_quit_callback));

  g_source_unref (source);

}

#endif

int

main (int argc,

      char *argv[])

{

#ifndef G_OS_WIN32

  sigset_t sig_mask, old_mask;

  sigemptyset (&sig_mask);

  sigaddset (&sig_mask, SIGUSR1);

  if (sigprocmask (SIG_UNBLOCK, &sig_mask, &old_mask) == 0)

    {

      if (sigismember (&old_mask, SIGUSR1))

        g_message ("SIGUSR1 was blocked, unblocking it");

    }

#endif

  g_test_init (&argc, &argv, NULL);

  g_test_add_func ("/closure/idle", test_closure_idle);

  g_test_add_func ("/closure/timeout", test_closure_timeout);

  g_test_add_func ("/closure/iochannel", test_closure_iochannel);

  g_test_add_func ("/closure/child", test_closure_child);

#ifdef G_OS_UNIX

  g_test_add_func ("/closure/fd", test_closure_fd);

  g_test_add_func ("/closure/signal", test_closure_signal);

#endif

  return g_test_run ();

}