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"); }
void test_hattrie_iteration() { fprintf(stderr, "iterating through %zu keys ... \n", k); hattrie_iter_t* i = hattrie_iter_begin(T, false); size_t count = 0; value_t* u; value_t v; size_t len; const char* key; while (!hattrie_iter_finished(i)) { ++count; key = hattrie_iter_key(i, &len); u = hattrie_iter_val(i); v = str_map_get(M, key, len); if (*u != v) { if (v == 0) { fprintf(stderr, "[error] incorrect iteration (%lu, %lu)\n", *u, v); } else { fprintf(stderr, "[error] incorrect iteration tally (%lu, %lu)\n", *u, v); } } // this way we will see an error if the same key is iterated through // twice str_map_set(M, key, len, 0); hattrie_iter_next(i); } if (count != M->m) { fprintf(stderr, "[error] iterated through %zu element, expected %zu\n", count, M->m); } hattrie_iter_free(i); fprintf(stderr, "done.\n"); }
hattrie_t* hattrie_dup(const hattrie_t* T, value_t (*nval)(value_t)) { hattrie_t *N = hattrie_create_n(T->bsize, &T->mm); /* assignment */ if (!nval) nval = hattrie_setval; /*! \todo could be probably implemented faster */ size_t l = 0; const char *k = 0; hattrie_iter_t *i = hattrie_iter_begin(T, false); while (!hattrie_iter_finished(i)) { k = hattrie_iter_key(i, &l); *hattrie_get(N, k, l) = nval(*hattrie_iter_val(i)); hattrie_iter_next(i); } hattrie_iter_free(i); return N; }
void test_hattrie_sorted_iteration() { fprintf(stderr, "iterating in order through %zu keys ... \n", k); hattrie_iter_t* i = hattrie_iter_begin(T, true); size_t count = 0; value_t* u; value_t v; char* key_copy = malloc(m_high + 1); char* prev_key = malloc(m_high + 1); memset(prev_key, 0, m_high + 1); size_t prev_len = 0; const char *key = NULL; size_t len = 0; while (!hattrie_iter_finished(i)) { memcpy(prev_key, key_copy, len); prev_key[len] = '\0'; prev_len = len; ++count; key = hattrie_iter_key(i, &len); /* memory for key may be changed on iter, copy it */ strncpy(key_copy, key, len); if (prev_key != NULL && cmpkey(prev_key, prev_len, key, len) > 0) { fprintf(stderr, "[error] iteration is not correctly ordered.\n"); } u = hattrie_iter_val(i); v = str_map_get(M, key, len); if (*u != v) { if (v == 0) { fprintf(stderr, "[error] incorrect iteration (%lu, %lu)\n", *u, v); } else { fprintf(stderr, "[error] incorrect iteration tally (%lu, %lu)\n", *u, v); } } // this way we will see an error if the same key is iterated through // twice str_map_set(M, key, len, 0); hattrie_iter_next(i); } if (count != M->m) { fprintf(stderr, "[error] iterated through %zu element, expected %zu\n", count, M->m); } hattrie_iter_free(i); free(prev_key); free(key_copy); 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; }