path: root/infra/test/TestVNode.cc

#include <gtest/gtest.h>
#include <thread>

extern "C"
{
#include <rte_ring.h>
#include <rte_mempool.h>
#include <rte_mbuf.h>
#include <vnode.h>
}

unsigned int g_logger_to_stdout = 1;
unsigned int g_logger_level = LOG_DEBUG;

class TestCaseVNode : public ::testing::Test
{
  protected:
    static struct rte_mempool * pktmbuf_pool_;
    static void SetUpTestCase()
    {
        pktmbuf_pool_ = ::rte_pktmbuf_pool_create("test_pktmbuf_pool", 8192, 0, 0, RTE_PKTMBUF_HEADROOM, 0);
        EXPECT_NE(pktmbuf_pool_, nullptr);
        EXPECT_EQ(rte_mempool_avail_count(pktmbuf_pool_), 8192);
    }

    static void TearDownTestCase()
    {
        EXPECT_EQ(rte_mempool_avail_count(pktmbuf_pool_), 8192);
        ::rte_mempool_free(pktmbuf_pool_);
    }
};

class TestCaseVNodeQueue : public TestCaseVNode
{
  protected:
    struct vnode * vnode_{nullptr};
    struct vnode_prod * prod_{nullptr};
    struct vnode_cons * cons_{nullptr};

    void SetUp() override
    {
        vnode_ = vnode_mirror_create("m-vnode", 1024, 0, 32, 0, 0);
        ASSERT_NE(vnode_, nullptr);

        assert(prod_ == nullptr);
        assert(cons_ == nullptr);
    }

    void TearDown() override
    {
        int ret = 0;
        if (prod_ != nullptr)
        {
            ret = vnode_mirror_delete_prod(prod_);
            EXPECT_EQ(ret, 0);
        }

        if (cons_ != nullptr)
        {
            ret = vnode_mirror_delete_cons(cons_);
            EXPECT_EQ(ret, 0);
        }

        if (vnode_ != nullptr)
        {
            ret = vnode_mirror_delete(vnode_);
            EXPECT_EQ(ret, 0);
        }
    }

    void VNodeProdAndConsCreateHelper(int nr_prodq, int nr_consq)
    {
        prod_ = vnode_mirror_create_prod(vnode_, "prod", nr_prodq);
        ASSERT_NE(prod_, nullptr);

        cons_ = vnode_mirror_create_cons(vnode_, "cons", nr_consq);
        ASSERT_NE(cons_, nullptr);
    }
};

struct rte_mempool * TestCaseVNode::pktmbuf_pool_ = nullptr;

TEST_F(TestCaseVNode, CreateAndDeleteInEmptyNode)
{
    struct vnode * vnode_ptr = vnode_mirror_create("m-vnode", 1024, 0, 32, 0, 0);
    EXPECT_NE(vnode_ptr, nullptr);

    int ret = vnode_mirror_delete(vnode_ptr);
    EXPECT_EQ(ret, 0);
}

TEST_F(TestCaseVNode, CreateAndDelete)
{
    struct vnode * vnode_ptr = vnode_mirror_create("m-vnode", 1024, 0, 32, 0, 0);
    ASSERT_NE(vnode_ptr, nullptr);

    struct vnode_prod * prod;
    struct vnode_cons * cons;

    prod = vnode_mirror_create_prod(vnode_ptr, "prod", 1);
    ASSERT_NE(prod, nullptr);

    cons = vnode_mirror_create_cons(vnode_ptr, "cons", 1);
    ASSERT_NE(cons, nullptr);

    int ret = vnode_mirror_delete(vnode_ptr);
    EXPECT_EQ(ret, 0);
}

