tests: Move unit tests into a separate directory

The main tests directory still looks very crowded, and it's not
clear which files are part of a unit tests and which belong to
a different test subsystem. Let's clean up the mess and move the
unit tests to a separate directory.

Message-Id: <20210310063314.1049838-1-thuth@redhat.com>
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Thomas Huth <thuth@redhat.com>

1 files changed, 0 insertions, 774 deletions

diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
deleted file mode 100644
index 3f866a35c6..0000000000
--- a/tests/test-block-iothread.c
+++ /dev/null
@@ -1,774 +0,0 @@
-/*
- * Block tests for iothreads
- *
- * Copyright (c) 2018 Kevin Wolf <kwolf@redhat.com>
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
- */
-
-#include "qemu/osdep.h"
-#include "block/block.h"
-#include "block/blockjob_int.h"
-#include "sysemu/block-backend.h"
-#include "qapi/error.h"
-#include "qapi/qmp/qdict.h"
-#include "qemu/main-loop.h"
-#include "iothread.h"
-
-static int coroutine_fn bdrv_test_co_prwv(BlockDriverState *bs,
-                                          uint64_t offset, uint64_t bytes,
-                                          QEMUIOVector *qiov, int flags)
-{
-    return 0;
-}
-
-static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
-                                              int64_t offset, int bytes)
-{
-    return 0;
-}
-
-static int coroutine_fn
-bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                      PreallocMode prealloc, BdrvRequestFlags flags,
-                      Error **errp)
-{
-    return 0;
-}
-
-static int coroutine_fn bdrv_test_co_block_status(BlockDriverState *bs,
-                                                  bool want_zero,
-                                                  int64_t offset, int64_t count,
-                                                  int64_t *pnum, int64_t *map,
-                                                  BlockDriverState **file)
-{
-    *pnum = count;
-    return 0;
-}
-
-static BlockDriver bdrv_test = {
-    .format_name            = "test",
-    .instance_size          = 1,
-
-    .bdrv_co_preadv         = bdrv_test_co_prwv,
-    .bdrv_co_pwritev        = bdrv_test_co_prwv,
-    .bdrv_co_pdiscard       = bdrv_test_co_pdiscard,
-    .bdrv_co_truncate       = bdrv_test_co_truncate,
-    .bdrv_co_block_status   = bdrv_test_co_block_status,
-};
-
-static void test_sync_op_pread(BdrvChild *c)
-{
-    uint8_t buf[512];
-    int ret;
-
-    /* Success */
-    ret = bdrv_pread(c, 0, buf, sizeof(buf));
-    g_assert_cmpint(ret, ==, 512);
-
-    /* Early error: Negative offset */
-    ret = bdrv_pread(c, -2, buf, sizeof(buf));
-    g_assert_cmpint(ret, ==, -EIO);
-}
-
-static void test_sync_op_pwrite(BdrvChild *c)
-{
-    uint8_t buf[512];
-    int ret;
-
-    /* Success */
-    ret = bdrv_pwrite(c, 0, buf, sizeof(buf));
-    g_assert_cmpint(ret, ==, 512);
-
-    /* Early error: Negative offset */
-    ret = bdrv_pwrite(c, -2, buf, sizeof(buf));
-    g_assert_cmpint(ret, ==, -EIO);
-}
-
-static void test_sync_op_blk_pread(BlockBackend *blk)
-{
-    uint8_t buf[512];
-    int ret;
-
-    /* Success */
-    ret = blk_pread(blk, 0, buf, sizeof(buf));
-    g_assert_cmpint(ret, ==, 512);
-
-    /* Early error: Negative offset */
-    ret = blk_pread(blk, -2, buf, sizeof(buf));
-    g_assert_cmpint(ret, ==, -EIO);
-}
-
-static void test_sync_op_blk_pwrite(BlockBackend *blk)
-{
-    uint8_t buf[512];
-    int ret;
-
-    /* Success */
-    ret = blk_pwrite(blk, 0, buf, sizeof(buf), 0);
-    g_assert_cmpint(ret, ==, 512);
-
-    /* Early error: Negative offset */
-    ret = blk_pwrite(blk, -2, buf, sizeof(buf), 0);
-    g_assert_cmpint(ret, ==, -EIO);
-}
-
-static void test_sync_op_load_vmstate(BdrvChild *c)
-{
-    uint8_t buf[512];
-    int ret;
-
-    /* Error: Driver does not support snapshots */
-    ret = bdrv_load_vmstate(c->bs, buf, 0, sizeof(buf));
-    g_assert_cmpint(ret, ==, -ENOTSUP);
-}
-
-static void test_sync_op_save_vmstate(BdrvChild *c)
-{
-    uint8_t buf[512];
-    int ret;
-
-    /* Error: Driver does not support snapshots */
-    ret = bdrv_save_vmstate(c->bs, buf, 0, sizeof(buf));
-    g_assert_cmpint(ret, ==, -ENOTSUP);
-}
-
-static void test_sync_op_pdiscard(BdrvChild *c)
-{
-    int ret;
-
-    /* Normal success path */
-    c->bs->open_flags |= BDRV_O_UNMAP;
-    ret = bdrv_pdiscard(c, 0, 512);
-    g_assert_cmpint(ret, ==, 0);
-
-    /* Early success: UNMAP not supported */
-    c->bs->open_flags &= ~BDRV_O_UNMAP;
-    ret = bdrv_pdiscard(c, 0, 512);
-    g_assert_cmpint(ret, ==, 0);
-
-    /* Early error: Negative offset */
-    ret = bdrv_pdiscard(c, -2, 512);
-    g_assert_cmpint(ret, ==, -EIO);
-}
-
-static void test_sync_op_blk_pdiscard(BlockBackend *blk)
-{
-    int ret;
-
-    /* Early success: UNMAP not supported */
-    ret = blk_pdiscard(blk, 0, 512);
-    g_assert_cmpint(ret, ==, 0);
-
-    /* Early error: Negative offset */
-    ret = blk_pdiscard(blk, -2, 512);
-    g_assert_cmpint(ret, ==, -EIO);
-}
-
-static void test_sync_op_truncate(BdrvChild *c)
-{
-    int ret;
-
-    /* Normal success path */
-    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
-    g_assert_cmpint(ret, ==, 0);
-
-    /* Early error: Negative offset */
-    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
-    g_assert_cmpint(ret, ==, -EINVAL);
-
-    /* Error: Read-only image */
-    c->bs->read_only = true;
-    c->bs->open_flags &= ~BDRV_O_RDWR;
-
-    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
-    g_assert_cmpint(ret, ==, -EACCES);
-
-    c->bs->read_only = false;
-    c->bs->open_flags |= BDRV_O_RDWR;
-}
-
-static void test_sync_op_block_status(BdrvChild *c)
-{
-    int ret;
-    int64_t n;
-
-    /* Normal success path */
-    ret = bdrv_is_allocated(c->bs, 0, 65536, &n);
-    g_assert_cmpint(ret, ==, 0);
-
-    /* Early success: No driver support */
-    bdrv_test.bdrv_co_block_status = NULL;
-    ret = bdrv_is_allocated(c->bs, 0, 65536, &n);
-    g_assert_cmpint(ret, ==, 1);
-
-    /* Early success: bytes = 0 */
-    ret = bdrv_is_allocated(c->bs, 0, 0, &n);
-    g_assert_cmpint(ret, ==, 0);
-
-    /* Early success: Offset > image size*/
-    ret = bdrv_is_allocated(c->bs, 0x1000000, 0x1000000, &n);
-    g_assert_cmpint(ret, ==, 0);
-}
-
-static void test_sync_op_flush(BdrvChild *c)
-{
-    int ret;
-
-    /* Normal success path */
-    ret = bdrv_flush(c->bs);
-    g_assert_cmpint(ret, ==, 0);
-
-    /* Early success: Read-only image */
-    c->bs->read_only = true;
-    c->bs->open_flags &= ~BDRV_O_RDWR;
-
-    ret = bdrv_flush(c->bs);
-    g_assert_cmpint(ret, ==, 0);
-
-    c->bs->read_only = false;
-    c->bs->open_flags |= BDRV_O_RDWR;
-}
-
-static void test_sync_op_blk_flush(BlockBackend *blk)
-{
-    BlockDriverState *bs = blk_bs(blk);
-    int ret;
-
-    /* Normal success path */
-    ret = blk_flush(blk);
-    g_assert_cmpint(ret, ==, 0);
-
-    /* Early success: Read-only image */
-    bs->read_only = true;
-    bs->open_flags &= ~BDRV_O_RDWR;
-
-    ret = blk_flush(blk);
-    g_assert_cmpint(ret, ==, 0);
-
-    bs->read_only = false;
-    bs->open_flags |= BDRV_O_RDWR;
-}
-
-static void test_sync_op_check(BdrvChild *c)
-{
-    BdrvCheckResult result;
-    int ret;
-
-    /* Error: Driver does not implement check */
-    ret = bdrv_check(c->bs, &result, 0);
-    g_assert_cmpint(ret, ==, -ENOTSUP);
-}
-
-static void test_sync_op_invalidate_cache(BdrvChild *c)
-{
-    /* Early success: Image is not inactive */
-    bdrv_invalidate_cache(c->bs, NULL);
-}
-
-
-typedef struct SyncOpTest {
-    const char *name;
-    void (*fn)(BdrvChild *c);
-    void (*blkfn)(BlockBackend *blk);
-} SyncOpTest;
-
-const SyncOpTest sync_op_tests[] = {
-    {
-        .name   = "/sync-op/pread",
-        .fn     = test_sync_op_pread,
-        .blkfn  = test_sync_op_blk_pread,
-    }, {
-        .name   = "/sync-op/pwrite",
-        .fn     = test_sync_op_pwrite,
-        .blkfn  = test_sync_op_blk_pwrite,
-    }, {
-        .name   = "/sync-op/load_vmstate",
-        .fn     = test_sync_op_load_vmstate,
-    }, {
-        .name   = "/sync-op/save_vmstate",
-        .fn     = test_sync_op_save_vmstate,
-    }, {
-        .name   = "/sync-op/pdiscard",
-        .fn     = test_sync_op_pdiscard,
-        .blkfn  = test_sync_op_blk_pdiscard,
-    }, {
-        .name   = "/sync-op/truncate",
-        .fn     = test_sync_op_truncate,
-    }, {
-        .name   = "/sync-op/block_status",
-        .fn     = test_sync_op_block_status,
-    }, {
-        .name   = "/sync-op/flush",
-        .fn     = test_sync_op_flush,
-        .blkfn  = test_sync_op_blk_flush,
-    }, {
-        .name   = "/sync-op/check",
-        .fn     = test_sync_op_check,
-    }, {
-        .name   = "/sync-op/invalidate_cache",
-        .fn     = test_sync_op_invalidate_cache,
-    },
-};
-
-/* Test synchronous operations that run in a different iothread, so we have to
- * poll for the coroutine there to return. */
-static void test_sync_op(const void *opaque)
-{
-    const SyncOpTest *t = opaque;
-    IOThread *iothread = iothread_new();
-    AioContext *ctx = iothread_get_aio_context(iothread);
-    BlockBackend *blk;
-    BlockDriverState *bs;
-    BdrvChild *c;
-
-    blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
-    bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
-    bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;
-    blk_insert_bs(blk, bs, &error_abort);
-    c = QLIST_FIRST(&bs->parents);
-
-    blk_set_aio_context(blk, ctx, &error_abort);
-    aio_context_acquire(ctx);
-    t->fn(c);
-    if (t->blkfn) {
-        t->blkfn(blk);
-    }
-    blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
-    aio_context_release(ctx);
-
-    bdrv_unref(bs);
-    blk_unref(blk);
-}
-
-typedef struct TestBlockJob {
-    BlockJob common;
-    bool should_complete;
-    int n;
-} TestBlockJob;
-
-static int test_job_prepare(Job *job)
-{
-    g_assert(qemu_get_current_aio_context() == qemu_get_aio_context());
-    return 0;
-}
-
-static int coroutine_fn test_job_run(Job *job, Error **errp)
-{
-    TestBlockJob *s = container_of(job, TestBlockJob, common.job);
-
-    job_transition_to_ready(&s->common.job);
-    while (!s->should_complete) {
-        s->n++;
-        g_assert(qemu_get_current_aio_context() == job->aio_context);
-
-        /* Avoid job_sleep_ns() because it marks the job as !busy. We want to
-         * emulate some actual activity (probably some I/O) here so that the
-         * drain involved in AioContext switches has to wait for this activity
-         * to stop. */
-        qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 1000000);
-
-        job_pause_point(&s->common.job);
-    }
-
-    g_assert(qemu_get_current_aio_context() == job->aio_context);
-    return 0;
-}
-
-static void test_job_complete(Job *job, Error **errp)
-{
-    TestBlockJob *s = container_of(job, TestBlockJob, common.job);
-    s->should_complete = true;
-}
-
-BlockJobDriver test_job_driver = {
-    .job_driver = {
-        .instance_size  = sizeof(TestBlockJob),
-        .free           = block_job_free,
-        .user_resume    = block_job_user_resume,
-        .run            = test_job_run,
-        .complete       = test_job_complete,
-        .prepare        = test_job_prepare,
-    },
-};
-
-static void test_attach_blockjob(void)
-{
-    IOThread *iothread = iothread_new();
-    AioContext *ctx = iothread_get_aio_context(iothread);
-    BlockBackend *blk;
-    BlockDriverState *bs;
-    TestBlockJob *tjob;
-
-    blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
-    bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
-    blk_insert_bs(blk, bs, &error_abort);
-
-    tjob = block_job_create("job0", &test_job_driver, NULL, bs,
-                            0, BLK_PERM_ALL,
-                            0, 0, NULL, NULL, &error_abort);
-    job_start(&tjob->common.job);
-
-    while (tjob->n == 0) {
-        aio_poll(qemu_get_aio_context(), false);
-    }
-
-    blk_set_aio_context(blk, ctx, &error_abort);
-
-    tjob->n = 0;
-    while (tjob->n == 0) {
-        aio_poll(qemu_get_aio_context(), false);
-    }
-
-    aio_context_acquire(ctx);
-    blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
-    aio_context_release(ctx);
-
-    tjob->n = 0;
-    while (tjob->n == 0) {
-        aio_poll(qemu_get_aio_context(), false);
-    }
-
-    blk_set_aio_context(blk, ctx, &error_abort);
-
-    tjob->n = 0;
-    while (tjob->n == 0) {
-        aio_poll(qemu_get_aio_context(), false);
-    }
-
-    aio_context_acquire(ctx);
-    job_complete_sync(&tjob->common.job, &error_abort);
-    blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
-    aio_context_release(ctx);
-
-    bdrv_unref(bs);
-    blk_unref(blk);
-}
-
-/*
- * Test that changing the AioContext for one node in a tree (here through blk)
- * changes all other nodes as well:
- *
- *  blk
- *   |
- *   |  bs_verify [blkverify]
- *   |   /               \
- *   |  /                 \
- *  bs_a [bdrv_test]    bs_b [bdrv_test]
- *
- */
-static void test_propagate_basic(void)
-{
-    IOThread *iothread = iothread_new();
-    AioContext *ctx = iothread_get_aio_context(iothread);
-    AioContext *main_ctx;
-    BlockBackend *blk;
-    BlockDriverState *bs_a, *bs_b, *bs_verify;
-    QDict *options;
-
-    /*
-     * Create bs_a and its BlockBackend.  We cannot take the RESIZE
-     * permission because blkverify will not share it on the test
-     * image.
-     */
-    blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
-                  BLK_PERM_ALL);
-    bs_a = bdrv_new_open_driver(&bdrv_test, "bs_a", BDRV_O_RDWR, &error_abort);
-    blk_insert_bs(blk, bs_a, &error_abort);
-
-    /* Create bs_b */
-    bs_b = bdrv_new_open_driver(&bdrv_test, "bs_b", BDRV_O_RDWR, &error_abort);
-
-    /* Create blkverify filter that references both bs_a and bs_b */
-    options = qdict_new();
-    qdict_put_str(options, "driver", "blkverify");
-    qdict_put_str(options, "test", "bs_a");
-    qdict_put_str(options, "raw", "bs_b");
-
-    bs_verify = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
-
-    /* Switch the AioContext */
-    blk_set_aio_context(blk, ctx, &error_abort);
-    g_assert(blk_get_aio_context(blk) == ctx);
-    g_assert(bdrv_get_aio_context(bs_a) == ctx);
-    g_assert(bdrv_get_aio_context(bs_verify) == ctx);
-    g_assert(bdrv_get_aio_context(bs_b) == ctx);
-
-    /* Switch the AioContext back */
-    main_ctx = qemu_get_aio_context();
-    aio_context_acquire(ctx);
-    blk_set_aio_context(blk, main_ctx, &error_abort);
-    aio_context_release(ctx);
-    g_assert(blk_get_aio_context(blk) == main_ctx);
-    g_assert(bdrv_get_aio_context(bs_a) == main_ctx);
-    g_assert(bdrv_get_aio_context(bs_verify) == main_ctx);
-    g_assert(bdrv_get_aio_context(bs_b) == main_ctx);
-
-    bdrv_unref(bs_verify);
-    bdrv_unref(bs_b);
-    bdrv_unref(bs_a);
-    blk_unref(blk);
-}
-
-/*
- * Test that diamonds in the graph don't lead to endless recursion:
- *
- *              blk
- *               |
- *      bs_verify [blkverify]
- *       /              \
- *      /                \
- *   bs_b [raw]         bs_c[raw]
- *      \                /
- *       \              /
- *       bs_a [bdrv_test]
- */
-static void test_propagate_diamond(void)
-{
-    IOThread *iothread = iothread_new();
-    AioContext *ctx = iothread_get_aio_context(iothread);
-    AioContext *main_ctx;
-    BlockBackend *blk;
-    BlockDriverState *bs_a, *bs_b, *bs_c, *bs_verify;
-    QDict *options;
-
-    /* Create bs_a */
-    bs_a = bdrv_new_open_driver(&bdrv_test, "bs_a", BDRV_O_RDWR, &error_abort);
-
-    /* Create bs_b and bc_c */
-    options = qdict_new();
-    qdict_put_str(options, "driver", "raw");
-    qdict_put_str(options, "file", "bs_a");
-    qdict_put_str(options, "node-name", "bs_b");
-    bs_b = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
-
-    options = qdict_new();
-    qdict_put_str(options, "driver", "raw");
-    qdict_put_str(options, "file", "bs_a");
-    qdict_put_str(options, "node-name", "bs_c");
-    bs_c = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
-
-    /* Create blkverify filter that references both bs_b and bs_c */
-    options = qdict_new();
-    qdict_put_str(options, "driver", "blkverify");
-    qdict_put_str(options, "test", "bs_b");
-    qdict_put_str(options, "raw", "bs_c");
-
-    bs_verify = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
-    /*
-     * Do not take the RESIZE permission: This would require the same
-     * from bs_c and thus from bs_a; however, blkverify will not share
-     * it on bs_b, and thus it will not be available for bs_a.
-     */
-    blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL & ~BLK_PERM_RESIZE,
-                  BLK_PERM_ALL);
-    blk_insert_bs(blk, bs_verify, &error_abort);
-
-    /* Switch the AioContext */
-    blk_set_aio_context(blk, ctx, &error_abort);
-    g_assert(blk_get_aio_context(blk) == ctx);
-    g_assert(bdrv_get_aio_context(bs_verify) == ctx);
-    g_assert(bdrv_get_aio_context(bs_a) == ctx);
-    g_assert(bdrv_get_aio_context(bs_b) == ctx);
-    g_assert(bdrv_get_aio_context(bs_c) == ctx);
-
-    /* Switch the AioContext back */
-    main_ctx = qemu_get_aio_context();
-    aio_context_acquire(ctx);
-    blk_set_aio_context(blk, main_ctx, &error_abort);
-    aio_context_release(ctx);
-    g_assert(blk_get_aio_context(blk) == main_ctx);
-    g_assert(bdrv_get_aio_context(bs_verify) == main_ctx);
-    g_assert(bdrv_get_aio_context(bs_a) == main_ctx);
-    g_assert(bdrv_get_aio_context(bs_b) == main_ctx);
-    g_assert(bdrv_get_aio_context(bs_c) == main_ctx);
-
-    blk_unref(blk);
-    bdrv_unref(bs_verify);
-    bdrv_unref(bs_c);
-    bdrv_unref(bs_b);
-    bdrv_unref(bs_a);
-}
-
-static void test_propagate_mirror(void)
-{
-    IOThread *iothread = iothread_new();
-    AioContext *ctx = iothread_get_aio_context(iothread);
-    AioContext *main_ctx = qemu_get_aio_context();
-    BlockDriverState *src, *target, *filter;
-    BlockBackend *blk;
-    Job *job;
-    Error *local_err = NULL;
-
-    /* Create src and target*/
-    src = bdrv_new_open_driver(&bdrv_test, "src", BDRV_O_RDWR, &error_abort);
-    target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
-                                  &error_abort);
-
-    /* Start a mirror job */
-    mirror_start("job0", src, target, NULL, JOB_DEFAULT, 0, 0, 0,
-                 MIRROR_SYNC_MODE_NONE, MIRROR_OPEN_BACKING_CHAIN, false,
-                 BLOCKDEV_ON_ERROR_REPORT, BLOCKDEV_ON_ERROR_REPORT,
-                 false, "filter_node", MIRROR_COPY_MODE_BACKGROUND,
-                 &error_abort);
-    job = job_get("job0");
-    filter = bdrv_find_node("filter_node");
-
-    /* Change the AioContext of src */
-    bdrv_try_set_aio_context(src, ctx, &error_abort);
-    g_assert(bdrv_get_aio_context(src) == ctx);
-    g_assert(bdrv_get_aio_context(target) == ctx);
-    g_assert(bdrv_get_aio_context(filter) == ctx);
-    g_assert(job->aio_context == ctx);
-
-    /* Change the AioContext of target */
-    aio_context_acquire(ctx);
-    bdrv_try_set_aio_context(target, main_ctx, &error_abort);
-    aio_context_release(ctx);
-    g_assert(bdrv_get_aio_context(src) == main_ctx);
-    g_assert(bdrv_get_aio_context(target) == main_ctx);
-    g_assert(bdrv_get_aio_context(filter) == main_ctx);
-
-    /* With a BlockBackend on src, changing target must fail */
-    blk = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
-    blk_insert_bs(blk, src, &error_abort);
-
-    bdrv_try_set_aio_context(target, ctx, &local_err);
-    error_free_or_abort(&local_err);
-
-    g_assert(blk_get_aio_context(blk) == main_ctx);
-    g_assert(bdrv_get_aio_context(src) == main_ctx);
-    g_assert(bdrv_get_aio_context(target) == main_ctx);
-    g_assert(bdrv_get_aio_context(filter) == main_ctx);
-
-    /* ...unless we explicitly allow it */
-    aio_context_acquire(ctx);
-    blk_set_allow_aio_context_change(blk, true);
-    bdrv_try_set_aio_context(target, ctx, &error_abort);
-    aio_context_release(ctx);
-
-    g_assert(blk_get_aio_context(blk) == ctx);
-    g_assert(bdrv_get_aio_context(src) == ctx);
-    g_assert(bdrv_get_aio_context(target) == ctx);
-    g_assert(bdrv_get_aio_context(filter) == ctx);
-
-    job_cancel_sync_all();
-
-    aio_context_acquire(ctx);
-    blk_set_aio_context(blk, main_ctx, &error_abort);
-    bdrv_try_set_aio_context(target, main_ctx, &error_abort);
-    aio_context_release(ctx);
-
-    blk_unref(blk);
-    bdrv_unref(src);
-    bdrv_unref(target);
-}
-
-static void test_attach_second_node(void)
-{
-    IOThread *iothread = iothread_new();
-    AioContext *ctx = iothread_get_aio_context(iothread);
-    AioContext *main_ctx = qemu_get_aio_context();
-    BlockBackend *blk;
-    BlockDriverState *bs, *filter;
-    QDict *options;
-
-    blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
-    bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
-    blk_insert_bs(blk, bs, &error_abort);
-
-    options = qdict_new();
-    qdict_put_str(options, "driver", "raw");
-    qdict_put_str(options, "file", "base");
-
-    filter = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
-    g_assert(blk_get_aio_context(blk) == ctx);
-    g_assert(bdrv_get_aio_context(bs) == ctx);
-    g_assert(bdrv_get_aio_context(filter) == ctx);
-
-    aio_context_acquire(ctx);
-    blk_set_aio_context(blk, main_ctx, &error_abort);
-    aio_context_release(ctx);
-    g_assert(blk_get_aio_context(blk) == main_ctx);
-    g_assert(bdrv_get_aio_context(bs) == main_ctx);
-    g_assert(bdrv_get_aio_context(filter) == main_ctx);
-
-    bdrv_unref(filter);
-    bdrv_unref(bs);
-    blk_unref(blk);
-}
-
-static void test_attach_preserve_blk_ctx(void)
-{
-    IOThread *iothread = iothread_new();
-    AioContext *ctx = iothread_get_aio_context(iothread);
-    BlockBackend *blk;
-    BlockDriverState *bs;
-
-    blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
-    bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
-    bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;
-
-    /* Add node to BlockBackend that has an iothread context assigned */
-    blk_insert_bs(blk, bs, &error_abort);
-    g_assert(blk_get_aio_context(blk) == ctx);
-    g_assert(bdrv_get_aio_context(bs) == ctx);
-
-    /* Remove the node again */
-    aio_context_acquire(ctx);
-    blk_remove_bs(blk);
-    aio_context_release(ctx);
-    g_assert(blk_get_aio_context(blk) == ctx);
-    g_assert(bdrv_get_aio_context(bs) == qemu_get_aio_context());
-
-    /* Re-attach the node */
-    blk_insert_bs(blk, bs, &error_abort);
-    g_assert(blk_get_aio_context(blk) == ctx);
-    g_assert(bdrv_get_aio_context(bs) == ctx);
-
-    aio_context_acquire(ctx);
-    blk_set_aio_context(blk, qemu_get_aio_context(), &error_abort);
-    aio_context_release(ctx);
-    bdrv_unref(bs);
-    blk_unref(blk);
-}
-
-int main(int argc, char **argv)
-{
-    int i;
-
-    bdrv_init();
-    qemu_init_main_loop(&error_abort);
-
-    g_test_init(&argc, &argv, NULL);
-
-    for (i = 0; i < ARRAY_SIZE(sync_op_tests); i++) {
-        const SyncOpTest *t = &sync_op_tests[i];
-        g_test_add_data_func(t->name, t, test_sync_op);
-    }
-
-    g_test_add_func("/attach/blockjob", test_attach_blockjob);
-    g_test_add_func("/attach/second_node", test_attach_second_node);
-    g_test_add_func("/attach/preserve_blk_ctx", test_attach_preserve_blk_ctx);
-    g_test_add_func("/propagate/basic", test_propagate_basic);
-    g_test_add_func("/propagate/diamond", test_propagate_diamond);
-    g_test_add_func("/propagate/mirror", test_propagate_mirror);
-
-    return g_test_run();
-}