basic_kvs_test.c

/*
 * Basic key value store in C but with separated tests.
 * only runs on 1 thread. 
 * */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

#define NUM_BUCKETS 1024
#define VALUE_SIZE 32

typedef struct Entry {
    size_t key;
    char value[VALUE_SIZE];
    struct Entry* next;
} Entry;

typedef struct {
    Entry* buckets[NUM_BUCKETS];
    pthread_mutex_t locks[NUM_BUCKETS];
} KVStore;

// Simple hash function
size_t hash(size_t key) {
    return key % NUM_BUCKETS;
}

// ---------------- KV Store Functions ---------------- //

KVStore* kvstore_create() {
    KVStore* store = malloc(sizeof(KVStore));
    for (size_t i = 0; i < NUM_BUCKETS; i++) {
        store->buckets[i] = NULL;
        pthread_mutex_init(&store->locks[i], NULL);
    }
    return store;
}

void kv_set(KVStore* store, size_t key, const char* value) {
    size_t idx = hash(key);
    pthread_mutex_lock(&store->locks[idx]);

    Entry* curr = store->buckets[idx];
    while (curr) {
        if (curr->key == key) {
            strncpy(curr->value, value, VALUE_SIZE);
            printf("[SET] Updated key %zu -> %s\n", key, value);
            pthread_mutex_unlock(&store->locks[idx]);
            return;
        }
        curr = curr->next;
    }

    Entry* new_entry = malloc(sizeof(Entry));
    new_entry->key = key;
    strncpy(new_entry->value, value, VALUE_SIZE);
    new_entry->next = store->buckets[idx];
    store->buckets[idx] = new_entry;

    printf("[SET] Inserted key %zu -> %s\n", key, value);
    pthread_mutex_unlock(&store->locks[idx]);
}

int kv_get(KVStore* store, size_t key, char* out_value) {
    if (!store) {
        printf("[GET] ERROR: KV store is NULL\n");
        return 0;
    }

    size_t idx = hash(key);
    pthread_mutex_lock(&store->locks[idx]);

    Entry* curr = store->buckets[idx];
    while (curr) {
        if (curr->key == key) {
            strncpy(out_value, curr->value, VALUE_SIZE);
            pthread_mutex_unlock(&store->locks[idx]);
            printf("[GET] Key %zu -> %s\n", key, out_value);
            return 1;
        }
        curr = curr->next;
    }

    pthread_mutex_unlock(&store->locks[idx]);
    printf("[GET] Key %zu not found\n", key);
    return 0;
}

void kvstore_destroy(KVStore** store_ptr) {
    if (!store_ptr || !*store_ptr) return;

    KVStore* store = *store_ptr;
    printf("[DESTROY] Destroying KV store...\n");
    for (size_t i = 0; i < NUM_BUCKETS; i++) {
        Entry* curr = store->buckets[i];
        while (curr) {
            Entry* tmp = curr;
            curr = curr->next;
            printf("[DESTROY] Freeing key %zu\n", tmp->key);
            free(tmp);
        }
        pthread_mutex_destroy(&store->locks[i]);
    }
    free(store);
    *store_ptr = NULL;
    printf("[DESTROY] KV store destroyed and pointer set to NULL\n");
}

// ---------------- Test Cases ---------------- //

void test_basic() {
    printf("\n=== Test: Basic Set/Get ===\n");
    KVStore* store = kvstore_create();
    char value[VALUE_SIZE];

    kv_set(store, 1, "Hello");
    kv_set(store, 2, "World");

    kv_get(store, 1, value);
    kv_get(store, 2, value);
    kv_get(store, 3, value); // not found

    kvstore_destroy(&store);
}

void test_update() {
    printf("\n=== Test: Update ===\n");
    KVStore* store = kvstore_create();
    char value[VALUE_SIZE];

    kv_set(store, 42, "First");
    kv_set(store, 42, "Second"); // update
    kv_get(store, 42, value);

    kvstore_destroy(&store);
}

void test_destroy() {
    printf("\n=== Test: Destroy Access ===\n");
    KVStore* store = kvstore_create();
    char value[VALUE_SIZE];

    kv_set(store, 100, "Hundred");
    kv_get(store, 100, value);

    kvstore_destroy(&store);

    printf("Trying to access store after destroy...\n");
    kv_get(store, 100, value); // safe check
}

// ---------------- Main ---------------- //

int main() {
    test_basic();
    test_update();
    test_destroy();

    printf("\nAll tests done!\n");
    return 0;
}