?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update German translation
[glib.git] / gio / tests / task.c
blob60ca2847a4d97d2097ba01180ce42375c9207d08
1 /*
2 * Copyright 2012 Red Hat, Inc.
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as published
6 * by the Free Software Foundation; either version 2 of the licence or (at
7 * your option) any later version.
8 *
9 * See the included COPYING file for more information.
10 */
11
12 #include <gio/gio.h>
13 #include <string.h>
14
15 static GMainLoop *loop;
16 static GThread *main_thread;
17 static gssize magic;
18
19 /* We need objects for a few tests where we don't care what type
20 * they are, just that they're GObjects.
21 */
22 #define g_dummy_object_new g_socket_client_new
23
24 static gboolean
25 idle_quit_loop (gpointer user_data)
26 {
27 g_main_loop_quit (loop);
28 return FALSE;
29 }
30
31 static void
32 completed_cb (GObject *gobject,
33 GParamSpec *pspec,
34 gpointer user_data)
35 {
36 gboolean *notification_emitted = user_data;
37 *notification_emitted = TRUE;
38 }
39
40 static void
41 wait_for_completed_notification (GTask *task)
42 {
43 gboolean notification_emitted = FALSE;
44 gboolean is_completed = FALSE;
45
46 /* Hold a ref. so we can check the :completed property afterwards. */
47 g_object_ref (task);
48
49 g_signal_connect (task, "notify::completed",
50 (GCallback) completed_cb, &notification_emitted);
51 g_idle_add (idle_quit_loop, NULL);
52 g_main_loop_run (loop);
53 g_assert_true (notification_emitted);
54
55 g_assert_true (g_task_get_completed (task));
56 g_object_get (G_OBJECT (task), "completed", &is_completed, NULL);
57 g_assert_true (is_completed);
58
59 g_object_unref (task);
60 }
61
62 /* test_basic */
63
64 static void
65 basic_callback (GObject *object,
66 GAsyncResult *result,
67 gpointer user_data)
68 {
69 gssize *result_out = user_data;
70 GError *error = NULL;
71
72 g_assert (object == NULL);
73 g_assert (g_task_is_valid (result, object));
74 g_assert (g_async_result_get_user_data (result) == user_data);
75 g_assert (!g_task_had_error (G_TASK (result)));
76 g_assert_false (g_task_get_completed (G_TASK (result)));
77
78 *result_out = g_task_propagate_int (G_TASK (result), &error);
79 g_assert_no_error (error);
80
81 g_assert (!g_task_had_error (G_TASK (result)));
82
83 g_main_loop_quit (loop);
84 }
85
86 static gboolean
87 basic_return (gpointer user_data)
88 {
89 GTask *task = user_data;
90
91 g_task_return_int (task, magic);
92 g_object_unref (task);
93
94 return FALSE;
95 }
96
97 static void
98 basic_destroy_notify (gpointer user_data)
99 {
100 gboolean *destroyed = user_data;
101
102 *destroyed = TRUE;
103 }
104
105 static void
106 test_basic (void)
107 {
108 GTask *task;
109 gssize result;
110 gboolean task_data_destroyed = FALSE;
111 gboolean notification_emitted = FALSE;
112
113 task = g_task_new (NULL, NULL, basic_callback, &result);
114 g_task_set_task_data (task, &task_data_destroyed, basic_destroy_notify);
115 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
116 g_signal_connect (task, "notify::completed",
117 (GCallback) completed_cb, &notification_emitted);
118
119 g_idle_add (basic_return, task);
120 g_main_loop_run (loop);
121
122 g_assert_cmpint (result, ==, magic);
123 g_assert (task_data_destroyed == TRUE);
124 g_assert_true (notification_emitted);
125 g_assert (task == NULL);
126 }
127
128 /* test_error */
129
130 static void
131 error_callback (GObject *object,
132 GAsyncResult *result,
133 gpointer user_data)
134 {
135 gssize *result_out = user_data;
136 GError *error = NULL;
137
138 g_assert (object == NULL);
139 g_assert (g_task_is_valid (result, object));
140 g_assert (g_async_result_get_user_data (result) == user_data);
141 g_assert (g_task_had_error (G_TASK (result)));
142 g_assert_false (g_task_get_completed (G_TASK (result)));
143
144 *result_out = g_task_propagate_int (G_TASK (result), &error);
145 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
146 g_error_free (error);
147
148 g_assert (g_task_had_error (G_TASK (result)));
149
150 g_main_loop_quit (loop);
151 }
152
153 static gboolean
154 error_return (gpointer user_data)
155 {
156 GTask *task = user_data;
157
158 g_task_return_new_error (task,
159 G_IO_ERROR, G_IO_ERROR_FAILED,
160 "Failed");
161 g_object_unref (task);
162
163 return FALSE;
164 }
165
166 static void
167 error_destroy_notify (gpointer user_data)
168 {
169 gboolean *destroyed = user_data;
170
171 *destroyed = TRUE;
172 }
173
174 static void
175 test_error (void)
176 {
177 GTask *task;
178 gssize result;
179 gboolean first_task_data_destroyed = FALSE;
180 gboolean second_task_data_destroyed = FALSE;
181 gboolean notification_emitted = FALSE;
182
183 task = g_task_new (NULL, NULL, error_callback, &result);
184 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
185 g_signal_connect (task, "notify::completed",
186 (GCallback) completed_cb, &notification_emitted);
187
188 g_assert (first_task_data_destroyed == FALSE);
189 g_task_set_task_data (task, &first_task_data_destroyed, error_destroy_notify);
190 g_assert (first_task_data_destroyed == FALSE);
191
192 /* Calling g_task_set_task_data() again will destroy the first data */
193 g_task_set_task_data (task, &second_task_data_destroyed, error_destroy_notify);
194 g_assert (first_task_data_destroyed == TRUE);
195 g_assert (second_task_data_destroyed == FALSE);
196
197 g_idle_add (error_return, task);
198 g_main_loop_run (loop);
199
200 g_assert_cmpint (result, ==, -1);
201 g_assert (second_task_data_destroyed == TRUE);
202 g_assert_true (notification_emitted);
203 g_assert (task == NULL);
204 }
205
206 /* test_return_from_same_iteration: calling g_task_return_* from the
207 * loop iteration the task was created in defers completion until the
208 * next iteration.
209 */
210 gboolean same_result = FALSE;
211 gboolean same_notification_emitted = FALSE;
212
213 static void
214 same_callback (GObject *object,
215 GAsyncResult *result,
216 gpointer user_data)
217 {
218 gboolean *result_out = user_data;
219 GError *error = NULL;
220
221 g_assert (object == NULL);
222 g_assert (g_task_is_valid (result, object));
223 g_assert (g_async_result_get_user_data (result) == user_data);
224 g_assert (!g_task_had_error (G_TASK (result)));
225 g_assert_false (g_task_get_completed (G_TASK (result)));
226
227 *result_out = g_task_propagate_boolean (G_TASK (result), &error);
228 g_assert_no_error (error);
229
230 g_assert (!g_task_had_error (G_TASK (result)));
231
232 g_main_loop_quit (loop);
233 }
234
235 static gboolean
236 same_start (gpointer user_data)
237 {
238 gpointer *weak_pointer = user_data;
239 GTask *task;
240
241 task = g_task_new (NULL, NULL, same_callback, &same_result);
242 *weak_pointer = task;
243 g_object_add_weak_pointer (G_OBJECT (task), weak_pointer);
244 g_signal_connect (task, "notify::completed",
245 (GCallback) completed_cb, &same_notification_emitted);
246
247 g_task_return_boolean (task, TRUE);
248 g_object_unref (task);
249
250 /* same_callback should not have been invoked yet */
251 g_assert (same_result == FALSE);
252 g_assert (*weak_pointer == task);
253 g_assert_false (same_notification_emitted);
254
255 return FALSE;
256 }
257
258 static void
259 test_return_from_same_iteration (void)
260 {
261 gpointer weak_pointer;
262
263 g_idle_add (same_start, &weak_pointer);
264 g_main_loop_run (loop);
265
266 g_assert (same_result == TRUE);
267 g_assert (weak_pointer == NULL);
268 g_assert_true (same_notification_emitted);
269 }
270
271 /* test_return_from_toplevel: calling g_task_return_* from outside any
272 * main loop completes the task inside the main loop.
273 */
274 gboolean toplevel_notification_emitted = FALSE;
275
276 static void
277 toplevel_callback (GObject *object,
278 GAsyncResult *result,
279 gpointer user_data)
280 {
281 gboolean *result_out = user_data;
282 GError *error = NULL;
283
284 g_assert (object == NULL);
285 g_assert (g_task_is_valid (result, object));
286 g_assert (g_async_result_get_user_data (result) == user_data);
287 g_assert (!g_task_had_error (G_TASK (result)));
288 g_assert_false (g_task_get_completed (G_TASK (result)));
289
290 *result_out = g_task_propagate_boolean (G_TASK (result), &error);
291 g_assert_no_error (error);
292
293 g_assert (!g_task_had_error (G_TASK (result)));
294
295 g_main_loop_quit (loop);
296 }
297
298 static void
299 test_return_from_toplevel (void)
300 {
301 GTask *task;
302 gboolean result = FALSE;
303
304 task = g_task_new (NULL, NULL, toplevel_callback, &result);
305 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
306 g_signal_connect (task, "notify::completed",
307 (GCallback) completed_cb, &toplevel_notification_emitted);
308
309 g_task_return_boolean (task, TRUE);
310 g_object_unref (task);
311
312 /* toplevel_callback should not have been invoked yet */
313 g_assert (result == FALSE);
314 g_assert (task != NULL);
315 g_assert_false (toplevel_notification_emitted);
316
317 g_main_loop_run (loop);
318
319 g_assert (result == TRUE);
320 g_assert (task == NULL);
321 g_assert_true (toplevel_notification_emitted);
322 }
323
324 /* test_return_from_anon_thread: calling g_task_return_* from a
325 * thread with no thread-default main context will complete the
326 * task in the task's context/thread.
327 */
328
329 gboolean anon_thread_notification_emitted = FALSE;
330 GThread *anon_thread;
331
332 static void
333 anon_callback (GObject *object,
334 GAsyncResult *result,
335 gpointer user_data)
336 {
337 gssize *result_out = user_data;
338 GError *error = NULL;
339
340 g_assert (object == NULL);
341 g_assert (g_task_is_valid (result, object));
342 g_assert (g_async_result_get_user_data (result) == user_data);
343 g_assert (!g_task_had_error (G_TASK (result)));
344 g_assert_false (g_task_get_completed (G_TASK (result)));
345
346 g_assert (g_thread_self () == main_thread);
347
348 *result_out = g_task_propagate_int (G_TASK (result), &error);
349 g_assert_no_error (error);
350
351 g_assert (!g_task_had_error (G_TASK (result)));
352
353 g_main_loop_quit (loop);
354 }
355
356 static gpointer
357 anon_thread_func (gpointer user_data)
358 {
359 GTask *task = user_data;
360
361 g_task_return_int (task, magic);
362 g_object_unref (task);
363
364 return NULL;
365 }
366
367 static gboolean
368 anon_start (gpointer user_data)
369 {
370 GTask *task = user_data;
371
372 anon_thread = g_thread_new ("test_return_from_anon_thread",
373 anon_thread_func, task);
374 return FALSE;
375 }
376
377 static void
378 test_return_from_anon_thread (void)
379 {
380 GTask *task;
381 gssize result = 0;
382
383 task = g_task_new (NULL, NULL, anon_callback, &result);
384 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
385 g_signal_connect (task, "notify::completed",
386 (GCallback) completed_cb,
387 &anon_thread_notification_emitted);
388
389 g_idle_add (anon_start, task);
390 g_main_loop_run (loop);
391
392 g_thread_join (anon_thread);
393
394 g_assert_cmpint (result, ==, magic);
395 g_assert (task == NULL);
396 g_assert_true (anon_thread_notification_emitted);
397 }
398
399 /* test_return_from_wrong_thread: calling g_task_return_* from a
400 * thread with its own thread-default main context will complete the
401 * task in the task's context/thread.
402 */
403
404 gboolean wrong_thread_notification_emitted = FALSE;
405 GThread *wrong_thread;
406
407 static void
408 wrong_callback (GObject *object,
409 GAsyncResult *result,
410 gpointer user_data)
411 {
412 gssize *result_out = user_data;
413 GError *error = NULL;
414
415 g_assert (object == NULL);
416 g_assert (g_task_is_valid (result, object));
417 g_assert (g_async_result_get_user_data (result) == user_data);
418 g_assert (!g_task_had_error (G_TASK (result)));
419 g_assert_false (g_task_get_completed (G_TASK (result)));
420
421 g_assert (g_thread_self () == main_thread);
422
423 *result_out = g_task_propagate_int (G_TASK (result), &error);
424 g_assert_no_error (error);
425
426 g_assert (!g_task_had_error (G_TASK (result)));
427
428 g_main_loop_quit (loop);
429 }
430
431 static gpointer
432 wrong_thread_func (gpointer user_data)
433 {
434 GTask *task = user_data;
435 GMainContext *context;
436
437 context = g_main_context_new ();
438 g_main_context_push_thread_default (context);
439
440 g_assert (g_task_get_context (task) != context);
441
442 g_task_return_int (task, magic);
443 g_object_unref (task);
444
445 g_main_context_pop_thread_default (context);
446 g_main_context_unref (context);
447
448 return NULL;
449 }
450
451 static gboolean
452 wrong_start (gpointer user_data)
453 {
454 GTask *task = user_data;
455
456 wrong_thread = g_thread_new ("test_return_from_anon_thread",
457 wrong_thread_func, task);
458 return FALSE;
459 }
460
461 static void
462 test_return_from_wrong_thread (void)
463 {
464 GTask *task;
465 gssize result = 0;
466
467 task = g_task_new (NULL, NULL, wrong_callback, &result);
468 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
469 g_signal_connect (task, "notify::completed",
470 (GCallback) completed_cb,
471 &wrong_thread_notification_emitted);
472
473 g_idle_add (wrong_start, task);
474 g_main_loop_run (loop);
475
476 g_thread_join (wrong_thread);
477
478 g_assert_cmpint (result, ==, magic);
479 g_assert (task == NULL);
480 g_assert_true (wrong_thread_notification_emitted);
481 }
482
483 /* test_no_callback */
484
485 static void
486 test_no_callback (void)
487 {
488 GTask *task;
489
490 task = g_task_new (NULL, NULL, NULL, NULL);
491 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
492
493 g_task_return_boolean (task, TRUE);
494 g_object_unref (task);
495
496 /* Even though there’s no callback, the :completed notification has to
497 * happen in an idle handler. */
498 g_assert_nonnull (task);
499 wait_for_completed_notification (task);
500 g_assert_null (task);
501 }
502
503 /* test_report_error */
504
505 static void test_report_error (void);
506 gboolean error_notification_emitted = FALSE;
507
508 static void
509 report_callback (GObject *object,
510 GAsyncResult *result,
511 gpointer user_data)
512 {
513 gpointer *weak_pointer = user_data;
514 GError *error = NULL;
515 gssize ret;
516
517 g_assert (object == NULL);
518 g_assert (g_task_is_valid (result, object));
519 g_assert (g_async_result_get_user_data (result) == user_data);
520 g_assert (g_async_result_is_tagged (result, test_report_error));
521 g_assert (g_task_get_source_tag (G_TASK (result)) == test_report_error);
522 g_assert (g_task_had_error (G_TASK (result)));
523 g_assert_false (g_task_get_completed (G_TASK (result)));
524
525 ret = g_task_propagate_int (G_TASK (result), &error);
526 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
527 g_assert_cmpint (ret, ==, -1);
528 g_error_free (error);
529
530 g_assert (g_task_had_error (G_TASK (result)));
531
532 *weak_pointer = result;
533 g_object_add_weak_pointer (G_OBJECT (result), weak_pointer);
534 g_signal_connect (result, "notify::completed",
535 (GCallback) completed_cb, &error_notification_emitted);
536
537 g_main_loop_quit (loop);
538 }
539
540 static void
541 test_report_error (void)
542 {
543 gpointer weak_pointer = (gpointer)-1;
544
545 g_task_report_new_error (NULL, report_callback, &weak_pointer,
546 test_report_error,
547 G_IO_ERROR, G_IO_ERROR_FAILED,
548 "Failed");
549 g_main_loop_run (loop);
550
551 g_assert (weak_pointer == NULL);
552 g_assert_true (error_notification_emitted);
553 }
554
555 /* test_priority: tasks complete in priority order */
556
557 static int counter = 0;
558
559 static void
560 priority_callback (GObject *object,
561 GAsyncResult *result,
562 gpointer user_data)
563 {
564 gssize *ret_out = user_data;
565 GError *error = NULL;
566
567 g_assert (object == NULL);
568 g_assert (g_task_is_valid (result, object));
569 g_assert (g_async_result_get_user_data (result) == user_data);
570 g_assert (!g_task_had_error (G_TASK (result)));
571 g_assert_false (g_task_get_completed (G_TASK (result)));
572
573 g_task_propagate_boolean (G_TASK (result), &error);
574 g_assert_no_error (error);
575
576 g_assert (!g_task_had_error (G_TASK (result)));
577
578 *ret_out = ++counter;
579
580 if (counter == 3)
581 g_main_loop_quit (loop);
582 }
583
584 static void
585 test_priority (void)
586 {
587 GTask *t1, *t2, *t3;
588 gssize ret1, ret2, ret3;
589
590 /* t2 has higher priority than either t1 or t3, so we can't
591 * accidentally pass the test just by completing the tasks in the
592 * order they were created (or in reverse order).
593 */
594
595 t1 = g_task_new (NULL, NULL, priority_callback, &ret1);
596 g_task_set_priority (t1, G_PRIORITY_DEFAULT);
597 g_task_return_boolean (t1, TRUE);
598 g_object_unref (t1);
599
600 t2 = g_task_new (NULL, NULL, priority_callback, &ret2);
601 g_task_set_priority (t2, G_PRIORITY_HIGH);
602 g_task_return_boolean (t2, TRUE);
603 g_object_unref (t2);
604
605 t3 = g_task_new (NULL, NULL, priority_callback, &ret3);
606 g_task_set_priority (t3, G_PRIORITY_LOW);
607 g_task_return_boolean (t3, TRUE);
608 g_object_unref (t3);
609
610 g_main_loop_run (loop);
611
612 g_assert_cmpint (ret2, ==, 1);
613 g_assert_cmpint (ret1, ==, 2);
614 g_assert_cmpint (ret3, ==, 3);
615 }
616
617 /* test_check_cancellable: cancellation overrides return value */
618
619 enum {
620 CANCEL_BEFORE = (1 << 1),
621 CANCEL_AFTER = (1 << 2),
622 CHECK_CANCELLABLE = (1 << 3)
623 };
624 #define NUM_CANCEL_TESTS (CANCEL_BEFORE | CANCEL_AFTER | CHECK_CANCELLABLE)
625
626 static void
627 cancel_callback (GObject *object,
628 GAsyncResult *result,
629 gpointer user_data)
630 {
631 int state = GPOINTER_TO_INT (user_data);
632 GTask *task;
633 GCancellable *cancellable;
634 GError *error = NULL;
635
636 g_assert (object == NULL);
637 g_assert (g_task_is_valid (result, object));
638 g_assert (g_async_result_get_user_data (result) == user_data);
639
640 task = G_TASK (result);
641 cancellable = g_task_get_cancellable (task);
642 g_assert (G_IS_CANCELLABLE (cancellable));
643
644 if (state & (CANCEL_BEFORE | CANCEL_AFTER))
645 g_assert (g_cancellable_is_cancelled (cancellable));
646 else
647 g_assert (!g_cancellable_is_cancelled (cancellable));
648
649 if (state & CHECK_CANCELLABLE)
650 g_assert (g_task_get_check_cancellable (task));
651 else
652 g_assert (!g_task_get_check_cancellable (task));
653
654 if (g_task_propagate_boolean (task, &error))
655 {
656 g_assert (!g_cancellable_is_cancelled (cancellable) ||
657 !g_task_get_check_cancellable (task));
658 }
659 else
660 {
661 g_assert (g_cancellable_is_cancelled (cancellable) &&
662 g_task_get_check_cancellable (task));
663 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
664 g_error_free (error);
665 }
666
667 g_main_loop_quit (loop);
668 }
669
670 static void
671 test_check_cancellable (void)
672 {
673 GTask *task;
674 GCancellable *cancellable;
675 int state;
676
677 cancellable = g_cancellable_new ();
678
679 for (state = 0; state <= NUM_CANCEL_TESTS; state++)
680 {
681 task = g_task_new (NULL, cancellable, cancel_callback,
682 GINT_TO_POINTER (state));
683 g_task_set_check_cancellable (task, (state & CHECK_CANCELLABLE) != 0);
684
685 if (state & CANCEL_BEFORE)
686 g_cancellable_cancel (cancellable);
687 g_task_return_boolean (task, TRUE);
688 if (state & CANCEL_AFTER)
689 g_cancellable_cancel (cancellable);
690
691 g_main_loop_run (loop);
692 g_object_unref (task);
693 g_cancellable_reset (cancellable);
694 }
695
696 g_object_unref (cancellable);
697 }
698
699 /* test_return_if_cancelled */
700
701 static void
702 return_if_cancelled_callback (GObject *object,
703 GAsyncResult *result,
704 gpointer user_data)
705 {
706 GError *error = NULL;
707
708 g_assert (object == NULL);
709 g_assert (g_task_is_valid (result, object));
710 g_assert (g_async_result_get_user_data (result) == user_data);
711 g_assert (g_task_had_error (G_TASK (result)));
712 g_assert_false (g_task_get_completed (G_TASK (result)));
713
714 g_task_propagate_boolean (G_TASK (result), &error);
715 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
716 g_clear_error (&error);
717
718 g_assert (g_task_had_error (G_TASK (result)));
719
720 g_main_loop_quit (loop);
721 }
722
723 static void
724 test_return_if_cancelled (void)
725 {
726 GTask *task;
727 GCancellable *cancellable;
728 gboolean cancelled;
729 gboolean notification_emitted = FALSE;
730
731 cancellable = g_cancellable_new ();
732
733 task = g_task_new (NULL, cancellable, return_if_cancelled_callback, NULL);
734 g_signal_connect (task, "notify::completed",
735 (GCallback) completed_cb, &notification_emitted);
736
737 g_cancellable_cancel (cancellable);
738 cancelled = g_task_return_error_if_cancelled (task);
739 g_assert (cancelled);
740 g_assert_false (notification_emitted);
741 g_main_loop_run (loop);
742 g_object_unref (task);
743 g_assert_true (notification_emitted);
744 g_cancellable_reset (cancellable);
745
746 notification_emitted = FALSE;
747
748 task = g_task_new (NULL, cancellable, return_if_cancelled_callback, NULL);
749 g_signal_connect (task, "notify::completed",
750 (GCallback) completed_cb, &notification_emitted);
751
752 g_task_set_check_cancellable (task, FALSE);
753 g_cancellable_cancel (cancellable);
754 cancelled = g_task_return_error_if_cancelled (task);
755 g_assert (cancelled);
756 g_assert_false (notification_emitted);
757 g_main_loop_run (loop);
758 g_object_unref (task);
759 g_assert_true (notification_emitted);
760 g_object_unref (cancellable);
761 }
762
763 /* test_run_in_thread */
764
765 static GMutex run_in_thread_mutex;
766 static GCond run_in_thread_cond;
767
768 static void
769 task_weak_notify (gpointer user_data,
770 GObject *ex_task)
771 {
772 gboolean *weak_notify_ran = user_data;
773
774 g_mutex_lock (&run_in_thread_mutex);
775 *weak_notify_ran = TRUE;
776 g_cond_signal (&run_in_thread_cond);
777 g_mutex_unlock (&run_in_thread_mutex);
778 }
779
780 static void
781 run_in_thread_callback (GObject *object,
782 GAsyncResult *result,
783 gpointer user_data)
784 {
785 gboolean *done = user_data;
786 GError *error = NULL;
787 gssize ret;
788
789 g_assert (g_thread_self () == main_thread);
790
791 g_assert (object == NULL);
792 g_assert (g_task_is_valid (result, object));
793 g_assert (g_async_result_get_user_data (result) == user_data);
794 g_assert (!g_task_had_error (G_TASK (result)));
795 g_assert_false (g_task_get_completed (G_TASK (result)));
796
797 ret = g_task_propagate_int (G_TASK (result), &error);
798 g_assert_no_error (error);
799 g_assert_cmpint (ret, ==, magic);
800
801 g_assert (!g_task_had_error (G_TASK (result)));
802
803 *done = TRUE;
804 g_main_loop_quit (loop);
805 }
806
807 static void
808 run_in_thread_thread (GTask *task,
809 gpointer source_object,
810 gpointer task_data,
811 GCancellable *cancellable)
812 {
813 gboolean *thread_ran = task_data;
814
815 g_assert (source_object == g_task_get_source_object (task));
816 g_assert (task_data == g_task_get_task_data (task));
817 g_assert (cancellable == g_task_get_cancellable (task));
818 g_assert_false (g_task_get_completed (task));
819
820 g_assert (g_thread_self () != main_thread);
821
822 g_mutex_lock (&run_in_thread_mutex);
823 *thread_ran = TRUE;
824 g_cond_signal (&run_in_thread_cond);
825 g_mutex_unlock (&run_in_thread_mutex);
826
827 g_task_return_int (task, magic);
828 }
829
830 static void
831 test_run_in_thread (void)
832 {
833 GTask *task;
834 volatile gboolean thread_ran = FALSE;
835 volatile gboolean weak_notify_ran = FALSE;
836 gboolean notification_emitted = FALSE;
837 gboolean done = FALSE;
838
839 task = g_task_new (NULL, NULL, run_in_thread_callback, &done);
840 g_object_weak_ref (G_OBJECT (task), task_weak_notify, (gpointer)&weak_notify_ran);
841 g_signal_connect (task, "notify::completed",
842 (GCallback) completed_cb, &notification_emitted);
843
844 g_task_set_task_data (task, (gpointer)&thread_ran, NULL);
845 g_task_run_in_thread (task, run_in_thread_thread);
846 g_object_unref (task);
847
848 g_mutex_lock (&run_in_thread_mutex);
849 while (!thread_ran)
850 g_cond_wait (&run_in_thread_cond, &run_in_thread_mutex);
851 g_mutex_unlock (&run_in_thread_mutex);
852
853 g_assert (done == FALSE);
854 g_assert (weak_notify_ran == FALSE);
855
856 g_main_loop_run (loop);
857
858 g_assert (done == TRUE);
859 g_assert_true (notification_emitted);
860
861 g_mutex_lock (&run_in_thread_mutex);
862 while (!weak_notify_ran)
863 g_cond_wait (&run_in_thread_cond, &run_in_thread_mutex);
864 g_mutex_unlock (&run_in_thread_mutex);
865 }
866
867 /* test_run_in_thread_sync */
868
869 static void
870 run_in_thread_sync_callback (GObject *object,
871 GAsyncResult *result,
872 gpointer user_data)
873 {
874 /* g_task_run_in_thread_sync() does not invoke the task's callback */
875 g_assert_not_reached ();
876 }
877
878 static void
879 run_in_thread_sync_thread (GTask *task,
880 gpointer source_object,
881 gpointer task_data,
882 GCancellable *cancellable)
883 {
884 gboolean *thread_ran = task_data;
885
886 g_assert (source_object == g_task_get_source_object (task));
887 g_assert (task_data == g_task_get_task_data (task));
888 g_assert (cancellable == g_task_get_cancellable (task));
889 g_assert_false (g_task_get_completed (task));
890
891 g_assert (g_thread_self () != main_thread);
892
893 *thread_ran = TRUE;
894 g_task_return_int (task, magic);
895 }
896
897 static void
898 test_run_in_thread_sync (void)
899 {
900 GTask *task;
901 gboolean thread_ran = FALSE;
902 gssize ret;
903 gboolean notification_emitted = FALSE;
904 GError *error = NULL;
905
906 task = g_task_new (NULL, NULL, run_in_thread_sync_callback, NULL);
907 g_signal_connect (task, "notify::completed",
908 (GCallback) completed_cb,
909 &notification_emitted);
910
911 g_task_set_task_data (task, &thread_ran, NULL);
912 g_task_run_in_thread_sync (task, run_in_thread_sync_thread);
913
914 g_assert (thread_ran == TRUE);
915 g_assert (task != NULL);
916 g_assert (!g_task_had_error (task));
917 g_assert_true (g_task_get_completed (task));
918 g_assert_true (notification_emitted);
919
920 ret = g_task_propagate_int (task, &error);
921 g_assert_no_error (error);
922 g_assert_cmpint (ret, ==, magic);
923
924 g_assert (!g_task_had_error (task));
925
926 g_object_unref (task);
927 }
928
929 /* test_run_in_thread_priority */
930
931 static GMutex fake_task_mutex, last_fake_task_mutex;
932 static gint sequence_number = 0;
933
934 static void
935 quit_main_loop_callback (GObject *object,
936 GAsyncResult *result,
937 gpointer user_data)
938 {
939 GError *error = NULL;
940 gboolean ret;
941
942 g_assert (g_thread_self () == main_thread);
943
944 g_assert (object == NULL);
945 g_assert (g_task_is_valid (result, object));
946 g_assert (g_async_result_get_user_data (result) == user_data);
947 g_assert (!g_task_had_error (G_TASK (result)));
948 g_assert_false (g_task_get_completed (G_TASK (result)));
949
950 ret = g_task_propagate_boolean (G_TASK (result), &error);
951 g_assert_no_error (error);
952 g_assert_cmpint (ret, ==, TRUE);
953
954 g_assert (!g_task_had_error (G_TASK (result)));
955
956 g_main_loop_quit (loop);
957 }
958
959 static void
960 set_sequence_number_thread (GTask *task,
961 gpointer source_object,
962 gpointer task_data,
963 GCancellable *cancellable)
964 {
965 gint *seq_no_p = task_data;
966
967 *seq_no_p = ++sequence_number;
968 g_task_return_boolean (task, TRUE);
969 }
970
971 static void
972 fake_task_thread (GTask *task,
973 gpointer source_object,
974 gpointer task_data,
975 GCancellable *cancellable)
976 {
977 GMutex *mutex = task_data;
978
979 g_mutex_lock (mutex);
980 g_mutex_unlock (mutex);
981 g_task_return_boolean (task, TRUE);
982 }
983
984 #define G_TASK_THREAD_POOL_SIZE 10
985 static int fake_tasks_running;
986
987 static void
988 fake_task_callback (GObject *source,
989 GAsyncResult *result,
990 gpointer user_data)
991 {
992 if (--fake_tasks_running == 0)
993 g_main_loop_quit (loop);
994 }
995
996 static void
997 clog_up_thread_pool (void)
998 {
999 GTask *task;
1000 int i;
1001
1002 g_thread_pool_stop_unused_threads ();
1003
1004 g_mutex_lock (&fake_task_mutex);
1005 for (i = 0; i < G_TASK_THREAD_POOL_SIZE - 1; i++)
1006 {
1007 task = g_task_new (NULL, NULL, fake_task_callback, NULL);
1008 g_task_set_task_data (task, &fake_task_mutex, NULL);
1009 g_assert_cmpint (g_task_get_priority (task), ==, G_PRIORITY_DEFAULT);
1010 g_task_set_priority (task, G_PRIORITY_HIGH * 2);
1011 g_assert_cmpint (g_task_get_priority (task), ==, G_PRIORITY_HIGH * 2);
1012 g_task_run_in_thread (task, fake_task_thread);
1013 g_object_unref (task);
1014 fake_tasks_running++;
1015 }
1016
1017 g_mutex_lock (&last_fake_task_mutex);
1018 task = g_task_new (NULL, NULL, NULL, NULL);
1019 g_task_set_task_data (task, &last_fake_task_mutex, NULL);
1020 g_task_set_priority (task, G_PRIORITY_HIGH * 2);
1021 g_task_run_in_thread (task, fake_task_thread);
1022 g_object_unref (task);
1023 }
1024
1025 static void
1026 unclog_thread_pool (void)
1027 {
1028 g_mutex_unlock (&fake_task_mutex);
1029 g_main_loop_run (loop);
1030 }
1031
1032 static void
1033 test_run_in_thread_priority (void)
1034 {
1035 GTask *task;
1036 GCancellable *cancellable;
1037 int seq_a, seq_b, seq_c, seq_d;
1038
1039 clog_up_thread_pool ();
1040
1041 /* Queue three more tasks that we'll arrange to have run serially */
1042 task = g_task_new (NULL, NULL, NULL, NULL);
1043 g_task_set_task_data (task, &seq_a, NULL);
1044 g_task_run_in_thread (task, set_sequence_number_thread);
1045 g_object_unref (task);
1046
1047 task = g_task_new (NULL, NULL, quit_main_loop_callback, NULL);
1048 g_task_set_task_data (task, &seq_b, NULL);
1049 g_task_set_priority (task, G_PRIORITY_LOW);
1050 g_task_run_in_thread (task, set_sequence_number_thread);
1051 g_object_unref (task);
1052
1053 task = g_task_new (NULL, NULL, NULL, NULL);
1054 g_task_set_task_data (task, &seq_c, NULL);
1055 g_task_set_priority (task, G_PRIORITY_HIGH);
1056 g_task_run_in_thread (task, set_sequence_number_thread);
1057 g_object_unref (task);
1058
1059 cancellable = g_cancellable_new ();
1060 task = g_task_new (NULL, cancellable, NULL, NULL);
1061 g_task_set_task_data (task, &seq_d, NULL);
1062 g_task_run_in_thread (task, set_sequence_number_thread);
1063 g_cancellable_cancel (cancellable);
1064 g_object_unref (cancellable);
1065 g_object_unref (task);
1066
1067 /* Let the last fake task complete; the four other tasks will then
1068 * complete serially, in the order D, C, A, B, and B will quit the
1069 * main loop.
1070 */
1071 g_mutex_unlock (&last_fake_task_mutex);
1072 g_main_loop_run (loop);
1073
1074 g_assert_cmpint (seq_d, ==, 1);
1075 g_assert_cmpint (seq_c, ==, 2);
1076 g_assert_cmpint (seq_a, ==, 3);
1077 g_assert_cmpint (seq_b, ==, 4);
1078
1079 unclog_thread_pool ();
1080 }
1081
1082 /* test_run_in_thread_nested: task threads that block waiting on
1083 * other task threads will not cause the thread pool to starve.
1084 */
1085
1086 static void
1087 run_nested_task_thread (GTask *task,
1088 gpointer source_object,
1089 gpointer task_data,
1090 GCancellable *cancellable)
1091 {
1092 GTask *nested;
1093 int *nested_tasks_left = task_data;
1094
1095 if ((*nested_tasks_left)--)
1096 {
1097 nested = g_task_new (NULL, NULL, NULL, NULL);
1098 g_task_set_task_data (nested, nested_tasks_left, NULL);
1099 g_task_run_in_thread_sync (nested, run_nested_task_thread);
1100 g_object_unref (nested);
1101 }
1102
1103 g_task_return_boolean (task, TRUE);
1104 }
1105
1106 static void
1107 test_run_in_thread_nested (void)
1108 {
1109 GTask *task;
1110 int nested_tasks_left = 2;
1111
1112 clog_up_thread_pool ();
1113
1114 task = g_task_new (NULL, NULL, quit_main_loop_callback, NULL);
1115 g_task_set_task_data (task, &nested_tasks_left, NULL);
1116 g_task_run_in_thread (task, run_nested_task_thread);
1117 g_object_unref (task);
1118
1119 g_mutex_unlock (&last_fake_task_mutex);
1120 g_main_loop_run (loop);
1121
1122 unclog_thread_pool ();
1123 }
1124
1125 /* test_run_in_thread_overflow: if you queue lots and lots and lots of
1126 * tasks, they won't all run at once.
1127 */
1128 static GMutex overflow_mutex;
1129
1130 static void
1131 run_overflow_task_thread (GTask *task,
1132 gpointer source_object,
1133 gpointer task_data,
1134 GCancellable *cancellable)
1135 {
1136 gchar *result = task_data;
1137
1138 if (g_task_return_error_if_cancelled (task))
1139 {
1140 *result = 'X';
1141 return;
1142 }
1143
1144 /* Block until the main thread is ready. */
1145 g_mutex_lock (&overflow_mutex);
1146 g_mutex_unlock (&overflow_mutex);
1147
1148 *result = '.';
1149
1150 g_task_return_boolean (task, TRUE);
1151 }
1152
1153 #define NUM_OVERFLOW_TASKS 1024
1154
1155 static void
1156 test_run_in_thread_overflow (void)
1157 {
1158 GCancellable *cancellable;
1159 GTask *task;
1160 gchar buf[NUM_OVERFLOW_TASKS + 1];
1161 gint i;
1162
1163 /* Queue way too many tasks and then sleep for a bit. The first 10
1164 * tasks will be dispatched to threads and will then block on
1165 * overflow_mutex, so more threads will be created while this thread
1166 * is sleeping. Then we cancel the cancellable, unlock the mutex,
1167 * wait for all of the tasks to complete, and make sure that we got
1168 * the behavior we expected.
1169 */
1170
1171 memset (buf, 0, sizeof (buf));
1172 cancellable = g_cancellable_new ();
1173
1174 g_mutex_lock (&overflow_mutex);
1175
1176 for (i = 0; i < NUM_OVERFLOW_TASKS; i++)
1177 {
1178 task = g_task_new (NULL, cancellable, NULL, NULL);
1179 g_task_set_task_data (task, buf + i, NULL);
1180 g_task_run_in_thread (task, run_overflow_task_thread);
1181 g_object_unref (task);
1182 }
1183
1184 if (g_test_slow ())
1185 g_usleep (5000000); /* 5 s */
1186 else
1187 g_usleep (500000); /* 0.5 s */
1188 g_cancellable_cancel (cancellable);
1189 g_object_unref (cancellable);
1190
1191 g_mutex_unlock (&overflow_mutex);
1192
1193 /* Wait for all tasks to complete. */
1194 while (strlen (buf) != NUM_OVERFLOW_TASKS)
1195 g_usleep (1000);
1196
1197 i = strspn (buf, ".");
1198 /* Given the sleep times above, i should be 14 for normal, 40 for
1199 * slow. But if the machine is too slow/busy then the scheduling
1200 * might get messed up and we'll get more or fewer threads than
1201 * expected. But there are limits to how messed up it could
1202 * plausibly get (and we hope that if gtask is actually broken then
1203 * it will exceed those limits).
1204 */
1205 g_assert_cmpint (i, >=, 10);
1206 if (g_test_slow ())
1207 g_assert_cmpint (i, <, 50);
1208 else
1209 g_assert_cmpint (i, <, 20);
1210
1211 g_assert_cmpint (i + strspn (buf + i, "X"), ==, NUM_OVERFLOW_TASKS);
1212 }
1213
1214 /* test_return_on_cancel */
1215
1216 GMutex roc_init_mutex, roc_finish_mutex;
1217 GCond roc_init_cond, roc_finish_cond;
1218
1219 typedef enum {
1220 THREAD_STARTING,
1221 THREAD_RUNNING,
1222 THREAD_CANCELLED,
1223 THREAD_COMPLETED
1224 } ThreadState;
1225
1226 static void
1227 return_on_cancel_callback (GObject *object,
1228 GAsyncResult *result,
1229 gpointer user_data)
1230 {
1231 gboolean *callback_ran = user_data;
1232 GError *error = NULL;
1233 gssize ret;
1234
1235 g_assert (g_thread_self () == main_thread);
1236
1237 g_assert (object == NULL);
1238 g_assert (g_task_is_valid (result, object));
1239 g_assert (g_async_result_get_user_data (result) == user_data);
1240 g_assert (g_task_had_error (G_TASK (result)));
1241 g_assert_false (g_task_get_completed (G_TASK (result)));
1242
1243 ret = g_task_propagate_int (G_TASK (result), &error);
1244 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1245 g_clear_error (&error);
1246 g_assert_cmpint (ret, ==, -1);
1247
1248 g_assert (g_task_had_error (G_TASK (result)));
1249
1250 *callback_ran = TRUE;
1251 g_main_loop_quit (loop);
1252 }
1253
1254 static void
1255 return_on_cancel_thread (GTask *task,
1256 gpointer source_object,
1257 gpointer task_data,
1258 GCancellable *cancellable)
1259 {
1260 ThreadState *state = task_data;
1261
1262 g_assert (source_object == g_task_get_source_object (task));
1263 g_assert (task_data == g_task_get_task_data (task));
1264 g_assert (cancellable == g_task_get_cancellable (task));
1265
1266 g_assert (g_thread_self () != main_thread);
1267
1268 g_mutex_lock (&roc_init_mutex);
1269 *state = THREAD_RUNNING;
1270 g_cond_signal (&roc_init_cond);
1271 g_mutex_unlock (&roc_init_mutex);
1272
1273 g_mutex_lock (&roc_finish_mutex);
1274
1275 if (!g_task_get_return_on_cancel (task) ||
1276 g_task_set_return_on_cancel (task, FALSE))
1277 {
1278 *state = THREAD_COMPLETED;
1279 g_task_return_int (task, magic);
1280 }
1281 else
1282 *state = THREAD_CANCELLED;
1283
1284 g_cond_signal (&roc_finish_cond);
1285 g_mutex_unlock (&roc_finish_mutex);
1286 }
1287
1288 static void
1289 test_return_on_cancel (void)
1290 {
1291 GTask *task;
1292 GCancellable *cancellable;
1293 volatile ThreadState thread_state;
1294 volatile gboolean weak_notify_ran = FALSE;
1295 gboolean callback_ran;
1296 gboolean notification_emitted = FALSE;
1297
1298 cancellable = g_cancellable_new ();
1299
1300 /* If return-on-cancel is FALSE (default), the task does not return
1301 * early.
1302 */
1303 callback_ran = FALSE;
1304 thread_state = THREAD_STARTING;
1305 task = g_task_new (NULL, cancellable, return_on_cancel_callback, &callback_ran);
1306 g_signal_connect (task, "notify::completed",
1307 (GCallback) completed_cb, &notification_emitted);
1308
1309 g_task_set_task_data (task, (gpointer)&thread_state, NULL);
1310 g_mutex_lock (&roc_init_mutex);
1311 g_mutex_lock (&roc_finish_mutex);
1312 g_task_run_in_thread (task, return_on_cancel_thread);
1313 g_object_unref (task);
1314
1315 while (thread_state == THREAD_STARTING)
1316 g_cond_wait (&roc_init_cond, &roc_init_mutex);
1317 g_mutex_unlock (&roc_init_mutex);
1318
1319 g_assert (thread_state == THREAD_RUNNING);
1320 g_assert (callback_ran == FALSE);
1321
1322 g_cancellable_cancel (cancellable);
1323 g_mutex_unlock (&roc_finish_mutex);
1324 g_main_loop_run (loop);
1325
1326 g_assert (thread_state == THREAD_COMPLETED);
1327 g_assert (callback_ran == TRUE);
1328 g_assert_true (notification_emitted);
1329
1330 g_cancellable_reset (cancellable);
1331
1332 /* If return-on-cancel is TRUE, it does return early */
1333 callback_ran = FALSE;
1334 notification_emitted = FALSE;
1335 thread_state = THREAD_STARTING;
1336 task = g_task_new (NULL, cancellable, return_on_cancel_callback, &callback_ran);
1337 g_object_weak_ref (G_OBJECT (task), task_weak_notify, (gpointer)&weak_notify_ran);
1338 g_signal_connect (task, "notify::completed",
1339 (GCallback) completed_cb, &notification_emitted);
1340 g_task_set_return_on_cancel (task, TRUE);
1341
1342 g_task_set_task_data (task, (gpointer)&thread_state, NULL);
1343 g_mutex_lock (&roc_init_mutex);
1344 g_mutex_lock (&roc_finish_mutex);
1345 g_task_run_in_thread (task, return_on_cancel_thread);
1346 g_object_unref (task);
1347
1348 while (thread_state == THREAD_STARTING)
1349 g_cond_wait (&roc_init_cond, &roc_init_mutex);
1350 g_mutex_unlock (&roc_init_mutex);
1351
1352 g_assert (thread_state == THREAD_RUNNING);
1353 g_assert (callback_ran == FALSE);
1354
1355 g_cancellable_cancel (cancellable);
1356 g_main_loop_run (loop);
1357 g_assert (thread_state == THREAD_RUNNING);
1358 g_assert (callback_ran == TRUE);
1359
1360 g_assert (weak_notify_ran == FALSE);
1361
1362 while (thread_state == THREAD_RUNNING)
1363 g_cond_wait (&roc_finish_cond, &roc_finish_mutex);
1364 g_mutex_unlock (&roc_finish_mutex);
1365
1366 g_assert (thread_state == THREAD_CANCELLED);
1367 g_mutex_lock (&run_in_thread_mutex);
1368 while (!weak_notify_ran)
1369 g_cond_wait (&run_in_thread_cond, &run_in_thread_mutex);
1370 g_mutex_unlock (&run_in_thread_mutex);
1371
1372 g_assert_true (notification_emitted);
1373 g_cancellable_reset (cancellable);
1374
1375 /* If the task is already cancelled before it starts, it returns
1376 * immediately, but the thread func still runs.
1377 */
1378 callback_ran = FALSE;
1379 notification_emitted = FALSE;
1380 thread_state = THREAD_STARTING;
1381 task = g_task_new (NULL, cancellable, return_on_cancel_callback, &callback_ran);
1382 g_signal_connect (task, "notify::completed",
1383 (GCallback) completed_cb, &notification_emitted);
1384 g_task_set_return_on_cancel (task, TRUE);
1385
1386 g_cancellable_cancel (cancellable);
1387
1388 g_task_set_task_data (task, (gpointer)&thread_state, NULL);
1389 g_mutex_lock (&roc_init_mutex);
1390 g_mutex_lock (&roc_finish_mutex);
1391 g_task_run_in_thread (task, return_on_cancel_thread);
1392 g_object_unref (task);
1393
1394 g_main_loop_run (loop);
1395 g_assert (callback_ran == TRUE);
1396
1397 while (thread_state == THREAD_STARTING)
1398 g_cond_wait (&roc_init_cond, &roc_init_mutex);
1399 g_mutex_unlock (&roc_init_mutex);
1400
1401 g_assert (thread_state == THREAD_RUNNING);
1402
1403 while (thread_state == THREAD_RUNNING)
1404 g_cond_wait (&roc_finish_cond, &roc_finish_mutex);
1405 g_mutex_unlock (&roc_finish_mutex);
1406
1407 g_assert (thread_state == THREAD_CANCELLED);
1408 g_assert_true (notification_emitted);
1409
1410 g_object_unref (cancellable);
1411 }
1412
1413 /* test_return_on_cancel_sync */
1414
1415 static gpointer
1416 cancel_sync_runner_thread (gpointer task)
1417 {
1418 g_task_run_in_thread_sync (task, return_on_cancel_thread);
1419 return NULL;
1420 }
1421
1422 static void
1423 test_return_on_cancel_sync (void)
1424 {
1425 GTask *task;
1426 GCancellable *cancellable;
1427 volatile ThreadState thread_state;
1428 GThread *runner_thread;
1429 gssize ret;
1430 GError *error = NULL;
1431
1432 cancellable = g_cancellable_new ();
1433
1434 /* If return-on-cancel is FALSE, the task does not return early.
1435 */
1436 thread_state = THREAD_STARTING;
1437 task = g_task_new (NULL, cancellable, run_in_thread_sync_callback, NULL);
1438
1439 g_task_set_task_data (task, (gpointer)&thread_state, NULL);
1440 g_mutex_lock (&roc_init_mutex);
1441 g_mutex_lock (&roc_finish_mutex);
1442 runner_thread = g_thread_new ("return-on-cancel-sync runner thread",
1443 cancel_sync_runner_thread, task);
1444
1445 while (thread_state == THREAD_STARTING)
1446 g_cond_wait (&roc_init_cond, &roc_init_mutex);
1447 g_mutex_unlock (&roc_init_mutex);
1448
1449 g_assert (thread_state == THREAD_RUNNING);
1450
1451 g_cancellable_cancel (cancellable);
1452 g_mutex_unlock (&roc_finish_mutex);
1453 g_thread_join (runner_thread);
1454 g_assert (thread_state == THREAD_COMPLETED);
1455
1456 ret = g_task_propagate_int (task, &error);
1457 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1458 g_clear_error (&error);
1459 g_assert_cmpint (ret, ==, -1);
1460
1461 g_object_unref (task);
1462
1463 g_cancellable_reset (cancellable);
1464
1465 /* If return-on-cancel is TRUE, it does return early */
1466 thread_state = THREAD_STARTING;
1467 task = g_task_new (NULL, cancellable, run_in_thread_sync_callback, NULL);
1468 g_task_set_return_on_cancel (task, TRUE);
1469
1470 g_task_set_task_data (task, (gpointer)&thread_state, NULL);
1471 g_mutex_lock (&roc_init_mutex);
1472 g_mutex_lock (&roc_finish_mutex);
1473 runner_thread = g_thread_new ("return-on-cancel-sync runner thread",
1474 cancel_sync_runner_thread, task);
1475
1476 while (thread_state == THREAD_STARTING)
1477 g_cond_wait (&roc_init_cond, &roc_init_mutex);
1478 g_mutex_unlock (&roc_init_mutex);
1479
1480 g_assert (thread_state == THREAD_RUNNING);
1481
1482 g_cancellable_cancel (cancellable);
1483 g_thread_join (runner_thread);
1484 g_assert (thread_state == THREAD_RUNNING);
1485
1486 ret = g_task_propagate_int (task, &error);
1487 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1488 g_clear_error (&error);
1489 g_assert_cmpint (ret, ==, -1);
1490
1491 g_object_unref (task);
1492
1493 while (thread_state == THREAD_RUNNING)
1494 g_cond_wait (&roc_finish_cond, &roc_finish_mutex);
1495 g_mutex_unlock (&roc_finish_mutex);
1496
1497 g_assert (thread_state == THREAD_CANCELLED);
1498
1499 g_cancellable_reset (cancellable);
1500
1501 /* If the task is already cancelled before it starts, it returns
1502 * immediately, but the thread func still runs.
1503 */
1504 thread_state = THREAD_STARTING;
1505 task = g_task_new (NULL, cancellable, run_in_thread_sync_callback, NULL);
1506 g_task_set_return_on_cancel (task, TRUE);
1507
1508 g_cancellable_cancel (cancellable);
1509
1510 g_task_set_task_data (task, (gpointer)&thread_state, NULL);
1511 g_mutex_lock (&roc_init_mutex);
1512 g_mutex_lock (&roc_finish_mutex);
1513 runner_thread = g_thread_new ("return-on-cancel-sync runner thread",
1514 cancel_sync_runner_thread, task);
1515
1516 g_thread_join (runner_thread);
1517 g_assert (thread_state == THREAD_STARTING);
1518
1519 ret = g_task_propagate_int (task, &error);
1520 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1521 g_clear_error (&error);
1522 g_assert_cmpint (ret, ==, -1);
1523
1524 g_object_unref (task);
1525
1526 while (thread_state == THREAD_STARTING)
1527 g_cond_wait (&roc_init_cond, &roc_init_mutex);
1528 g_mutex_unlock (&roc_init_mutex);
1529
1530 g_assert (thread_state == THREAD_RUNNING);
1531
1532 while (thread_state == THREAD_RUNNING)
1533 g_cond_wait (&roc_finish_cond, &roc_finish_mutex);
1534 g_mutex_unlock (&roc_finish_mutex);
1535
1536 g_assert (thread_state == THREAD_CANCELLED);
1537
1538 g_object_unref (cancellable);
1539 }
1540
1541 /* test_return_on_cancel_atomic: turning return-on-cancel on/off is
1542 * non-racy
1543 */
1544
1545 GMutex roca_mutex_1, roca_mutex_2;
1546 GCond roca_cond_1, roca_cond_2;
1547
1548 static void
1549 return_on_cancel_atomic_callback (GObject *object,
1550 GAsyncResult *result,
1551 gpointer user_data)
1552 {
1553 gboolean *callback_ran = user_data;
1554 GError *error = NULL;
1555 gssize ret;
1556
1557 g_assert (g_thread_self () == main_thread);
1558
1559 g_assert (object == NULL);
1560 g_assert (g_task_is_valid (result, object));
1561 g_assert (g_async_result_get_user_data (result) == user_data);
1562 g_assert (g_task_had_error (G_TASK (result)));
1563 g_assert_false (g_task_get_completed (G_TASK (result)));
1564
1565 ret = g_task_propagate_int (G_TASK (result), &error);
1566 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1567 g_clear_error (&error);
1568 g_assert_cmpint (ret, ==, -1);
1569
1570 g_assert (g_task_had_error (G_TASK (result)));
1571
1572 *callback_ran = TRUE;
1573 g_main_loop_quit (loop);
1574 }
1575
1576 static void
1577 return_on_cancel_atomic_thread (GTask *task,
1578 gpointer source_object,
1579 gpointer task_data,
1580 GCancellable *cancellable)
1581 {
1582 gint *state = task_data;
1583
1584 g_assert (source_object == g_task_get_source_object (task));
1585 g_assert (task_data == g_task_get_task_data (task));
1586 g_assert (cancellable == g_task_get_cancellable (task));
1587 g_assert_false (g_task_get_completed (task));
1588
1589 g_assert (g_thread_self () != main_thread);
1590 g_assert_cmpint (*state, ==, 0);
1591
1592 g_mutex_lock (&roca_mutex_1);
1593 *state = 1;
1594 g_cond_signal (&roca_cond_1);
1595 g_mutex_unlock (&roca_mutex_1);
1596
1597 g_mutex_lock (&roca_mutex_2);
1598 if (g_task_set_return_on_cancel (task, FALSE))
1599 *state = 2;
1600 else
1601 *state = 3;
1602 g_cond_signal (&roca_cond_2);
1603 g_mutex_unlock (&roca_mutex_2);
1604
1605 g_mutex_lock (&roca_mutex_1);
1606 if (g_task_set_return_on_cancel (task, TRUE))
1607 *state = 4;
1608 else
1609 *state = 5;
1610 g_cond_signal (&roca_cond_1);
1611 g_mutex_unlock (&roca_mutex_1);
1612
1613 g_mutex_lock (&roca_mutex_2);
1614 if (g_task_set_return_on_cancel (task, TRUE))
1615 *state = 6;
1616 else
1617 *state = 7;
1618 g_cond_signal (&roca_cond_2);
1619 g_mutex_unlock (&roca_mutex_2);
1620
1621 g_task_return_int (task, magic);
1622 }
1623
1624 static void
1625 test_return_on_cancel_atomic (void)
1626 {
1627 GTask *task;
1628 GCancellable *cancellable;
1629 volatile gint state;
1630 gboolean notification_emitted = FALSE;
1631 gboolean callback_ran;
1632
1633 cancellable = g_cancellable_new ();
1634 g_mutex_lock (&roca_mutex_1);
1635 g_mutex_lock (&roca_mutex_2);
1636
1637 /* If we don't cancel it, each set_return_on_cancel() call will succeed */
1638 state = 0;
1639 callback_ran = FALSE;
1640 task = g_task_new (NULL, cancellable, return_on_cancel_atomic_callback, &callback_ran);
1641 g_task_set_return_on_cancel (task, TRUE);
1642 g_signal_connect (task, "notify::completed",
1643 (GCallback) completed_cb, &notification_emitted);
1644
1645 g_task_set_task_data (task, (gpointer)&state, NULL);
1646 g_task_run_in_thread (task, return_on_cancel_atomic_thread);
1647 g_object_unref (task);
1648
1649 g_assert_cmpint (state, ==, 0);
1650
1651 while (state == 0)
1652 g_cond_wait (&roca_cond_1, &roca_mutex_1);
1653 g_assert (state == 1);
1654
1655 while (state == 1)
1656 g_cond_wait (&roca_cond_2, &roca_mutex_2);
1657 g_assert (state == 2);
1658
1659 while (state == 2)
1660 g_cond_wait (&roca_cond_1, &roca_mutex_1);
1661 g_assert (state == 4);
1662
1663 while (state == 4)
1664 g_cond_wait (&roca_cond_2, &roca_mutex_2);
1665 g_assert (state == 6);
1666
1667 /* callback assumes there'll be a cancelled error */
1668 g_cancellable_cancel (cancellable);
1669
1670 g_assert (callback_ran == FALSE);
1671 g_main_loop_run (loop);
1672 g_assert (callback_ran == TRUE);
1673 g_assert_true (notification_emitted);
1674
1675 g_cancellable_reset (cancellable);
1676
1677
1678 /* If we cancel while it's temporarily not return-on-cancel, the
1679 * task won't complete right away, and further
1680 * g_task_set_return_on_cancel() calls will return FALSE.
1681 */
1682 state = 0;
1683 callback_ran = FALSE;
1684 notification_emitted = FALSE;
1685 task = g_task_new (NULL, cancellable, return_on_cancel_atomic_callback, &callback_ran);
1686 g_task_set_return_on_cancel (task, TRUE);
1687 g_signal_connect (task, "notify::completed",
1688 (GCallback) completed_cb, &notification_emitted);
1689
1690 g_task_set_task_data (task, (gpointer)&state, NULL);
1691 g_task_run_in_thread (task, return_on_cancel_atomic_thread);
1692 g_object_unref (task);
1693
1694 g_assert_cmpint (state, ==, 0);
1695
1696 while (state == 0)
1697 g_cond_wait (&roca_cond_1, &roca_mutex_1);
1698 g_assert (state == 1);
1699 g_assert (g_task_get_return_on_cancel (task));
1700
1701 while (state == 1)
1702 g_cond_wait (&roca_cond_2, &roca_mutex_2);
1703 g_assert (state == 2);
1704 g_assert (!g_task_get_return_on_cancel (task));
1705
1706 g_cancellable_cancel (cancellable);
1707 g_idle_add (idle_quit_loop, NULL);
1708 g_main_loop_run (loop);
1709 g_assert (callback_ran == FALSE);
1710
1711 while (state == 2)
1712 g_cond_wait (&roca_cond_1, &roca_mutex_1);
1713 g_assert (state == 5);
1714 g_assert (!g_task_get_return_on_cancel (task));
1715
1716 g_main_loop_run (loop);
1717 g_assert (callback_ran == TRUE);
1718 g_assert_true (notification_emitted);
1719
1720 while (state == 5)
1721 g_cond_wait (&roca_cond_2, &roca_mutex_2);
1722 g_assert (state == 7);
1723
1724 g_object_unref (cancellable);
1725 g_mutex_unlock (&roca_mutex_1);
1726 g_mutex_unlock (&roca_mutex_2);
1727 }
1728
1729 /* test_return_pointer: memory management of pointer returns */
1730
1731 static void
1732 test_return_pointer (void)
1733 {
1734 GObject *object, *ret;
1735 GTask *task;
1736 GCancellable *cancellable;
1737 GError *error = NULL;
1738
1739 /* If we don't read back the return value, the task will
1740 * run its destroy notify.
1741 */
1742 object = (GObject *)g_dummy_object_new ();
1743 g_assert_cmpint (object->ref_count, ==, 1);
1744 g_object_add_weak_pointer (object, (gpointer *)&object);
1745
1746 task = g_task_new (NULL, NULL, NULL, NULL);
1747 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
1748 g_task_return_pointer (task, object, g_object_unref);
1749 g_assert_cmpint (object->ref_count, ==, 1);
1750
1751 /* Task and object are reffed until the :completed notification in idle. */
1752 g_object_unref (task);
1753 g_assert_nonnull (task);
1754 g_assert_nonnull (object);
1755
1756 wait_for_completed_notification (task);
1757
1758 g_assert_null (task);
1759 g_assert_null (object);
1760
1761 /* Likewise, if the return value is overwritten by an error */
1762 object = (GObject *)g_dummy_object_new ();
1763 g_assert_cmpint (object->ref_count, ==, 1);
1764 g_object_add_weak_pointer (object, (gpointer *)&object);
1765
1766 cancellable = g_cancellable_new ();
1767 task = g_task_new (NULL, cancellable, NULL, NULL);
1768 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
1769 g_task_return_pointer (task, object, g_object_unref);
1770 g_assert_cmpint (object->ref_count, ==, 1);
1771 g_cancellable_cancel (cancellable);
1772 g_assert_cmpint (object->ref_count, ==, 1);
1773
1774 ret = g_task_propagate_pointer (task, &error);
1775 g_assert (ret == NULL);
1776 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_CANCELLED);
1777 g_clear_error (&error);
1778 g_assert_cmpint (object->ref_count, ==, 1);
1779
1780 g_object_unref (task);
1781 g_object_unref (cancellable);
1782 g_assert_nonnull (task);
1783 g_assert_nonnull (object);
1784
1785 wait_for_completed_notification (task);
1786
1787 g_assert_null (task);
1788 g_assert_null (object);
1789
1790 /* If we read back the return value, we steal its ref */
1791 object = (GObject *)g_dummy_object_new ();
1792 g_assert_cmpint (object->ref_count, ==, 1);
1793 g_object_add_weak_pointer (object, (gpointer *)&object);
1794
1795 task = g_task_new (NULL, NULL, NULL, NULL);
1796 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
1797 g_task_return_pointer (task, object, g_object_unref);
1798 g_assert_cmpint (object->ref_count, ==, 1);
1799
1800 ret = g_task_propagate_pointer (task, &error);
1801 g_assert_no_error (error);
1802 g_assert (ret == object);
1803 g_assert_cmpint (object->ref_count, ==, 1);
1804
1805 g_object_unref (task);
1806 g_assert_nonnull (task);
1807 g_assert_cmpint (object->ref_count, ==, 1);
1808 g_object_unref (object);
1809 g_assert (object == NULL);
1810
1811 wait_for_completed_notification (task);
1812 g_assert_null (task);
1813 }
1814
1815 /* test_object_keepalive: GTask takes a ref on its source object */
1816
1817 static GObject *keepalive_object;
1818
1819 static void
1820 keepalive_callback (GObject *object,
1821 GAsyncResult *result,
1822 gpointer user_data)
1823 {
1824 gssize *result_out = user_data;
1825 GError *error = NULL;
1826
1827 g_assert (object == keepalive_object);
1828 g_assert (g_task_is_valid (result, object));
1829 g_assert (g_async_result_get_user_data (result) == user_data);
1830 g_assert (!g_task_had_error (G_TASK (result)));
1831 g_assert_false (g_task_get_completed (G_TASK (result)));
1832
1833 *result_out = g_task_propagate_int (G_TASK (result), &error);
1834 g_assert_no_error (error);
1835
1836 g_assert (!g_task_had_error (G_TASK (result)));
1837
1838 g_main_loop_quit (loop);
1839 }
1840
1841 static void
1842 test_object_keepalive (void)
1843 {
1844 GObject *object;
1845 GTask *task;
1846 gssize result;
1847 int ref_count;
1848 gboolean notification_emitted = FALSE;
1849
1850 keepalive_object = object = (GObject *)g_dummy_object_new ();
1851 g_object_add_weak_pointer (object, (gpointer *)&object);
1852
1853 task = g_task_new (object, NULL, keepalive_callback, &result);
1854 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
1855 g_signal_connect (task, "notify::completed",
1856 (GCallback) completed_cb, &notification_emitted);
1857
1858 ref_count = object->ref_count;
1859 g_assert_cmpint (ref_count, >, 1);
1860
1861 g_assert (g_task_get_source_object (task) == object);
1862 g_assert (g_async_result_get_source_object (G_ASYNC_RESULT (task)) == object);
1863 g_assert_cmpint (object->ref_count, ==, ref_count + 1);
1864 g_object_unref (object);
1865
1866 g_object_unref (object);
1867 g_assert (object != NULL);
1868
1869 g_task_return_int (task, magic);
1870 g_main_loop_run (loop);
1871
1872 g_assert (object != NULL);
1873 g_assert_cmpint (result, ==, magic);
1874 g_assert_true (notification_emitted);
1875
1876 g_object_unref (task);
1877 g_assert (task == NULL);
1878 g_assert (object == NULL);
1879 }
1880
1881 /* test_legacy_error: legacy GSimpleAsyncResult handling */
1882 static void test_legacy_error (void);
1883
1884 static void
1885 legacy_error_callback (GObject *object,
1886 GAsyncResult *result,
1887 gpointer user_data)
1888 {
1889 gssize *result_out = user_data;
1890 GError *error = NULL;
1891
1892 g_assert (object == NULL);
1893 g_assert (g_async_result_is_tagged (result, test_legacy_error));
1894 g_assert (g_async_result_get_user_data (result) == user_data);
1895
1896 if (g_async_result_legacy_propagate_error (result, &error))
1897 {
1898 g_assert (!g_task_is_valid (result, object));
1899 G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
1900 g_assert (g_simple_async_result_is_valid (result, object, test_legacy_error));
1901 G_GNUC_END_IGNORE_DEPRECATIONS;
1902
1903 g_assert_error (error, G_IO_ERROR, G_IO_ERROR_FAILED);
1904 *result_out = -2;
1905 }
1906 else
1907 {
1908 g_assert (g_task_is_valid (result, object));
1909
1910 *result_out = g_task_propagate_int (G_TASK (result), NULL);
1911 /* Might be error, might not */
1912 }
1913
1914 g_main_loop_quit (loop);
1915 }
1916
1917 static gboolean
1918 legacy_error_return (gpointer user_data)
1919 {
1920 if (G_IS_TASK (user_data))
1921 {
1922 GTask *task = user_data;
1923
1924 g_task_return_int (task, magic);
1925 g_object_unref (task);
1926 }
1927 else
1928 {
1929 GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (user_data);
1930
1931 G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
1932 g_simple_async_result_set_error (simple,
1933 G_IO_ERROR,
1934 G_IO_ERROR_FAILED,
1935 "Failed");
1936 g_simple_async_result_complete (simple);
1937 G_GNUC_END_IGNORE_DEPRECATIONS;
1938 g_object_unref (simple);
1939 }
1940
1941 return FALSE;
1942 }
1943
1944 static void
1945 test_legacy_error (void)
1946 {
1947 GTask *task;
1948 GSimpleAsyncResult *simple;
1949 gssize result;
1950
1951 /* GTask success */
1952 task = g_task_new (NULL, NULL, legacy_error_callback, &result);
1953 g_task_set_source_tag (task, test_legacy_error);
1954 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
1955
1956 g_idle_add (legacy_error_return, task);
1957 g_main_loop_run (loop);
1958
1959 g_assert_cmpint (result, ==, magic);
1960 g_assert (task == NULL);
1961
1962 /* GTask error */
1963 task = g_task_new (NULL, NULL, legacy_error_callback, &result);
1964 g_task_set_source_tag (task, test_legacy_error);
1965 g_object_add_weak_pointer (G_OBJECT (task), (gpointer *)&task);
1966
1967 g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
1968 "Failed");
1969 g_object_unref (task);
1970 g_main_loop_run (loop);
1971
1972 g_assert_cmpint (result, ==, -1);
1973 g_assert (task == NULL);
1974
1975 /* GSimpleAsyncResult error */
1976 G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
1977 simple = g_simple_async_result_new (NULL, legacy_error_callback, &result,
1978 test_legacy_error);
1979 G_GNUC_END_IGNORE_DEPRECATIONS;
1980 g_object_add_weak_pointer (G_OBJECT (simple), (gpointer *)&simple);
1981
1982 g_idle_add (legacy_error_return, simple);
1983 g_main_loop_run (loop);
1984
1985 g_assert_cmpint (result, ==, -2);
1986 g_assert (simple == NULL);
1987 }
1988
1989
1990 int
1991 main (int argc, char **argv)
1992 {
1993 int ret;
1994
1995 g_test_init (&argc, &argv, NULL);
1996
1997 loop = g_main_loop_new (NULL, FALSE);
1998 main_thread = g_thread_self ();
1999 magic = g_get_monotonic_time ();
2000
2001 g_test_add_func ("/gtask/basic", test_basic);
2002 g_test_add_func ("/gtask/error", test_error);
2003 g_test_add_func ("/gtask/return-from-same-iteration", test_return_from_same_iteration);
2004 g_test_add_func ("/gtask/return-from-toplevel", test_return_from_toplevel);
2005 g_test_add_func ("/gtask/return-from-anon-thread", test_return_from_anon_thread);
2006 g_test_add_func ("/gtask/return-from-wrong-thread", test_return_from_wrong_thread);
2007 g_test_add_func ("/gtask/no-callback", test_no_callback);
2008 g_test_add_func ("/gtask/report-error", test_report_error);
2009 g_test_add_func ("/gtask/priority", test_priority);
2010 g_test_add_func ("/gtask/check-cancellable", test_check_cancellable);
2011 g_test_add_func ("/gtask/return-if-cancelled", test_return_if_cancelled);
2012 g_test_add_func ("/gtask/run-in-thread", test_run_in_thread);
2013 g_test_add_func ("/gtask/run-in-thread-sync", test_run_in_thread_sync);
2014 g_test_add_func ("/gtask/run-in-thread-priority", test_run_in_thread_priority);
2015 g_test_add_func ("/gtask/run-in-thread-nested", test_run_in_thread_nested);
2016 g_test_add_func ("/gtask/run-in-thread-overflow", test_run_in_thread_overflow);
2017 g_test_add_func ("/gtask/return-on-cancel", test_return_on_cancel);
2018 g_test_add_func ("/gtask/return-on-cancel-sync", test_return_on_cancel_sync);
2019 g_test_add_func ("/gtask/return-on-cancel-atomic", test_return_on_cancel_atomic);
2020 g_test_add_func ("/gtask/return-pointer", test_return_pointer);
2021 g_test_add_func ("/gtask/object-keepalive", test_object_keepalive);
2022 g_test_add_func ("/gtask/legacy-error", test_legacy_error);
2023
2024 ret = g_test_run();
2025
2026 g_main_loop_unref (loop);
2027
2028 return ret;
2029 }
glib mirror