tests: Convert event-test to new test extension

Fixes https://bugs.freedesktop.org/show_bug.cgi?id=56819

Signed-off-by: U. Artie Eoff <ullysses.a.eoff@intel.com>

tests/.gitignore

@@ -6,3 +6,4 @@ wayland-test-client-protocol.h
 wayland-test-protocol.c
 wayland-test-server-protocol.h
 keyboard-test
+event-test

tests/Makefile.am

@@ -1,12 +1,13 @@
 TESTS = $(module_tests) $(weston_tests)
 
 module_tests = surface-test.la client-test.la	\
-	event-test.la text-test.la	\
+	text-test.la			\
 	surface-global-test.la		\
 	button-test.la
 
 weston_tests =				\
-	keyboard-test
+	keyboard-test			\
+	event-test
 
 TESTS_ENVIRONMENT = $(SHELL) $(top_srcdir)/tests/weston-tests-env
 
@@ -36,7 +37,6 @@ test_runner_src = test-runner.c test-runner.h
 surface_global_test_la_SOURCES = surface-global-test.c $(test_runner_src)
 surface_test_la_SOURCES = surface-test.c $(test_runner_src)
 client_test_la_SOURCES = client-test.c $(test_runner_src)
-event_test_la_SOURCES = event-test.c $(test_runner_src)
 text_test_la_SOURCES = text-test.c $(test_runner_src)
 button_test_la_SOURCES = button-test.c $(test_runner_src)
 
@@ -71,6 +71,9 @@ weston_test_client_libs =		\
 keyboard_test_SOURCES = keyboard-test.c $(weston_test_client_src)
 keyboard_test_LDADD = $(weston_test_client_libs)
 
+event_test_SOURCES = event-test.c $(weston_test_client_src)
+event_test_LDADD = $(weston_test_client_libs)
+
 matrix_test_SOURCES =				\
 	matrix-test.c				\
 	$(top_srcdir)/shared/matrix.c		\

tests/event-test.c

@@ -20,326 +20,329 @@
  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
-#include <stdlib.h>
+#include "weston-test-client-helper.h"
-#include <stdio.h>
-#include <sys/socket.h>
-#include <assert.h>
-#include <unistd.h>
-#include <string.h>
-
-#include "test-runner.h"
-
-struct state {
-	int px; /* pointer x */
-	int py; /* pointer y */
-	int sx; /* surface x */
-	int sy; /* surface y */
-	int sw; /* surface width */
-	int sh; /* surface height */
-};
-
-static size_t state_size = sizeof(struct state);
-
-struct context {
-	struct weston_layer *layer;
-	struct weston_seat *seat;
-	struct weston_surface *surface;
-	int pointer_x; /* server pointer x */
-	int pointer_y; /* server pointer y */
-	size_t index;
-	struct wl_array states;
-};
 
 static void
