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, 770 deletions

diff --git a/tests/test-throttle.c b/tests/test-throttle.c
deleted file mode 100644
index 7adb5e6652..0000000000
--- a/tests/test-throttle.c
+++ /dev/null
@@ -1,770 +0,0 @@
-/*
- * Throttle infrastructure tests
- *
- * Copyright Nodalink, EURL. 2013-2014
- * Copyright Igalia, S.L. 2015
- *
- * Authors:
- *  Benoît Canet     <benoit.canet@nodalink.com>
- *  Alberto Garcia   <berto@igalia.com>
- *
- * This work is licensed under the terms of the GNU LGPL, version 2 or later.
- * See the COPYING.LIB file in the top-level directory.
- */
-
-#include "qemu/osdep.h"
-#include <math.h>
-#include "block/aio.h"
-#include "qapi/error.h"
-#include "qemu/throttle.h"
-#include "qemu/error-report.h"
-#include "qemu/main-loop.h"
-#include "qemu/module.h"
-#include "block/throttle-groups.h"
-#include "sysemu/block-backend.h"
-
-static AioContext     *ctx;
-static LeakyBucket    bkt;
-static ThrottleConfig cfg;
-static ThrottleGroupMember tgm;
-static ThrottleState  ts;
-static ThrottleTimers *tt;
-
-/* useful function */
-static bool double_cmp(double x, double y)
-{
-    return fabsl(x - y) < 1e-6;
-}
-
-/* tests for single bucket operations */
-static void test_leak_bucket(void)
-{
-    throttle_config_init(&cfg);
-    bkt = cfg.buckets[THROTTLE_BPS_TOTAL];
-
-    /* set initial value */
-    bkt.avg = 150;
-    bkt.max = 15;
-    bkt.level = 1.5;
-
-    /* leak an op work of time */
-    throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
-    g_assert(bkt.avg == 150);
-    g_assert(bkt.max == 15);
-    g_assert(double_cmp(bkt.level, 0.5));
-
-    /* leak again emptying the bucket */
-    throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
-    g_assert(bkt.avg == 150);
-    g_assert(bkt.max == 15);
-    g_assert(double_cmp(bkt.level, 0));
-
-    /* check that the bucket level won't go lower */
-    throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 150);
-    g_assert(bkt.avg == 150);
-    g_assert(bkt.max == 15);
-    g_assert(double_cmp(bkt.level, 0));
-
-    /* check that burst_level leaks correctly */
-    bkt.burst_level = 6;
-    bkt.max = 250;
-    bkt.burst_length = 2; /* otherwise burst_level will not leak */
-    throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
-    g_assert(double_cmp(bkt.burst_level, 3.5));
-
-    throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
-    g_assert(double_cmp(bkt.burst_level, 1));
-
-    throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
-    g_assert(double_cmp(bkt.burst_level, 0));
-
-    throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 100);
-    g_assert(double_cmp(bkt.burst_level, 0));
-}
-
-static void test_compute_wait(void)
-{
-    unsigned i;
-    int64_t wait;
-    int64_t result;
-
-    throttle_config_init(&cfg);
-    bkt = cfg.buckets[THROTTLE_BPS_TOTAL];
-
-    /* no operation limit set */
-    bkt.avg = 0;
-    bkt.max = 15;
-    bkt.level = 1.5;
-    wait = throttle_compute_wait(&bkt);
-    g_assert(!wait);
-
-    /* zero delta */
-    bkt.avg = 150;
-    bkt.max = 15;
-    bkt.level = 15;
-    wait = throttle_compute_wait(&bkt);
-    g_assert(!wait);
-
-    /* below zero delta */
-    bkt.avg = 150;
-    bkt.max = 15;
-    bkt.level = 9;
-    wait = throttle_compute_wait(&bkt);
-    g_assert(!wait);
-
-    /* half an operation above max */
-    bkt.avg = 150;
-    bkt.max = 15;
-    bkt.level = 15.5;
-    wait = throttle_compute_wait(&bkt);
-    /* time required to do half an operation */
-    result = (int64_t)  NANOSECONDS_PER_SECOND / 150 / 2;
-    g_assert(wait == result);
-
-    /* Perform I/O for 2.2 seconds at a rate of bkt.max */
-    bkt.burst_length = 2;
-    bkt.level = 0;
-    bkt.avg = 10;
-    bkt.max = 200;
-    for (i = 0; i < 22; i++) {
-        double units = bkt.max / 10;
-        bkt.level += units;
-        bkt.burst_level += units;
-        throttle_leak_bucket(&bkt, NANOSECONDS_PER_SECOND / 10);
-        wait = throttle_compute_wait(&bkt);
-        g_assert(double_cmp(bkt.burst_level, 0));
-        g_assert(double_cmp(bkt.level, (i + 1) * (bkt.max - bkt.avg) / 10));
-        /* We can do bursts for the 2 seconds we have configured in
-         * burst_length. We have 100 extra miliseconds of burst
-         * because bkt.level has been leaking during this time.
-         * After that, we have to wait. */
-        result = i < 21 ? 0 : 1.8 * NANOSECONDS_PER_SECOND;
-        g_assert(wait == result);
-    }
-}
-
-/* functions to test ThrottleState initialization/destroy methods */
-static void read_timer_cb(void *opaque)
-{
-}
-
-static void write_timer_cb(void *opaque)
-{
-}
-
-static void test_init(void)
-{
-    int i;
-
-    tt = &tgm.throttle_timers;
-
-    /* fill the structures with crap */
-    memset(&ts, 1, sizeof(ts));
-    memset(tt, 1, sizeof(*tt));
-
-    /* init structures */
-    throttle_init(&ts);
-    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
-                         read_timer_cb, write_timer_cb, &ts);
-
-    /* check initialized fields */
-    g_assert(tt->clock_type == QEMU_CLOCK_VIRTUAL);
-    g_assert(tt->timers[0]);
-    g_assert(tt->timers[1]);
-
-    /* check other fields where cleared */
-    g_assert(!ts.previous_leak);
-    g_assert(!ts.cfg.op_size);
-    for (i = 0; i < BUCKETS_COUNT; i++) {
-        g_assert(!ts.cfg.buckets[i].avg);
-        g_assert(!ts.cfg.buckets[i].max);
-        g_assert(!ts.cfg.buckets[i].level);
-    }
-
-    throttle_timers_destroy(tt);
-}
-
-static void test_destroy(void)
-{
-    int i;
-    throttle_init(&ts);
-    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
-                         read_timer_cb, write_timer_cb, &ts);
-    throttle_timers_destroy(tt);
-    for (i = 0; i < 2; i++) {
-        g_assert(!tt->timers[i]);
-    }
-}
-
-/* function to test throttle_config and throttle_get_config */
-static void test_config_functions(void)
-{
-    int i;
-    ThrottleConfig orig_cfg, final_cfg;
-
-    orig_cfg.buckets[THROTTLE_BPS_TOTAL].avg = 153;
-    orig_cfg.buckets[THROTTLE_BPS_READ].avg  = 56;
-    orig_cfg.buckets[THROTTLE_BPS_WRITE].avg = 1;
-
-    orig_cfg.buckets[THROTTLE_OPS_TOTAL].avg = 150;
-    orig_cfg.buckets[THROTTLE_OPS_READ].avg  = 69;
-    orig_cfg.buckets[THROTTLE_OPS_WRITE].avg = 23;
-
-    orig_cfg.buckets[THROTTLE_BPS_TOTAL].max = 0;
-    orig_cfg.buckets[THROTTLE_BPS_READ].max  = 56;
-    orig_cfg.buckets[THROTTLE_BPS_WRITE].max = 120;
-
-    orig_cfg.buckets[THROTTLE_OPS_TOTAL].max = 150;
-    orig_cfg.buckets[THROTTLE_OPS_READ].max  = 400;
-    orig_cfg.buckets[THROTTLE_OPS_WRITE].max = 500;
-
-    orig_cfg.buckets[THROTTLE_BPS_TOTAL].level = 45;
-    orig_cfg.buckets[THROTTLE_BPS_READ].level  = 65;
-    orig_cfg.buckets[THROTTLE_BPS_WRITE].level = 23;
-
-    orig_cfg.buckets[THROTTLE_OPS_TOTAL].level = 1;
-    orig_cfg.buckets[THROTTLE_OPS_READ].level  = 90;
-    orig_cfg.buckets[THROTTLE_OPS_WRITE].level = 75;
-
-    orig_cfg.op_size = 1;
-
-    throttle_init(&ts);
-    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
-                         read_timer_cb, write_timer_cb, &ts);
-    /* structure reset by throttle_init previous_leak should be null */
-    g_assert(!ts.previous_leak);
-    throttle_config(&ts, QEMU_CLOCK_VIRTUAL, &orig_cfg);
-
-    /* has previous leak been initialized by throttle_config ? */
-    g_assert(ts.previous_leak);
-
-    /* get back the fixed configuration */
-    throttle_get_config(&ts, &final_cfg);
-
-    throttle_timers_destroy(tt);
-
-    g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].avg == 153);
-    g_assert(final_cfg.buckets[THROTTLE_BPS_READ].avg  == 56);
-    g_assert(final_cfg.buckets[THROTTLE_BPS_WRITE].avg == 1);
-
-    g_assert(final_cfg.buckets[THROTTLE_OPS_TOTAL].avg == 150);
-    g_assert(final_cfg.buckets[THROTTLE_OPS_READ].avg  == 69);
-    g_assert(final_cfg.buckets[THROTTLE_OPS_WRITE].avg == 23);
-
-    g_assert(final_cfg.buckets[THROTTLE_BPS_TOTAL].max == 0);
-    g_assert(final_cfg.buckets[THROTTLE_BPS_READ].max  == 56);
-    g_assert(final_cfg.buckets[THROTTLE_BPS_WRITE].max == 120);
-
-    g_assert(final_cfg.buckets[THROTTLE_OPS_TOTAL].max == 150);
-    g_assert(final_cfg.buckets[THROTTLE_OPS_READ].max  == 400);
-    g_assert(final_cfg.buckets[THROTTLE_OPS_WRITE].max == 500);
-
-    g_assert(final_cfg.op_size == 1);
-
-    /* check bucket have been cleared */
-    for (i = 0; i < BUCKETS_COUNT; i++) {
-        g_assert(!final_cfg.buckets[i].level);
-    }
-}
-
-/* functions to test is throttle is enabled by a config */
-static void set_cfg_value(bool is_max, int index, int value)
-{
-    if (is_max) {
-        cfg.buckets[index].max = value;
-        /* If max is set, avg should never be 0 */
-        cfg.buckets[index].avg = MAX(cfg.buckets[index].avg, 1);
-    } else {
-        cfg.buckets[index].avg = value;
-    }
-}
-
-static void test_enabled(void)
-{
-    int i;
-
-    throttle_config_init(&cfg);
-    g_assert(!throttle_enabled(&cfg));
-
-    for (i = 0; i < BUCKETS_COUNT; i++) {
-        throttle_config_init(&cfg);
-        set_cfg_value(false, i, 150);
-        g_assert(throttle_is_valid(&cfg, NULL));
-        g_assert(throttle_enabled(&cfg));
-    }
-
-    for (i = 0; i < BUCKETS_COUNT; i++) {
-        throttle_config_init(&cfg);
-        set_cfg_value(false, i, -150);
-        g_assert(!throttle_is_valid(&cfg, NULL));
-    }
-}
-
-/* tests functions for throttle_conflicting */
-
-static void test_conflicts_for_one_set(bool is_max,
-                                       int total,
-                                       int read,
-                                       int write)
-{
-    throttle_config_init(&cfg);
-    g_assert(throttle_is_valid(&cfg, NULL));
-
-    set_cfg_value(is_max, total, 1);
-    set_cfg_value(is_max, read,  1);
-    g_assert(!throttle_is_valid(&cfg, NULL));
-
-    throttle_config_init(&cfg);
-    set_cfg_value(is_max, total, 1);
-    set_cfg_value(is_max, write, 1);
-    g_assert(!throttle_is_valid(&cfg, NULL));
-
-    throttle_config_init(&cfg);
-    set_cfg_value(is_max, total, 1);
-    set_cfg_value(is_max, read,  1);
-    set_cfg_value(is_max, write, 1);
-    g_assert(!throttle_is_valid(&cfg, NULL));
-
-    throttle_config_init(&cfg);
-    set_cfg_value(is_max, total, 1);
-    g_assert(throttle_is_valid(&cfg, NULL));
-
-    throttle_config_init(&cfg);
-    set_cfg_value(is_max, read,  1);
-    set_cfg_value(is_max, write, 1);
-    g_assert(throttle_is_valid(&cfg, NULL));
-}
-
-static void test_conflicting_config(void)
-{
-    /* bps average conflicts */
-    test_conflicts_for_one_set(false,
-                               THROTTLE_BPS_TOTAL,
-                               THROTTLE_BPS_READ,
-                               THROTTLE_BPS_WRITE);
-
-    /* ops average conflicts */
-    test_conflicts_for_one_set(false,
-                               THROTTLE_OPS_TOTAL,
-                               THROTTLE_OPS_READ,
-                               THROTTLE_OPS_WRITE);
-
-    /* bps average conflicts */
-    test_conflicts_for_one_set(true,
-                               THROTTLE_BPS_TOTAL,
-                               THROTTLE_BPS_READ,
-                               THROTTLE_BPS_WRITE);
-    /* ops average conflicts */
-    test_conflicts_for_one_set(true,
-                               THROTTLE_OPS_TOTAL,
-                               THROTTLE_OPS_READ,
-                               THROTTLE_OPS_WRITE);
-}
-/* functions to test the throttle_is_valid function */
-static void test_is_valid_for_value(int value, bool should_be_valid)
-{
-    int is_max, index;
-    for (is_max = 0; is_max < 2; is_max++) {
-        for (index = 0; index < BUCKETS_COUNT; index++) {
-            throttle_config_init(&cfg);
-            set_cfg_value(is_max, index, value);
-            g_assert(throttle_is_valid(&cfg, NULL) == should_be_valid);
-        }
-    }
-}
-
-static void test_is_valid(void)
-{
-    /* negative number are invalid */
-    test_is_valid_for_value(-1, false);
-    /* zero are valids */
-    test_is_valid_for_value(0, true);
-    /* positives numers are valids */
-    test_is_valid_for_value(1, true);
-}
-
-static void test_ranges(void)
-{
-    int i;
-
-    for (i = 0; i < BUCKETS_COUNT; i++) {
-        LeakyBucket *b = &cfg.buckets[i];
-        throttle_config_init(&cfg);
-
-        /* avg = 0 means throttling is disabled, but the config is valid */
-        b->avg = 0;
-        g_assert(throttle_is_valid(&cfg, NULL));
-        g_assert(!throttle_enabled(&cfg));
-
-        /* These are valid configurations (values <= THROTTLE_VALUE_MAX) */
-        b->avg = 1;
-        g_assert(throttle_is_valid(&cfg, NULL));
-
-        b->avg = THROTTLE_VALUE_MAX;
-        g_assert(throttle_is_valid(&cfg, NULL));
-
-        b->avg = THROTTLE_VALUE_MAX;
-        b->max = THROTTLE_VALUE_MAX;
-        g_assert(throttle_is_valid(&cfg, NULL));
-
-        /* Values over THROTTLE_VALUE_MAX are not allowed */
-        b->avg = THROTTLE_VALUE_MAX + 1;
-        g_assert(!throttle_is_valid(&cfg, NULL));
-
-        b->avg = THROTTLE_VALUE_MAX;
-        b->max = THROTTLE_VALUE_MAX + 1;
-        g_assert(!throttle_is_valid(&cfg, NULL));
-
-        /* burst_length must be between 1 and THROTTLE_VALUE_MAX */
-        b->avg = 1;
-        b->max = 1;
-        b->burst_length = 0;
-        g_assert(!throttle_is_valid(&cfg, NULL));
-
-        b->avg = 1;
-        b->max = 1;
-        b->burst_length = 1;
-        g_assert(throttle_is_valid(&cfg, NULL));
-
-        b->avg = 1;
-        b->max = 1;
-        b->burst_length = THROTTLE_VALUE_MAX;
-        g_assert(throttle_is_valid(&cfg, NULL));
-
-        b->avg = 1;
-        b->max = 1;
-        b->burst_length = THROTTLE_VALUE_MAX + 1;
-        g_assert(!throttle_is_valid(&cfg, NULL));
-
-        /* burst_length * max cannot exceed THROTTLE_VALUE_MAX */
-        b->avg = 1;
-        b->max = 2;
-        b->burst_length = THROTTLE_VALUE_MAX / 2;
-        g_assert(throttle_is_valid(&cfg, NULL));
-
-        b->avg = 1;
-        b->max = 3;
-        b->burst_length = THROTTLE_VALUE_MAX / 2;
-        g_assert(!throttle_is_valid(&cfg, NULL));
-
-        b->avg = 1;
-        b->max = THROTTLE_VALUE_MAX;
-        b->burst_length = 1;
-        g_assert(throttle_is_valid(&cfg, NULL));
-
-        b->avg = 1;
-        b->max = THROTTLE_VALUE_MAX;
-        b->burst_length = 2;
-        g_assert(!throttle_is_valid(&cfg, NULL));
-    }
-}
-
-static void test_max_is_missing_limit(void)
-{
-    int i;
-
-    for (i = 0; i < BUCKETS_COUNT; i++) {
-        throttle_config_init(&cfg);
-        cfg.buckets[i].max = 100;
-        cfg.buckets[i].avg = 0;
-        g_assert(!throttle_is_valid(&cfg, NULL));
-
-        cfg.buckets[i].max = 0;
-        cfg.buckets[i].avg = 0;
-        g_assert(throttle_is_valid(&cfg, NULL));
-
-        cfg.buckets[i].max = 0;
-        cfg.buckets[i].avg = 100;
-        g_assert(throttle_is_valid(&cfg, NULL));
-
-        cfg.buckets[i].max = 30;
-        cfg.buckets[i].avg = 100;
-        g_assert(!throttle_is_valid(&cfg, NULL));
-
-        cfg.buckets[i].max = 100;
-        cfg.buckets[i].avg = 100;
-        g_assert(throttle_is_valid(&cfg, NULL));
-    }
-}
-
-static void test_iops_size_is_missing_limit(void)
-{
-    /* A total/read/write iops limit is required */
-    throttle_config_init(&cfg);
-    cfg.op_size = 4096;
-    g_assert(!throttle_is_valid(&cfg, NULL));
-}
-
-static void test_have_timer(void)
-{
-    /* zero structures */
-    memset(&ts, 0, sizeof(ts));
-    memset(tt, 0, sizeof(*tt));
-
-    /* no timer set should return false */
-    g_assert(!throttle_timers_are_initialized(tt));
-
-    /* init structures */
-    throttle_init(&ts);
-    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
-                         read_timer_cb, write_timer_cb, &ts);
-
-    /* timer set by init should return true */
-    g_assert(throttle_timers_are_initialized(tt));
-
-    throttle_timers_destroy(tt);
-}
-
-static void test_detach_attach(void)
-{
-    /* zero structures */
-    memset(&ts, 0, sizeof(ts));
-    memset(tt, 0, sizeof(*tt));
-
-    /* init the structure */
-    throttle_init(&ts);
-    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
-                         read_timer_cb, write_timer_cb, &ts);
-
-    /* timer set by init should return true */
-    g_assert(throttle_timers_are_initialized(tt));
-
-    /* timer should no longer exist after detaching */
-    throttle_timers_detach_aio_context(tt);
-    g_assert(!throttle_timers_are_initialized(tt));
-
-    /* timer should exist again after attaching */
-    throttle_timers_attach_aio_context(tt, ctx);
-    g_assert(throttle_timers_are_initialized(tt));
-
-    throttle_timers_destroy(tt);
-}
-
-static bool do_test_accounting(bool is_ops, /* are we testing bps or ops */
-                int size,                   /* size of the operation to do */
-                double avg,                 /* io limit */
-                uint64_t op_size,           /* ideal size of an io */
-                double total_result,
-                double read_result,
-                double write_result)
-{
-    BucketType to_test[2][3] = { { THROTTLE_BPS_TOTAL,
-                                   THROTTLE_BPS_READ,
-                                   THROTTLE_BPS_WRITE, },
-                                 { THROTTLE_OPS_TOTAL,
-                                   THROTTLE_OPS_READ,
-                                   THROTTLE_OPS_WRITE, } };
-    ThrottleConfig cfg;
-    BucketType index;
-    int i;
-
-    throttle_config_init(&cfg);
-
-    for (i = 0; i < 3; i++) {
-        BucketType index = to_test[is_ops][i];
-        cfg.buckets[index].avg = avg;
-    }
-
-    cfg.op_size = op_size;
-
-    throttle_init(&ts);
-    throttle_timers_init(tt, ctx, QEMU_CLOCK_VIRTUAL,
-                         read_timer_cb, write_timer_cb, &ts);
-    throttle_config(&ts, QEMU_CLOCK_VIRTUAL, &cfg);
-
-    /* account a read */
-    throttle_account(&ts, false, size);
-    /* account a write */
-    throttle_account(&ts, true, size);
-
-    /* check total result */
-    index = to_test[is_ops][0];
-    if (!double_cmp(ts.cfg.buckets[index].level, total_result)) {
-        return false;
-    }
-
-    /* check read result */
-    index = to_test[is_ops][1];
-    if (!double_cmp(ts.cfg.buckets[index].level, read_result)) {
-        return false;
-    }
-
-    /* check write result */
-    index = to_test[is_ops][2];
-    if (!double_cmp(ts.cfg.buckets[index].level, write_result)) {
-        return false;
-    }
-
-    throttle_timers_destroy(tt);
-
-    return true;
-}
-
-static void test_accounting(void)
-{
-    /* tests for bps */
-
-    /* op of size 1 */
-    g_assert(do_test_accounting(false,
-                                1 * 512,
-                                150,
-                                0,
-                                1024,
-                                512,
-                                512));
-
-    /* op of size 2 */
-    g_assert(do_test_accounting(false,
-                                2 * 512,
-                                150,
-                                0,
-                                2048,
-                                1024,
-                                1024));
-
-    /* op of size 2 and orthogonal parameter change */
-    g_assert(do_test_accounting(false,
-                                2 * 512,
-                                150,
-                                17,
-                                2048,
-                                1024,
-                                1024));
-
-
-    /* tests for ops */
-
-    /* op of size 1 */
-    g_assert(do_test_accounting(true,
-                                1 * 512,
-                                150,
-                                0,
-                                2,
-                                1,
-                                1));
-
-    /* op of size 2 */
-    g_assert(do_test_accounting(true,
-                                2 *  512,
-                                150,
-                                0,
-                                2,
-                                1,
-                                1));
-
-    /* jumbo op accounting fragmentation : size 64 with op size of 13 units */
-    g_assert(do_test_accounting(true,
-                                64 * 512,
-                                150,
-                                13 * 512,
-                                (64.0 * 2) / 13,
-                                (64.0 / 13),
-                                (64.0 / 13)));
-
-    /* same with orthogonal parameters changes */
-    g_assert(do_test_accounting(true,
-                                64 * 512,
-                                300,
-                                13 * 512,
-                                (64.0 * 2) / 13,
-                                (64.0 / 13),
-                                (64.0 / 13)));
-}
-
-static void test_groups(void)
-{
-    ThrottleConfig cfg1, cfg2;
-    BlockBackend *blk1, *blk2, *blk3;
-    BlockBackendPublic *blkp1, *blkp2, *blkp3;
-    ThrottleGroupMember *tgm1, *tgm2, *tgm3;
-
-    /* No actual I/O is performed on these devices */
-    blk1 = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
-    blk2 = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
-    blk3 = blk_new(qemu_get_aio_context(), 0, BLK_PERM_ALL);
-
-    blkp1 = blk_get_public(blk1);
-    blkp2 = blk_get_public(blk2);
-    blkp3 = blk_get_public(blk3);
-
-    tgm1 = &blkp1->throttle_group_member;
-    tgm2 = &blkp2->throttle_group_member;
-    tgm3 = &blkp3->throttle_group_member;
-
-    g_assert(tgm1->throttle_state == NULL);
-    g_assert(tgm2->throttle_state == NULL);
-    g_assert(tgm3->throttle_state == NULL);
-
-    throttle_group_register_tgm(tgm1, "bar", blk_get_aio_context(blk1));
-    throttle_group_register_tgm(tgm2, "foo", blk_get_aio_context(blk2));
-    throttle_group_register_tgm(tgm3, "bar", blk_get_aio_context(blk3));
-
-    g_assert(tgm1->throttle_state != NULL);
-    g_assert(tgm2->throttle_state != NULL);
-    g_assert(tgm3->throttle_state != NULL);
-
-    g_assert(!strcmp(throttle_group_get_name(tgm1), "bar"));
-    g_assert(!strcmp(throttle_group_get_name(tgm2), "foo"));
-    g_assert(tgm1->throttle_state == tgm3->throttle_state);
-
-    /* Setting the config of a group member affects the whole group */
-    throttle_config_init(&cfg1);
-    cfg1.buckets[THROTTLE_BPS_READ].avg  = 500000;
-    cfg1.buckets[THROTTLE_BPS_WRITE].avg = 285000;
-    cfg1.buckets[THROTTLE_OPS_READ].avg  = 20000;
-    cfg1.buckets[THROTTLE_OPS_WRITE].avg = 12000;
-    throttle_group_config(tgm1, &cfg1);
-
-    throttle_group_get_config(tgm1, &cfg1);
-    throttle_group_get_config(tgm3, &cfg2);
-    g_assert(!memcmp(&cfg1, &cfg2, sizeof(cfg1)));
-
-    cfg2.buckets[THROTTLE_BPS_READ].avg  = 4547;
-    cfg2.buckets[THROTTLE_BPS_WRITE].avg = 1349;
-    cfg2.buckets[THROTTLE_OPS_READ].avg  = 123;
-    cfg2.buckets[THROTTLE_OPS_WRITE].avg = 86;
-    throttle_group_config(tgm3, &cfg1);
-
-    throttle_group_get_config(tgm1, &cfg1);
-    throttle_group_get_config(tgm3, &cfg2);
-    g_assert(!memcmp(&cfg1, &cfg2, sizeof(cfg1)));
-
-    throttle_group_unregister_tgm(tgm1);
-    throttle_group_unregister_tgm(tgm2);
-    throttle_group_unregister_tgm(tgm3);
-
-    g_assert(tgm1->throttle_state == NULL);
-    g_assert(tgm2->throttle_state == NULL);
-    g_assert(tgm3->throttle_state == NULL);
-}
-
-int main(int argc, char **argv)
-{
-    qemu_init_main_loop(&error_fatal);
-    ctx = qemu_get_aio_context();
-    bdrv_init();
-    module_call_init(MODULE_INIT_QOM);
-
-    do {} while (g_main_context_iteration(NULL, false));
-
-    /* tests in the same order as the header function declarations */
-    g_test_init(&argc, &argv, NULL);
-    g_test_add_func("/throttle/leak_bucket",        test_leak_bucket);
-    g_test_add_func("/throttle/compute_wait",       test_compute_wait);
-    g_test_add_func("/throttle/init",               test_init);
-    g_test_add_func("/throttle/destroy",            test_destroy);
-    g_test_add_func("/throttle/have_timer",         test_have_timer);
-    g_test_add_func("/throttle/detach_attach",      test_detach_attach);
-    g_test_add_func("/throttle/config/enabled",     test_enabled);
-    g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
-    g_test_add_func("/throttle/config/is_valid",    test_is_valid);
-    g_test_add_func("/throttle/config/ranges",      test_ranges);
-    g_test_add_func("/throttle/config/max",         test_max_is_missing_limit);
-    g_test_add_func("/throttle/config/iops_size",
-                    test_iops_size_is_missing_limit);
-    g_test_add_func("/throttle/config_functions",   test_config_functions);
-    g_test_add_func("/throttle/accounting",         test_accounting);
-    g_test_add_func("/throttle/groups",             test_groups);
-    return g_test_run();
-}
-