Most of the code of queue-test is covered by the test compositor,
so we can save few lines and use the test compositor
instead. I think it's also more readable.
---
 tests/queue-test.c | 158 +++++++----------------------------------------------
 1 file changed, 20 insertions(+), 138 deletions(-)

diff --git a/tests/queue-test.c b/tests/queue-test.c
index a4b165d..36d7a69 100644
--- a/tests/queue-test.c
+++ b/tests/queue-test.c
@@ -31,33 +31,17 @@
 #include "wayland-client.h"
 #include "wayland-server.h"
 #include "test-runner.h"
-
-#define SOCKET_NAME "wayland-queue-test"
+#include "test-compositor.h"
 
 #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);
+       assert(*pcounter == 1);
        wl_registry_destroy(registry);
 }
 
@@ -68,15 +52,15 @@ static const struct wl_registry_listener registry_listener 
= {
 
 /* Test that destroying a proxy object doesn't result in any more
  * callback being invoked, even though were many queued. */
-static int
+static void
 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);
+       display = wl_display_connect(NULL);
+       assert(display);
 
        registry = wl_display_get_registry(display);
        assert(registry != NULL);
@@ -84,11 +68,9 @@ client_test_proxy_destroy(void)
                                 &counter);
        wl_display_roundtrip(display);
 
-       client_assert(counter == 1);
+       assert(counter == 1);
 
        wl_display_disconnect(display);
-
-       return 0;
 }
 
 struct multiple_queues_state {
@@ -117,7 +99,7 @@ static const struct wl_callback_listener sync_listener = {
 /* 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
+static void
 client_test_multiple_queues(void)
 {
        struct wl_event_queue *queue;
@@ -125,8 +107,8 @@ client_test_multiple_queues(void)
        struct multiple_queues_state state;
        int ret = 0;
 
-       state.display = wl_display_connect(SOCKET_NAME);
-       client_assert(state.display);
+       state.display = wl_display_connect(NULL);
+       assert(state.display);
 
        /* Make the current thread the display thread. This is because
         * wl_display_dispatch_queue() will only read the display fd if
@@ -134,7 +116,7 @@ client_test_multiple_queues(void)
        wl_display_dispatch_pending(state.display);
 
        queue = wl_display_create_queue(state.display);
-       client_assert(queue);
+       assert(queue);
 
        state.done = false;
        callback1 = wl_display_sync(state.display);
@@ -154,52 +136,7 @@ client_test_multiple_queues(void)
 
        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;
+       exit(ret == -1 ? -1 : 0);
 }
 
 static void
@@ -208,35 +145,9 @@ dummy_bind(struct wl_client *client,
 {
 }
 
-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;
+       struct display *d;
        const struct wl_interface *dummy_interfaces[] = {
                &wl_seat_interface,
                &wl_pointer_interface,
@@ -244,48 +155,19 @@ TEST(queue)
                &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();
-       }
+
+       d = display_create();
 
        for (i = 0; i < ARRAY_LENGTH(dummy_interfaces); i++)
-               wl_global_create(display.display, dummy_interfaces[i],
+               wl_global_create(d->wl_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);
+       client_create(d, client_test_proxy_destroy);
+       display_run(d);
 
-       wl_event_source_remove(signal_source);
-       wl_display_destroy(display.display);
+       client_create(d, client_test_multiple_queues);
+       display_run(d);
 
-       assert(WIFEXITED(display.child_exit_status) &&
-              WEXITSTATUS(display.child_exit_status) == EXIT_SUCCESS);
+       display_destroy(d);
 }
-- 
1.9.1

_______________________________________________
wayland-devel mailing list
wayland-devel@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/wayland-devel

Reply via email to