-resize(struct context *context, int w, int h)
+check_pointer(struct client *client, int x, int y)
 {
-	/* resize the surface only if the width or height is different */
+	int sx, sy;
-	if (context->surface->geometry.width != w ||
+
-	    context->surface->geometry.height != h) {
+	/* check that the client got the global pointer update */
-
+	assert(client->test->pointer_x == x);
-		weston_surface_configure(context->surface,
+	assert(client->test->pointer_y == y);
-					 context->surface->geometry.x,
+
-					 context->surface->geometry.y,
+	/* Does global pointer map onto the surface? */
-					 w, h);
+	if (surface_contains(client->surface, x, y)) {
-		weston_surface_update_transform(context->surface);
+		/* check that the surface has the pointer focus */
-		weston_surface_damage(context->surface);
+		assert(client->input->pointer->focus == client->surface);
-
+
-		fprintf(stderr, "resize surface: %d %d\n",
+		/*
-			context->surface->geometry.width,
+		 * check that the local surface pointer maps
-			context->surface->geometry.height);
+		 * to the global pointer.
+		 */
+		sx = client->input->pointer->x + client->surface->x;
+		sy = client->input->pointer->y + client->surface->y;
+		assert(sx == x);
+		assert(sy == y);
+	} else {
+		/*
+		 * The global pointer does not map onto surface.  So
+		 * check that it doesn't have the pointer focus.
+		 */
+		assert(client->input->pointer->focus == NULL);
 	}
 }
 
 static void
-move(struct context *context, int x, int y)
+check_pointer_move(struct client *client, int x, int y)
 {
-	/* move the surface only if x or y is different */
+	move_pointer(client, x, y);
-	if (context->surface->geometry.x != x ||
+	check_pointer(client, x, y);
-	    context->surface->geometry.y != y) {
-
-		weston_surface_configure(context->surface,
-					 x, y,
-					 context->surface->geometry.width,
-					 context->surface->geometry.height);
-		weston_surface_update_transform(context->surface);
-		weston_surface_damage(context->surface);
-
-		fprintf(stderr, "move surface: %f %f\n",
-			context->surface->geometry.x,
-			context->surface->geometry.y);
-	}
 }
 
-static int
+TEST(test_pointer_top_left)
-contains(struct context *context, int x, int y)
 {
-	/* test whether a global x,y point is contained in the surface */
+	struct client *client;
-	int sx = context->surface->geometry.x;
+	int x, y;
-	int sy = context->surface->geometry.y;
-	int sw = context->surface->geometry.width;
-	int sh = context->surface->geometry.height;
-	return x >= sx && y >= sy && x < sx + sw && y < sy + sh;
-}
 
-static void
+	client = client_create(46, 76, 111, 134);
-move_pointer(struct context *context, int x, int y)
+	assert(client);
-{
-	if (contains(context, context->pointer_x, context->pointer_y)) {
-		/* pointer is currently on the surface */
-		notify_motion(context->seat, 100,
-			      wl_fixed_from_int(x), wl_fixed_from_int(y));
-	} else {
-		/* pointer is not currently on the surface */
-		notify_pointer_focus(context->seat, context->surface->output,
-				     wl_fixed_from_int(x),
-				     wl_fixed_from_int(y));
-	}
 
-	/* update server expected pointer location */
+	/* move pointer outside top left */
-	context->pointer_x = x;
+	x = client->surface->x - 1;
-	context->pointer_y = y;
+	y = client->surface->y - 1;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
 
-	fprintf(stderr, "move pointer: %d %d\n", x, y);
+	/* move pointer on top left */
-}
+	x += 1; y += 1;
+	assert(surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
 
-static void
+	/* move pointer outside top left */
-check_pointer(struct context *context, int cx, int cy)
+	x -= 1; y -= 1;
-{
+	assert(!surface_contains(client->surface, x, y));
-	/*
+	check_pointer_move(client, x, y);
-	 * Check whether the client reported pointer position matches
-	 * the server expected pointer position.  The client
-	 * reports -1,-1 when the pointer is not on its surface and
-	 * a surface relative x,y otherwise.
-	 */
-	int gx = context->surface->geometry.x + cx;
-	int gy = context->surface->geometry.y + cy;
-	if (!contains(context, gx, gy)) {
-		assert(!contains(context, context->pointer_x,
-				 context->pointer_y));
-	} else {
-		assert(gx == context->pointer_x);
-		assert(gy == context->pointer_y);
-	}
 }
 
-static void
+TEST(test_pointer_bottom_left)
-check_visible(struct context *context, int visible)
 {
-	/*
+	struct client *client;
-	 * Check whether the client reported surface visibility matches
+	int x, y;
-	 * the servers expected surface visibility
-	 */
-	int ow = context->surface->output->width;
-	int oh = context->surface->output->height;
-	int sx = context->surface->geometry.x;
-	int sy = context->surface->geometry.y;
-	int sw = context->surface->geometry.width;
-	int sh = context->surface->geometry.height;
-
-	const int expect = sx < ow && sy < oh && sx + sw > 0 && sy + sh > 0;
-
-	assert(visible == expect);
-}
 
-static void
+	client = client_create(99, 100, 100, 98);
-handle_state(struct test_client *);
+	assert(client);
 
-static void
+	/* move pointer outside bottom left */
-set_state(struct test_client *client)
+	x = client->surface->x - 1;
-{
+	y = client->surface->y + client->surface->height;
-	struct state* state;
+	assert(!surface_contains(client->surface, x, y));
-	struct context *context = client->data;
+	check_pointer_move(client, x, y);
-
+
-	if (context->index < context->states.size) {
+	/* move pointer on bottom left */
-		state = context->states.data + context->index;
+	x += 1; y -= 1;
-		resize(context, state->sw, state->sh);
+	assert(surface_contains(client->surface, x, y));
-		move(context, state->sx, state->sy);
+	check_pointer_move(client, x, y);
-		move_pointer(context, state->px, state->py);
+
-		context->index += state_size;
+	/* move pointer outside bottom left */
-
+	x -= 1; y += 1;
-		test_client_send(client, "send-state\n");
+	assert(!surface_contains(client->surface, x, y));
-		client->handle = handle_state;
+	check_pointer_move(client, x, y);
-	} else {
-		test_client_send(client, "bye\n");
-		client->handle = NULL;
-	}
 }
 
-static void
+TEST(test_pointer_top_right)
-handle_state(struct test_client *client)
 {
-	struct context *context = client->data;
+	struct client *client;
-	wl_fixed_t x, y;
+	int x, y;
-	int visible;
+
+	client = client_create(48, 100, 67, 100);
+	assert(client);
 
-	assert(sscanf(client->buf, "%d %d %d", &x, &y, &visible) == 3);
+	/* move pointer outside top right */
+	x = client->surface->x + client->surface->width;
+	y = client->surface->y - 1;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
 
-	check_pointer(context, wl_fixed_to_int(x), wl_fixed_to_int(y));
+	/* move pointer on top right */
-	check_visible(context, visible);
+	x -= 1; y += 1;
+	assert(surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
 
-	set_state(client);
+	/* move pointer outside top right */
+	x += 1; y -= 1;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
 }
 
-static void
+TEST(test_pointer_bottom_right)
-add_state(struct context *context, int px, int py, int sx, int sy,
-	  int sw, int sh)
 {
-	struct state *state = wl_array_add(&context->states,
+	struct client *client;
-					   sizeof(struct state));
+	int x, y;
+
+	client = client_create(100, 123, 100, 69);
+	assert(client);
 
-	assert(state);
+	/* move pointer outside bottom right */
+	x = client->surface->x + client->surface->width;
+	y = client->surface->y + client->surface->height;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+
+	/* move pointer on bottom right */
+	x -= 1; y -= 1;
+	assert(surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
 
-	state->px = px;
+	/* move pointer outside bottom right */
-	state->py = py;
+	x += 1; y += 1;
-	state->sx = sx;
+	assert(!surface_contains(client->surface, x, y));
-	state->sy = sy;
+	check_pointer_move(client, x, y);
-	state->sw = sw;
-	state->sh = sh;
 }
 
-static void
+TEST(test_pointer_top_center)
-initialize_states(struct test_client *client)
 {
-	struct context *context = client->data;
+	struct client *client;
-	struct weston_surface *surface = context->surface;
+	int x, y;
 
-	int x = surface->geometry.x;
+	client = client_create(100, 201, 100, 50);
-	int y = surface->geometry.y;
+	assert(client);
-	int w = surface->geometry.width;
-	int h = surface->geometry.height;
 
-	wl_array_init(&context->states);
+	/* move pointer outside top center */
+	x = client->surface->x + client->surface->width/2;
+	y = client->surface->y - 1;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
 
-	/* move pointer outside top left */
+	/* move pointer on top center */
-	add_state(context, x - 1, y - 1, x, y, w, h);
+	y += 1;
-	/* move pointer on top left */
+	assert(surface_contains(client->surface, x, y));
-	add_state(context, x, y, x, y, w, h);
+	check_pointer_move(client, x, y);
-	/* move pointer outside bottom left */
-	add_state(context, x - 1, y + h, x, y, w, h);
-	/* move pointer on bottom left */
-	add_state(context, x, y + h - 1, x, y, w, h);
-	/* move pointer outside top right */
-	add_state(context, x + w, y - 1, x, y, w, h);
-	/* move pointer on top right */
-	add_state(context, x + w - 1, y, x, y, w, h);
-	/* move pointer outside bottom right */
-	add_state(context, x + w, y + h, x, y, w, h);
-	/* move pointer on bottom right */
-	add_state(context, x + w - 1, y + h - 1, x, y, w, h);
 
 	/* move pointer outside top center */
-	add_state(context, x + w/2, y - 1, x, y, w, h);
+	y -= 1;
-	/* move pointer on top center */
+	assert(!surface_contains(client->surface, x, y));
-	add_state(context, x + w/2, y, x, y, w, h);
+	check_pointer_move(client, x, y);
+}
+
+TEST(test_pointer_bottom_center)
+{
+	struct client *client;
+	int x, y;
+
+	client = client_create(100, 45, 67, 100);
+	assert(client);
+
 	/* move pointer outside bottom center */
-	add_state(context, x + w/2, y + h, x, y, w, h);
+	x = client->surface->x + client->surface->width/2;
+	y = client->surface->y + client->surface->height;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+
 	/* move pointer on bottom center */
-	add_state(context, x + w/2, y + h - 1, x, y, w, h);
+	y -= 1;
+	assert(surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+
+	/* move pointer outside bottom center */
+	y += 1;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+}
+
+TEST(test_pointer_left_center)
+{
+	struct client *client;
+	int x, y;
+
+	client = client_create(167, 45, 78, 100);
+	assert(client);
+
 	/* move pointer outside left center */
-	add_state(context, x - 1, y + h/2, x, y, w, h);
+	x = client->surface->x - 1;
+	y = client->surface->y + client->surface->height/2;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+
 	/* move pointer on left center */
-	add_state(context, x, y + h/2, x, y, w, h);
+	x += 1;
+	assert(surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+
+	/* move pointer outside left center */
+	x -= 1;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+}
+
+TEST(test_pointer_right_center)
+{
+	struct client *client;
+	int x, y;
+
+	client = client_create(110, 37, 100, 46);
+	assert(client);
+
 	/* move pointer outside right center */
-	add_state(context, x + w, y + h/2, x, y, w, h);
+	x = client->surface->x + client->surface->width;
+	y = client->surface->y + client->surface->height/2;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+
 	/* move pointer on right center */
-	add_state(context, x + w - 1, y + h/2, x, y, w, h);
+	x -= 1;
+	assert(surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+
+	/* move pointer outside right center */
+	x += 1;
+	assert(!surface_contains(client->surface, x, y));
+	check_pointer_move(client, x, y);
+}
+
+TEST(test_pointer_surface_move)
+{
+	struct client *client;
+
+	client = client_create(100, 100, 100, 100);
+	assert(client);
 
 	/* move pointer outside of client */
-	add_state(context, 50, 50, x, y, w, h);
+	assert(!surface_contains(client->surface, 50, 50));
+	check_pointer_move(client, 50, 50);
+
 	/* move client center to pointer */
-	add_state(context, 50, 50, 0, 0, w, h);
+	move_client(client, 0, 0);
+	assert(surface_contains(client->surface, 50, 50));
+	check_pointer(client, 50, 50);
+}
 
-	/* not visible */
+static int
-	add_state(context, 0, 0, 0, -h, w, h);
+output_contains_client(struct client *client)
-	/* visible */
+{
-	add_state(context, 0, 0, 0, -h+1, w, h);
+	struct output *output = client->output;
-	/* not visible */
+	struct surface *surface = client->surface;
-	add_state(context, 0, 0, 0, context->surface->output->height, w, h);
-	/* visible */
-	add_state(context, 0, 0, 0, context->surface->output->height - 1, w, h);
-	/* not visible */
-	add_state(context, 0, 0, -w, 0, w, h);
-	/* visible */
-	add_state(context, 0, 0, -w+1, 0, w, h);
-	/* not visible */
-	add_state(context, 0, 0, context->surface->output->width, 0, w, h);
-	/* visible */
-	add_state(context, 0, 0, context->surface->output->width - 1, 0, w, h);
 
-	set_state(client);
+	return !(output->x >= surface->x + surface->width
+		|| output->x + output->width <= surface->x
+		|| output->y >= surface->y + surface->height
+		|| output->y + output->height <= surface->y);
 }
 
 static void
-handle_surface(struct test_client *client)
+check_client_move(struct client *client, int x, int y)
 {
-	uint32_t id;
+	move_client(client, x, y);
-	struct context *context = client->data;
+
-	struct wl_resource *resource;
+	if (output_contains_client(client)) {
-	struct wl_list *seat_list;
+		assert(client->surface->output == client->output);
-
+	} else {
-	assert(sscanf(client->buf, "surface %u", &id) == 1);
+		assert(client->surface->output == NULL);
-	fprintf(stderr, "server: got surface id %u\n", id);
+	}
-	resource = wl_client_get_object(client->client, id);
-	assert(resource);
-	assert(strcmp(resource->object.interface->name, "wl_surface") == 0);
-
-	context->surface = (struct weston_surface *) resource;
-	weston_surface_set_color(context->surface, 0.0, 0.0, 0.0, 1.0);
-
-	context->layer = malloc(sizeof *context->layer);
-	assert(context->layer);
-	weston_layer_init(context->layer,
-			  &client->compositor->cursor_layer.link);
-	wl_list_insert(&context->layer->surface_list,
-		       &context->surface->layer_link);
-
-	seat_list = &client->compositor->seat_list;
-	assert(wl_list_length(seat_list) == 1);
-	context->seat = container_of(seat_list->next, struct weston_seat, link);
-
-	client->compositor->focus = 1; /* Make it work even if pointer is
-					* outside X window. */
-
-	resize(context, 100, 100);
-	move(context, 100, 100);
-	move_pointer(context, 150, 150);
-
-	test_client_send(client, "send-state\n");
-	client->handle = initialize_states;
 }
 
-TEST(event_test)
+TEST(test_surface_output)
 {
-	struct context *context;
+	struct client *client;
-	struct test_client *client;
+	int x, y;
+
+	client = client_create(100, 100, 100, 100);
+	assert(client);
 
-	client = test_client_launch(compositor, "test-client");
+	assert(output_contains_client(client));
-	client->terminate = 1;
 
-	test_client_send(client, "create-surface\n");
+	/* not visible */
-	client->handle = handle_surface;
+	x = 0;
+	y = -client->surface->height;
+	check_client_move(client, x, y);
 
-	context = calloc(1, sizeof *context);
+	/* visible */
-	assert(context);
+	check_client_move(client, x, ++y);
-	client->data = context;
+
+	/* not visible */
+	x = -client->surface->width;
+	y = 0;
+	check_client_move(client, x, y);
+
+	/* visible */
+	check_client_move(client, ++x, y);
+
+	/* not visible */
+	x = client->output->width;
+	y = 0;
+	check_client_move(client, x, y);
+
+	/* visible */
+	check_client_move(client, --x, y);
+	assert(output_contains_client(client));
+
+	/* not visible */
+	x = 0;
+	y = client->output->height;
+	check_client_move(client, x, y);
+	assert(!output_contains_client(client));
+
+	/* visible */
+	check_client_move(client, x, --y);
+	assert(output_contains_client(client));
 }