TEST_F(TestCaseVNode, CreateAndDeleteMultiThread)
{
    struct vnode * vnode_ptr = vnode_mirror_create("m-vnode", 1024, 0, 32, 0, 0);
    ASSERT_NE(vnode_ptr, nullptr);

    /* create multiple thread and run them at same time */
    struct vnode_prod * prod;
    struct vnode_cons * cons;

    std::thread test_prod_create_thread([vnode_ptr, &prod] {
        prod = vnode_mirror_create_prod(vnode_ptr, "prod", 1);
        ASSERT_NE(prod, nullptr);
    });

    std::thread test_cons_create_thread([vnode_ptr, &cons] {
        cons = vnode_mirror_create_cons(vnode_ptr, "prod", 1);
        ASSERT_NE(cons, nullptr);
    });

    test_prod_create_thread.join();
    test_cons_create_thread.join();

    std::thread test_delete_thread([prod, cons] {
        vnode_mirror_delete_prod(prod);
        vnode_mirror_delete_cons(cons);
    });

    test_delete_thread.join();
    int ret = vnode_mirror_delete(vnode_ptr);
    EXPECT_EQ(ret, 0);
}

TEST_F(TestCaseVNode, TestVNodeProdAndConsLookup)
{
    struct vnode * vnode_ptr = vnode_mirror_create("m-vnode", 1024, 0, 32, 0, 0);
    ASSERT_NE(vnode_ptr, nullptr);

    struct vnode_prod * prod;
    struct vnode_cons * cons;

    prod = vnode_mirror_create_prod(vnode_ptr, "prod", 1);
    ASSERT_NE(prod, nullptr);

    cons = vnode_mirror_create_cons(vnode_ptr, "cons", 1);
    ASSERT_NE(cons, nullptr);

    struct vnode_prod * prod_lookup = vnode_mirror_prod_lookup(vnode_ptr, "prod");
    EXPECT_EQ(prod, prod_lookup);

    struct vnode_cons * cons_lookup = vnode_mirror_cons_lookup(vnode_ptr, "cons");
    EXPECT_EQ(cons, cons_lookup);

    vnode_mirror_delete(vnode_ptr);
}

TEST_F(TestCaseVNode, TestVNodeEnqueue)
{
    struct vnode * vnode_ptr = vnode_mirror_create("m-vnode", 1024, 0, 32, 0, 0);
    ASSERT_NE(vnode_ptr, nullptr);

    struct vnode_prod * prod;
    struct vnode_cons * cons;

    prod = vnode_mirror_create_prod(vnode_ptr, "prod", 1);
    ASSERT_NE(prod, nullptr);

    cons = vnode_mirror_create_cons(vnode_ptr, "cons", 1);
    ASSERT_NE(cons, nullptr);

#define TEST_COUNT 32
    struct rte_mbuf * enq_objs[TEST_COUNT] = {};
    struct rte_mbuf * deq_objs[TEST_COUNT] = {};

    int ret = rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs, RTE_DIM(enq_objs));
    ASSERT_EQ(ret, 0);

    for (unsigned int i = 0; i < RTE_DIM(enq_objs); i++)
    {
        enq_objs[i]->hash.usr = 0x4d5a;
    }

    uint32_t enq_hashs[TEST_COUNT] = {};
    for (unsigned int i = 0; i < RTE_DIM(enq_hashs); i++)
    {
        enq_hashs[i] = 0x4d5a;
    }

    int enq_ret = vnode_mirror_enqueue_bulk(prod, 0, enq_objs, enq_hashs, RTE_DIM(enq_hashs));
    EXPECT_EQ(enq_ret, 0);

    int deq_ret = vnode_mirror_dequeue_burst(cons, 0, deq_objs, RTE_DIM(deq_objs));
    EXPECT_EQ(deq_ret, 32);

    for (unsigned int i = 0; i < RTE_DIM(deq_objs); i++)
    {
        EXPECT_EQ(enq_objs[i], deq_objs[i]);
    }

    rte_pktmbuf_free_bulk(deq_objs, deq_ret);
    vnode_mirror_delete(vnode_ptr);
}

