| 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 |
} |