test: add C unit tests and update Makefile for testing

andinux · andinux · commit 786ab516420d · 2025-11-12T11:51:20.000-06:00
Introduces a new C unit test runner at tests/c/unittest.c with basic tests for the SQLite AI extension. The Makefile is updated to build and run these tests, including logic to download a test model if needed and link against the appropriate SQLite libraries.
diff --git a/Makefile b/Makefile
@@ -29,6 +29,10 @@ SRC_DIR = src
 DIST_DIR = dist
 VPATH = $(SRC_DIR)
 BUILD_DIR = build
+CTEST_BIN = $(BUILD_DIR)/tests/sqlite_ai_tests
+TEST_MODEL_DIR = tests/models/unsloth/gemma-3-270m-it-GGUF
+TEST_MODEL_FILE = $(TEST_MODEL_DIR)/gemma-3-270m-it-UD-IQ2_M.gguf
+TEST_MODEL_URL = https://huggingface.co/unsloth/gemma-3-270m-it-GGUF/resolve/main/gemma-3-270m-it-UD-IQ2_M.gguf
 LLAMA_DIR = modules/llama.cpp
 WHISPER_DIR = modules/whisper.cpp
 MINIAUDIO_DIR = modules/miniaudio
@@ -55,6 +59,16 @@ LLAMA_LDFLAGS = -L./$(BUILD_LLAMA)/common -L./$(BUILD_GGML)/lib -L./$(BUILD_LLAM
 WHISPER_LDFLAGS = -L./$(BUILD_WHISPER)/src -lwhisper
 MINIAUDIO_LDFLAGS = -L./$(BUILD_MINIAUDIO) -lminiaudio -lminiaudio_channel_combiner_node -lminiaudio_channel_separator_node -lminiaudio_ltrim_node -lminiaudio_reverb_node -lminiaudio_vocoder_node
 LDFLAGS = $(LLAMA_LDFLAGS) $(WHISPER_LDFLAGS) $(MINIAUDIO_LDFLAGS)
+SQLITE_TEST_LIBS = -lpthread -lm
+ifneq ($(PLATFORM),macos)
+	SQLITE_TEST_LIBS += -ldl
+endif
+ifneq ($(SQLITE3),sqlite3)
+SQLITE3_BINDIR := $(dir $(SQLITE3))
+SQLITE3_PREFIX := $(abspath $(SQLITE3_BINDIR)/..)
+SQLITE_TEST_LIBS += -L$(SQLITE3_PREFIX)/lib
+endif
+SQLITE_TEST_LIBS += -lsqlite3
 
 # Files
 SRC_FILES = $(wildcard $(SRC_DIR)/*.c)
@@ -210,8 +224,17 @@ endif
 $(BUILD_DIR)/%.o: %.c $(BUILD_DIR)/llama.cpp.stamp
 	$(CC) $(CFLAGS) -O3 -fPIC -c $< -o $@
 
-test: $(TARGET)
-	$(SQLITE3) ":memory:" -cmd ".bail on" ".load ./dist/ai" "SELECT ai_version();"
+$(CTEST_BIN): tests/c/unittest.c
+	@mkdir -p $(dir $@)
+	$(CC) -std=c11 -Wall -Wextra -I$(SRC_DIR) tests/c/unittest.c -o $@ $(SQLITE_TEST_LIBS)
+
+$(TEST_MODEL_FILE):
+	@mkdir -p $(TEST_MODEL_DIR)
+	curl -L --fail --retry 3 -o $@ $(TEST_MODEL_URL)
+
+test: $(TARGET) $(CTEST_BIN) $(TEST_MODEL_FILE)
+		$(SQLITE3) ":memory:" -cmd ".bail on" ".load ./dist/ai" "SELECT ai_version();"
+		$(CTEST_BIN) --extension "$(TARGET)" --model "$(TEST_MODEL_FILE)"
 
 # Build submodules
 ifeq ($(PLATFORM),windows)
diff --git a/tests/c/unittest.c b/tests/c/unittest.c
@@ -0,0 +1,257 @@
+#ifndef SQLITE_ENABLE_LOAD_EXTENSION
+#define SQLITE_ENABLE_LOAD_EXTENSION 1
+#endif
+#include "sqlite3.h"
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef SQLITEAI_LOAD_FROM_SOURCES
+#include "sqlite-ai.h"
+#endif
+
+#define DEFAULT_MODEL_PATH "tests/models/unsloth/gemma-3-270m-it-GGUF/gemma-3-270m-it-UD-IQ2_M.gguf"
+
+typedef struct {
+    const char *extension_path;
+    const char *model_path;
+    bool verbose;
+} test_env;
+
+typedef int (*test_fn)(const test_env *env);
+
+typedef struct {
+    const char *name;
+    test_fn fn;
+} test_case;
+
+static void usage(const char *prog) {
+    fprintf(stderr, "Usage: %s [--extension /path/to/ai] [--model /path/to/model] [--verbose]\n", prog);
+}
+
+static int expect_error_contains(const char *err_msg, const char *needle) {
+    if (!err_msg) {
+        fprintf(stderr, "Expected SQLite error message but got NULL\n");
+        return 1;
+    }
+    if (!strstr(err_msg, needle)) {
+        fprintf(stderr, "Expected error to contain \"%s\", got: %s\n", needle, err_msg);
+        return 1;
+    }
+    return 0;
+}
+
+static int open_db_and_load(const test_env *env, sqlite3 **out_db) {
+    sqlite3 *db = NULL;
+    int rc = sqlite3_open(":memory:", &db);
+    if (rc != SQLITE_OK) {
+        fprintf(stderr, "sqlite3_open failed: %s\n", db ? sqlite3_errmsg(db) : "unknown error");
+        if (db) sqlite3_close(db);
+        return rc;
+    }
+    sqlite3_enable_load_extension(db, 1);
+    char *errmsg = NULL;
+#ifdef SQLITEAI_LOAD_FROM_SOURCES
+    rc = sqlite3_ai_init(db, NULL, NULL);
+#else
+    rc = sqlite3_load_extension(db, env->extension_path, NULL, &errmsg);
+#endif
+    if (rc != SQLITE_OK) {
+        fprintf(stderr, "sqlite3_load_extension failed: %s\n", errmsg ? errmsg : sqlite3_errmsg(db));
+        if (errmsg) sqlite3_free(errmsg);
+        sqlite3_close(db);
+        return rc;
+    }
+    if (errmsg) sqlite3_free(errmsg);
+    *out_db = db;
+    return SQLITE_OK;
+}
+
+typedef struct {
+    const test_env *env;
+} exec_userdata;
+
+static int verbose_callback(void *udata, int columns, char **values, char **names) {
+    exec_userdata *ud = (exec_userdata *)udata;
+    if (!ud || !ud->env || !ud->env->verbose) {
+        return 0;
+    }
+    printf("[SQL] row:\n");
+    for (int i = 0; i < columns; ++i) {
+        printf("  %s = %s\n", names[i] ? names[i] : "(null)", values[i] ? values[i] : "NULL");
+    }
+    return 0;
+}
+
+static int exec_expect_error(const test_env *env, sqlite3 *db, const char *sql, const char *needle) {
+    if (env->verbose) {
+        printf("[SQL] %s\n", sql);
+    }
+    char *errmsg = NULL;
+    exec_userdata udata = {.env = env};
+    int rc = sqlite3_exec(db, sql, env->verbose ? verbose_callback : NULL, env->verbose ? &udata : NULL, &errmsg);
+    if (rc == SQLITE_OK) {
+        fprintf(stderr, "Expected failure executing SQL: %s\n", sql);
+        return 1;
+    }
+    if (env->verbose && errmsg) {
+        printf("[SQL][ERROR] %s\n", errmsg);
+    }
+    int status = expect_error_contains(errmsg, needle);
+    sqlite3_free(errmsg);
+    return status;
+}
+
+static int exec_expect_ok(const test_env *env, sqlite3 *db, const char *sql) {
+    if (env->verbose) {
+        printf("[SQL] %s\n", sql);
+    }
+    char *errmsg = NULL;
+    exec_userdata udata = {.env = env};
+    int rc = sqlite3_exec(db, sql, env->verbose ? verbose_callback : NULL, env->verbose ? &udata : NULL, &errmsg);
+    if (rc != SQLITE_OK) {
+        fprintf(stderr, "SQL execution failed (%d): %s\n", rc, errmsg ? errmsg : sqlite3_errmsg(db));
+        if (errmsg) sqlite3_free(errmsg);
+        return 1;
+    }
+    if (errmsg) sqlite3_free(errmsg);
+    return 0;
+}
+
+static int test_issue15_chat_without_context(const test_env *env) {
+    sqlite3 *db = NULL;
+    if (open_db_and_load(env, &db) != SQLITE_OK) {
+        return 1;
+    }
+
+    int rc = exec_expect_error(env, db, "SELECT llm_chat_create();", "Please call llm_context_create()");
+    sqlite3_close(db);
+    return rc;
+}
+
+static int test_llm_chat_respond_repeated(const test_env *env) {
+    sqlite3 *db = NULL;
+    if (open_db_and_load(env, &db) != SQLITE_OK) {
+        return 1;
+    }
+
+    char sqlbuf[512];
+    const char *model = env->model_path ? env->model_path : DEFAULT_MODEL_PATH;
+    snprintf(sqlbuf, sizeof(sqlbuf), "SELECT llm_model_load('%s');", model);
+    if (exec_expect_ok(env, db, sqlbuf) != 0) {
+        sqlite3_close(db);
+        return 1;
+    }
+    if (exec_expect_ok(env, db, "SELECT llm_context_create('context_size=32000');") != 0) {
+        sqlite3_close(db);
+        return 1;
+    }
+    if (exec_expect_ok(env, db, "SELECT llm_chat_create();") != 0) {
+        sqlite3_close(db);
+        return 1;
+    }
+
+    const int iterations = 3;
+    for (int i = 0; i < iterations; ++i) {
+        if (exec_expect_ok(env, db, "SELECT llm_chat_respond('Hello world');") != 0) {
+            sqlite3_close(db);
+            return 1;
+        }
+        
+        if (exec_expect_ok(env, db, "SELECT llm_context_usage();") != 0) {
+            sqlite3_close(db);
+            return 1;
+        }
+    }
+
+    if (exec_expect_ok(env, db, "SELECT llm_chat_free();") != 0) {
+        sqlite3_close(db);
+        return 1;
+    }
+    if (exec_expect_ok(env, db, "SELECT llm_context_free();") != 0) {
+        sqlite3_close(db);
+        return 1;
+    }
+    if (exec_expect_ok(env, db, "SELECT llm_model_free();") != 0) {
+        sqlite3_close(db);
+        return 1;
+    }
+
+    sqlite3_close(db);
+
+    sqlite3_int64 current = 0;
+    sqlite3_int64 highwater = 0;
+    if (sqlite3_status64(SQLITE_STATUS_MEMORY_USED, &current, &highwater, 0) != SQLITE_OK) {
+        fprintf(stderr, "[chat_respond_repeated] sqlite3_status64 failed\n");
+        return 1;
+    }
+    if (env->verbose) {
+        printf("[STATUS] memory current=%lld highwater=%lld\n", (long long)current, (long long)highwater);
+    }
+    if (current > 0 || highwater <= 0) {
+        fprintf(stderr, "[chat_respond_repeated] invalid memory stats: current=%lld highwater=%lld\n",
+                (long long)current, (long long)highwater);
+        return 1;
+    }
+
+    return 0;
+}
+
+static const test_case TESTS[] = {
+    {"issue15_llm_chat_without_context", test_issue15_chat_without_context},
+    {"llm_chat_respond_repeated", test_llm_chat_respond_repeated},
+};
+
+int main(int argc, char **argv) {
+    test_env env = {
+        .extension_path = "./dist/ai",
+        .model_path = NULL,
+        .verbose = false,
+    };
+
+    for (int i = 1; i < argc; ++i) {
+        if (strcmp(argv[i], "--extension") == 0) {
+            if (++i >= argc) {
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+            env.extension_path = argv[i];
+        } else if (strcmp(argv[i], "--model") == 0) {
+            if (++i >= argc) {
+                usage(argv[0]);
+                return EXIT_FAILURE;
+            }
+            env.model_path = argv[i];
+        } else if (strcmp(argv[i], "--verbose") == 0) {
+            env.verbose = true;
+        } else if (strcmp(argv[i], "--help") == 0) {
+            usage(argv[0]);
+            return EXIT_SUCCESS;
+        } else {
+            fprintf(stderr, "Unknown argument: %s\n", argv[i]);
+            usage(argv[0]);
+            return EXIT_FAILURE;
+        }
+    }
+
+    size_t total = sizeof(TESTS) / sizeof(TESTS[0]);
+    int failures = 0;
+
+    printf("Running %zu C test(s)\n\n", total);
+    for (size_t i = 0; i < total; ++i) {
+        const test_case *tc = &TESTS[i];
+        int rc = tc->fn(&env);
+        printf("- %s ... %s\n", tc->name, rc == 0 ? "PASS" : "FAIL");
+        if (rc != 0) failures += 1;
+    }
+
+    if (failures) {
+        fprintf(stderr, "\n%d C test(s) failed.\n", failures);
+        return EXIT_FAILURE;
+    }
+
+    printf("\nAll C tests passed.\n");
+    return EXIT_SUCCESS;
+}