TEST_F(TestCaseVNode, TestVNodeMultipleThreadEnqueueUseSharedCredict)
{
    /* create multiple thread */
    struct vnode * vnode_ptr = vnode_mirror_create("m-vnode", 32, 2048, 32, 0, 0);
    ASSERT_NE(vnode_ptr, nullptr);

    struct vnode_prod * prod;
    struct vnode_cons * cons;

    prod = vnode_mirror_create_prod(vnode_ptr, "prod", 4);
    ASSERT_NE(prod, nullptr);

    cons = vnode_mirror_create_cons(vnode_ptr, "cons", 1);
    ASSERT_NE(cons, nullptr);

    constexpr unsigned int TEST_MBUFS_COUNT = 2048;
    struct rte_mbuf * enq_objs[TEST_MBUFS_COUNT] = {};

    int ret = rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs, RTE_DIM(enq_objs));
    ASSERT_EQ(ret, 0);

    uint32_t enq_hashs[TEST_MBUFS_COUNT] = {};
    for (unsigned int i = 0; i < RTE_DIM(enq_hashs); i++)
    {
        enq_hashs[i] = 0x4d5a;
    }

    std::thread test_thread_1([&prod, &enq_objs, &enq_hashs] {
        int enq_ret = vnode_mirror_enqueue_bulk(prod, 0, enq_objs, enq_hashs, 512);
        EXPECT_EQ(enq_ret, 0);
    });

    std::thread test_thread_2([&prod, &enq_objs, &enq_hashs] {
        int enq_ret = vnode_mirror_enqueue_bulk(prod, 1, enq_objs + 512, enq_hashs, 512);
        EXPECT_EQ(enq_ret, 0);
    });

    std::thread test_thread_3([&prod, &enq_objs, &enq_hashs] {
        int enq_ret = vnode_mirror_enqueue_bulk(prod, 2, enq_objs + 1024, enq_hashs, 512);
        EXPECT_EQ(enq_ret, 0);
    });

    std::thread test_thread_4([&prod, &enq_objs, &enq_hashs] {
        int enq_ret = vnode_mirror_enqueue_bulk(prod, 3, enq_objs + 1536, enq_hashs, 512);
        EXPECT_EQ(enq_ret, 0);
    });

    test_thread_1.join();
    test_thread_2.join();
    test_thread_3.join();
    test_thread_4.join();

    unsigned int prod_on_line_total = 0;
    unsigned int prod_deliver_total = 0;
    unsigned int prod_missed_total = 0;

    /* verify the stats */
    struct vnode_prod_stat * prod_stat = vnode_mirror_prod_stat_get(prod);
    for (unsigned int i = 0; i < 4; i++)
    {
        prod_on_line_total += prod_stat[i].on_line;
        prod_deliver_total += prod_stat[i].deliver;
        prod_missed_total += prod_stat[i].missed;
    }

    EXPECT_EQ(prod_on_line_total, 2048);
    EXPECT_EQ(prod_deliver_total, 2048);
    EXPECT_EQ(prod_missed_total, 0);

    /* on cons side */
    struct vnode_cons_stat * cons_stat = vnode_mirror_cons_stat_get(cons);
    EXPECT_EQ(cons_stat[0].on_line, 2048);
    EXPECT_EQ(cons_stat[0].deliver, 2048);
    EXPECT_EQ(cons_stat[0].missed, 0);

    int deq_ret = vnode_mirror_dequeue_burst(cons, 0, enq_objs, RTE_DIM(enq_objs));
    EXPECT_EQ(deq_ret, 2048);

    rte_pktmbuf_free_bulk(enq_objs, deq_ret);
    vnode_mirror_delete(vnode_ptr);
}

