feat: implement kvmgr_capture_keys for lock-free checkpoint serialization (P0-14a)
Add kvtab_foreach walk primitive (P0-14) to kv.c/kv.h, then implement kvmgr_capture_keys in kvmgr.c that deep-copies all key→index mappings into a malloc'd slot_key_t[] array safe to read after the write lock is released during checkpoint serialization (Part 3.8). Key design points: - Both kvtab_foreach and kvmgr_capture_keys take var (RTTI data pointer) and use RTTI_DATA_TO_OBJ internally — the RTTI framework's makeInstance returns the data region pointer, not the meta_obj_t header pointer - String keys are copied via strncpy into slot_key_t.key[XCE_MAXNAME_LEN] - Integer keys are formatted as decimal strings via snprintf - Two-pass approach: count live entries first, allocate, then fill - Tests cover string kvmgr (3 entries), empty kvmgr, and deep-copy safety
This commit is contained in:
parent
4903c83f28
commit
eaf1801d6d
7 changed files with 361 additions and 0 deletions
|
|
@ -30,6 +30,7 @@ extern void test_qobj(void);
|
|||
extern void test_wobj(void);
|
||||
extern void test_request(void);
|
||||
extern void test_zarray_cow(void);
|
||||
extern void test_kvmgr_capture(void);
|
||||
|
||||
void setUp(void) { return; }
|
||||
|
||||
|
|
@ -129,6 +130,7 @@ int main(int argc, char* argv[])
|
|||
TEST(test_qobj);
|
||||
TEST(test_request);
|
||||
TEST(test_zarray_cow);
|
||||
TEST(test_kvmgr_capture);
|
||||
|
||||
return UNITY_END();
|
||||
}
|
||||
|
|
|
|||
184
src/lib/testsuite/test_kvmgr_capture.c
Normal file
184
src/lib/testsuite/test_kvmgr_capture.c
Normal file
|
|
@ -0,0 +1,184 @@
|
|||
/*
|
||||
* Test suite for kvmgr_capture_keys() — P0-14a.
|
||||
*
|
||||
* Tests follow TDD: written BEFORE implementation.
|
||||
* All tests exercise the public API declared in kvmgr.h.
|
||||
*/
|
||||
|
||||
#include <rtti.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <unity/unity.h>
|
||||
|
||||
#include "kv.h"
|
||||
#include "kvmgr.h"
|
||||
#include "persist.h"
|
||||
#include "utils.h"
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* helpers */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
static int find_key_in_captured(slot_key_t* keys, size_t n,
|
||||
const char* target_key, int* index_out)
|
||||
{
|
||||
size_t i;
|
||||
for (i = 0; i < n; i++) {
|
||||
if (strcmp(keys[i].key, target_key) == 0) {
|
||||
if (index_out != NULL) {
|
||||
*index_out = keys[i].index;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* test 1: capture from a string-keyed kvmgr with 3 entries */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
static void test_capture_keys_string_kvmgr(void)
|
||||
{
|
||||
kvmgr_params_t params = { .key_type = KVMGR_KEY_STRING,
|
||||
.nslots = 8,
|
||||
.delta = 4,
|
||||
.datakiller = NULL };
|
||||
var kvmgr = makeInstance(&xkvmgr_type, ¶ms);
|
||||
TEST_ASSERT_NOT_NULL(kvmgr);
|
||||
|
||||
/* Add 3 string-keyed entries whose values are arbitrary pointers;
|
||||
the index returned by key_add is the slot index we capture. */
|
||||
int idx_a = key_add(kvmgr, (void*)"alpha", (void*)"data_alpha");
|
||||
int idx_b = key_add(kvmgr, (void*)"beta", (void*)"data_beta");
|
||||
int idx_c = key_add(kvmgr, (void*)"gamma", (void*)"data_gamma");
|
||||
TEST_ASSERT_TRUE(idx_a >= 0);
|
||||
TEST_ASSERT_TRUE(idx_b >= 0);
|
||||
TEST_ASSERT_TRUE(idx_c >= 0);
|
||||
|
||||
slot_key_t* keys = NULL;
|
||||
size_t n_keys = 0;
|
||||
int rc = kvmgr_capture_keys(kvmgr, &keys, &n_keys);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(0, rc);
|
||||
TEST_ASSERT_EQUAL_size_t(3, n_keys);
|
||||
TEST_ASSERT_NOT_NULL(keys);
|
||||
|
||||
/* Every inserted key must appear exactly once with the correct index */
|
||||
int found_idx = -1;
|
||||
TEST_ASSERT_TRUE(find_key_in_captured(keys, n_keys, "alpha", &found_idx));
|
||||
TEST_ASSERT_EQUAL_INT(idx_a, found_idx);
|
||||
|
||||
TEST_ASSERT_TRUE(find_key_in_captured(keys, n_keys, "beta", &found_idx));
|
||||
TEST_ASSERT_EQUAL_INT(idx_b, found_idx);
|
||||
|
||||
TEST_ASSERT_TRUE(find_key_in_captured(keys, n_keys, "gamma", &found_idx));
|
||||
TEST_ASSERT_EQUAL_INT(idx_c, found_idx);
|
||||
|
||||
/* key_len must equal strlen(key)+1 */
|
||||
size_t i;
|
||||
for (i = 0; i < n_keys; i++) {
|
||||
TEST_ASSERT_EQUAL_size_t(strlen(keys[i].key) + 1, keys[i].key_len);
|
||||
}
|
||||
|
||||
free(keys);
|
||||
destroy(kvmgr);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* test 2: empty kvmgr returns 0 entries and NULL keys_out */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
static void test_capture_keys_empty_kvmgr(void)
|
||||
{
|
||||
kvmgr_params_t params = { .key_type = KVMGR_KEY_STRING,
|
||||
.nslots = 4,
|
||||
.delta = 4,
|
||||
.datakiller = NULL };
|
||||
var kvmgr = makeInstance(&xkvmgr_type, ¶ms);
|
||||
TEST_ASSERT_NOT_NULL(kvmgr);
|
||||
|
||||
slot_key_t* keys = (slot_key_t*)(uintptr_t)0xdeadbeef; /* sentinel */
|
||||
size_t n_keys = 99;
|
||||
|
||||
int rc = kvmgr_capture_keys(kvmgr, &keys, &n_keys);
|
||||
|
||||
TEST_ASSERT_EQUAL_INT(0, rc);
|
||||
TEST_ASSERT_EQUAL_size_t(0, n_keys);
|
||||
TEST_ASSERT_NULL(keys);
|
||||
|
||||
destroy(kvmgr);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* test 3: captured keys are deep copies — safe after kvmgr destroyed */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
static void test_capture_keys_are_deep_copies(void)
|
||||
{
|
||||
kvmgr_params_t params = { .key_type = KVMGR_KEY_STRING,
|
||||
.nslots = 4,
|
||||
.delta = 4,
|
||||
.datakiller = NULL };
|
||||
var kvmgr = makeInstance(&xkvmgr_type, ¶ms);
|
||||
TEST_ASSERT_NOT_NULL(kvmgr);
|
||||
|
||||
key_add(kvmgr, (void*)"keyA", (void*)"valA");
|
||||
key_add(kvmgr, (void*)"keyB", (void*)"valB");
|
||||
|
||||
slot_key_t* keys = NULL;
|
||||
size_t n_keys = 0;
|
||||
int rc = kvmgr_capture_keys(kvmgr, &keys, &n_keys);
|
||||
TEST_ASSERT_EQUAL_INT(0, rc);
|
||||
TEST_ASSERT_EQUAL_size_t(2, n_keys);
|
||||
|
||||
/* Stash manual copies of the captured key strings */
|
||||
char copy_a[256], copy_b[256];
|
||||
int found_a = 0, found_b = 0;
|
||||
size_t i;
|
||||
for (i = 0; i < n_keys; i++) {
|
||||
if (strcmp(keys[i].key, "keyA") == 0) {
|
||||
strncpy(copy_a, keys[i].key, sizeof(copy_a) - 1);
|
||||
copy_a[sizeof(copy_a) - 1] = '\0';
|
||||
found_a = 1;
|
||||
} else if (strcmp(keys[i].key, "keyB") == 0) {
|
||||
strncpy(copy_b, keys[i].key, sizeof(copy_b) - 1);
|
||||
copy_b[sizeof(copy_b) - 1] = '\0';
|
||||
found_b = 1;
|
||||
}
|
||||
}
|
||||
TEST_ASSERT_TRUE(found_a);
|
||||
TEST_ASSERT_TRUE(found_b);
|
||||
|
||||
/* Destroy the kvmgr — this frees all kvtab entries including the
|
||||
original key strings. Captured keys[] must remain valid. */
|
||||
destroy(kvmgr);
|
||||
|
||||
TEST_ASSERT_EQUAL_STRING("keyA", copy_a);
|
||||
TEST_ASSERT_EQUAL_STRING("keyB", copy_b);
|
||||
|
||||
/* Directly verify the captured keys array is still readable */
|
||||
int still_a = 0, still_b = 0;
|
||||
for (i = 0; i < n_keys; i++) {
|
||||
if (strcmp(keys[i].key, "keyA") == 0) still_a = 1;
|
||||
if (strcmp(keys[i].key, "keyB") == 0) still_b = 1;
|
||||
}
|
||||
TEST_ASSERT_TRUE(still_a);
|
||||
TEST_ASSERT_TRUE(still_b);
|
||||
|
||||
free(keys);
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
/* entry point called from test.c */
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
void test_kvmgr_capture(void)
|
||||
{
|
||||
printf("\n>> kvmgr_capture_keys test\n");
|
||||
RUN_TEST(test_capture_keys_string_kvmgr);
|
||||
RUN_TEST(test_capture_keys_empty_kvmgr);
|
||||
RUN_TEST(test_capture_keys_are_deep_copies);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue