static int recreate_nsec3_tree(const zone_contents_t *z, zone_contents_t *out)
{
out->nsec3_nodes = hattrie_dup(z->nsec3_nodes, NULL);
if (out->nsec3_nodes == NULL) {
return KNOT_ENOMEM;
}
hattrie_iter_t *itt = hattrie_iter_begin(z->nsec3_nodes, false);
if (itt == NULL) {
return KNOT_ENOMEM;
}
while (!hattrie_iter_finished(itt)) {
const zone_node_t *to_cpy = (zone_node_t *)*hattrie_iter_val(itt);
zone_node_t *to_add = node_shallow_copy(to_cpy, NULL);
if (to_add == NULL) {
hattrie_iter_free(itt);
return KNOT_ENOMEM;
}
int ret = zone_contents_add_nsec3_node(out, to_add);
if (ret != KNOT_EOK) {
hattrie_iter_free(itt);
node_free(&to_add, NULL);
return ret;
}
hattrie_iter_next(itt);
}
hattrie_iter_free(itt);
hattrie_build_index(out->nsec3_nodes);
return KNOT_EOK;
}
static int recreate_normal_tree(const zone_contents_t *z, zone_contents_t *out)
{
out->nodes = hattrie_dup(z->nodes, NULL);
if (out->nodes == NULL) {
return KNOT_ENOMEM;
}
// Insert APEX first.
zone_node_t *apex_cpy = node_shallow_copy(z->apex, NULL);
if (apex_cpy == NULL) {
return KNOT_ENOMEM;
}
// Normal additions need apex ... so we need to insert directly.
int ret = zone_tree_insert(out->nodes, apex_cpy);
if (ret != KNOT_EOK) {
node_free(&apex_cpy, NULL);
return ret;
}
out->apex = apex_cpy;
hattrie_iter_t *itt = hattrie_iter_begin(z->nodes, true);
if (itt == NULL) {
return KNOT_ENOMEM;
}
while (!hattrie_iter_finished(itt)) {
const zone_node_t *to_cpy = (zone_node_t *)*hattrie_iter_val(itt);
if (to_cpy == z->apex) {
// Inserted already.
hattrie_iter_next(itt);
continue;
}
zone_node_t *to_add = node_shallow_copy(to_cpy, NULL);
if (to_add == NULL) {
hattrie_iter_free(itt);
return KNOT_ENOMEM;
}
int ret = zone_contents_add_node(out, to_add, true);
if (ret != KNOT_EOK) {
node_free(&to_add, NULL);
hattrie_iter_free(itt);
return ret;
}
hattrie_iter_next(itt);
}
hattrie_iter_free(itt);
hattrie_build_index(out->nodes);
return KNOT_EOK;
}
static int ztree_tests_run(int argc, char *argv[])
{
ztree_init_data();
/* 1. create test */
knot_zone_tree_t* t = knot_zone_tree_create();
ok(t != NULL, "ztree: created");
/* 2. insert test */
unsigned passed = 1;
for (unsigned i = 0; i < NCOUNT; ++i) {
if (knot_zone_tree_insert(t, NODE + i) != KNOT_EOK) {
passed = 0;
break;
}
}
ok(passed, "ztree: insertion");
/* 3. check data test */
passed = 1;
const knot_node_t *node = NULL;
for (unsigned i = 0; i < NCOUNT; ++i) {
int r = knot_zone_tree_find(t, NAME[i], &node);
if (r != KNOT_EOK || node != NODE + i) {
passed = 0;
break;
}
}
ok(passed, "ztree: lookup");
/* heal index for ordered lookup */
hattrie_build_index(t);
/* 4. ordered lookup */
passed = 1;
node = NULL;
const knot_node_t *prev = NULL;
knot_dname_t *tmp_dn = knot_dname_new_from_str("z.ac.", 5, NULL);
knot_zone_tree_find_less_or_equal(t, tmp_dn, &node, &prev);
knot_dname_free(&tmp_dn);
ok(prev == NODE + 1, "ztree: ordered lookup");
/* 5. ordered traversal */
struct ztree_iter it = { KNOT_EOK, 0 };
knot_zone_tree_apply_inorder(t, ztree_iter_data, &it);
ok (it.ret == KNOT_EOK, "ztree: ordered traversal");
knot_zone_tree_free(&t);
ztree_free_data();
return 0;
}
void test_hattrie_find_prev()
{
fprintf(stderr, "finding previous for %zu keys ... \n", k);
hattrie_build_index(T);
hattrie_iter_t* i = hattrie_iter_begin(T, true);
value_t* u;
const char *key = NULL;
char *dkey = NULL;
char *fkey = NULL;
size_t len = 0, flen = 0;
while (!hattrie_iter_finished(i)) {
u = hattrie_iter_val(i);
key = hattrie_iter_key(i, &len);
/* first key */
if (!fkey) {
fkey = malloc(len); memcpy(fkey, key, len);
--fkey[len-1];
flen = len;
}
/* check hattrie_find_leq functionality */
dkey = realloc(dkey, len); memcpy(dkey, key, len);
++dkey[len-1];
value_t *fp = NULL;
int r = hattrie_find_leq(T, dkey, len, &fp);
if (*fp != *u || r != -1) {
fprintf(stderr, "[error] hattrie_find_leq should find %lu, "
"but found prev=%lu, rval=%d\n",
*u, *fp, r);
}
hattrie_iter_next(i);
}
hattrie_iter_free(i);
/* check before first key */
value_t *fp = NULL;
int r = hattrie_find_leq(T, fkey, flen, &fp);
if (r != 1 || fp != NULL) {
fprintf(stderr, "[error] hattrie_find_leq should return 1 and NULL for "
"string < first string, returned %d (%p)\n",
r, (void*)fp);
}
free(fkey);
free(dkey);
fprintf(stderr, "done.\n");
}
int main(int argc, char *argv[])
{
plan_lazy();
/* Random keys. */
srand(time(NULL));
unsigned key_count = 100000;
char **keys = malloc(sizeof(char*) * key_count);
for (unsigned i = 0; i < key_count; ++i) {
keys[i] = str_key_rand(KEY_MAXLEN);
}
/* Sort random keys. */
str_key_sort(keys, key_count);
/* Create trie */
value_t *val = NULL;
hattrie_t *trie = hattrie_create();
ok(trie != NULL, "hattrie: create");
/* Insert keys */
bool passed = true;
size_t inserted = 0;
for (unsigned i = 0; i < key_count; ++i) {
val = hattrie_get(trie, keys[i], strlen(keys[i]) + 1);
if (!val) {
passed = false;
break;
}
if (*val == NULL) {
*val = keys[i];
++inserted;
}
}
ok(passed, "hattrie: insert");
/* Check total insertions against trie weight. */
is_int(hattrie_weight(trie), inserted, "hattrie: trie weight matches insertions");
/* Build order-index. */
hattrie_build_index(trie);
/* Lookup all keys */
passed = true;
for (unsigned i = 0; i < key_count; ++i) {
val = hattrie_tryget(trie, keys[i], strlen(keys[i]) + 1);
if (val && (*val == keys[i] || strcmp(*val, keys[i]) == 0)) {
continue;
} else {
diag("hattrie: mismatch on element '%u'", i);
passed = false;
break;
}
}
ok(passed, "hattrie: lookup all keys");
/* Lesser or equal lookup. */
passed = true;
for (unsigned i = 0; i < key_count; ++i) {
if (!str_key_find_leq(trie, keys, i, key_count)) {
passed = false;
for (int off = -10; off < 10; ++off) {
int k = (int)i + off;
if (k < 0 || k >= key_count) {
continue;
}
diag("[%u/%d]: %s%s", i, off, off == 0?">":"",keys[k]);
}
break;
}
}
ok(passed, "hattrie: find lesser or equal for all keys");
/* Next lookup. */
passed = true;
for (unsigned i = 0; i < key_count - 1 && passed; ++i) {
value_t *val;
hattrie_find_next(trie, keys[i], strlen(keys[i]), &val);
passed = val && *val == (void *)keys[(i + 1)];
}
ok(passed, "hattrie: find next for all keys");
/* Unsorted iteration */
size_t iterated = 0;
hattrie_iter_t *it = hattrie_iter_begin(trie, false);
while (!hattrie_iter_finished(it)) {
++iterated;
hattrie_iter_next(it);
}
is_int(inserted, iterated, "hattrie: unsorted iteration");
hattrie_iter_free(it);
/* Sorted iteration. */
char key_buf[KEY_MAXLEN] = {'\0'};
iterated = 0;
it = hattrie_iter_begin(trie, true);
while (!hattrie_iter_finished(it)) {
size_t cur_key_len = 0;
const char *cur_key = hattrie_iter_key(it, &cur_key_len);
if (iterated > 0) { /* Only if previous exists. */
if (strcmp(key_buf, cur_key) > 0) {
diag("'%s' <= '%s' FAIL\n", key_buf, cur_key);
break;
}
}
++iterated;
memcpy(key_buf, cur_key, cur_key_len);
hattrie_iter_next(it);
}
is_int(inserted, iterated, "hattrie: sorted iteration");
hattrie_iter_free(it);
/* Cleanup */
for (unsigned i = 0; i < key_count; ++i) {
free(keys[i]);
}
free(keys);
hattrie_free(trie);
return 0;
}