TEST_F(TestCaseVNode, TestVNodeEnqueueAndDequeueUseSharedCredict)
{
    struct vnode * vnode_ptr = vnode_mirror_create("m-vnode", 32, 512, 32, 0, 0);
    ASSERT_NE(vnode_ptr, nullptr);

    struct vnode_prod * prod;
    struct vnode_cons * cons;

    prod = vnode_mirror_create_prod(vnode_ptr, "prod", 1);
    ASSERT_NE(prod, nullptr);

    cons = vnode_mirror_create_cons(vnode_ptr, "cons", 1);
    ASSERT_NE(cons, nullptr);

    constexpr unsigned int TEST_MBUFS_COUNT = 2048;
    struct rte_mbuf * enq_objs[TEST_MBUFS_COUNT] = {};
    struct rte_mbuf * deq_objs[TEST_MBUFS_COUNT] = {};

    int ret = rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs, RTE_DIM(enq_objs));
    ASSERT_EQ(ret, 0);

    uint32_t enq_hashs[TEST_MBUFS_COUNT] = {};

    for (unsigned int i = 0; i < RTE_DIM(enq_hashs); i++)
    {
        enq_hashs[i] = 0x4d5a;
    }

    /* first 512 mbufs, use the exclusive credit */
    int enq_ret = vnode_mirror_enqueue_bulk(prod, 0, enq_objs, enq_hashs, 512);
    EXPECT_EQ(enq_ret, 0);

    /* second 512 mbufs, use the shared credict */
    int enq_ret_2 = vnode_mirror_enqueue_bulk(prod, 0, enq_objs + 512, enq_hashs, 512);
    EXPECT_EQ(enq_ret_2, 0);

    /* until here, we have 512 + 32 credict, so only 544 mbufs can be enqueue. */
    int deq_ret_1 = vnode_mirror_dequeue_burst(cons, 0, deq_objs, RTE_DIM(deq_objs));
    EXPECT_EQ(deq_ret_1, 544);

    struct vnode_prod_stat * prod_stat = vnode_mirror_prod_stat_get(prod);
    EXPECT_EQ(prod_stat->on_line, 1024);
    EXPECT_EQ(prod_stat->deliver, 544);
    EXPECT_EQ(prod_stat->missed, 480);

    struct vnode_cons_stat * cons_stat = vnode_mirror_cons_stat_get(cons);
    EXPECT_EQ(cons_stat->on_line, 1024);
    EXPECT_EQ(cons_stat->deliver, 544);
    EXPECT_EQ(cons_stat->missed, 480);

    /* free these mbufs */
    rte_pktmbuf_free_bulk(deq_objs, deq_ret_1);

    /* put another 512 mbufs */
    int enq_ret_3 = vnode_mirror_enqueue_bulk(prod, 0, enq_objs + 1024, enq_hashs, 512);
    EXPECT_EQ(enq_ret_3, 0);

    int enq_ret_4 = vnode_mirror_enqueue_bulk(prod, 0, enq_objs + 1536, enq_hashs, 512);
    EXPECT_EQ(enq_ret_4, 0);

    int deq_ret_2 = vnode_mirror_dequeue_burst(cons, 0, deq_objs, RTE_DIM(deq_objs));
    EXPECT_EQ(deq_ret_2, 544);

    /* another round, the stat should be double */
    EXPECT_EQ(prod_stat->on_line, 2048);
    EXPECT_EQ(prod_stat->deliver, 1088);
    EXPECT_EQ(prod_stat->missed, 960);

    EXPECT_EQ(cons_stat->on_line, 2048);
    EXPECT_EQ(cons_stat->deliver, 1088);
    EXPECT_EQ(cons_stat->missed, 960);

    rte_pktmbuf_free_bulk(deq_objs, deq_ret_2);
    vnode_mirror_delete(vnode_ptr);
}

