mirror of
https://gitlab.freedesktop.org/wayland/wayland.git
synced 2025-10-29 05:40:16 -04:00
291 lines
7 KiB
C
291 lines
7 KiB
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, ®istry_listener,
|
|
&counter);
|
|
wl_display_roundtrip(display);
|
|
|
|
client_assert(counter == 1);
|
|
|
|
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);
|
|
|
|
/* Make the current thread the display thread. This is because
|
|
* wl_display_dispatch_queue() will only read the display fd if
|
|
* the main display thread has been set. */
|
|
wl_display_dispatch_pending(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_display_disconnect(state.display);
|
|
|
|
return ret == -1 ? -1 : 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;
|
|
}
|
|
|
|
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);
|
|
}
|