This patch introduces a set of functions that can create a display and clients for tests. On server side the user can use functions: display_create() display_destroy() create_client() display_run() display_resume() and on client side the user can use: client_connect() client_disconnect() stop_display()
The stop_display() and display_resume() are functions that serve as a barrier and also allow the display to take some action after the display_run() was called, because after the display is stopped, it can run arbitrary code until it calls display_resume(). client_connect() function connects to wayland display and creates a proxy to test_compositor global object, so it can ask for stopping the display later using stop_display(). An example: void client_main() { /* or client can use wl_display_connect(NULL) * and do all the stuff manually */ struct client *c = client_connect(); /* do some stuff, ... */ /* stop the display so that it can * do some other stuff */ stop_display(c, 1); /* ... */ client_disconnect(c); } TEST(dummy_tst) { struct display *d = display_create(); /* set up the display */ wl_global_create(d->wl_display, ...); /* ... */ create_client(d, client_main); display_run(); /* if we are here, the display has been stopped * and we can do some code, i. e. create another global or so */ wl_global_create(d->wl_display, ...); /* ... */ display_resume(d); /* resume display and clients */ display_destroy(d); } --- Makefile.am | 3 +- tests/test-compositor.c | 462 ++++++++++++++++++++++++++++++++++++++++++++++++ tests/test-compositor.h | 97 ++++++++++ 3 files changed, 561 insertions(+), 1 deletion(-) create mode 100644 tests/test-compositor.c create mode 100644 tests/test-compositor.h diff --git a/Makefile.am b/Makefile.am index c15d8b8..fe8a7a2 100644 --- a/Makefile.am +++ b/Makefile.am @@ -142,7 +142,8 @@ check_LTLIBRARIES = libtest-runner.la libtest_runner_la_SOURCES = \ tests/test-runner.c \ tests/test-runner.h \ - tests/test-helpers.c + tests/test-helpers.c \ + tests/test-compositor.c libtest_runner_la_LIBADD = \ libwayland-util.la \ libwayland-client.la \ diff --git a/tests/test-compositor.c b/tests/test-compositor.c new file mode 100644 index 0000000..f4b3f54 --- /dev/null +++ b/tests/test-compositor.c @@ -0,0 +1,462 @@ +/* + * Copyright (c) 2014 Red Hat, Inc. + * + * 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 <assert.h> +#include <errno.h> +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <unistd.h> +#include <sys/time.h> +#include <sys/socket.h> +#include <sys/wait.h> +#include <signal.h> + +#include "test-compositor.h" + +/* --- Protocol --- */ +struct test_compositor; + +static const struct wl_message tc_requests[] = { + /* this request serves as a barrier for synchronizing*/ + { "stop_display", "u", NULL } +}; + +static const struct wl_message tc_events[] = { + { "display_resumed", "", NULL } +}; + +const struct wl_interface test_compositor_interface = { + "test", 1, + 1, tc_requests, + 1, tc_events +}; + +struct test_compositor_interface { + void (*stop_display)(struct wl_client *client, + struct wl_resource *resource, + uint32_t num); +}; + +struct test_compositor_listener { + void (*display_resumed)(void *data, struct test_compositor *tc); + +}; + +enum { + STOP_DISPLAY = 0 +}; + +enum { + DISPLAY_RESUMED = 0 +}; + +/* Since tests can run parallely, we need unique socket names + * for each test, otherwise the test can fail on wl_display_add_socket. */ +static const char * +get_socket_name(void) +{ + struct timeval tv; + static char retval[64]; + + gettimeofday(&tv, NULL); + snprintf(retval, sizeof retval, "wayland-test-%ld%ld", + tv.tv_sec, tv.tv_usec); + + return retval; +} + +/** + * Check client's state and terminate display when all clients exited + */ +static void +client_destroyed(struct wl_listener *listener, void *data) +{ + struct display *d; + struct client_info *ci; + siginfo_t status; + + ci = wl_container_of(listener, ci, destroy_listener); + d = ci->display; + + assert(waitid(P_PID, ci->pid, &status, WEXITED) != -1); + + switch (status.si_code) { + case CLD_KILLED: + case CLD_DUMPED: + fprintf(stderr, "Client '%s' was killed by signal %d\n", + ci->name, status.si_status); + ci->exit_code = status.si_status; + break; + case CLD_EXITED: + if (status.si_status != EXIT_SUCCESS) + fprintf(stderr, "Client '%s' exited with code %d\n", + ci->name, status.si_status); + + ci->exit_code = status.si_status; + break; + } + + ++d->clients_terminated_no; + if (d->clients_no == d->clients_terminated_no) { + wl_display_terminate(d->wl_display); + } + + /* the clients are not removed from the list, because + * at the end of the test we check the exit codes of all + * clients. In the case that the test would go through + * the clients list manually, zero out the wl_client as a sign + * that the client is not running anymore */ + ci->wl_client = NULL; +} + +static void +run_client(void (*client_main)(void), int wayland_sock, int client_pipe) +{ + char s[8]; + int can_continue = 0; + + /* Wait until display signals that client can continue */ + assert(read(client_pipe, &can_continue, sizeof(int)) == sizeof(int)); + + if (can_continue == 0) + abort(); /* error in parent */ + + /* for wl_display_connect() */ + snprintf(s, sizeof s, "%d", wayland_sock); + setenv("WAYLAND_SOCKET", s, 0); + + client_main(); +} + +static struct client_info * +display_create_client(struct display *d, + void (*client_main)(void), + const char *name) +{ + int pipe_cli[2]; + int sock_wayl[2]; + pid_t pid; + int can_continue = 0; + struct client_info *cl; + + assert(pipe(pipe_cli) == 0 && "Failed creating pipe"); + assert(socketpair(AF_UNIX, SOCK_STREAM, 0, sock_wayl) == 0 + && "Failed creating socket pair"); + + pid = fork(); + assert(pid != -1 && "Fork failed"); + + if (pid == 0) { + close(sock_wayl[1]); + close(pipe_cli[1]); + + run_client(client_main, sock_wayl[0], pipe_cli[0]); + + close(sock_wayl[0]); + close(pipe_cli[0]); + + exit(0); + } + + close(sock_wayl[0]); + close(pipe_cli[0]); + + cl = calloc(1, sizeof(struct client_info)); + assert(cl); + + wl_list_insert(&d->clients, &cl->link); + + cl->display = d; + cl->name = name; + cl->pid = pid; + cl->pipe = pipe_cli[1]; + cl->destroy_listener.notify = &client_destroyed; + + cl->wl_client = wl_client_create(d->wl_display, sock_wayl[1]); + if (!cl->wl_client) { + /* abort the client */ + write(cl->pipe, &can_continue, sizeof(int)); + assert(0 && "Couldn't create wayland client"); + } + + wl_client_add_destroy_listener(cl->wl_client, + &cl->destroy_listener); + + ++d->clients_no; + + return cl; +} + +struct client_info * +client_create_with_name(struct display *d, void (*client_main)(void), + const char *name) +{ + int can_continue = 1; + struct client_info *cl = display_create_client(d, client_main, name); + + /* let the show begin! */ + assert(write(cl->pipe, &can_continue, sizeof(int))); + + return cl; +} + +/* wfr = waiting for resume */ +struct wfr { + struct wl_resource *resource; + struct wl_list link; +}; + +static void +handle_stop_display(struct wl_client *client, + struct wl_resource *resource, uint32_t num) +{ + struct display *d = wl_resource_get_user_data(resource); + + assert(d->wfr_num < num && + "Only one group of clients can stop the display"); + + ++d->wfr_num; + + struct wfr *wfr = malloc(sizeof *wfr); + if (!wfr) { + wl_client_post_no_memory(client); + assert(0 && "Out of memory"); + } + + wfr->resource = resource; + wl_list_insert(&d->waiting_for_resume, &wfr->link); + + if (d->wfr_num == num) + wl_display_terminate(d->wl_display); +} + +static const struct test_compositor_interface tc_implementation = { + handle_stop_display +}; + +static void +tc_bind(struct wl_client *client, void *data, + uint32_t ver, uint32_t id) +{ + struct wl_resource *res; + + res = wl_resource_create(client, &test_compositor_interface, ver, id); + if (!res) { + wl_client_post_no_memory(client); + assert(0 && "Out of memory"); + } + + wl_resource_set_implementation(res, &tc_implementation, data, NULL); +} + +struct display * +display_create(void) +{ + struct display *d = NULL; + struct wl_global *g; + int stat = 0; + + d = calloc(1, sizeof *d); + assert(d && "Out of memory"); + + d->wl_display = wl_display_create(); + assert(d->wl_display && "Creating display failed"); + + /* hope the path won't be longer than 108 ... */ + const char *socket_name = get_socket_name(); + stat = wl_display_add_socket(d->wl_display, socket_name); + assert(stat == 0 && "Failed adding socket"); + + wl_list_init(&d->clients); + d->clients_no = d->clients_terminated_no = 0; + + wl_list_init(&d->waiting_for_resume); + d->wfr_num = 0; + + g = wl_global_create(d->wl_display, &test_compositor_interface, + 1, d, tc_bind); + assert(g); + + return d; +} + +void +display_run(struct display *d) +{ + assert(d->wfr_num == 0 && "Have waiting clients. Use display_resume."); + wl_display_run(d->wl_display); +} + +void +display_resume(struct display *d) +{ + assert(d->wfr_num > 0 && "No clients waiting."); + + struct wfr *wfr, *next; + wl_list_for_each_safe(wfr, next, &d->waiting_for_resume, link) { + wl_resource_post_event(wfr->resource, DISPLAY_RESUMED); + wl_list_remove(&wfr->link); + free(wfr); + } + + assert(wl_list_empty(&d->waiting_for_resume)); + d->wfr_num = 0; + + wl_display_run(d->wl_display); +} + +void +display_destroy(struct display *d) +{ + struct client_info *cl, *next; + int failed = 0; + + assert(d->wfr_num == 0 && "Didn't you forget to call display_resume?"); + + wl_list_for_each_safe(cl, next, &d->clients, link) { + assert(cl->wl_client == NULL); + + if (cl->exit_code != 0) { + ++failed; + fprintf(stderr, "Clinet '%s' failed\n", cl->name); + } + + close(cl->pipe); + free(cl); + } + + wl_display_destroy(d->wl_display); + free(d); + + if (failed) { + fprintf(stderr, "%d child(ren) failed\n", failed); + abort(); + } +} + +/* + * --- Client helper functions --- + */ +static void +handle_display_resumed(void *data, struct test_compositor *tc) +{ + struct client *c = data; + + c->display_stopped = 0; +} + +static const struct test_compositor_listener tc_listener = { + handle_display_resumed +}; + +static void +registry_handle_globals(void *data, struct wl_registry *registry, + uint32_t id, const char *intf, uint32_t ver) +{ + struct client *c = data; + + if (strcmp(intf, "test") != 0) + return; + + c->tc = wl_registry_bind(registry, id, &test_compositor_interface, ver); + assert(c->tc); + + wl_proxy_add_listener((struct wl_proxy *) c->tc, + (void *) &tc_listener, c); +} + +static const struct wl_registry_listener registry_listener = +{ + registry_handle_globals, + NULL +}; + +struct client *client_connect() +{ + struct wl_registry *reg; + struct client *c = calloc(1, sizeof *c); + assert(c); + + c->wl_display = wl_display_connect(NULL); + assert(c->wl_display); + + /* create test_compositor proxy. Do it with temporary + * registry so that client can define it's own listener later */ + reg = wl_display_get_registry(c->wl_display); + assert(reg); + wl_registry_add_listener(reg, ®istry_listener, c); + wl_display_roundtrip(c->wl_display); + assert(c->tc); + + wl_registry_destroy(reg); + + return c; +} + +static void +check_error(struct wl_display *display) +{ + uint32_t ec, id; + const struct wl_interface *intf; + int err; + + err = wl_display_get_error(display); + /* write out message about protocol error */ + if (err == EPROTO) { + ec = wl_display_get_protocol_error(display, &intf, &id); + fprintf(stderr, "Client: Got protocol error %u on interface %s" + " (object %u)\n", ec, intf->name, id); + } + + if (err) { + fprintf(stderr, "Client error: %s\n", strerror(errno)); + abort(); + } +} + +void +client_disconnect(struct client *c) +{ + /* check for errors */ + check_error(c->wl_display); + + wl_proxy_destroy((struct wl_proxy *) c->tc); + wl_display_disconnect(c->wl_display); +} + +/* num is number of clients that requests to stop display. + * Display is stopped after it recieve num STOP_DISPLAY requests */ +int +stop_display(struct client *c, int num) +{ + int n = 0; + + c->display_stopped = 1; + wl_proxy_marshal((struct wl_proxy *) c->tc, STOP_DISPLAY, num); + + while (c->display_stopped && n >= 0) { + n = wl_display_dispatch(c->wl_display); + } + + return n; +} diff --git a/tests/test-compositor.h b/tests/test-compositor.h new file mode 100644 index 0000000..c41b17b --- /dev/null +++ b/tests/test-compositor.h @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2014 Red Hat, Inc. + * + * 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 <unistd.h> + +#include "wayland-server.h" +#include "wayland-client.h" + +/* info about a client on server side */ +struct client_info { + struct display *display; + struct wl_client *wl_client; + struct wl_listener destroy_listener; + const char *name; /* for debugging */ + + int pipe; + pid_t pid; + int exit_code; + + struct wl_list link; + void *data; /* for arbitrary use */ +}; + +struct display { + struct wl_display *wl_display; + + struct wl_list clients; + uint32_t clients_no; + uint32_t clients_terminated_no; + + /* list of clients waiting for display_resumed event */ + struct wl_list waiting_for_resume; + uint32_t wfr_num; +}; + +/* This is a helper structure for clients. + * Instead of calling wl_display_connect() and all the other stuff, + * client can use client_connect and it will return this structure + * filled. */ +struct client { + struct wl_display *wl_display; + struct test_compositor *tc; + + int display_stopped; +}; + +struct client *client_connect(void); +void client_disconnect(struct client *); +int stop_display(struct client *, int); + +/** + * Usual workflow: + * + * d = display_create(); + * + * wl_global_create(d->wl_display, ...); + * ... other setups ... + * + * client_create(d, client_main); + * client_create(d, client_main2); + * + * display_run(d); + * display_destroy(d); + */ +struct display *display_create(void); +void display_destroy(struct display *d); +void display_run(struct display *d); + +/* After n clients called stop_display(..., n), the display + * is stopped and can process the code after display_run(). + * This function rerun the display again and send display_resumed + * event to waiting clients, so the clients will stop waiting and continue */ +void display_resume(struct display *d); + +struct client_info *client_create_with_name(struct display *d, + void (*client_main)(void), + const char *name); +#define client_create(d, c) client_create_with_name((d), (c), (#c)) -- 1.9.1 _______________________________________________ wayland-devel mailing list wayland-devel@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/wayland-devel