1 | /* |
2 | * Copyright © 2012 Jonas Ådahl |
3 | * |
4 | * Permission is hereby granted, free of charge, to any person obtaining |
5 | * a copy of this software and associated documentation files (the |
6 | * "Software"), to deal in the Software without restriction, including |
7 | * without limitation the rights to use, copy, modify, merge, publish, |
8 | * distribute, sublicense, and/or sell copies of the Software, and to |
9 | * permit persons to whom the Software is furnished to do so, subject to |
10 | * the following conditions: |
11 | * |
12 | * The above copyright notice and this permission notice (including the |
13 | * next paragraph) shall be included in all copies or substantial |
14 | * portions of the Software. |
15 | * |
16 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
17 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
18 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
19 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
20 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
21 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
22 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
23 | * SOFTWARE. |
24 | */ |
25 | |
26 | #include <stdlib.h> |
27 | #include <stdint.h> |
28 | #include <stdio.h> |
29 | #include <stdbool.h> |
30 | #include <unistd.h> |
31 | #include <sys/types.h> |
32 | #include <sys/wait.h> |
33 | #include <assert.h> |
34 | |
35 | #include "wayland-client.h" |
36 | #include "wayland-server.h" |
37 | #include "test-runner.h" |
38 | #include "test-compositor.h" |
39 | |
40 | #define ARRAY_LENGTH(a) (sizeof (a) / sizeof (a)[0]) |
41 | |
42 | static void |
43 | registry_handle_global(void *data, struct wl_registry *registry, |
44 | uint32_t id, const char *interface, uint32_t version) |
45 | { |
46 | int *pcounter = data; |
47 | (*pcounter)++; |
48 | assert(*pcounter == 1); |
49 | wl_registry_destroy(wl_registry: registry); |
50 | } |
51 | |
52 | static const struct wl_registry_listener registry_listener = { |
53 | registry_handle_global, |
54 | NULL |
55 | }; |
56 | |
57 | /* Test that destroying a proxy object doesn't result in any more |
58 | * callback being invoked, even though were many queued. */ |
59 | static void |
60 | client_test_proxy_destroy(void) |
61 | { |
62 | struct wl_display *display; |
63 | struct wl_registry *registry; |
64 | int counter = 0; |
65 | |
66 | display = wl_display_connect(NULL); |
67 | assert(display); |
68 | |
69 | registry = wl_display_get_registry(wl_display: display); |
70 | assert(registry != NULL); |
71 | wl_registry_add_listener(wl_registry: registry, listener: ®istry_listener, |
72 | data: &counter); |
73 | assert(wl_display_roundtrip(display) != -1); |
74 | |
75 | assert(counter == 1); |
76 | |
77 | /* don't destroy the registry, we have already destroyed them |
78 | * in the global handler */ |
79 | wl_display_disconnect(display); |
80 | } |
81 | |
82 | struct multiple_queues_state { |
83 | struct wl_display *display; |
84 | struct wl_callback* callback2; |
85 | bool done; |
86 | }; |
87 | |
88 | static void |
89 | sync_callback(void *data, struct wl_callback *callback, uint32_t serial) |
90 | { |
91 | struct multiple_queues_state *state = data; |
92 | |
93 | state->done = true; |
94 | wl_callback_destroy(wl_callback: callback); |
95 | |
96 | wl_display_dispatch_pending(display: state->display); |
97 | |
98 | wl_callback_destroy(wl_callback: state->callback2); |
99 | } |
100 | |
101 | static const struct wl_callback_listener sync_listener = { |
102 | sync_callback |
103 | }; |
104 | |
105 | /* Test that when receiving the first of two synchronization |
106 | * callback events, destroying the second one doesn't cause any |
107 | * errors even if the delete_id event is handled out of order. */ |
108 | static void |
109 | client_test_multiple_queues(void) |
110 | { |
111 | struct wl_event_queue *queue; |
112 | struct wl_callback *callback1; |
113 | struct multiple_queues_state state; |
114 | int ret = 0; |
115 | |
116 | state.display = wl_display_connect(NULL); |
117 | assert(state.display); |
118 | |
119 | queue = wl_display_create_queue(display: state.display); |
120 | assert(queue); |
121 | |
122 | state.done = false; |
123 | callback1 = wl_display_sync(wl_display: state.display); |
124 | assert(callback1 != NULL); |
125 | wl_callback_add_listener(wl_callback: callback1, listener: &sync_listener, data: &state); |
126 | wl_proxy_set_queue(proxy: (struct wl_proxy *) callback1, queue); |
127 | |
128 | state.callback2 = wl_display_sync(wl_display: state.display); |
129 | assert(state.callback2 != NULL); |
130 | wl_callback_add_listener(wl_callback: state.callback2, listener: &sync_listener, NULL); |
131 | wl_proxy_set_queue(proxy: (struct wl_proxy *) state.callback2, queue); |
132 | |
133 | wl_display_flush(display: state.display); |
134 | |
135 | while (!state.done && !ret) |
136 | ret = wl_display_dispatch_queue(display: state.display, queue); |
137 | |
138 | wl_event_queue_destroy(queue); |
139 | wl_display_disconnect(display: state.display); |
140 | |
141 | exit(status: ret == -1 ? -1 : 0); |
142 | } |
143 | |
144 | static void |
145 | sync_callback_roundtrip(void *data, struct wl_callback *callback, uint32_t serial) |
146 | { |
147 | bool *done = data; |
148 | *done = true; |
149 | } |
150 | |
151 | static const struct wl_callback_listener sync_listener_roundtrip = { |
152 | sync_callback_roundtrip |
153 | }; |
154 | |
155 | /* Test that doing a roundtrip on a queue only the events on that |
156 | * queue get dispatched. */ |
157 | static void |
158 | client_test_queue_roundtrip(void) |
159 | { |
160 | struct wl_event_queue *queue; |
161 | struct wl_callback *callback1; |
162 | struct wl_callback *callback2; |
163 | struct wl_display *display; |
164 | bool done1 = false; |
165 | bool done2 = false; |
166 | |
167 | display = wl_display_connect(NULL); |
168 | assert(display); |
169 | |
170 | queue = wl_display_create_queue(display); |
171 | assert(queue); |
172 | |
173 | /* arm a callback on the default queue */ |
174 | callback1 = wl_display_sync(wl_display: display); |
175 | assert(callback1 != NULL); |
176 | wl_callback_add_listener(wl_callback: callback1, listener: &sync_listener_roundtrip, data: &done1); |
177 | |
178 | /* arm a callback on the other queue */ |
179 | callback2 = wl_display_sync(wl_display: display); |
180 | assert(callback2 != NULL); |
181 | wl_callback_add_listener(wl_callback: callback2, listener: &sync_listener_roundtrip, data: &done2); |
182 | wl_proxy_set_queue(proxy: (struct wl_proxy *) callback2, queue); |
183 | |
184 | /* roundtrip on default queue must not dispatch the other queue. */ |
185 | wl_display_roundtrip(display); |
186 | assert(done1 == true); |
187 | assert(done2 == false); |
188 | |
189 | /* re-arm the sync callback on the default queue, so we see that |
190 | * wl_display_roundtrip_queue() does not dispatch the default queue. */ |
191 | wl_callback_destroy(wl_callback: callback1); |
192 | done1 = false; |
193 | callback1 = wl_display_sync(wl_display: display); |
194 | assert(callback1 != NULL); |
195 | wl_callback_add_listener(wl_callback: callback1, listener: &sync_listener_roundtrip, data: &done1); |
196 | |
197 | wl_display_roundtrip_queue(display, queue); |
198 | assert(done1 == false); |
199 | assert(done2 == true); |
200 | |
201 | wl_callback_destroy(wl_callback: callback1); |
202 | wl_callback_destroy(wl_callback: callback2); |
203 | wl_event_queue_destroy(queue); |
204 | |
205 | wl_display_disconnect(display); |
206 | } |
207 | |
208 | static void |
209 | client_test_queue_proxy_wrapper(void) |
210 | { |
211 | struct wl_event_queue *queue; |
212 | struct wl_display *display; |
213 | struct wl_display *display_wrapper; |
214 | struct wl_callback *callback; |
215 | bool done = false; |
216 | |
217 | /* |
218 | * For an illustration of what usage would normally fail without using |
219 | * proxy wrappers, see the `client_test_queue_set_queue_race' test case. |
220 | */ |
221 | |
222 | display = wl_display_connect(NULL); |
223 | assert(display); |
224 | |
225 | /* Pretend we are in a separate thread where a thread-local queue is |
226 | * used. */ |
227 | queue = wl_display_create_queue(display); |
228 | assert(queue); |
229 | |
230 | display_wrapper = wl_proxy_create_wrapper(proxy: display); |
231 | assert(display_wrapper); |
232 | wl_proxy_set_queue(proxy: (struct wl_proxy *) display_wrapper, queue); |
233 | callback = wl_display_sync(wl_display: display_wrapper); |
234 | wl_proxy_wrapper_destroy(proxy_wrapper: display_wrapper); |
235 | assert(callback != NULL); |
236 | |
237 | /* Pretend we are now another thread and dispatch the dispatch the main |
238 | * queue while also knowing our callback is read and queued. */ |
239 | wl_display_roundtrip(display); |
240 | |
241 | /* Make sure that the pretend-to-be main thread didn't dispatch our |
242 | * callback, behind our back. */ |
243 | wl_callback_add_listener(wl_callback: callback, listener: &sync_listener_roundtrip, data: &done); |
244 | wl_display_flush(display); |
245 | |
246 | assert(!done); |
247 | |
248 | /* Make sure that we eventually end up dispatching our callback. */ |
249 | while (!done) |
250 | assert(wl_display_dispatch_queue(display, queue) != -1); |
251 | |
252 | wl_callback_destroy(wl_callback: callback); |
253 | wl_event_queue_destroy(queue); |
254 | |
255 | wl_display_disconnect(display); |
256 | } |
257 | |
258 | static void |
259 | client_test_queue_set_queue_race(void) |
260 | { |
261 | struct wl_event_queue *queue; |
262 | struct wl_display *display; |
263 | struct wl_callback *callback; |
264 | bool done = false; |
265 | |
266 | /* |
267 | * This test illustrates the multi threading scenario which would fail |
268 | * without doing what is done in the `client_test_queue_proxy_wrapper' |
269 | * test. |
270 | */ |
271 | |
272 | display = wl_display_connect(NULL); |
273 | assert(display); |
274 | |
275 | /* Pretend we are in a separate thread where a thread-local queue is |
276 | * used. */ |
277 | queue = wl_display_create_queue(display); |
278 | assert(queue); |
279 | |
280 | callback = wl_display_sync(wl_display: display); |
281 | assert(callback != NULL); |
282 | |
283 | /* Pretend we are now another thread and dispatch the dispatch the main |
284 | * queue while also knowing our callback is read, queued on the wrong |
285 | * queue, and dispatched. */ |
286 | wl_display_roundtrip(display); |
287 | |
288 | /* Pretend we are back in the separate thread, and continue with setting |
289 | * up our callback. */ |
290 | wl_callback_add_listener(wl_callback: callback, listener: &sync_listener_roundtrip, data: &done); |
291 | wl_proxy_set_queue(proxy: (struct wl_proxy *) callback, queue); |
292 | |
293 | /* Roundtrip our separate thread queue to make sure any events are |
294 | * dispatched. */ |
295 | wl_display_roundtrip_queue(display, queue); |
296 | |
297 | /* Verify that the callback has indeed been dropped. */ |
298 | assert(!done); |
299 | |
300 | wl_callback_destroy(wl_callback: callback); |
301 | wl_event_queue_destroy(queue); |
302 | |
303 | wl_display_disconnect(display); |
304 | } |
305 | |
306 | static void |
307 | dummy_bind(struct wl_client *client, |
308 | void *data, uint32_t version, uint32_t id) |
309 | { |
310 | } |
311 | |
312 | TEST(queue_proxy_destroy) |
313 | { |
314 | struct display *d; |
315 | const struct wl_interface *dummy_interfaces[] = { |
316 | &wl_seat_interface, |
317 | &wl_pointer_interface, |
318 | &wl_keyboard_interface, |
319 | &wl_surface_interface |
320 | }; |
321 | unsigned int i; |
322 | |
323 | d = display_create(); |
324 | |
325 | for (i = 0; i < ARRAY_LENGTH(dummy_interfaces); i++) |
326 | wl_global_create(display: d->wl_display, interface: dummy_interfaces[i], |
327 | version: dummy_interfaces[i]->version, |
328 | NULL, bind: dummy_bind); |
329 | |
330 | test_set_timeout(2); |
331 | |
332 | client_create_noarg(d, client_test_proxy_destroy); |
333 | display_run(d); |
334 | |
335 | display_destroy(d); |
336 | } |
337 | |
338 | TEST(queue_multiple_queues) |
339 | { |
340 | struct display *d = display_create(); |
341 | |
342 | test_set_timeout(2); |
343 | |
344 | client_create_noarg(d, client_test_multiple_queues); |
345 | display_run(d); |
346 | |
347 | display_destroy(d); |
348 | } |
349 | |
350 | TEST(queue_roundtrip) |
351 | { |
352 | struct display *d = display_create(); |
353 | |
354 | test_set_timeout(2); |
355 | |
356 | client_create_noarg(d, client_test_queue_roundtrip); |
357 | display_run(d); |
358 | |
359 | display_destroy(d); |
360 | } |
361 | |
362 | TEST(queue_set_queue_proxy_wrapper) |
363 | { |
364 | struct display *d = display_create(); |
365 | |
366 | test_set_timeout(2); |
367 | |
368 | client_create_noarg(d, client_test_queue_proxy_wrapper); |
369 | display_run(d); |
370 | |
371 | display_destroy(d); |
372 | } |
373 | |
374 | TEST(queue_set_queue_race) |
375 | { |
376 | struct display *d = display_create(); |
377 | |
378 | test_set_timeout(2); |
379 | |
380 | client_create_noarg(d, client_test_queue_set_queue_race); |
381 | display_run(d); |
382 | |
383 | display_destroy(d); |
384 | } |
385 | |