trap signals for "-serial mon:stdio"
[qemu.git] / tests / test-aio.c
1 /*
2 * AioContext tests
3 *
4 * Copyright Red Hat, Inc. 2012
5 *
6 * Authors:
7 * Paolo Bonzini <pbonzini@redhat.com>
8 *
9 * This work is licensed under the terms of the GNU LGPL, version 2 or later.
10 * See the COPYING.LIB file in the top-level directory.
11 */
12
13 #include <glib.h>
14 #include "block/aio.h"
15
16 AioContext *ctx;
17
18 /* Wait until there are no more BHs or AIO requests */
19 static void wait_for_aio(void)
20 {
21 while (aio_poll(ctx, true)) {
22 /* Do nothing */
23 }
24 }
25
26 /* Simple callbacks for testing. */
27
28 typedef struct {
29 QEMUBH *bh;
30 int n;
31 int max;
32 } BHTestData;
33
34 static void bh_test_cb(void *opaque)
35 {
36 BHTestData *data = opaque;
37 if (++data->n < data->max) {
38 qemu_bh_schedule(data->bh);
39 }
40 }
41
42 static void bh_delete_cb(void *opaque)
43 {
44 BHTestData *data = opaque;
45 if (++data->n < data->max) {
46 qemu_bh_schedule(data->bh);
47 } else {
48 qemu_bh_delete(data->bh);
49 data->bh = NULL;
50 }
51 }
52
53 typedef struct {
54 EventNotifier e;
55 int n;
56 int active;
57 bool auto_set;
58 } EventNotifierTestData;
59
60 static int event_active_cb(EventNotifier *e)
61 {
62 EventNotifierTestData *data = container_of(e, EventNotifierTestData, e);
63 return data->active > 0;
64 }
65
66 static void event_ready_cb(EventNotifier *e)
67 {
68 EventNotifierTestData *data = container_of(e, EventNotifierTestData, e);
69 g_assert(event_notifier_test_and_clear(e));
70 data->n++;
71 if (data->active > 0) {
72 data->active--;
73 }
74 if (data->auto_set && data->active) {
75 event_notifier_set(e);
76 }
77 }
78
79 /* Tests using aio_*. */
80
81 static void test_notify(void)
82 {
83 g_assert(!aio_poll(ctx, false));
84 aio_notify(ctx);
85 g_assert(!aio_poll(ctx, true));
86 g_assert(!aio_poll(ctx, false));
87 }
88
89 static void test_bh_schedule(void)
90 {
91 BHTestData data = { .n = 0 };
92 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
93
94 qemu_bh_schedule(data.bh);
95 g_assert_cmpint(data.n, ==, 0);
96
97 g_assert(aio_poll(ctx, true));
98 g_assert_cmpint(data.n, ==, 1);
99
100 g_assert(!aio_poll(ctx, false));
101 g_assert_cmpint(data.n, ==, 1);
102 qemu_bh_delete(data.bh);
103 }
104
105 static void test_bh_schedule10(void)
106 {
107 BHTestData data = { .n = 0, .max = 10 };
108 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
109
110 qemu_bh_schedule(data.bh);
111 g_assert_cmpint(data.n, ==, 0);
112
113 g_assert(aio_poll(ctx, false));
114 g_assert_cmpint(data.n, ==, 1);
115
116 g_assert(aio_poll(ctx, true));
117 g_assert_cmpint(data.n, ==, 2);
118
119 wait_for_aio();
120 g_assert_cmpint(data.n, ==, 10);
121
122 g_assert(!aio_poll(ctx, false));
123 g_assert_cmpint(data.n, ==, 10);
124 qemu_bh_delete(data.bh);
125 }
126
127 static void test_bh_cancel(void)
128 {
129 BHTestData data = { .n = 0 };
130 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
131
132 qemu_bh_schedule(data.bh);
133 g_assert_cmpint(data.n, ==, 0);
134
135 qemu_bh_cancel(data.bh);
136 g_assert_cmpint(data.n, ==, 0);
137
138 g_assert(!aio_poll(ctx, false));
139 g_assert_cmpint(data.n, ==, 0);
140 qemu_bh_delete(data.bh);
141 }
142
143 static void test_bh_delete(void)
144 {
145 BHTestData data = { .n = 0 };
146 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
147
148 qemu_bh_schedule(data.bh);
149 g_assert_cmpint(data.n, ==, 0);
150
151 qemu_bh_delete(data.bh);
152 g_assert_cmpint(data.n, ==, 0);
153
154 g_assert(!aio_poll(ctx, false));
155 g_assert_cmpint(data.n, ==, 0);
156 }
157
158 static void test_bh_delete_from_cb(void)
159 {
160 BHTestData data1 = { .n = 0, .max = 1 };
161
162 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
163
164 qemu_bh_schedule(data1.bh);
165 g_assert_cmpint(data1.n, ==, 0);
166
167 wait_for_aio();
168 g_assert_cmpint(data1.n, ==, data1.max);
169 g_assert(data1.bh == NULL);
170
171 g_assert(!aio_poll(ctx, false));
172 g_assert(!aio_poll(ctx, true));
173 }
174
175 static void test_bh_delete_from_cb_many(void)
176 {
177 BHTestData data1 = { .n = 0, .max = 1 };
178 BHTestData data2 = { .n = 0, .max = 3 };
179 BHTestData data3 = { .n = 0, .max = 2 };
180 BHTestData data4 = { .n = 0, .max = 4 };
181
182 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
183 data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2);
184 data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3);
185 data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4);
186
187 qemu_bh_schedule(data1.bh);
188 qemu_bh_schedule(data2.bh);
189 qemu_bh_schedule(data3.bh);
190 qemu_bh_schedule(data4.bh);
191 g_assert_cmpint(data1.n, ==, 0);
192 g_assert_cmpint(data2.n, ==, 0);
193 g_assert_cmpint(data3.n, ==, 0);
194 g_assert_cmpint(data4.n, ==, 0);
195
196 g_assert(aio_poll(ctx, false));
197 g_assert_cmpint(data1.n, ==, 1);
198 g_assert_cmpint(data2.n, ==, 1);
199 g_assert_cmpint(data3.n, ==, 1);
200 g_assert_cmpint(data4.n, ==, 1);
201 g_assert(data1.bh == NULL);
202
203 wait_for_aio();
204 g_assert_cmpint(data1.n, ==, data1.max);
205 g_assert_cmpint(data2.n, ==, data2.max);
206 g_assert_cmpint(data3.n, ==, data3.max);
207 g_assert_cmpint(data4.n, ==, data4.max);
208 g_assert(data1.bh == NULL);
209 g_assert(data2.bh == NULL);
210 g_assert(data3.bh == NULL);
211 g_assert(data4.bh == NULL);
212 }
213
214 static void test_bh_flush(void)
215 {
216 BHTestData data = { .n = 0 };
217 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
218
219 qemu_bh_schedule(data.bh);
220 g_assert_cmpint(data.n, ==, 0);
221
222 wait_for_aio();
223 g_assert_cmpint(data.n, ==, 1);
224
225 g_assert(!aio_poll(ctx, false));
226 g_assert_cmpint(data.n, ==, 1);
227 qemu_bh_delete(data.bh);
228 }
229
230 static void test_set_event_notifier(void)
231 {
232 EventNotifierTestData data = { .n = 0, .active = 0 };
233 event_notifier_init(&data.e, false);
234 aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);
235 g_assert(!aio_poll(ctx, false));
236 g_assert_cmpint(data.n, ==, 0);
237
238 aio_set_event_notifier(ctx, &data.e, NULL, NULL);
239 g_assert(!aio_poll(ctx, false));
240 g_assert_cmpint(data.n, ==, 0);
241 event_notifier_cleanup(&data.e);
242 }
243
244 static void test_wait_event_notifier(void)
245 {
246 EventNotifierTestData data = { .n = 0, .active = 1 };
247 event_notifier_init(&data.e, false);
248 aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);
249 g_assert(aio_poll(ctx, false));
250 g_assert_cmpint(data.n, ==, 0);
251 g_assert_cmpint(data.active, ==, 1);
252
253 event_notifier_set(&data.e);
254 g_assert(aio_poll(ctx, false));
255 g_assert_cmpint(data.n, ==, 1);
256 g_assert_cmpint(data.active, ==, 0);
257
258 g_assert(!aio_poll(ctx, false));
259 g_assert_cmpint(data.n, ==, 1);
260 g_assert_cmpint(data.active, ==, 0);
261
262 aio_set_event_notifier(ctx, &data.e, NULL, NULL);
263 g_assert(!aio_poll(ctx, false));
264 g_assert_cmpint(data.n, ==, 1);
265
266 event_notifier_cleanup(&data.e);
267 }
268
269 static void test_flush_event_notifier(void)
270 {
271 EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
272 event_notifier_init(&data.e, false);
273 aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);
274 g_assert(aio_poll(ctx, false));
275 g_assert_cmpint(data.n, ==, 0);
276 g_assert_cmpint(data.active, ==, 10);
277
278 event_notifier_set(&data.e);
279 g_assert(aio_poll(ctx, false));
280 g_assert_cmpint(data.n, ==, 1);
281 g_assert_cmpint(data.active, ==, 9);
282 g_assert(aio_poll(ctx, false));
283
284 wait_for_aio();
285 g_assert_cmpint(data.n, ==, 10);
286 g_assert_cmpint(data.active, ==, 0);
287 g_assert(!aio_poll(ctx, false));
288
289 aio_set_event_notifier(ctx, &data.e, NULL, NULL);
290 g_assert(!aio_poll(ctx, false));
291 event_notifier_cleanup(&data.e);
292 }
293
294 static void test_wait_event_notifier_noflush(void)
295 {
296 EventNotifierTestData data = { .n = 0 };
297 EventNotifierTestData dummy = { .n = 0, .active = 1 };
298
299 event_notifier_init(&data.e, false);
300 aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL);
301
302 g_assert(!aio_poll(ctx, false));
303 g_assert_cmpint(data.n, ==, 0);
304
305 /* Until there is an active descriptor, aio_poll may or may not call
306 * event_ready_cb. Still, it must not block. */
307 event_notifier_set(&data.e);
308 g_assert(!aio_poll(ctx, true));
309 data.n = 0;
310
311 /* An active event notifier forces aio_poll to look at EventNotifiers. */
312 event_notifier_init(&dummy.e, false);
313 aio_set_event_notifier(ctx, &dummy.e, event_ready_cb, event_active_cb);
314
315 event_notifier_set(&data.e);
316 g_assert(aio_poll(ctx, false));
317 g_assert_cmpint(data.n, ==, 1);
318 g_assert(aio_poll(ctx, false));
319 g_assert_cmpint(data.n, ==, 1);
320
321 event_notifier_set(&data.e);
322 g_assert(aio_poll(ctx, false));
323 g_assert_cmpint(data.n, ==, 2);
324 g_assert(aio_poll(ctx, false));
325 g_assert_cmpint(data.n, ==, 2);
326
327 event_notifier_set(&dummy.e);
328 wait_for_aio();
329 g_assert_cmpint(data.n, ==, 2);
330 g_assert_cmpint(dummy.n, ==, 1);
331 g_assert_cmpint(dummy.active, ==, 0);
332
333 aio_set_event_notifier(ctx, &dummy.e, NULL, NULL);
334 event_notifier_cleanup(&dummy.e);
335
336 aio_set_event_notifier(ctx, &data.e, NULL, NULL);
337 g_assert(!aio_poll(ctx, false));
338 g_assert_cmpint(data.n, ==, 2);
339
340 event_notifier_cleanup(&data.e);
341 }
342
343 /* Now the same tests, using the context as a GSource. They are
344 * very similar to the ones above, with g_main_context_iteration
345 * replacing aio_poll. However:
346 * - sometimes both the AioContext and the glib main loop wake
347 * themselves up. Hence, some "g_assert(!aio_poll(ctx, false));"
348 * are replaced by "while (g_main_context_iteration(NULL, false));".
349 * - there is no exact replacement for a blocking wait.
350 * "while (g_main_context_iteration(NULL, true)" seems to work,
351 * but it is not documented _why_ it works. For these tests a
352 * non-blocking loop like "while (g_main_context_iteration(NULL, false)"
353 * works well, and that's what I am using.
354 */
355
356 static void test_source_notify(void)
357 {
358 while (g_main_context_iteration(NULL, false));
359 aio_notify(ctx);
360 g_assert(g_main_context_iteration(NULL, true));
361 g_assert(!g_main_context_iteration(NULL, false));
362 }
363
364 static void test_source_flush(void)
365 {
366 g_assert(!g_main_context_iteration(NULL, false));
367 aio_notify(ctx);
368 while (g_main_context_iteration(NULL, false));
369 g_assert(!g_main_context_iteration(NULL, false));
370 }
371
372 static void test_source_bh_schedule(void)
373 {
374 BHTestData data = { .n = 0 };
375 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
376
377 qemu_bh_schedule(data.bh);
378 g_assert_cmpint(data.n, ==, 0);
379
380 g_assert(g_main_context_iteration(NULL, true));
381 g_assert_cmpint(data.n, ==, 1);
382
383 g_assert(!g_main_context_iteration(NULL, false));
384 g_assert_cmpint(data.n, ==, 1);
385 qemu_bh_delete(data.bh);
386 }
387
388 static void test_source_bh_schedule10(void)
389 {
390 BHTestData data = { .n = 0, .max = 10 };
391 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
392
393 qemu_bh_schedule(data.bh);
394 g_assert_cmpint(data.n, ==, 0);
395
396 g_assert(g_main_context_iteration(NULL, false));
397 g_assert_cmpint(data.n, ==, 1);
398
399 g_assert(g_main_context_iteration(NULL, true));
400 g_assert_cmpint(data.n, ==, 2);
401
402 while (g_main_context_iteration(NULL, false));
403 g_assert_cmpint(data.n, ==, 10);
404
405 g_assert(!g_main_context_iteration(NULL, false));
406 g_assert_cmpint(data.n, ==, 10);
407 qemu_bh_delete(data.bh);
408 }
409
410 static void test_source_bh_cancel(void)
411 {
412 BHTestData data = { .n = 0 };
413 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
414
415 qemu_bh_schedule(data.bh);
416 g_assert_cmpint(data.n, ==, 0);
417
418 qemu_bh_cancel(data.bh);
419 g_assert_cmpint(data.n, ==, 0);
420
421 while (g_main_context_iteration(NULL, false));
422 g_assert_cmpint(data.n, ==, 0);
423 qemu_bh_delete(data.bh);
424 }
425
426 static void test_source_bh_delete(void)
427 {
428 BHTestData data = { .n = 0 };
429 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
430
431 qemu_bh_schedule(data.bh);
432 g_assert_cmpint(data.n, ==, 0);
433
434 qemu_bh_delete(data.bh);
435 g_assert_cmpint(data.n, ==, 0);
436
437 while (g_main_context_iteration(NULL, false));
438 g_assert_cmpint(data.n, ==, 0);
439 }
440
441 static void test_source_bh_delete_from_cb(void)
442 {
443 BHTestData data1 = { .n = 0, .max = 1 };
444
445 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
446
447 qemu_bh_schedule(data1.bh);
448 g_assert_cmpint(data1.n, ==, 0);
449
450 g_main_context_iteration(NULL, true);
451 g_assert_cmpint(data1.n, ==, data1.max);
452 g_assert(data1.bh == NULL);
453
454 g_assert(!g_main_context_iteration(NULL, false));
455 }
456
457 static void test_source_bh_delete_from_cb_many(void)
458 {
459 BHTestData data1 = { .n = 0, .max = 1 };
460 BHTestData data2 = { .n = 0, .max = 3 };
461 BHTestData data3 = { .n = 0, .max = 2 };
462 BHTestData data4 = { .n = 0, .max = 4 };
463
464 data1.bh = aio_bh_new(ctx, bh_delete_cb, &data1);
465 data2.bh = aio_bh_new(ctx, bh_delete_cb, &data2);
466 data3.bh = aio_bh_new(ctx, bh_delete_cb, &data3);
467 data4.bh = aio_bh_new(ctx, bh_delete_cb, &data4);
468
469 qemu_bh_schedule(data1.bh);
470 qemu_bh_schedule(data2.bh);
471 qemu_bh_schedule(data3.bh);
472 qemu_bh_schedule(data4.bh);
473 g_assert_cmpint(data1.n, ==, 0);
474 g_assert_cmpint(data2.n, ==, 0);
475 g_assert_cmpint(data3.n, ==, 0);
476 g_assert_cmpint(data4.n, ==, 0);
477
478 g_assert(g_main_context_iteration(NULL, false));
479 g_assert_cmpint(data1.n, ==, 1);
480 g_assert_cmpint(data2.n, ==, 1);
481 g_assert_cmpint(data3.n, ==, 1);
482 g_assert_cmpint(data4.n, ==, 1);
483 g_assert(data1.bh == NULL);
484
485 while (g_main_context_iteration(NULL, false));
486 g_assert_cmpint(data1.n, ==, data1.max);
487 g_assert_cmpint(data2.n, ==, data2.max);
488 g_assert_cmpint(data3.n, ==, data3.max);
489 g_assert_cmpint(data4.n, ==, data4.max);
490 g_assert(data1.bh == NULL);
491 g_assert(data2.bh == NULL);
492 g_assert(data3.bh == NULL);
493 g_assert(data4.bh == NULL);
494 }
495
496 static void test_source_bh_flush(void)
497 {
498 BHTestData data = { .n = 0 };
499 data.bh = aio_bh_new(ctx, bh_test_cb, &data);
500
501 qemu_bh_schedule(data.bh);
502 g_assert_cmpint(data.n, ==, 0);
503
504 g_assert(g_main_context_iteration(NULL, true));
505 g_assert_cmpint(data.n, ==, 1);
506
507 g_assert(!g_main_context_iteration(NULL, false));
508 g_assert_cmpint(data.n, ==, 1);
509 qemu_bh_delete(data.bh);
510 }
511
512 static void test_source_set_event_notifier(void)
513 {
514 EventNotifierTestData data = { .n = 0, .active = 0 };
515 event_notifier_init(&data.e, false);
516 aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);
517 while (g_main_context_iteration(NULL, false));
518 g_assert_cmpint(data.n, ==, 0);
519
520 aio_set_event_notifier(ctx, &data.e, NULL, NULL);
521 while (g_main_context_iteration(NULL, false));
522 g_assert_cmpint(data.n, ==, 0);
523 event_notifier_cleanup(&data.e);
524 }
525
526 static void test_source_wait_event_notifier(void)
527 {
528 EventNotifierTestData data = { .n = 0, .active = 1 };
529 event_notifier_init(&data.e, false);
530 aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);
531 g_assert(g_main_context_iteration(NULL, false));
532 g_assert_cmpint(data.n, ==, 0);
533 g_assert_cmpint(data.active, ==, 1);
534
535 event_notifier_set(&data.e);
536 g_assert(g_main_context_iteration(NULL, false));
537 g_assert_cmpint(data.n, ==, 1);
538 g_assert_cmpint(data.active, ==, 0);
539
540 while (g_main_context_iteration(NULL, false));
541 g_assert_cmpint(data.n, ==, 1);
542 g_assert_cmpint(data.active, ==, 0);
543
544 aio_set_event_notifier(ctx, &data.e, NULL, NULL);
545 while (g_main_context_iteration(NULL, false));
546 g_assert_cmpint(data.n, ==, 1);
547
548 event_notifier_cleanup(&data.e);
549 }
550
551 static void test_source_flush_event_notifier(void)
552 {
553 EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
554 event_notifier_init(&data.e, false);
555 aio_set_event_notifier(ctx, &data.e, event_ready_cb, event_active_cb);
556 g_assert(g_main_context_iteration(NULL, false));
557 g_assert_cmpint(data.n, ==, 0);
558 g_assert_cmpint(data.active, ==, 10);
559
560 event_notifier_set(&data.e);
561 g_assert(g_main_context_iteration(NULL, false));
562 g_assert_cmpint(data.n, ==, 1);
563 g_assert_cmpint(data.active, ==, 9);
564 g_assert(g_main_context_iteration(NULL, false));
565
566 while (g_main_context_iteration(NULL, false));
567 g_assert_cmpint(data.n, ==, 10);
568 g_assert_cmpint(data.active, ==, 0);
569 g_assert(!g_main_context_iteration(NULL, false));
570
571 aio_set_event_notifier(ctx, &data.e, NULL, NULL);
572 while (g_main_context_iteration(NULL, false));
573 event_notifier_cleanup(&data.e);
574 }
575
576 static void test_source_wait_event_notifier_noflush(void)
577 {
578 EventNotifierTestData data = { .n = 0 };
579 EventNotifierTestData dummy = { .n = 0, .active = 1 };
580
581 event_notifier_init(&data.e, false);
582 aio_set_event_notifier(ctx, &data.e, event_ready_cb, NULL);
583
584 while (g_main_context_iteration(NULL, false));
585 g_assert_cmpint(data.n, ==, 0);
586
587 /* Until there is an active descriptor, glib may or may not call
588 * event_ready_cb. Still, it must not block. */
589 event_notifier_set(&data.e);
590 g_main_context_iteration(NULL, true);
591 data.n = 0;
592
593 /* An active event notifier forces aio_poll to look at EventNotifiers. */
594 event_notifier_init(&dummy.e, false);
595 aio_set_event_notifier(ctx, &dummy.e, event_ready_cb, event_active_cb);
596
597 event_notifier_set(&data.e);
598 g_assert(g_main_context_iteration(NULL, false));
599 g_assert_cmpint(data.n, ==, 1);
600 g_assert(!g_main_context_iteration(NULL, false));
601 g_assert_cmpint(data.n, ==, 1);
602
603 event_notifier_set(&data.e);
604 g_assert(g_main_context_iteration(NULL, false));
605 g_assert_cmpint(data.n, ==, 2);
606 g_assert(!g_main_context_iteration(NULL, false));
607 g_assert_cmpint(data.n, ==, 2);
608
609 event_notifier_set(&dummy.e);
610 while (g_main_context_iteration(NULL, false));
611 g_assert_cmpint(data.n, ==, 2);
612 g_assert_cmpint(dummy.n, ==, 1);
613 g_assert_cmpint(dummy.active, ==, 0);
614
615 aio_set_event_notifier(ctx, &dummy.e, NULL, NULL);
616 event_notifier_cleanup(&dummy.e);
617
618 aio_set_event_notifier(ctx, &data.e, NULL, NULL);
619 while (g_main_context_iteration(NULL, false));
620 g_assert_cmpint(data.n, ==, 2);
621
622 event_notifier_cleanup(&data.e);
623 }
624
625 /* End of tests. */
626
627 int main(int argc, char **argv)
628 {
629 GSource *src;
630
631 ctx = aio_context_new();
632 src = aio_get_g_source(ctx);
633 g_source_attach(src, NULL);
634 g_source_unref(src);
635
636 while (g_main_context_iteration(NULL, false));
637
638 g_test_init(&argc, &argv, NULL);
639 g_test_add_func("/aio/notify", test_notify);
640 g_test_add_func("/aio/bh/schedule", test_bh_schedule);
641 g_test_add_func("/aio/bh/schedule10", test_bh_schedule10);
642 g_test_add_func("/aio/bh/cancel", test_bh_cancel);
643 g_test_add_func("/aio/bh/delete", test_bh_delete);
644 g_test_add_func("/aio/bh/callback-delete/one", test_bh_delete_from_cb);
645 g_test_add_func("/aio/bh/callback-delete/many", test_bh_delete_from_cb_many);
646 g_test_add_func("/aio/bh/flush", test_bh_flush);
647 g_test_add_func("/aio/event/add-remove", test_set_event_notifier);
648 g_test_add_func("/aio/event/wait", test_wait_event_notifier);
649 g_test_add_func("/aio/event/wait/no-flush-cb", test_wait_event_notifier_noflush);
650 g_test_add_func("/aio/event/flush", test_flush_event_notifier);
651
652 g_test_add_func("/aio-gsource/notify", test_source_notify);
653 g_test_add_func("/aio-gsource/flush", test_source_flush);
654 g_test_add_func("/aio-gsource/bh/schedule", test_source_bh_schedule);
655 g_test_add_func("/aio-gsource/bh/schedule10", test_source_bh_schedule10);
656 g_test_add_func("/aio-gsource/bh/cancel", test_source_bh_cancel);
657 g_test_add_func("/aio-gsource/bh/delete", test_source_bh_delete);
658 g_test_add_func("/aio-gsource/bh/callback-delete/one", test_source_bh_delete_from_cb);
659 g_test_add_func("/aio-gsource/bh/callback-delete/many", test_source_bh_delete_from_cb_many);
660 g_test_add_func("/aio-gsource/bh/flush", test_source_bh_flush);
661 g_test_add_func("/aio-gsource/event/add-remove", test_source_set_event_notifier);
662 g_test_add_func("/aio-gsource/event/wait", test_source_wait_event_notifier);
663 g_test_add_func("/aio-gsource/event/wait/no-flush-cb", test_source_wait_event_notifier_noflush);
664 g_test_add_func("/aio-gsource/event/flush", test_source_flush_event_notifier);
665 return g_test_run();
666 }