src/tests/test-surface.c

   1 #include <assert.h>
   2 #include <stdbool.h>
   3 #include <string.h>
   4 #include <stdlib.h>
   5 #include <unistd.h>
   6
   7 #include <wayland-server.h>
   8 #include <wayland-client.h>
   9 #include <libds/compositor.h>
  10 #include <libds/surface.h>
  11 #include <libds/log.h>
  12
  13 struct server_base
  14 {
  15     struct wl_display *display;
  16     struct ds_compositor *compositor;
  17     const char *socket;
  18 };
  19
  20 void
  21 test_server_init(struct server_base *server)
  22 {
  23     server->display = wl_display_create();
  24     assert(server->display);
  25     server->compositor = ds_compositor_create(server->display);
  26     assert(server->compositor);
  27     server->socket = wl_display_add_socket_auto(server->display);
  28     assert(server->socket);
  29 }
  30
  31 void
  32 test_server_finish(struct server_base *server)
  33 {
  34     wl_display_destroy(server->display);
  35 }
  36
  37 struct client
  38 {
  39     struct wl_display *display;
  40     struct wl_registry *registry;
  41     struct wl_compositor *compositor;
  42     struct wl_surface *surface;
  43 };
  44
  45 static void
  46 handle_global(void *data, struct wl_registry *registry, uint32_t id,
  47         const char *interface, uint32_t version)
  48 {
  49     struct client *client = data;
  50
  51     if (strcmp(interface, "wl_compositor") == 0) {
  52         client->compositor =
  53             wl_registry_bind(registry, id, &wl_compositor_interface, version);
  54     }
  55 }
  56
  57 static const struct wl_registry_listener registry_listener = {
  58     .global = handle_global,
  59 };
  60
  61 void
  62 test_client_init(struct client *client, const char *name)
  63 {
  64     client->display = wl_display_connect(name);
  65     assert(client->display);
  66     client->registry = wl_display_get_registry(client->display);
  67     assert(client->registry);
  68
  69     wl_registry_add_listener(client->registry, &registry_listener, client);
  70
  71     wl_display_roundtrip(client->display);
  72
  73     assert(client->compositor);
  74 }
  75
  76 void
  77 test_client_finish(struct client *client)
  78 {
  79     wl_compositor_destroy(client->compositor);
  80     wl_registry_destroy(client->registry);
  81     wl_display_disconnect(client->display);
  82 }
  83
  84 struct test_server {
  85     struct server_base base;
  86     bool cb_called;
  87
  88     struct wl_listener new_surface;
  89     struct wl_listener surface_destroy;
  90 };
  91
  92 static void
  93 cb_surface_destroy(struct wl_listener *listener, void *data)
  94 {
  95     struct test_server *server;
  96
  97     server = wl_container_of(listener, server, surface_destroy);
  98     server->cb_called = true;
  99     wl_display_terminate(server->base.display);
 100 }
 101
 102 static void
 103 cb_new_surface(struct wl_listener *listener, void *data)
 104 {
 105     struct ds_surface *surface = data;
 106     struct test_server *server;
 107
 108     server = wl_container_of(listener, server, new_surface);
 109     server->surface_destroy.notify = cb_surface_destroy;
 110     ds_surface_add_destroy_listener(surface, &server->surface_destroy);
 111 }
 112
 113 static void
 114 run_client(const char *name)
 115 {
 116     struct client client;
 117
 118     test_client_init(&client, name);
 119
 120     struct wl_surface *surface =
 121         wl_compositor_create_surface(client.compositor);
 122
 123     wl_display_roundtrip(client.display);
 124
 125     wl_surface_destroy(surface);
 126
 127     test_client_finish(&client);
 128 }
 129
 130 static void
 131 test_surface_create_and_destroy(void)
 132 {
 133     struct test_server server = { .cb_called = false };
 134     pid_t pid;
 135
 136     test_server_init(&server.base);
 137
 138     pid = fork();
 139     assert(pid != -1);
 140
 141     if (pid == 0) {
 142         run_client(server.base.socket);
 143         exit(0);
 144     }
 145
 146     server.new_surface.notify = cb_new_surface;
 147     ds_compositor_add_new_surface_listener(server.base.compositor,
 148             &server.new_surface);
 149
 150     wl_display_run(server.base.display);
 151
 152     assert(server.cb_called);
 153
 154     test_server_finish(&server.base);
 155 }
 156
 157 int
 158 main(void)
 159 {
 160     test_surface_create_and_destroy();
 161     return 0;
 162 }