tests/queue-test: Add tests for proxy wrappers

Test that doing wl_display.sync on a wrapped proxy with a special queue
works as expected.

Test that creating a wrapper on a destroyed but not freed proxy fails.

Signed-off-by: Jonas Ådahl <jadahl@gmail.com>
Reviewed-by: Pekka Paalanen <pekka.paalanen@collabora.co.uk>

1 files changed, 122 insertions, 0 deletions

diff --git a/tests/queue-test.c b/tests/queue-test.c
index 02865ae..932bc55 100644
--- a/tests/queue-test.c
+++ b/tests/queue-test.c
@@ -205,6 +205,104 @@ client_test_queue_roundtrip(void)
 }
 
 static void
+client_test_queue_proxy_wrapper(void)
+{
+	struct wl_event_queue *queue;
+	struct wl_display *display;
+	struct wl_display *display_wrapper;
+	struct wl_callback *callback;
+	bool done = false;
+
+	/*
+	 * For an illustration of what usage would normally fail without using
+	 * proxy wrappers, see the `client_test_queue_set_queue_race' test case.
+	 */
+
+	display = wl_display_connect(NULL);
+	assert(display);
+
+	/* Pretend we are in a separate thread where a thread-local queue is
+	 * used. */
+	queue = wl_display_create_queue(display);
+	assert(queue);
+
+	display_wrapper = wl_proxy_create_wrapper(display);
+	assert(display_wrapper);
+	wl_proxy_set_queue((struct wl_proxy *) display_wrapper, queue);
+	callback = wl_display_sync(display_wrapper);
+	wl_proxy_wrapper_destroy(display_wrapper);
+	assert(callback != NULL);
+
+	/* Pretend we are now another thread and dispatch the dispatch the main
+	 * queue while also knowing our callback is read and queued. */
+	wl_display_roundtrip(display);
+
+	/* Make sure that the pretend-to-be main thread didn't dispatch our
+	 * callback, behind our back. */
+	wl_callback_add_listener(callback, &sync_listener_roundtrip, &done);
+	wl_display_flush(display);
+
+	assert(!done);
+
+	/* Make sure that we eventually end up dispatching our callback. */
+	while (!done)
+		assert(wl_display_dispatch_queue(display, queue) != -1);
+
+	wl_callback_destroy(callback);
+	wl_event_queue_destroy(queue);
+
+	wl_display_disconnect(display);
+}
+
+static void
+client_test_queue_set_queue_race(void)
+{
+	struct wl_event_queue *queue;
+	struct wl_display *display;
+	struct wl_callback *callback;
+	bool done = false;
+
+	/*
+	 * This test illustrates the multi threading scenario which would fail
+	 * without doing what is done in the `client_test_queue_proxy_wrapper'
+	 * test.
+	 */
+
+	display = wl_display_connect(NULL);
+	assert(display);
+
+	/* Pretend we are in a separate thread where a thread-local queue is
+	 * used. */
+	queue = wl_display_create_queue(display);
+	assert(queue);
+
+	callback = wl_display_sync(display);
+	assert(callback != NULL);
+
+	/* Pretend we are now another thread and dispatch the dispatch the main
+	 * queue while also knowing our callback is read, queued on the wrong
+	 * queue, and dispatched. */
+	wl_display_roundtrip(display);
+
+	/* Pretend we are back in the separate thread, and continue with setting
+	 * up our callback. */
+	wl_callback_add_listener(callback, &sync_listener_roundtrip, &done);
+	wl_proxy_set_queue((struct wl_proxy *) callback, queue);
+
+	/* Roundtrip our separate thread queue to make sure any events are
+	 * dispatched. */
+	wl_display_roundtrip_queue(display, queue);
+
+	/* Verify that the callback has indeed been dropped. */
+	assert(!done);
+
+	wl_callback_destroy(callback);
+	wl_event_queue_destroy(queue);
+
+	wl_display_disconnect(display);
+}
+
+static void
 dummy_bind(struct wl_client *client,
 	   void *data, uint32_t version, uint32_t id)
 {
@@ -259,3 +357,27 @@ TEST(queue_roundtrip)
 
 	display_destroy(d);
 }
+
+TEST(queue_set_queue_proxy_wrapper)
+{
+	struct display *d = display_create();
+
+	test_set_timeout(2);
+
+	client_create_noarg(d, client_test_queue_proxy_wrapper);
+	display_run(d);
+
+	display_destroy(d);
+}
+
+TEST(queue_set_queue_race)
+{
+	struct display *d = display_create();
+
+	test_set_timeout(2);
+
+	client_create_noarg(d, client_test_queue_set_queue_race);
+	display_run(d);
+
+	display_destroy(d);
+}