wrt/tests/dl.cpp

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

extern "C" {
#include "utils/defs.h"
#include "wrt/lib/dl.h"
#include "wasm_exec_env.h"
}

DLContext   dl_context;
WASMExecEnv exec_env;

void init() {
    dl_context.mem.malloc = malloc;
    dl_context.mem.free   = free;
    dl_init(&dl_context);
    exec_env.attachment = &dl_context;
}

TEST(DLTest, InitAndFree) {
    // use valgrind !
    auto *context = (DLContext *)malloc(sizeof(DLContext));
    ASSERT_NE(context, nullptr);
    context->mem.malloc = malloc;
    context->mem.free   = free;
    dl_init(context);

    EXPECT_NE(context->symTable, nullptr);
    for (auto &hnd : context->hnd) {
        EXPECT_EQ(hnd.handle, nullptr);
    }
    for (auto &sym : context->sym) {
        EXPECT_EQ(sym.symbol, nullptr);
        EXPECT_EQ(sym.cif, nullptr);
        EXPECT_EQ(sym.backref, 0);
    }

    dl_free(context);
    free(context);
}

TEST(DLTest, OpenAndClose) {
    init();

    int handle = dl_open(&exec_env, "./SimpleLib.so", RTLD_LAZY);
    ASSERT_GT(handle, 0);
    int result = dl_close(&exec_env, handle);
    EXPECT_EQ(result, WRT_OK);

    handle = dl_open(&exec_env, "not_exists", RTLD_LAZY);
    EXPECT_EQ(handle, WRT_ERROR);

    handle = dl_open(&exec_env, "", RTLD_LAZY);
    EXPECT_EQ(handle, WRT_ERROR);

    handle = dl_open(&exec_env, nullptr, RTLD_LAZY);
    EXPECT_EQ(handle, WRT_ERROR);

    dl_free(&dl_context);
}

TEST(DLTest, ManyOpen) {
    init();

    int handles[DL_MAX_HANDLES];
    for (int &handle : handles) {
        handle = dl_open(&exec_env, "./SimpleLib.so", RTLD_LAZY);
        ASSERT_GT(handle, 0);
    }

    {
        int handle = dl_open(&exec_env, "./SimpleLib.so", RTLD_LAZY);
        EXPECT_EQ(handle, WRT_ERROR);
    }

    for (int handle : handles) {
        int result = dl_close(&exec_env, handle);
        EXPECT_EQ(result, WRT_OK);
    }

    for (int i = 0; i < DL_MAX_HANDLES; i++) {
        EXPECT_EQ(dl_context.hnd->handle, nullptr);
    }

    dl_free(&dl_context);
}

TEST(DLTest, GetCloseSym) {
    init();

    int hnd = dl_open(&exec_env, "./SimpleLib.so", RTLD_LAZY);
    ASSERT_EQ(hnd, 1);

    int sym;

    sym = dl_sym(&exec_env, hnd, "fib_fast", "(i)i");
    EXPECT_EQ(sym, 1);
    EXPECT_NE(dl_context.sym[0].symbol, nullptr);
    EXPECT_NE(dl_context.sym[0].cif, nullptr);
    EXPECT_EQ(dl_context.sym[0].cif->nargs, 1);
    EXPECT_EQ(dl_context.sym[0].cif->rtype, &ffi_type_sint);
    EXPECT_EQ(dl_context.sym[0].cif->arg_types[0], &ffi_type_sint);
    EXPECT_EQ(dl_context.sym[0].backref, 1);

    sym = dl_sym(&exec_env, hnd, "fib_fast", "(v)i");
    EXPECT_EQ(sym, WRT_ERROR);

    dl_close_sym(&exec_env, 1);
    EXPECT_EQ(dl_context.sym[0].symbol, nullptr);
    EXPECT_EQ(dl_context.sym[0].cif, nullptr);
    EXPECT_EQ(dl_context.sym[0].backref, 0);

    dl_free(&dl_context);
}

TEST(DLTest, SignatureCheck) {
    typedef struct {
        const char *test;
        bool        result;
        int         arg_count;
        bool        has_ret;
    } Case;

    const static Case cases[] = {
        {"", false, 0, false},           {"()", true, 0, false},    {"(i)", true, 1, false},
        {"()i", true, 0, true},          {"(x)", false, 0, false},  {"()x", false, 0, false},
        {"(i)f", true, 1, true},         {"(i)x", false, 0, false}, {"(x)f", false, 0, false},
        {"i", false, 0, false},          {"i()", false, 0, false},  {"i(i)", false, 0, false},
        {"(i)()", false, 0, false},      {"(ii", false, 0, false},  {"(iiffdd)l", true, 6, true},
        {"(ffddii)ll", false, 0, false}, {"()ii", false, 0, false}, {"(i", false, 0, false},
        {"(i(i))i", false, 0, false},    {"i)i", false, 0, false},  {"((i)i", false, 0, false},
        {"(i))i", false, 0, false},      {"())", false, 0, false}};

    init();
    int hnd = dl_open(&exec_env, "./SimpleLib.so", RTLD_LAZY);
    ASSERT_EQ(hnd, 1);

    for (const auto &cur_case : cases) {
        int sym = dl_sym(&exec_env, hnd, "fib_fast", cur_case.test);
        if (cur_case.result) {
            EXPECT_EQ(sym, 1);

            EXPECT_NE(dl_context.sym[0].symbol, nullptr);
            EXPECT_NE(dl_context.sym[0].cif, nullptr);
            EXPECT_EQ(dl_context.sym[0].cif->nargs, cur_case.arg_count);
            if (cur_case.has_ret) {
                EXPECT_NE(dl_context.sym[0].cif->rtype, &ffi_type_void);
                EXPECT_NE(dl_context.sym[0].cif->rtype, nullptr);
            } else {
                EXPECT_EQ(dl_context.sym[0].cif->rtype, &ffi_type_void);
            }

            dl_close_sym(&exec_env, 1);
            EXPECT_EQ(dl_context.sym[0].symbol, nullptr);
            EXPECT_EQ(dl_context.sym[0].cif, nullptr);
            EXPECT_EQ(dl_context.sym[0].backref, 0);
        } else {
            EXPECT_EQ(sym, WRT_ERROR);
        }
    }

    dl_free(&dl_context);
}