wayland/tests/queue-test.c

/*
 * Copyright © 2012 Jonas Ådahl
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that copyright
 * notice and this permission notice appear in supporting documentation, and
 * that the name of the copyright holders not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  The copyright holders make no representations
 * about the suitability of this software for any purpose.  It is provided "as
 * is" without express or implied warranty.
 *
 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
 * OF THIS SOFTWARE.
 */

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <assert.h>

#include "wayland-client.h"
#include "wayland-server.h"
#include "test-runner.h"

#define SOCKET_NAME "wayland-queue-test"

#define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0])

#define client_assert(expr)					\
	do {							\
		if (!(expr)) {					\
			fprintf(stderr, "%s:%d: "		\
				"Assertion `%s' failed.\n",	\
				__FILE__, __LINE__, #expr);	\
			exit(EXIT_FAILURE);			\
		}						\
	} while (0)

struct display {
	struct wl_display *display;
	int child_exit_status;
};

static void
registry_handle_global(void *data, struct wl_registry *registry,
		       uint32_t id, const char *interface, uint32_t version)
{
	int *pcounter = data;
	(*pcounter)++;
	client_assert(*pcounter == 1);
	wl_registry_destroy(registry);
}

static const struct wl_registry_listener registry_listener = {
	registry_handle_global,
	NULL
};

/* Test that destroying a proxy object doesn't result in any more
 * callback being invoked, even though were many queued. */
static int
client_test_proxy_destroy(void)
{
	struct wl_display *display;
	struct wl_registry *registry;
	int counter = 0;

	display = wl_display_connect(SOCKET_NAME);
	client_assert(display);

	registry = wl_display_get_registry(display);
	assert(registry != NULL);
	wl_registry_add_listener(registry, &registry_listener,
				 &counter);
	wl_display_roundtrip(display);

	client_assert(counter == 1);

	/* don't destroy the registry, we have already destroyed them
	 * in the global handler */
	wl_display_disconnect(display);

	return 0;
}

struct multiple_queues_state {
	struct wl_display *display;
	struct wl_callback* callback2;
	bool done;
};

static void
sync_callback(void *data, struct wl_callback *callback, uint32_t serial)
{
	struct multiple_queues_state *state = data;

	state->done = true;
	wl_callback_destroy(callback);

	wl_display_dispatch_pending(state->display);

	wl_callback_destroy(state->callback2);
}

static const struct wl_callback_listener sync_listener = {
	sync_callback
};

/* Test that when receiving the first of two synchronization
 * callback events, destroying the second one doesn't cause any
 * errors even if the delete_id event is handled out of order. */
static int
client_test_multiple_queues(void)
{
	struct wl_event_queue *queue;
	struct wl_callback *callback1;
	struct multiple_queues_state state;
	int ret = 0;

	state.display = wl_display_connect(SOCKET_NAME);
	client_assert(state.display);

	queue = wl_display_create_queue(state.display);
	client_assert(queue);

	state.done = false;
	callback1 = wl_display_sync(state.display);
	assert(callback1 != NULL);
	wl_callback_add_listener(callback1, &sync_listener, &state);
	wl_proxy_set_queue((struct wl_proxy *) callback1, queue);

	state.callback2 = wl_display_sync(state.display);
	assert(state.callback2 != NULL);
	wl_callback_add_listener(state.callback2, &sync_listener, NULL);
	wl_proxy_set_queue((struct wl_proxy *) state.callback2, queue);

	wl_display_flush(state.display);

	while (!state.done && !ret)
		ret = wl_display_dispatch_queue(state.display, queue);

	wl_event_queue_destroy(queue);
	wl_display_disconnect(state.display);

	return ret == -1 ? -1 : 0;
}

static void
sync_callback_roundtrip(void *data, struct wl_callback *callback, uint32_t serial)
{
	bool *done = data;
	*done = true;
}

static const struct wl_callback_listener sync_listener_roundtrip = {
	sync_callback_roundtrip
};

/* Test that doing a roundtrip on a queue only the events on that
 * queue get dispatched. */
static int
client_test_queue_roundtrip(void)
{
	struct wl_event_queue *queue;
	struct wl_callback *callback1;
	struct wl_callback *callback2;
	struct wl_display *display;
	bool done1 = false;
	bool done2 = false;

	display = wl_display_connect(SOCKET_NAME);
	client_assert(display);

	queue = wl_display_create_queue(display);
	client_assert(queue);

	/* arm a callback on the default queue */
	callback1 = wl_display_sync(display);
	assert(callback1 != NULL);
	wl_callback_add_listener(callback1, &sync_listener_roundtrip, &done1);

	/* arm a callback on the other queue */
	callback2 = wl_display_sync(display);
	assert(callback2 != NULL);
	wl_callback_add_listener(callback2, &sync_listener_roundtrip, &done2);
	wl_proxy_set_queue((struct wl_proxy *) callback2, queue);

	/* roundtrip on default queue must not dispatch the other queue. */
	wl_display_roundtrip(display);
	client_assert(done1 == true);
	client_assert(done2 == false);

	/* re-arm the sync callback on the default queue, so we see that
	 * wl_display_roundtrip_queue() does not dispatch the default queue. */
	wl_callback_destroy(callback1);
	done1 = false;
	callback1 = wl_display_sync(display);
	assert(callback1 != NULL);
	wl_callback_add_listener(callback1, &sync_listener_roundtrip, &done1);

	wl_display_roundtrip_queue(display, queue);
	client_assert(done1 == false);
	client_assert(done2 == true);

	wl_callback_destroy(callback1);
	wl_callback_destroy(callback2);
	wl_event_queue_destroy(queue);

	wl_display_disconnect(display);

	return 0;
}

static void
client_alarm_handler(int sig)
{
	fprintf(stderr, "Received SIGALRM signal, aborting.\n");
	exit(EXIT_FAILURE);
}

static void
client_sigsegv_handler(int sig)
{
	fprintf(stderr, "Received SIGSEGV signal, aborting.\n");
	exit(EXIT_FAILURE);
}

static int
client_main(int fd)
{
	bool cont = false;

	signal(SIGSEGV, client_sigsegv_handler);
	signal(SIGALRM, client_alarm_handler);
	alarm(2);

	if (read(fd, &cont, sizeof cont) != 1) {
		close(fd);
		return EXIT_FAILURE;
	}
	close(fd);

	if (!cont)
		return EXIT_FAILURE;

	if (client_test_proxy_destroy() != 0) {
		fprintf(stderr, "proxy destroy test failed\n");
		return EXIT_FAILURE;
	}

	if (client_test_multiple_queues() != 0) {
		fprintf(stderr, "multiple proxy test failed\n");
		return EXIT_FAILURE;
	}

	if (client_test_queue_roundtrip() != 0) {
		fprintf(stderr, "queue rountrip test failed\n");
		return EXIT_FAILURE;
	}

	return EXIT_SUCCESS;
}

static void
dummy_bind(struct wl_client *client,
	   void *data, uint32_t version, uint32_t id)
{
}

static int
sigchld_handler(int signal_number, void *data)
{
	struct display *display = data;
	int status;

	waitpid(-1, &status, 0);
	display->child_exit_status = status;

	wl_display_terminate(display->display);

	return 0;
}

static void
signal_client(int fd, bool cont)
{
	int ret;

	ret = write(fd, &cont, sizeof cont);
	close(fd);
	assert(ret == sizeof cont);
}

TEST(queue)
{
	struct display display;
	struct wl_event_loop *loop;
	struct wl_event_source *signal_source;
	const struct wl_interface *dummy_interfaces[] = {
		&wl_seat_interface,
		&wl_pointer_interface,
		&wl_keyboard_interface,
		&wl_surface_interface
	};
	unsigned int i;
	pid_t pid;
	int fds[2];
	int ret;

	ret = pipe(fds);
	assert(ret == 0);

	pid = fork();
	if (pid == -1) {
		perror("fork");
		exit(EXIT_FAILURE);
	} else if (pid == 0) {
		close(fds[1]);
		exit(client_main(fds[0]));
	}
	close(fds[0]);

	display.child_exit_status = EXIT_FAILURE;
	display.display = wl_display_create();
	if (!display.display) {
		signal_client(fds[1], false);
		abort();
	}

	for (i = 0; i < ARRAY_LENGTH(dummy_interfaces); i++)
		wl_global_create(display.display, dummy_interfaces[i],
				 dummy_interfaces[i]->version,
				 NULL, dummy_bind);

	ret = wl_display_add_socket(display.display, SOCKET_NAME);
	assert(ret == 0);

	loop = wl_display_get_event_loop(display.display);
	signal_source = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
						 &display);

	signal_client(fds[1], true);
	wl_display_run(display.display);

	wl_event_source_remove(signal_source);
	wl_display_destroy(display.display);

	assert(WIFEXITED(display.child_exit_status) &&
	       WEXITSTATUS(display.child_exit_status) == EXIT_SUCCESS);
}