Debian Codegraph @

testsuite/test-future.c

raw
1 /* test-future.c
2 *
3 * Copyright 2022 Christian Hergert <[email protected]>
4 *
5 * This library is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU Lesser General Public License as
7 * published by the Free Software Foundation; either version 2.1 of the
8 * License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program. If not, see <http://www.gnu.org/licenses/>.
17 *
18 * SPDX-License-Identifier: LGPL-2.1-or-later
19 */
20
21 #include "config.h"
22
23 #include <libdex.h>
24
25 #include <gio/gio.h>
26
27 #include "dex-future-private.h"
28 #include "dex-async-pair-private.h"
29
30 #define ASSERT_STATUS(f,status) g_assert_cmpint(status, ==, dex_future_get_status(DEX_FUTURE(f)))
31 #define ASSERT_INSTANCE_TYPE(obj,type) \
32 G_STMT_START { \
33 if (!G_TYPE_CHECK_INSTANCE_TYPE((obj), (type))) \
34 g_error ("%s: %s is not a %s", \
35 G_STRLOC, \
36 (obj) ? G_OBJECT_TYPE_NAME((obj)) \
37 : "NULL", g_type_name(type)); \
38 } G_STMT_END
39
40 typedef struct
41 {
42 guint catch;
43 guint destroy;
44 guint finally;
45 guint then;
46 } TestInfo;
47
48 static DexFuture *
49 catch_cb (DexFuture *future,
50 gpointer user_data)
51 {
52 TestInfo *info = user_data;
53 g_atomic_int_inc (&info->catch);
54 return DEX_FUTURE (dex_future_new_for_string ("123"));
55 }
56
57 static DexFuture *
58 then_cb (DexFuture *future,
59 gpointer user_data)
60 {
61 TestInfo *info = user_data;
62 const GValue *value;
63 GError *error = NULL;
64
65 g_atomic_int_inc (&info->then);
66
67 value = dex_future_get_value (future, &error);
68 g_assert_no_error (error);
69 g_assert_nonnull (value);
70 g_assert_true (G_VALUE_HOLDS_STRING (value));
71 g_assert_cmpstr (g_value_get_string (value), ==, "123");
72
73 return DEX_FUTURE (dex_future_new_for_int (123));
74 }
75
76 static DexFuture *
77 finally_cb (DexFuture *future,
78 gpointer user_data)
79 {
80 TestInfo *info = user_data;
81 const GValue *value;
82 GError *error = NULL;
83
84 g_atomic_int_inc (&info->finally);
85
86 value = dex_future_get_value (future, &error);
87 g_assert_no_error (error);
88 g_assert_nonnull (value);
89 g_assert_true (G_VALUE_HOLDS_INT (value));
90 g_assert_cmpint (g_value_get_int (value), ==, 123);
91
92 return NULL;
93 }
94
95 static void
96 destroy_cb (gpointer data)
97 {
98 TestInfo *info = data;
99 g_atomic_int_inc (&info->destroy);
100 }
101
102 static void
103 test_future_then (void)
104 {
105 DexCancellable *cancellable;
106 const GValue *resolved;
107 DexFuture *future;
108 GError *error = NULL;
109 TestInfo info = {0};
110
111 cancellable = dex_cancellable_new ();
112 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (cancellable)), ==, DEX_FUTURE_STATUS_PENDING);
113
114 dex_cancellable_cancel (cancellable);
115 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (cancellable)), ==, DEX_FUTURE_STATUS_REJECTED);
116
117 future = dex_future_catch (dex_ref (cancellable), catch_cb, &info, destroy_cb);
118 g_assert_cmpint (dex_future_get_status (future), ==, DEX_FUTURE_STATUS_RESOLVED);
119
120 future = dex_future_then (future, then_cb, &info, destroy_cb);
121 g_assert_cmpint (dex_future_get_status (future), ==, DEX_FUTURE_STATUS_RESOLVED);
122
123 future = dex_future_finally (future, finally_cb, &info, destroy_cb);
124 g_assert_cmpint (dex_future_get_status (future), ==, DEX_FUTURE_STATUS_RESOLVED);
125
126 resolved = dex_future_get_value (future, &error);
127 g_assert_no_error (error);
128 g_assert_nonnull (resolved);
129 g_assert_true (G_VALUE_HOLDS_INT (resolved));
130 g_assert_cmpint (g_value_get_int (resolved), ==, 123);
131
132 dex_unref (future);
133 dex_unref (cancellable);
134
135 g_assert_cmpint (info.catch, ==, 1);
136 g_assert_cmpint (info.finally, ==, 1);
137 g_assert_cmpint (info.then, ==, 1);
138 g_assert_cmpint (info.destroy, ==, 3);
139 }
140
141 static void
142 test_cancellable_cancel (void)
143 {
144 DexCancellable *future = dex_cancellable_new ();
145 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (future)), ==, DEX_FUTURE_STATUS_PENDING);
146 dex_cancellable_cancel (future);
147 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (future)), ==, DEX_FUTURE_STATUS_REJECTED);
148 dex_unref (future);
149 }
150
151 static DexFuture *
152 on_timed_out (DexFuture *future,
153 gpointer user_data)
154 {
155 g_main_loop_quit (user_data);
156 return NULL;
157 }
158
159 static void
160 test_timeout (void)
161 {
162 GMainLoop *main_loop = g_main_loop_new (NULL, FALSE);
163 DexFuture *timeout = dex_timeout_new_deadline (g_get_monotonic_time ());
164 DexFuture *future = dex_future_catch (dex_ref (timeout), on_timed_out, main_loop, NULL);
165
166 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (timeout)), ==, DEX_FUTURE_STATUS_PENDING);
167 g_assert_cmpint (dex_future_get_status (future), ==, DEX_FUTURE_STATUS_PENDING);
168
169 g_main_loop_run (main_loop);
170
171 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (timeout)), ==, DEX_FUTURE_STATUS_REJECTED);
172 g_assert_cmpint (dex_future_get_status (future), ==, DEX_FUTURE_STATUS_REJECTED);
173
174 dex_clear (&future);
175 dex_clear (&timeout);
176
177 g_main_loop_unref (main_loop);
178 }
179
180 static void
181 test_promise_type (void)
182 {
183 g_assert_true (dex_promise_get_type() != G_TYPE_INVALID);
184 g_assert_true (G_TYPE_IS_INSTANTIATABLE (dex_promise_get_type()));
185 g_assert_false (G_TYPE_IS_ABSTRACT (dex_promise_get_type()));
186 g_assert_true (G_TYPE_IS_FINAL (dex_promise_get_type()));
187 }
188
189 #if !defined (_MSC_VER) && !defined (__clang__)
190 static void
191 test_promise_autoptr (void)
192 {
193 G_GNUC_UNUSED g_autoptr(DexPromise) promise = NULL;
194 }
195 #endif
196
197 static void
198 test_promise_new (void)
199 {
200 DexPromise *promise;
201
202 promise = dex_promise_new ();
203 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (promise)), ==, DEX_FUTURE_STATUS_PENDING);
204 g_assert_nonnull (promise);
205 g_assert_true (DEX_IS_FUTURE (promise));
206 dex_clear (&promise);
207 }
208
209 static void
210 test_static_future_new (void)
211 {
212 DexFuture *future;
213
214 future = dex_future_new_for_string ("123");
215 g_assert_true (DEX_IS_STATIC_FUTURE (future));
216 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (future)), ==, DEX_FUTURE_STATUS_RESOLVED);
217 dex_clear (&future);
218
219 future = dex_future_new_for_int (123);
220 g_assert_true (DEX_IS_STATIC_FUTURE (future));
221 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (future)), ==, DEX_FUTURE_STATUS_RESOLVED);
222 dex_clear (&future);
223
224 future = dex_future_new_for_boolean (TRUE);
225 g_assert_true (DEX_IS_STATIC_FUTURE (future));
226 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (future)), ==, DEX_FUTURE_STATUS_RESOLVED);
227 dex_clear (&future);
228
229 future = dex_future_new_for_error (g_error_new_literal (G_IO_ERROR, G_IO_ERROR_PENDING, "pending"));
230 g_assert_true (DEX_IS_STATIC_FUTURE (future));
231 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (future)), ==, DEX_FUTURE_STATUS_REJECTED);
232 dex_clear (&future);
233 }
234
235 static void
236 test_promise_resolve (void)
237 {
238 DexPromise *promise = dex_promise_new ();
239 GValue value = G_VALUE_INIT;
240 const GValue *resolved;
241 GError *error = NULL;
242
243 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (promise)), ==, DEX_FUTURE_STATUS_PENDING);
244
245 g_value_init (&value, G_TYPE_BOOLEAN);
246 g_value_set_boolean (&value, TRUE);
247 dex_promise_resolve (promise, &value);
248
249 g_assert_cmpint (dex_future_get_status (DEX_FUTURE (promise)), ==, DEX_FUTURE_STATUS_RESOLVED);
250
251 resolved = dex_future_get_value (DEX_FUTURE (promise), &error);
252 g_assert_no_error (error);
253 g_assert_cmpint (G_VALUE_TYPE (resolved), ==, G_VALUE_TYPE (&value));
254 g_assert_cmpint (g_value_get_boolean (resolved), ==, g_value_get_boolean (&value));
255
256 g_value_unset (&value);
257 dex_unref (promise);
258 }
259
260 #define ASYNC_TEST(T, TYPE, NAME, propagate, gvalue, res, cmp) \
261 typedef struct G_PASTE (_Test, T) G_PASTE (Test, T); \
262 static void \
263 G_PASTE (test_async_, T) (G_PASTE (Test, T) *instance, \
264 GCancellable *cancellable, \
265 GAsyncReadyCallback callback, \
266 gpointer user_data) \
267 { \
268 GTask *task = g_task_new (instance, cancellable, callback, user_data); \
269 g_assert_true (G_IS_OBJECT (instance)); \
270 g_assert_true (!cancellable || G_IS_CANCELLABLE (cancellable)); \
271 g_assert_true (callback != NULL); \
272 G_PASTE (g_task_return_, propagate)(task, res); \
273 g_object_unref (task); \
274 } \
275 static T \
276 G_PASTE (test_finish_, T)(G_PASTE (Test, T) *instance, GAsyncResult *result, GError **error) \
277 { \
278 g_assert_true (G_IS_TASK (result)); \
279 g_assert_true (G_IS_OBJECT (instance)); \
280 return G_PASTE (g_task_propagate_, propagate) (G_TASK (result), error); \
281 } \
282 static DexFuture * \
283 G_PASTE (test_complete_, T) (DexFuture *future, gpointer user_data) \
284 { \
285 GMainLoop *main_loop = user_data; \
286 GError *error = NULL; \
287 const GValue *value = dex_future_get_value (future, &error); \
288 g_assert_cmpint (dex_future_get_status (future), ==, DEX_FUTURE_STATUS_RESOLVED); \
289 g_assert_no_error (error); \
290 g_assert_true (G_PASTE (G_VALUE_HOLDS_, NAME)(value)); \
291 G_PASTE (g_assert_, cmp) (G_PASTE (g_value_get_, gvalue) (value), ==, res); \
292 g_main_loop_quit (main_loop); \
293 return NULL; \
294 } \
295 static void \
296 G_PASTE (test_async_pair_, T) (void) \
297 { \
298 GMainLoop *main_loop = g_main_loop_new (NULL, FALSE); \
299 GObject *object = G_OBJECT (g_menu_new ()); \
300 DexFuture *future = dex_async_pair_new (object, \
301 &DEX_ASYNC_PAIR_INFO (G_PASTE (test_async_, T), G_PASTE (test_finish_, T), TYPE)); \
302 future = dex_future_finally (future, G_PASTE (test_complete_, T), main_loop, NULL); \
303 g_main_loop_run (main_loop); \
304 dex_unref (future); \
305 g_clear_object (&object); \
306 g_main_loop_unref (main_loop); \
307 }
308
309 ASYNC_TEST (gboolean, G_TYPE_BOOLEAN, BOOLEAN, boolean, boolean, TRUE, cmpint)
310 ASYNC_TEST (int, G_TYPE_INT, INT, int, int, 123, cmpint)
311 ASYNC_TEST (guint, G_TYPE_UINT, UINT, int, uint, 321, cmpint)
312 ASYNC_TEST (gint64, G_TYPE_INT64, INT64, int, int64, -123123123L, cmpint)
313 ASYNC_TEST (guint64, G_TYPE_UINT64, UINT64, int, uint64, 123123123L, cmpint)
314 ASYNC_TEST (glong, G_TYPE_LONG, LONG, int, long, -123123, cmpint)
315 ASYNC_TEST (gulong, G_TYPE_ULONG, ULONG, int, ulong, 123123, cmpint)
316 ASYNC_TEST (DexFutureStatus, DEX_TYPE_FUTURE_STATUS, ENUM, int, enum, DEX_FUTURE_STATUS_REJECTED, cmpint)
317 ASYNC_TEST (GSubprocessFlags, G_TYPE_SUBPROCESS_FLAGS, FLAGS, int, flags, (G_SUBPROCESS_FLAGS_STDIN_PIPE|G_SUBPROCESS_FLAGS_STDOUT_PIPE), cmpint)
318
319 #define ASYNC_TEST_PTR(T, NAME, propagate, gvalue, res, cmp, copyfunc, freefunc) \
320 typedef struct G_PASTE (_Test, T) G_PASTE (Test, T); \
321 static void \
322 G_PASTE (test_async_, T) (G_PASTE (Test, T) *instance, \
323 GCancellable *cancellable, \
324 GAsyncReadyCallback callback, \
325 gpointer user_data) \
326 { \
327 GTask *task = g_task_new (instance, cancellable, callback, user_data); \
328 g_assert_true (G_IS_OBJECT (instance)); \
329 g_assert_true (!cancellable || G_IS_CANCELLABLE (cancellable)); \
330 g_assert_true (callback != NULL); \
331 G_PASTE (g_task_return_, propagate)(task, copyfunc, (GDestroyNotify)freefunc); \
332 g_object_unref (task); \
333 } \
334 static T * \
335 G_PASTE (test_finish_, T)(G_PASTE (Test, T) *instance, GAsyncResult *result, GError **error) \
336 { \
337 g_assert_true (G_IS_TASK (result)); \
338 g_assert_true (G_IS_OBJECT (instance)); \
339 return G_PASTE (g_task_propagate_, propagate) (G_TASK (result), error); \
340 } \
341 static DexFuture * \
342 G_PASTE (test_complete_, T) (DexFuture *future, gpointer user_data) \
343 { \
344 gpointer *state = user_data; \
345 GMainLoop *main_loop = state[0]; \
346 G_GNUC_UNUSED gpointer instance = state[1]; \
347 GError *error = NULL; \
348 const GValue *value = dex_future_get_value (future, &error); \
349 const T *ret = G_PASTE (g_value_get_, gvalue) (value); \
350 g_assert_cmpint (dex_future_get_status (future), ==, DEX_FUTURE_STATUS_RESOLVED); \
351 g_assert_no_error (error); \
352 g_assert_true (G_PASTE (G_VALUE_HOLDS_, NAME)(value)); \
353 g_assert_true (cmp(ret,res)); \
354 g_main_loop_quit (main_loop); \
355 return NULL; \
356 } \
357 static void \
358 G_PASTE (test_async_pair_, T) (void) \
359 { \
360 GMainLoop *main_loop = g_main_loop_new (NULL, FALSE); \
361 GObject *instance = G_OBJECT (g_menu_new ()); \
362 gpointer state[2] = { main_loop, instance }; \
363 DexFuture *future = dex_async_pair_new (instance, \
364 &G_PASTE (DEX_ASYNC_PAIR_INFO_, NAME) (G_PASTE (test_async_, T), \
365 G_PASTE (test_finish_, T))); \
366 future = dex_future_finally (future, G_PASTE (test_complete_, T), state, NULL); \
367 g_main_loop_run (main_loop); \
368 dex_unref (future); \
369 g_clear_object (&instance); \
370 g_main_loop_unref (main_loop); \
371 }
372
373 ASYNC_TEST_PTR (char, STRING, pointer, string, "string-test", g_str_equal, g_strdup("string-test"), g_free)
374
375 static void ptr_free (gpointer p) { }
376 static gboolean cmpptr (gconstpointer a, gconstpointer b) { return a == b; }
377 ASYNC_TEST_PTR (gpointer, POINTER, pointer, pointer, "a-pointer", cmpptr, (gpointer)"a-pointer", ptr_free)
378
379 ASYNC_TEST_PTR (GObject, OBJECT, pointer, object, instance, cmpptr, g_object_ref(instance), g_object_unref)
380
381 #define ASYNC_TEST_ERROR(T, NAME, propagate) \
382 typedef struct G_PASTE (_Test, T) G_PASTE (Test, T); \
383 static void \
384 G_PASTE (test_async_, T) (G_PASTE (Test, T) *instance, \
385 GCancellable *cancellable, \
386 GAsyncReadyCallback callback, \
387 gpointer user_data) \
388 { \
389 GTask *task = g_task_new (instance, cancellable, callback, user_data); \
390 g_assert_true (G_IS_OBJECT (instance)); \
391 g_assert_true (!cancellable || G_IS_CANCELLABLE (cancellable)); \
392 g_assert_true (callback != NULL); \
393 g_task_return_new_error (task, DEX_ERROR, DEX_ERROR_DEPENDENCY_FAILED, "Failed"); \
394 g_object_unref (task); \
395 } \
396 static T * \
397 G_PASTE (test_finish_, T)(G_PASTE (Test, T) *instance, GAsyncResult *result, GError **error) \
398 { \
399 g_assert_true (G_IS_TASK (result)); \
400 g_assert_true (G_IS_OBJECT (instance)); \
401 return G_PASTE (g_task_propagate_, propagate) (G_TASK (result), error); \
402 } \
403 static DexFuture * \
404 G_PASTE (test_complete_, T) (DexFuture *future, gpointer user_data) \
405 { \
406 GMainLoop *main_loop = user_data; \
407 GError *error = NULL; \
408 const GValue *value = dex_future_get_value (future, &error); \
409 g_assert_cmpint (dex_future_get_status (future), ==, DEX_FUTURE_STATUS_REJECTED); \
410 g_assert_error (error, DEX_ERROR, DEX_ERROR_DEPENDENCY_FAILED); \
411 g_assert_null (value); \
412 g_main_loop_quit (main_loop); \
413 g_error_free (error); \
414 return NULL; \
415 } \
416 static void \
417 G_PASTE (test_async_pair_, T) (void) \
418 { \
419 GMainLoop *main_loop = g_main_loop_new (NULL, FALSE); \
420 GObject *instance = G_OBJECT (g_menu_new ()); \
421 DexFuture *future = dex_async_pair_new (instance, \
422 &G_PASTE (DEX_ASYNC_PAIR_INFO_, NAME) (G_PASTE (test_async_, T), \
423 G_PASTE (test_finish_, T))); \
424 future = dex_future_finally (future, G_PASTE (test_complete_, T), main_loop, NULL); \
425 g_main_loop_run (main_loop); \
426 dex_unref (future); \
427 g_clear_object (&instance); \
428 g_main_loop_unref (main_loop); \
429 }
430
431 typedef GObject ErrorTest;
432 ASYNC_TEST_ERROR (ErrorTest, OBJECT, pointer)
433
434 static void
435 test_future_set_first_preresolved (void)
436 {
437 DexFuture *promise1 = dex_future_new_for_int (123);
438 DexFuture *promise2 = dex_future_new_for_int (321);
439 DexFuture *future = dex_future_first (DEX_FUTURE (promise1), promise2, NULL);
440 GError *error = NULL;
441 const GValue *value = dex_future_get_value (future, &error);
442 g_assert_no_error (error);
443 g_assert_nonnull (value);
444 g_assert_true (G_VALUE_HOLDS_INT (value));
445 g_assert_cmpint (g_value_get_int (value), ==, 123);
446 dex_unref (future);
447 }
448
449 static void
450 test_future_set_all_race_preresolved (void)
451 {
452 DexFuture *promise1 = dex_future_new_for_int (123);
453 DexFuture *promise2 = dex_future_new_for_int (321);
454 DexFuture *future = dex_future_all_race (DEX_FUTURE (promise1), promise2, NULL);
455 GError *error = NULL;
456 const GValue *value = dex_future_get_value (future, &error);
457 g_assert_no_error (error);
458 g_assert_nonnull (value);
459 g_assert_true (G_VALUE_HOLDS_BOOLEAN (value));
460 g_assert_cmpint (g_value_get_boolean (value), ==, TRUE);
461 dex_unref (future);
462 }
463
464 static void
465 test_future_set_any_preresolved (void)
466 {
467 DexFuture *promise1 = dex_future_new_for_int (123);
468 DexFuture *promise2 = dex_future_new_for_int (321);
469 DexFuture *future = dex_future_any (DEX_FUTURE (promise1), promise2, NULL);
470 GError *error = NULL;
471 const GValue *value = dex_future_get_value (future, &error);
472 g_assert_no_error (error);
473 g_assert_nonnull (value);
474 g_assert_true (G_VALUE_HOLDS_INT (value));
475 g_assert_cmpint (g_value_get_int (value), ==, 123);
476 dex_unref (future);
477 }
478
479 static void
480 test_future_set_all_preresolved (void)
481 {
482 DexFuture *promise1 = dex_future_new_for_int (123);
483 DexFuture *promise2 = dex_future_new_for_int (321);
484 DexFuture *future = dex_future_all (DEX_FUTURE (promise1), promise2, NULL);
485 GError *error = NULL;
486 const GValue *value = dex_future_get_value (future, &error);
487 g_assert_no_error (error);
488 g_assert_nonnull (value);
489 g_assert_true (G_VALUE_HOLDS_BOOLEAN (value));
490 g_assert_cmpint (g_value_get_boolean (value), ==, TRUE);
491 dex_unref (future);
492 }
493
494 static void
495 test_future_set_all_preresolved_error (void)
496 {
497 DexFuture *promise1 = dex_future_new_for_int (123);
498 DexCancellable *cancel1 = dex_cancellable_new ();
499 DexFuture *future;
500 GError *error = NULL;
501 const GValue *value;
502
503 dex_cancellable_cancel (cancel1);
504
505 future = dex_future_all (DEX_FUTURE (promise1), cancel1, NULL);
506 value = dex_future_get_value (future, &error);
507
508 g_assert_null (value);
509 g_assert_error (error, DEX_ERROR, DEX_ERROR_DEPENDENCY_FAILED);
510
511 g_clear_error (&error);
512 dex_unref (future);
513 }
514
515 static void
516 test_future_set_any_preresolved_error (void)
517 {
518 DexPromise *promise1 = dex_promise_new ();
519 DexCancellable *cancel1 = dex_cancellable_new ();
520 DexFuture *future;
521 GError *error = NULL;
522 const GValue *value;
523
524 dex_cancellable_cancel (cancel1);
525
526 future = dex_future_any (DEX_FUTURE (promise1), cancel1, NULL);
527 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
528 ASSERT_STATUS (promise1, DEX_FUTURE_STATUS_PENDING);
529 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
530
531 dex_promise_resolve_int (promise1, 123);
532 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
533 ASSERT_STATUS (promise1, DEX_FUTURE_STATUS_RESOLVED);
534 ASSERT_STATUS (future, DEX_FUTURE_STATUS_RESOLVED);
535
536 value = dex_future_get_value (future, &error);
537 g_assert_nonnull (value);
538 g_assert_true (G_VALUE_HOLDS_INT (value));
539 g_assert_cmpint (g_value_get_int (value), ==, 123);
540
541 g_clear_error (&error);
542 dex_unref (future);
543 }
544
545 static void
546 test_future_all (void)
547 {
548 DexCancellable *cancel1 = dex_cancellable_new ();
549 DexCancellable *cancel2 = dex_cancellable_new ();
550 DexCancellable *cancel3 = dex_cancellable_new ();
551 const GValue *value;
552 DexFuture *future;
553 GError *error = NULL;
554
555 future = dex_future_all (dex_ref (cancel1), dex_ref (cancel2), dex_ref (cancel3), NULL);
556 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_PENDING);
557 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_PENDING);
558 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
559 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
560
561 dex_cancellable_cancel (cancel1);
562 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
563 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_PENDING);
564 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
565 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
566
567 dex_cancellable_cancel (cancel2);
568 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
569 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_REJECTED);
570 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
571 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
572
573 dex_cancellable_cancel (cancel3);
574 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
575 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_REJECTED);
576 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_REJECTED);
577 ASSERT_STATUS (future, DEX_FUTURE_STATUS_REJECTED);
578 value = dex_future_get_value (future, &error);
579 g_assert_null (value);
580 g_assert_error (error, DEX_ERROR, DEX_ERROR_DEPENDENCY_FAILED);
581 g_clear_error (&error);
582
583 g_assert_true (DEX_IS_FUTURE_SET (future));
584 g_assert_cmpint (dex_future_set_get_size (DEX_FUTURE_SET (future)), ==, 3);
585
586 for (guint i = 0; i < dex_future_set_get_size (DEX_FUTURE_SET (future)); i++)
587 {
588 DexFuture *dep = dex_future_set_get_future_at (DEX_FUTURE_SET (future), i);
589 value = dex_future_get_value (dep, &error);
590 g_assert_null (value);
591 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
592 g_clear_error (&error);
593 }
594
595 dex_clear (&cancel1);
596 dex_clear (&cancel2);
597 dex_clear (&cancel3);
598 dex_clear (&future);
599 }
600
601 static void
602 test_future_all_race (void)
603 {
604 DexCancellable *cancel1 = dex_cancellable_new ();
605 DexCancellable *cancel2 = dex_cancellable_new ();
606 DexCancellable *cancel3 = dex_cancellable_new ();
607 const GValue *value;
608 DexFuture *future;
609 GError *error = NULL;
610
611 future = dex_future_all_race (dex_ref (cancel1), dex_ref (cancel2), dex_ref (cancel3), NULL);
612 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_PENDING);
613 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_PENDING);
614 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
615 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
616
617 dex_cancellable_cancel (cancel1);
618 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
619 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_PENDING);
620 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
621 ASSERT_STATUS (future, DEX_FUTURE_STATUS_REJECTED);
622
623 dex_cancellable_cancel (cancel2);
624 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
625 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_REJECTED);
626 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
627 ASSERT_STATUS (future, DEX_FUTURE_STATUS_REJECTED);
628
629 dex_cancellable_cancel (cancel3);
630 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
631 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_REJECTED);
632 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_REJECTED);
633 ASSERT_STATUS (future, DEX_FUTURE_STATUS_REJECTED);
634 value = dex_future_get_value (future, &error);
635 g_assert_null (value);
636 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
637 g_clear_error (&error);
638
639 g_assert_true (DEX_IS_FUTURE_SET (future));
640
641 g_assert_cmpint (dex_future_set_get_size (DEX_FUTURE_SET (future)), ==, 3);
642 for (guint i = 0; i < dex_future_set_get_size (DEX_FUTURE_SET (future)); i++)
643 {
644 DexFuture *dep = dex_future_set_get_future_at (DEX_FUTURE_SET (future), i);
645 value = dex_future_get_value (dep, &error);
646 g_assert_null (value);
647 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
648 g_clear_error (&error);
649 }
650
651 dex_clear (&cancel1);
652 dex_clear (&cancel2);
653 dex_clear (&cancel3);
654 dex_clear (&future);
655 }
656
657 static void
658 test_future_any (void)
659 {
660 DexCancellable *cancel1 = dex_cancellable_new ();
661 DexCancellable *cancel2 = dex_cancellable_new ();
662 DexCancellable *cancel3 = dex_cancellable_new ();
663 const GValue *value;
664 DexFuture *future;
665 GError *error = NULL;
666
667 future = dex_future_any (dex_ref (cancel1), dex_ref (cancel2), dex_ref (cancel3), NULL);
668 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_PENDING);
669 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_PENDING);
670 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
671 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
672
673 dex_cancellable_cancel (cancel1);
674 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
675 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_PENDING);
676 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
677 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
678
679 dex_cancellable_cancel (cancel2);
680 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
681 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_REJECTED);
682 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
683 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
684
685 dex_cancellable_cancel (cancel3);
686 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
687 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_REJECTED);
688 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_REJECTED);
689 ASSERT_STATUS (future, DEX_FUTURE_STATUS_REJECTED);
690 value = dex_future_get_value (future, &error);
691 g_assert_null (value);
692 g_assert_error (error, DEX_ERROR, DEX_ERROR_DEPENDENCY_FAILED);
693 g_clear_error (&error);
694
695 g_assert_true (DEX_IS_FUTURE_SET (future));
696
697 g_assert_cmpint (dex_future_set_get_size (DEX_FUTURE_SET (future)), ==, 3);
698 for (guint i = 0; i < dex_future_set_get_size (DEX_FUTURE_SET (future)); i++)
699 {
700 DexFuture *dep = dex_future_set_get_future_at (DEX_FUTURE_SET (future), i);
701 value = dex_future_get_value (dep, &error);
702 g_assert_null (value);
703 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
704 g_clear_error (&error);
705 }
706
707 dex_clear (&cancel1);
708 dex_clear (&cancel2);
709 dex_clear (&cancel3);
710 dex_clear (&future);
711 }
712
713 static void
714 test_future_first (void)
715 {
716 DexCancellable *cancel1 = dex_cancellable_new ();
717 DexCancellable *cancel2 = dex_cancellable_new ();
718 DexCancellable *cancel3 = dex_cancellable_new ();
719 const GValue *value;
720 DexFuture *future;
721 GError *error = NULL;
722
723 future = dex_future_first (dex_ref (cancel1), dex_ref (cancel2), dex_ref (cancel3), NULL);
724 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_PENDING);
725 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_PENDING);
726 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
727 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
728
729 dex_cancellable_cancel (cancel1);
730 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
731 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_PENDING);
732 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
733 ASSERT_STATUS (future, DEX_FUTURE_STATUS_REJECTED);
734
735 dex_cancellable_cancel (cancel2);
736 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
737 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_REJECTED);
738 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_PENDING);
739 ASSERT_STATUS (future, DEX_FUTURE_STATUS_REJECTED);
740
741 dex_cancellable_cancel (cancel3);
742 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
743 ASSERT_STATUS (cancel2, DEX_FUTURE_STATUS_REJECTED);
744 ASSERT_STATUS (cancel3, DEX_FUTURE_STATUS_REJECTED);
745 ASSERT_STATUS (future, DEX_FUTURE_STATUS_REJECTED);
746 value = dex_future_get_value (future, &error);
747 g_assert_null (value);
748 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
749 g_clear_error (&error);
750
751 g_assert_true (DEX_IS_FUTURE_SET (future));
752
753 g_assert_cmpint (dex_future_set_get_size (DEX_FUTURE_SET (future)), ==, 3);
754 for (guint i = 0; i < dex_future_set_get_size (DEX_FUTURE_SET (future)); i++)
755 {
756 DexFuture *dep = dex_future_set_get_future_at (DEX_FUTURE_SET (future), i);
757 value = dex_future_get_value (dep, &error);
758 g_assert_null (value);
759 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
760 g_clear_error (&error);
761 }
762
763 dex_clear (&cancel1);
764 dex_clear (&cancel2);
765 dex_clear (&cancel3);
766 dex_clear (&future);
767 }
768
769 static void
770 discard_async (GMenu *menu,
771 GCancellable *cancellable,
772 GAsyncReadyCallback callback,
773 gpointer user_data)
774 {
775 GTask *task;
776
777 g_print ("Discard async\n");
778
779 ASSERT_INSTANCE_TYPE (menu, G_TYPE_MENU);
780 ASSERT_INSTANCE_TYPE (cancellable, G_TYPE_CANCELLABLE);
781
782 task = g_task_new (menu, cancellable, callback, user_data);
783 g_task_set_check_cancellable (task, TRUE);
784 g_task_set_return_on_cancel (task, TRUE);
785 }
786
787 static gboolean
788 discard_finish (GMenu *menu,
789 GAsyncResult *result,
790 GError **error)
791 {
792 GTask *task = G_TASK (result);
793 gboolean ret;
794 ASSERT_INSTANCE_TYPE (menu, G_TYPE_MENU);
795 g_task_return_error_if_cancelled (task);
796 ret = g_task_propagate_boolean (task, error);
797 g_object_unref (task);
798 return ret;
799 }
800
801 static void
802 test_future_discard_cancelled (GCancellable *cancellable,
803 gpointer user_data)
804 {
805 gboolean *was_cancelled = user_data;
806 *was_cancelled = TRUE;
807 }
808
809 static void
810 test_future_discard (void)
811 {
812 GMenu *menu = g_menu_new ();
813 DexFuture *call = dex_async_pair_new (menu, &DEX_ASYNC_PAIR_INFO (discard_async, discard_finish, G_TYPE_BOOLEAN));
814 DexCancellable *cancel1;
815 DexFuture *any;
816 gboolean was_cancelled = FALSE;
817
818 ASSERT_INSTANCE_TYPE (call, DEX_TYPE_ASYNC_PAIR);
819 ASSERT_INSTANCE_TYPE (DEX_ASYNC_PAIR (call)->instance, G_TYPE_MENU);
820 ASSERT_INSTANCE_TYPE (DEX_ASYNC_PAIR (call)->cancellable, G_TYPE_CANCELLABLE);
821
822 cancel1 = dex_cancellable_new ();
823 ASSERT_INSTANCE_TYPE (cancel1, DEX_TYPE_CANCELLABLE);
824
825 any = dex_future_first (call, cancel1, NULL);
826 ASSERT_INSTANCE_TYPE (any, DEX_TYPE_FUTURE_SET);
827
828 g_signal_connect (DEX_ASYNC_PAIR (call)->cancellable,
829 "cancelled",
830 G_CALLBACK (test_future_discard_cancelled),
831 &was_cancelled);
832
833 dex_cancellable_cancel (cancel1);
834
835 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
836 ASSERT_STATUS (call, DEX_FUTURE_STATUS_PENDING);
837 ASSERT_STATUS (any, DEX_FUTURE_STATUS_REJECTED);
838
839 g_assert_true (was_cancelled);
840
841 ASSERT_STATUS (cancel1, DEX_FUTURE_STATUS_REJECTED);
842 ASSERT_STATUS (call, DEX_FUTURE_STATUS_PENDING);
843 ASSERT_STATUS (any, DEX_FUTURE_STATUS_REJECTED);
844
845 g_clear_object (&menu);
846 dex_clear (&any);
847 }
848
849 #ifdef G_OS_UNIX
850 static void
851 test_unix_signal_sigusr2 (void)
852 {
853 DexFuture *future = dex_unix_signal_new (SIGUSR2);
854 const GValue *value;
855 GError *error = NULL;
856
857 kill (getpid (), SIGUSR2);
858
859 while (dex_future_get_status (future) == DEX_FUTURE_STATUS_PENDING)
860 g_main_context_iteration (g_main_context_default (), TRUE);
861
862 ASSERT_STATUS (future, DEX_FUTURE_STATUS_RESOLVED);
863 value = dex_future_get_value (future, &error);
864 g_assert_no_error (error);
865 g_assert_nonnull (value);
866 g_assert_true (G_VALUE_HOLDS_INT (value));
867 g_assert_cmpint (SIGUSR2, ==, g_value_get_int (value));
868
869 dex_unref (future);
870 }
871 #endif
872
873 static void
874 test_delayed_simple (void)
875 {
876 DexFuture *result = dex_future_new_for_int (123);
877 DexFuture *delayed = dex_delayed_new (result);
878
879 ASSERT_STATUS (result, DEX_FUTURE_STATUS_RESOLVED);
880 ASSERT_STATUS (delayed, DEX_FUTURE_STATUS_PENDING);
881
882 dex_delayed_release (DEX_DELAYED (delayed));
883 ASSERT_STATUS (delayed, DEX_FUTURE_STATUS_RESOLVED);
884
885 dex_clear (&delayed);
886 dex_clear (&result);
887 }
888
889 static void
890 test_future_name (void)
891 {
892 DexFuture *future = DEX_FUTURE (dex_promise_new ());
893 dex_future_set_static_name (future, "futuristic programming");
894 g_assert_cmpstr ("futuristic programming", ==, dex_future_get_name (future));
895 dex_unref (future);
896 }
897
898 static void
899 test_infinite_simple (void)
900 {
901 DexFuture *future = dex_future_new_infinite ();
902 ASSERT_STATUS (future, DEX_FUTURE_STATUS_PENDING);
903 dex_unref (future);
904 }
905
906 static DexFuture *
907 then_cb_returns_null (DexFuture *future,
908 gpointer user_data)
909 {
910 GMainLoop *main_loop = user_data;
911 const GValue *value;
912 GError *error = NULL;
913
914 value = dex_future_get_value (future, &error);
915 g_assert_no_error (error);
916 g_assert_nonnull (value);
917 g_assert_true (G_VALUE_HOLDS_INT (value));
918 g_assert_cmpint (g_value_get_int (value), ==, 42);
919
920 g_main_loop_quit (main_loop);
921
922 return NULL;
923 }
924
925 static void
926 test_then_callback_returns_null (void)
927 {
928 GMainLoop *main_loop = g_main_loop_new (NULL, FALSE);
929 DexFuture *future;
930 DexFuture *chained_future;
931 const GValue *value;
932 GError *error = NULL;
933
934 future = dex_future_new_for_int (42);
935 chained_future = dex_future_then (dex_ref (future),
936 then_cb_returns_null,
937 g_main_loop_ref (main_loop),
938 (GDestroyNotify) g_main_loop_unref);
939
940 if (dex_future_is_pending (chained_future))
941 g_main_loop_run (main_loop);
942
943 g_assert_cmpint (dex_future_get_status (future), ==, DEX_FUTURE_STATUS_RESOLVED);
944 g_assert_cmpint (dex_future_get_status (chained_future), ==, DEX_FUTURE_STATUS_RESOLVED);
945
946 value = dex_future_get_value (chained_future, &error);
947 g_assert_no_error (error);
948 g_assert_nonnull (value);
949 g_assert_true (G_VALUE_HOLDS_INT (value));
950 g_assert_cmpint (g_value_get_int (value), ==, 42);
951
952 dex_unref (chained_future);
953 dex_unref (future);
954
955 g_main_loop_unref (main_loop);
956 }
957
958 int
959 main (int argc,
960 char *argv[])
961 {
962 dex_init ();
963 g_test_init (&argc, &argv, NULL);
964 g_test_add_func ("/Dex/TestSuite/Future/name", test_future_name);
965 g_test_add_func ("/Dex/TestSuite/Block/then", test_future_then);
966 g_test_add_func ("/Dex/TestSuite/Cancellable/cancel", test_cancellable_cancel);
967 g_test_add_func ("/Dex/TestSuite/StaticFuture/new", test_static_future_new);
968 g_test_add_func ("/Dex/TestSuite/Promise/type", test_promise_type);
969 #if !defined (_MSC_VER) && !defined (__clang__)
970 g_test_add_func ("/Dex/TestSuite/Promise/autoptr", test_promise_autoptr);
971 #endif
972 g_test_add_func ("/Dex/TestSuite/Promise/new", test_promise_new);
973 g_test_add_func ("/Dex/TestSuite/Promise/resolve", test_promise_resolve);
974 g_test_add_func ("/Dex/TestSuite/Timeout/timed-out", test_timeout);
975 g_test_add_func ("/Dex/TestSuite/AsyncPair/boolean", test_async_pair_gboolean);
976 g_test_add_func ("/Dex/TestSuite/AsyncPair/int", test_async_pair_int);
977 g_test_add_func ("/Dex/TestSuite/AsyncPair/uint", test_async_pair_guint);
978 g_test_add_func ("/Dex/TestSuite/AsyncPair/long", test_async_pair_glong);
979 g_test_add_func ("/Dex/TestSuite/AsyncPair/ulong", test_async_pair_gulong);
980 g_test_add_func ("/Dex/TestSuite/AsyncPair/int64", test_async_pair_gint64);
981 g_test_add_func ("/Dex/TestSuite/AsyncPair/uint64", test_async_pair_guint64);
982 g_test_add_func ("/Dex/TestSuite/AsyncPair/string", test_async_pair_char);
983 g_test_add_func ("/Dex/TestSuite/AsyncPair/object", test_async_pair_GObject);
984 g_test_add_func ("/Dex/TestSuite/AsyncPair/pointer", test_async_pair_gpointer);
985 g_test_add_func ("/Dex/TestSuite/AsyncPair/flags", test_async_pair_GSubprocessFlags);
986 g_test_add_func ("/Dex/TestSuite/AsyncPair/enums", test_async_pair_DexFutureStatus);
987 g_test_add_func ("/Dex/TestSuite/AsyncPair/GError", test_async_pair_ErrorTest);
988 g_test_add_func ("/Dex/TestSuite/Future/first_preresolved", test_future_set_first_preresolved);
989 g_test_add_func ("/Dex/TestSuite/Future/all_race_preresolved", test_future_set_all_race_preresolved);
990 g_test_add_func ("/Dex/TestSuite/Future/any_preresolved", test_future_set_any_preresolved);
991 g_test_add_func ("/Dex/TestSuite/Future/all_preresolved", test_future_set_all_preresolved);
992 g_test_add_func ("/Dex/TestSuite/Future/all_preresolved_error", test_future_set_all_preresolved_error);
993 g_test_add_func ("/Dex/TestSuite/Future/any_preresolved_error", test_future_set_any_preresolved_error);
994 g_test_add_func ("/Dex/TestSuite/Future/all", test_future_all);
995 g_test_add_func ("/Dex/TestSuite/Future/all_race", test_future_all_race);
996 g_test_add_func ("/Dex/TestSuite/Future/any", test_future_any);
997 g_test_add_func ("/Dex/TestSuite/Future/first", test_future_first);
998 g_test_add_func ("/Dex/TestSuite/Future/discard", test_future_discard);
999 g_test_add_func ("/Dex/TestSuite/Delayed/simple", test_delayed_simple);
1000 g_test_add_func ("/Dex/TestSuite/Infinite/simple", test_infinite_simple);
1001 g_test_add_func ("/Dex/TestSuite/Future/then_callback_returns_null", test_then_callback_returns_null);
1002 #ifdef G_OS_UNIX
1003 g_test_add_func ("/Dex/TestSuite/UnixSignal/sigusr2", test_unix_signal_sigusr2);
1004 #endif
1005 return g_test_run ();
1006 }