TEST_F(TestCaseVNode, TestVNodeMultipleQueueUseSharedCredict)
{
    struct vnode * vnode_ptr = vnode_mirror_create("m-vnode", 32, 512, 32, 0, 0);
    ASSERT_NE(vnode_ptr, nullptr);

    struct vnode_prod * prod;
    struct vnode_cons * cons;

    prod = vnode_mirror_create_prod(vnode_ptr, "prod", 2);
    ASSERT_NE(prod, nullptr);

    cons = vnode_mirror_create_cons(vnode_ptr, "cons", 1);
    ASSERT_NE(cons, nullptr);

    /* queue 1 */
    struct rte_mbuf * enq_objs_q1_exclusive[32] = {};
    struct rte_mbuf * enq_objs_q1_shared[32] = {};

    /* queue 2 */
    struct rte_mbuf * enq_objs_q2_exclusive[32] = {};
    struct rte_mbuf * enq_objs_q2_shared[32] = {};

    /* alloc mbufs */
    int ret = rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs_q1_exclusive, RTE_DIM(enq_objs_q1_exclusive));
    ASSERT_EQ(ret, 0);

    ret = rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs_q1_shared, RTE_DIM(enq_objs_q1_shared));
    ASSERT_EQ(ret, 0);

    ret = rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs_q2_exclusive, RTE_DIM(enq_objs_q2_exclusive));
    ASSERT_EQ(ret, 0);

    ret = rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs_q2_shared, RTE_DIM(enq_objs_q2_shared));
    ASSERT_EQ(ret, 0);

    /* enqueue */
    uint32_t enq_hashs[32] = {};
    for (unsigned int i = 0; i < RTE_DIM(enq_hashs); i++)
    {
        enq_hashs[i] = 0x4d5a;
    }

    /* first 32 mbufs, use the exclusive credit */
    int enq_ret = vnode_mirror_enqueue_bulk(prod, 0, enq_objs_q1_exclusive, enq_hashs, 32);
    EXPECT_EQ(enq_ret, 0);

    /* second 32 mbufs, use the shared credict */
    int enq_ret_2 = vnode_mirror_enqueue_bulk(prod, 0, enq_objs_q1_shared, enq_hashs, 32);
    EXPECT_EQ(enq_ret_2, 0);

    /* third 32 mbufs, use the exclusive credit */
    int enq_ret_3 = vnode_mirror_enqueue_bulk(prod, 1, enq_objs_q2_exclusive, enq_hashs, 32);
    EXPECT_EQ(enq_ret_3, 0);

    /* fourth 32 mbufs, use the shared credict */
    int enq_ret_4 = vnode_mirror_enqueue_bulk(prod, 1, enq_objs_q2_shared, enq_hashs, 32);
    EXPECT_EQ(enq_ret_4, 0);

    /* dequeue */
    struct rte_mbuf * deq_objs[128] = {};
    int deq_ret = vnode_mirror_dequeue_burst(cons, 0, deq_objs, RTE_DIM(deq_objs));
    EXPECT_EQ(deq_ret, 128);

    rte_pktmbuf_free_bulk(deq_objs, deq_ret);
    vnode_mirror_delete(vnode_ptr);
}

TEST_F(TestCaseVNode, TestVNodeEnqueueUseSharedCredict)
{
    struct vnode * vnode_ptr = vnode_mirror_create("m-vnode", 512, 512, 32, 0, 0);
    ASSERT_NE(vnode_ptr, nullptr);

    struct vnode_prod * prod;
    struct vnode_cons * cons;

    prod = vnode_mirror_create_prod(vnode_ptr, "prod", 1);
    ASSERT_NE(prod, nullptr);

    cons = vnode_mirror_create_cons(vnode_ptr, "cons", 1);
    ASSERT_NE(cons, nullptr);

    constexpr unsigned int TEST_MBUFS_COUNT = 2048;
    struct rte_mbuf * enq_objs[TEST_MBUFS_COUNT] = {};
    struct rte_mbuf * deq_objs[TEST_MBUFS_COUNT] = {};

    int ret = rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs, RTE_DIM(enq_objs));
    ASSERT_EQ(ret, 0);

    for (unsigned int i = 0; i < RTE_DIM(enq_objs); i++)
    {
        enq_objs[i]->hash.usr = 0x4d5a;
    }

    uint32_t enq_hashs[TEST_MBUFS_COUNT] = {};
    for (unsigned int i = 0; i < RTE_DIM(enq_hashs); i++)
    {
        enq_hashs[i] = 0x4d5a;
    }

    /* first 512 mbufs, use the exclusive credit */
    int enq_ret = vnode_mirror_enqueue_bulk(prod, 0, enq_objs, enq_hashs, 512);
    EXPECT_EQ(enq_ret, 0);

    /* second 512 mbufs, use the shared credict */
    int enq_ret_2 = vnode_mirror_enqueue_bulk(prod, 0, enq_objs + 512, enq_hashs, 512);
    EXPECT_EQ(enq_ret_2, 0);

    /* third 512 mbufs should be rejected */
    int enq_ret_3 = vnode_mirror_enqueue_bulk(prod, 0, enq_objs + 1024, enq_hashs, 512);
    EXPECT_EQ(enq_ret_3, 0);

    int enq_ret_4 = vnode_mirror_enqueue_bulk(prod, 0, enq_objs + 1536, enq_hashs, 512);
    EXPECT_EQ(enq_ret_4, 0);

    int deq_ret = vnode_mirror_dequeue_burst(cons, 0, deq_objs, RTE_DIM(deq_objs));
    EXPECT_EQ(deq_ret, 1024);

    rte_pktmbuf_free_bulk(deq_objs, deq_ret);
    vnode_mirror_delete(vnode_ptr);
}

