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; }