lsup_rdf/test/test_htable.c

#include "test.h"
#include "htable.h"

#define _CT 8

static inline uint64_t id_hash_fn(const void *key, ksize_t size, uint64_t seed)
{ return *(uint64_t*)key; }

static inline bool buffer_eq_fn(const void *a, const void *b, ksize_t size)
{ return memcmp(a, b, size) == 0; }


static int htable_idx()
{
    LSUP_Key keys[_CT] = {5, 8, 13, 21, 34, 55, 89, 5};

    LSUP_HTable *ht;
    LSUP_htable_new(
            _CT, sizeof(LSUP_Key), sizeof(LSUP_Buffer),
            id_hash_fn, buffer_eq_fn, &ht);

    LSUP_Buffer values[_CT];

    for (int i = 0; i < _CT; i++) {
        char tmp[64];
        sprintf(tmp, "<%lu>", keys[i]);
        LSUP_buffer_init(values + i, strlen(tmp) + 1);
        memcpy((values + i)->addr, tmp, strlen(tmp) + 1);
        printf("Buffer to insert: ");
        LSUP_buffer_print(values + i);

        if (LSUP_htable_put(ht, keys + i, values + i) != LSUP_OK)
            LSUP_buffer_done(values + i);
    }

    EXPECT_INT_EQ(LSUP_htable_size(ht), 7);

    for (int i = 0; i < _CT; i++) {
        LSUP_Buffer* vtmp;
        char ptmp[64];
        LSUP_htable_get(ht, keys + i, (void**)&vtmp);

        printf("Key in get: <%lu>: ", keys[i]);
        LSUP_buffer_print(vtmp);

        sprintf(ptmp, "<%lu>", keys[i]);

        EXPECT_INT_EQ(memcmp(ptmp, vtmp->addr, vtmp->size), 0);
    }

    LSUP_Key *ktmp;
    LSUP_Buffer *vtmp;
    htsize_t cur = 0;

    while(LSUP_htable_iter(ht, &cur, (void**)&ktmp, (void**)&vtmp) == LSUP_OK) {
        printf("Key in iter: <%lu>: ", *ktmp);
        LSUP_buffer_print(vtmp);

        char ptmp[64];
        sprintf(ptmp, "<%lu>", *ktmp);

        EXPECT_INT_EQ(memcmp(ptmp, vtmp->addr, vtmp->size), 0);
    }

    cur = 0;
    while(LSUP_htable_iter(ht, &cur, (void**)&ktmp, (void**)&vtmp) == LSUP_OK) {
        LSUP_buffer_done(vtmp);
    }

    printf("Freeing hash table.\n");
    LSUP_htable_free(ht);

    return 0;
}


static int htable_keys()
{
    LSUP_TripleKey keys[_CT] = {
        {1, 1, 1},
        {2, 1, 1},
        {1, 2, 3},
        {1, 9, 9},
        {5, 6, 7},
        {7, 6, 5},
        {1, 1, 1}, // Duplicate.
        {2, 1, 1}, // Duplicate.
    };

    LSUP_HTable *ht;
    LSUP_htable_new(
            _CT, sizeof(LSUP_TripleKey), sizeof(LSUP_Buffer),
            id_hash_fn, buffer_eq_fn, &ht);

    LSUP_Buffer values[_CT];

    for (int i = 0; i < _CT; i++) {
        char tmp[64];
        sprintf(tmp, "<%lu : %lu : %lu>", keys[i][0], keys[i][1], keys[i][2]);
        LSUP_buffer_init(values + i, strlen(tmp) + 1);
        memcpy((values + i)->addr, tmp, strlen(tmp) + 1);
        TRACE(STR, "Buffer to insert: ");
        LSUP_buffer_print(values + i);

        if (LSUP_htable_put(ht, keys + i, values + i) != LSUP_OK)
            LSUP_buffer_done(values + i);
    }

    EXPECT_INT_EQ(LSUP_htable_size(ht), 6);

    for (int i = 0; i < _CT; i++) {
        LSUP_Buffer* vtmp;
        char ptmp[64];
        LSUP_htable_get(ht, keys[i], (void**)&vtmp);

        printf(
                "Key in get: <%lu : %lu : %lu>: ",
                keys[i][0], keys[i][1], keys[i][2]);
        LSUP_buffer_print(vtmp);

        sprintf(ptmp, "<%lu : %lu : %lu>", keys[i][0], keys[i][1], keys[i][2]);

        EXPECT_INT_EQ(memcmp(ptmp, vtmp->addr, vtmp->size), 0);
    }

    LSUP_TripleKey *ktmp;
    LSUP_Buffer *vtmp;
    htsize_t cur = 0;

    while(LSUP_htable_iter(ht, &cur, (void**)&ktmp, (void**)&vtmp) == LSUP_OK) {
        printf(
                "Key in iter: <%lu : %lu : %lu>: ",
                (*ktmp)[0], (*ktmp)[1], (*ktmp)[2]);
        LSUP_buffer_print(vtmp);

        char ptmp[64];
        sprintf(ptmp, "<%lu : %lu : %lu>", (*ktmp)[0], (*ktmp)[1], (*ktmp)[2]);

        EXPECT_INT_EQ(memcmp(ptmp, vtmp->addr, vtmp->size), 0);
    }

    cur = 0;
    while(LSUP_htable_iter(ht, &cur, (void**)&ktmp, (void**)&vtmp) == LSUP_OK) {
        LSUP_buffer_done(vtmp);
    }

    printf("Freeing hash table.\n");
    LSUP_htable_free(ht);

    return 0;
}


int htable_tests()
{
    RUN(htable_idx);
    RUN(htable_keys);

    return 0;
}