TEST_F(TestCaseVNodeQueue, MultQueueEnqueue)
{
    struct vnode * vnode_ptr = vnode_mirror_create("vnode", 1024, 0, 32, 0, 0);
    ASSERT_NE(vnode_ptr, nullptr);

    struct vnode_prod * prod;
    struct vnode_cons * cons;

    prod = vnode_mirror_create_prod(vnode_ptr, "prod", 8);
    ASSERT_NE(prod, nullptr);

    cons = vnode_mirror_create_cons(vnode_ptr, "cons", 1);
    ASSERT_NE(cons, nullptr);

#define TEST_COUNT 32
    struct rte_mbuf * enq_objs[TEST_COUNT] = {};
    struct rte_mbuf * deq_objs[TEST_COUNT] = {};

    int ret = rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs, RTE_DIM(enq_objs));
    ASSERT_EQ(ret, 0);

    for (unsigned int i = 0; i < RTE_DIM(enq_objs); i++)
    {
        enq_objs[i]->hash.usr = 0x4d5a;
    }

    uint32_t enq_hashs[TEST_COUNT] = {};
    for (unsigned int i = 0; i < RTE_DIM(enq_hashs); i++)
    {
        enq_hashs[i] = 0x4d5a;
    }

    for (unsigned int i = 0; i < RTE_DIM(enq_hashs); i++)
    {
        int enq_ret = vnode_mirror_enqueue_bulk(prod, i % 8, &enq_objs[i], &enq_hashs[i], 1);
        EXPECT_EQ(enq_ret, 0);
    }

    for(unsigned int i = 0; i < 8; i++)
    {
        vnode_mirror_flush(prod, i);
    }

    int deq_ret = vnode_mirror_dequeue_burst(cons, 0, deq_objs, RTE_DIM(deq_objs));
    EXPECT_EQ(deq_ret, 32);

    /* convert the array enq_objs and deq_objs to set, and compare them */
    std::set<struct rte_mbuf *> enq_objs_set = std::set<struct rte_mbuf *>(std::begin(enq_objs), std::end(enq_objs));
    std::set<struct rte_mbuf *> deq_objs_set = std::set<struct rte_mbuf *>(std::begin(deq_objs), std::end(deq_objs));
    EXPECT_EQ(enq_objs_set, deq_objs_set);

    rte_pktmbuf_free_bulk(deq_objs, deq_ret);
    vnode_mirror_delete(vnode_ptr);
}

TEST_F(TestCaseVNodeQueue, MultiQueueDequeue)
{
    VNodeProdAndConsCreateHelper(1, 4);

    std::vector<struct rte_mbuf *> enq_objs(4);
    rte_pktmbuf_alloc_bulk(pktmbuf_pool_, enq_objs.data(), enq_objs.size());

    std::vector<uint32_t> enq_hash_values = {0x0, 0x1, 0x2, 0x3};
    vnode_mirror_enqueue_bulk(prod_, 0, enq_objs.data(), enq_hash_values.data(), (int)enq_objs.size());

    /* flush the node because too few packet in one queue */
    vnode_mirror_flush(prod_, 0);

    for (unsigned int qid = 0; qid < 4; qid++)
    {
        std::vector<struct rte_mbuf *> deq_objs(1);
        int deq_ret = vnode_mirror_dequeue_burst(cons_, qid, deq_objs.data(), (int)deq_objs.size());
        EXPECT_EQ(deq_ret, 1);

        EXPECT_EQ(enq_objs[qid], deq_objs[0]);
        rte_pktmbuf_free_bulk(deq_objs.data(), deq_objs.size());
    }
}

int main(int argc, char * argv[])
{
    /* generate eal parameters */
    const char * eal_args[] = {"unittest", "-c", "0x1", "-n", "4", "--proc-type", "auto", "--no-huge", "-m", "2048"};
    if (rte_eal_init(RTE_DIM(eal_args), (char **)eal_args) < 0)
    {
        return -1;
    }

    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}