libqaeda

commit b3c57e9b87e294aedcb1ae954772a4767d1ddce9
parent fffae0f311c28b5cf6416b510d68cf0952b3fbf3
Author: lash <dev@holbrook.no>
Date:   Sat, 22 Mar 2025 22:30:19 +0000

Add set get config test

Diffstat:
M
src/lq/config.c
 | 
71
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++---------
M
src/lq/config.h
 | 
8
++++++--
M
src/mem/std.c
 | 
2
+-
M
src/test/test_config.c
 | 
40
++++++++++++++++++++++++++++++++++++++++

4 files changed, 109 insertions(+), 12 deletions(-)
diff --git a/src/lq/config.c b/src/lq/config.c
@@ -1,3 +1,5 @@
+#include <string.h>
+
 #include "lq/err.h"
 #include "lq/mem.h"
 #include "lq/config.h"
@@ -7,12 +9,15 @@ const int lq_config_core_typs[] = {
 };
 
 static struct config_t {
-	void *members;
-	enum  lq_typ_e *typs;
-	size_t last;
+	void *mem; ///< Config data memory.
+	void **members; ///< Member pointer.
+	enum  lq_typ_e *typs; ///< Member type.
+	size_t last; ///< Last registered members index.
+	size_t cap; ///< Bytes allocated for config content.
+	size_t len; ///< Bytes currently used for content.
 } config;
 
-static int core_apply() {
+static int core_register() {
 	int i;
 	int r;
 
@@ -26,17 +31,26 @@ static int core_apply() {
 }
 
 int lq_config_init() {
-	config.members = lq_alloc(LQ_CONFIG_MAX * sizeof(void*));
+	config.mem = lq_alloc(LQ_CONFIG_MEMCAP);
+	if (config.mem == NULL) {
+		return ERR_MEM;
+	}
+	config.members = lq_alloc(LQ_CONFIG_MEMCAP * sizeof(void**));
 	if (config.members == NULL) {
+		lq_free(config.mem);
 		return ERR_MEM;
 	}
-	config.typs = lq_alloc(LQ_CONFIG_MAX * sizeof(void*));
+	config.typs = lq_alloc(LQ_CONFIG_MEMCAP * sizeof(void*));
 	if (config.typs == NULL) {
 		lq_free(config.members);
+		lq_free(config.mem);
 		return ERR_MEM;
 	}
 	config.last = 0;
-	return core_apply();
+	config.len = 0;
+	config.cap = LQ_CONFIG_MEMCAP;
+	*config.members = config.mem;
+	return core_register();
 }
 
 int lq_config_register(enum lq_typ_e typ) {
@@ -65,15 +79,54 @@ int lq_config_register(enum lq_typ_e typ) {
 	return ERR_OK;
 }
 
-int lq_config_set(char typ, int k, void *v) {
+int lq_config_set(int k, void *v) {
+	void *p;
+	size_t l;
+
+	if (k > config.last) {
+		return ERR_OVERFLOW;
+	}
+
+	switch (*(config.typs+k)) {
+		case LQ_TYP_VOID:
+			l = sizeof(void*);
+			break;
+		case LQ_TYP_STR:
+			l = strlen((char*)v);
+			break;
+		case LQ_TYP_NUM:
+			l = sizeof(long*);
+			break;
+		default:
+			l = 0;
+	}
+
+	if (config.len + l > config.cap) {
+		return ERR_OVERFLOW;
+	}
+	
+	p = config.mem + config.len;
+	*(config.members + k) = p;
+	p = lq_cpy(p, v, l);
+	if (p == NULL) {
+		return ERR_WRITE;
+	}
+	config.len += l;
 	return ERR_OK;
 }
 
-int lq_config_get(int k, void *r) {
+int lq_config_get(int k, void **r) {
+	if (k > config.last) {
+		return ERR_OVERFLOW;
+	}
+
+	*r = *(config.members + k);
+	
 	return ERR_OK;
 }
 
 void lq_config_free() {
 	lq_free(config.typs);
 	lq_free(config.members);
+	lq_free(config.mem);
 }
diff --git a/src/lq/config.h b/src/lq/config.h
@@ -1,6 +1,10 @@
 #ifndef LQ_CONFIG_H_
 #define LQ_CONFIG_H_
 
+#ifndef LQ_CONFIG_MEMCAP
+#define LQ_CONFIG_MEMCAP 65536
+#endif
+
 #ifndef LQ_CONFIG_MAX
 #define LQ_CONFIG_MAX 128
 #endif
@@ -15,8 +19,8 @@ enum lq_config_core_e {
 
 int lq_config_init();
 int lq_config_register(enum lq_typ_e typ);
-int lq_config_set(char typ, int k, void *v); 
-int lq_config_get(int k, void *r);
+int lq_config_set(int k, void *v); 
+int lq_config_get(int k, void **r);
 void lq_config_free();
 
 #endif
diff --git a/src/mem/std.c b/src/mem/std.c
@@ -18,6 +18,6 @@ void* lq_set(void *dst, const char b, size_t len) {
 	return memset(dst, (int)b, len);
 }
 
-void* lq_zero(void *dst, const char b, size_t len) {
+void* lq_zero(void *dst, size_t len) {
 	return lq_set(dst, 0, len);
 }
diff --git a/src/test/test_config.c b/src/test/test_config.c
@@ -9,10 +9,48 @@ START_TEST(check_core) {
 	int r;
 
 	r = lq_config_init();
+	lq_config_free();
 	ck_assert_int_eq(r, ERR_OK);
 }
 END_TEST
 
+START_TEST(check_register) {
+	int r;
+
+	lq_config_init();
+	r = lq_config_register(LQ_TYP_STR);
+	lq_config_free();
+	ck_assert_int_eq(r, ERR_OK);
+}
+END_TEST
+
+START_TEST(check_set) {
+	int r;
+	long v;
+	char *p;
+
+	lq_config_init();
+	r = lq_config_register(LQ_TYP_NUM);
+	ck_assert_int_eq(r, ERR_OK);
+	r = lq_config_register(LQ_TYP_STR);
+	ck_assert_int_eq(r, ERR_OK);
+
+	r = lq_config_set(2, "foobarbaz");
+	ck_assert_int_eq(r, ERR_OK);
+
+	v = 42;
+	r = lq_config_set(1, &v);
+	ck_assert_int_eq(r, ERR_OK);
+
+	r = lq_config_get(1, (void**)&p);
+	ck_assert_int_eq(r, ERR_OK);
+	v = *((long*)p);
+	ck_assert_int_eq(v, 42);
+
+	lq_config_free();
+}
+END_TEST
+
 Suite * common_suite(void) {
 	Suite *s;
 	TCase *tc;
@@ -20,6 +58,8 @@ Suite * common_suite(void) {
 	s = suite_create("config");
 	tc = tcase_create("core");
 	tcase_add_test(tc, check_core);
+	tcase_add_test(tc, check_register);
+	tcase_add_test(tc, check_set);
 	suite_add_tcase(s, tc);
 
 	return s;