mainnika
/
weston
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tests: Convert event-test to new test extension

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

Signed-off-by: U. Artie Eoff <ullysses.a.eoff@intel.com>
dev
U. Artie Eoff 12 years ago committed by Kristian Høgsberg
parent 1ba9b38ec6
commit 84f9db5f90
3 changed files with 272 additions and 265 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 1
      tests/.gitignore
  2. 9
      tests/Makefile.am
  3. 527
      tests/event-test.c

1
tests/.gitignore vendored
Unescape View File

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

9
tests/Makefile.am
Unescape View File

@ -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 \

527
tests/event-test.c
Unescape View File

@ -20,326 +20,329 @@
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <stdlib.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;
};
#include "weston-test-client-helper.h"
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 */
if (context->surface->geometry.width != w ||
context->surface->geometry.height != h) {
weston_surface_configure(context->surface,
context->surface->geometry.x,
context->surface->geometry.y,
w, h);
weston_surface_update_transform(context->surface);
weston_surface_damage(context->surface);
fprintf(stderr, "resize surface: %d %d\n",
context->surface->geometry.width,
context->surface->geometry.height);
int sx, sy;
/* check that the client got the global pointer update */
assert(client->test->pointer_x == x);
assert(client->test->pointer_y == y);
/* Does global pointer map onto the surface? */
if (surface_contains(client->surface, x, y)) {
/* check that the surface has the pointer focus */
assert(client->input->pointer->focus == client->surface);
/*
* check that the local surface pointer maps
* 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 */
if (context->surface->geometry.x != x ||
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);
}
move_pointer(client, x, y);
check_pointer(client, x, y);
}
static int
contains(struct context *context, int x, int y)
TEST(test_pointer_top_left)
{
/* test whether a global x,y point is contained in the surface */
int sx = context->surface->geometry.x;
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;
}
struct client *client;
int x, y;
static void
move_pointer(struct context *context, int x, int y)
{
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));
}
client = client_create(46, 76, 111, 134);
assert(client);
/* update server expected pointer location */
context->pointer_x = x;
context->pointer_y = y;
/* move pointer outside top left */
x = client->surface->x - 1;
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
check_pointer(struct context *context, int cx, int cy)
{
/*
* 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);
}
/* move pointer outside top left */
x -= 1; y -= 1;
assert(!surface_contains(client->surface, x, y));
check_pointer_move(client, x, y);
}
static void
check_visible(struct context *context, int visible)
TEST(test_pointer_bottom_left)
{
/*
* Check whether the client reported surface visibility matches
* 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);
}
struct client *client;
int x, y;
static void
handle_state(struct test_client *);
client = client_create(99, 100, 100, 98);
assert(client);
static void
set_state(struct test_client *client)
{
struct state* state;
struct context *context = client->data;
if (context->index < context->states.size) {
state = context->states.data + context->index;
resize(context, state->sw, state->sh);
move(context, state->sx, state->sy);
move_pointer(context, state->px, state->py);
context->index += state_size;
test_client_send(client, "send-state\n");
client->handle = handle_state;
} else {
test_client_send(client, "bye\n");
client->handle = NULL;
}
/* move pointer outside bottom left */
x = client->surface->x - 1;
y = client->surface->y + client->surface->height;
assert(!surface_contains(client->surface, x, y));
check_pointer_move(client, x, y);
/* move pointer on bottom left */
x += 1; y -= 1;
assert(surface_contains(client->surface, x, y));
check_pointer_move(client, x, y);
/* move pointer outside bottom left */
x -= 1; y += 1;
assert(!surface_contains(client->surface, x, y));
check_pointer_move(client, x, y);
}
static void
handle_state(struct test_client *client)
TEST(test_pointer_top_right)
{
struct context *context = client->data;
wl_fixed_t x, y;
int visible;
struct client *client;
int x, y;
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));
check_visible(context, visible);
/* move pointer on top right */
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
add_state(struct context *context, int px, int py, int sx, int sy,
int sw, int sh)
TEST(test_pointer_bottom_right)
{
struct state *state = wl_array_add(&context->states,
sizeof(struct state));
struct client *client;
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;
state->py = py;
state->sx = sx;
state->sy = sy;
state->sw = sw;
state->sh = sh;
/* move pointer outside bottom right */
x += 1; y += 1;
assert(!surface_contains(client->surface, x, y));
check_pointer_move(client, x, y);
}
static void
initialize_states(struct test_client *client)
TEST(test_pointer_top_center)
{
struct context *context = client->data;
struct weston_surface *surface = context->surface;
struct client *client;
int x, y;
int x = surface->geometry.x;
int y = surface->geometry.y;
int w = surface->geometry.width;
int h = surface->geometry.height;
client = client_create(100, 201, 100, 50);
assert(client);
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 */
add_state(context, x - 1, y - 1, x, y, w, h);
/* move pointer on top left */
add_state(context, x, y, x, y, w, h);
/* 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 on top center */
y += 1;
assert(surface_contains(client->surface, x, y));
check_pointer_move(client, x, y);
/* move pointer outside top center */
add_state(context, x + w/2, y - 1, x, y, w, h);
/* move pointer on top center */
add_state(context, x + w/2, y, x, y, w, h);
y -= 1;
assert(!surface_contains(client->surface, x, y));
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 */
add_state(context, 0, 0, 0, -h, w, h);
/* visible */
add_state(context, 0, 0, 0, -h+1, w, h);
/* not visible */
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);
static int
output_contains_client(struct client *client)
{
struct output *output = client->output;
struct surface *surface = client->surface;
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;
struct context *context = client->data;
struct wl_resource *resource;
struct wl_list *seat_list;
assert(sscanf(client->buf, "surface %u", &id) == 1);
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;
move_client(client, x, y);
if (output_contains_client(client)) {
assert(client->surface->output == client->output);
} else {
assert(client->surface->output == NULL);
}
}
TEST(event_test)
TEST(test_surface_output)
{
struct context *context;
struct test_client *client;
struct client *client;
int x, y;
client = client_create(100, 100, 100, 100);
assert(client);
client = test_client_launch(compositor, "test-client");
client->terminate = 1;
assert(output_contains_client(client));
test_client_send(client, "create-surface\n");
client->handle = handle_surface;
/* not visible */
x = 0;
y = -client->surface->height;
check_client_move(client, x, y);
context = calloc(1, sizeof *context);
assert(context);
client->data = context;
/* visible */
check_client_move(client, x, ++y);
/* 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));
}

Write Preview
Loading…
Cancel
Save