/*

 * test-events.c: unit tests for libvirt/glib mainloop integration

 *

 * Copyright (C) 2014 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library 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.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library. If not, see

 * <http://www.gnu.org/licenses/>.

 *

 * Author: Christophe Fergeau <cfergeau@redhat.com>

 */

#include <config.h>

#include <libvirt-glib/libvirt-glib.h>

#include <libvirt/libvirt.h>

#include <errno.h>

#include <fcntl.h>

#include <unistd.h>

static GMainLoop *main_loop;

static int watch_fd;

static int watch_id;

static int timeout_id;

static void watch_destroyed(void *opaque)

{

    gint *watch = opaque;

    g_assert_cmpint(*watch, >=, 0);

    g_assert_cmpint(*watch, ==, watch_id);

    g_message("destroyed watch %d", *watch);

    *watch = -1;

}

static gboolean check_destroyed(gpointer user_data)

{

    gint *id = user_data;

    g_assert_cmpint(*id, ==, -1);

    return G_SOURCE_REMOVE;

}

static void watch_cb(int watch, int fd, int events, void *opaque G_GNUC_UNUSED)

{

    g_assert_cmpint(watch_id, !=, -1);

    g_assert_cmpint(watch, ==, watch_id);

    g_assert_cmpint(fd, ==, watch_fd);

    g_message("got event(s) %x on fd %d (watch %d)", events, fd, watch);

}

static gboolean idle_quit_cb(gpointer user_data G_GNUC_UNUSED)

{

    g_main_loop_quit(main_loop);

    return G_SOURCE_REMOVE;

}

static gboolean test_watch(gpointer user_data G_GNUC_UNUSED)

{

    int removal_status;

    watch_id = virEventAddHandle(watch_fd,

                                 VIR_EVENT_HANDLE_READABLE | VIR_EVENT_HANDLE_WRITABLE,

                                 watch_cb, &watch_id, watch_destroyed);

    virEventUpdateHandle(watch_id, 0);

    removal_status = virEventRemoveHandle(watch_id);

    g_assert_cmpint(removal_status, ==, 0);

    virEventUpdateHandle(watch_id, VIR_EVENT_HANDLE_READABLE);

    removal_status = virEventRemoveHandle(watch_id);

    g_assert_cmpint(removal_status, ==, -1);

    g_idle_add_full(G_PRIORITY_LOW, check_destroyed, &watch_id, NULL);

    g_idle_add_full(G_PRIORITY_LOW,

                    idle_quit_cb,

                    main_loop,

                    NULL);

    return G_SOURCE_REMOVE;

}

static void test_remove_disabled_watch(void)

{

    main_loop = g_main_loop_new(NULL, FALSE);

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

    g_idle_add(test_watch, NULL);

    g_main_loop_run(main_loop);

    g_main_loop_unref(main_loop);

    close(watch_fd);

    watch_fd = -1;

    g_assert_cmpint(watch_id, ==, -1);

}

static void timeout_destroyed(void *opaque)

{

    gint *timeout = opaque;

    g_assert_cmpint(*timeout, !=, -1);

    g_assert_cmpint(*timeout, ==, timeout_id);

    g_message("destroyed timeout %d", *timeout);

    *timeout = -1;

}

static void timeout_cb(int timer, void *opaque G_GNUC_UNUSED)

{

    g_assert_cmpint(timeout_id, !=, -1);

    g_assert_cmpint(timer, ==, timeout_id);

    g_message("timer %d fired", timer);

}

static gboolean test_timeout(gpointer user_data G_GNUC_UNUSED)

{

    int removal_status;

    timeout_id = virEventAddTimeout(10000, timeout_cb, &timeout_id, timeout_destroyed);

    virEventUpdateTimeout(timeout_id, -1);

    removal_status = virEventRemoveTimeout(timeout_id);

    g_assert_cmpint(removal_status, ==, 0);

    virEventUpdateTimeout(timeout_id, 20000);

    removal_status = virEventRemoveTimeout(timeout_id);

    g_assert_cmpint(removal_status, ==, -1);

    g_idle_add_full(G_PRIORITY_LOW, check_destroyed, &timeout_id, NULL);

    g_idle_add_full(G_PRIORITY_LOW,

                    (GSourceFunc)g_main_loop_quit,

                    main_loop,

                    NULL);

    return G_SOURCE_REMOVE;

}

static void test_remove_disabled_timeout(void)

{

    main_loop = g_main_loop_new(NULL, FALSE);

    g_idle_add(test_timeout, NULL);

    g_main_loop_run(main_loop);

    g_main_loop_unref(main_loop);

    g_assert_cmpint(timeout_id, ==, -1);

}

int main(int argc, char **argv)

{

    gvir_init(&argc, &argv);

    g_test_init(&argc, &argv, NULL);

    gvir_event_register();

    g_test_add_func("/libvirt-glib/remove-disabled-watch",

                    test_remove_disabled_watch);

    g_test_add_func("/libvirt-glib/remove-disabled-timeout",

                    test_remove_disabled_timeout);

    return g_test_run();

}