main.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "mpdb.h"
#include <time.h>

#define assert(r)                                                                        \
    if (r)                                                                               \
    {                                                                                    \
        printf("\033[01;32m[%s] test OK!\033[00m\n", __FUNCTION__);                      \
    }                                                                                    \
    else                                                                                 \
    {                                                                                    \
        printf("\033[01;31m[%s:%d]%s test fail!\033[00m\n", __FUNCTION__, __LINE__, #r); \
    }

const u32 BLOCK_NUM = (32);
#define BLOCK_SIZE 4096

static Mpdb mpdb;
const char *file_path = "./db.bin";

static char buffer[BLOCK_SIZE];

FILE *f;
FILE *f_export;

int get_index = 0;

MpdbErr Mpdb_read_port(u32 addr, u8 *data, u32 data_size)
{
    if (f == NULL)
    {
        return MpdbErr_ERROR;
    }
    fseek(f, addr, SEEK_SET);
    fread(data, sizeof(u8), data_size, f);
    return MpdbErr_OK;
}

MpdbErr Mpdb_write_port(u32 addr, u8 *data, u32 data_size)
{
    if (f == NULL)
    {
        return MpdbErr_ERROR;
    }
    fseek(f, addr, SEEK_SET);
    fwrite(data, sizeof(u8), data_size, f);
    return MpdbErr_OK;
}

MpdbErr Mpdb_erase_port(u32 addr, u32 data_size)
{
    if (f == NULL)
    {
        return MpdbErr_ERROR;
    }
    memset(buffer, 0xFF, data_size);
    fseek(f, addr, SEEK_SET);
    fwrite(buffer, sizeof(u8), data_size, f);
    return MpdbErr_OK;
}

u32 Mpdb_capacity_port()
{
    return BLOCK_NUM * BLOCK_SIZE;
}

MpdbErr Mpdb_erase_all_port()
{
    fseek(f, 0, SEEK_SET);
    for (int i = 0; i < BLOCK_NUM; i++)
    {
        memset(buffer, 0xFF, BLOCK_SIZE);
        fwrite(buffer, sizeof(u8), BLOCK_SIZE, f);
    }
    return MpdbErr_OK;
}

MpdbErr Mpdb_export_open_port()
{
    f_export = fopen("./export.db", "wb");
    if (f_export == NULL)
    {
        return MpdbErr_ERROR;
    }
    else
    {
        return MpdbErr_OK;
    }
}

MpdbErr Mpdb_export_write_port(u32 addr, u8 *data, u32 data_size)
{
    fwrite(data, 1, data_size, f_export);
    return MpdbErr_OK;
}

void Mpdb_export_close_port()
{
    fclose(f_export);
}

void printf_run_time(clock_t s, clock_t e, char *func)
{
    double cpu_time_used = ((double)(e - s)) / CLOCKS_PER_SEC;
    printf("[%s]CPU time: %.3f ms\n", func, cpu_time_used * 1000);
}

struct data_struct
{
    char name[8];
    u32 index;
    u32 date;
    char location[16];
    u64 reserved[10];
};

void init_test()
{
    // const MpdbQueryMode query_mode = MpdbQueryMode_NORMAL;
    const MpdbQueryMode query_mode = MpdbQueryMode_FAST;
    Mpdb *mpdb_p = &mpdb;
    MpdbErr ret = Mpdb_init(mpdb_p, query_mode);
    if (ret != MpdbErr_OK)
    {
        assert(ret == MpdbErr_OK);
        Mpdb_reset(mpdb_p, sizeof(struct data_struct));
        ret = Mpdb_init(mpdb_p, query_mode);
    }
    assert(ret == MpdbErr_OK);
}

void add_test()
{
    Mpdb *mpdb_p = &mpdb;
    struct data_struct data = {
        .name = "hello",
        .date = clock(),
        .location = "tianjin"};
    MpdbErr ret;
    u32 index = Mpdb_count(mpdb_p);
    for (int i = 0; i < 1000; i++)
    {
        // printf("[%d/%d]add data\n", i, 100);
        data.index = index + i;
        ret = Mpdb_add(mpdb_p, &data);
    }
    assert(ret == MpdbErr_OK);
}

void get_capacity()
{
    Mpdb *mpdb_p = &mpdb;
    printf("db data capacity=%d\n", Mpdb_capacity(mpdb_p));
    printf("db data length=%d\n", Mpdb_count(mpdb_p));
}

void get_test()
{
    Mpdb *mpdb_p = &mpdb;
    MpdbItarContext context;
    struct data_struct data;
    // const u32 index = get_index;
    const u32 index = 0;
    for (int i = 0; i < 200; i++)
    {
        MpdbErr ret = Mpdb_positioning(mpdb_p, index + i, &context);
        if (ret == MpdbErr_OK)
        {
            MpdbErr ret = Mpdb_get(mpdb_p, &context, &data);
            printf("data.index=%d\n", data.index);
        }
        assert(ret == MpdbErr_OK);
    }

}

#define SLICE_BUFFER_SIZE 200
void get_slice_test()
{
    Mpdb *mpdb_p = &mpdb;
    MpdbItarContext context;
    struct data_struct data;
    const u32 index = 0;
    MpdbErr ret = Mpdb_positioning(mpdb_p, index, &context);
    if (ret == MpdbErr_OK)
    {
        for (int i = 0; i < SLICE_BUFFER_SIZE; i++)
        {
            MpdbErr ret = Mpdb_get(mpdb_p, &context, &data);
            printf("[%d|%d]data.index=%d\n", i, index + i, data.index);
            // if(ret != MpdbErr_OK){
            //     break;
            // }
        }
    }
}

void delete_test()
{
    Mpdb *mpdb_p = &mpdb;
    const u32 index = 30;
    for (int i = 0; i < 3; i++)
    {
        MpdbErr ret = Mpdb_delete(mpdb_p, index);
        assert(ret == MpdbErr_OK);
    }
}

void reset_test()
{
    Mpdb *mpdb_p = &mpdb;
    MpdbErr ret = Mpdb_reset(mpdb_p, sizeof(struct data_struct));
    assert(ret == MpdbErr_OK);
}

#define TEST_TIME_INIT clock_t start, end
#define TEST_TIME_FUNC(fn) \
    start = clock();       \
    fn();                  \
    end = clock();         \
    printf_run_time(start, end, #fn)

int main(int argc, char **argv)
{
    f = fopen(file_path, "rwb+");

    if (argc >= 2)
    {
        get_index = atoi(argv[1]);
    }
    else
    {
        get_index = 1000;
    }

    TEST_TIME_INIT;

    // TEST_TIME_FUNC(reset_test);

    TEST_TIME_FUNC(init_test);

    // TEST_TIME_FUNC(add_test);

    // TEST_TIME_FUNC(delete_test);

    TEST_TIME_FUNC(get_capacity);

    // TEST_TIME_FUNC(get_test);

    TEST_TIME_FUNC(get_slice_test);

    // Mpdb_export(&mpdb);

    fclose(f);

    return 0;
}