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; }
size_t zone_tree_weight(const zone_tree_t* tree) { return hattrie_weight(tree); }
size_t knot_zone_tree_weight(knot_zone_tree_t* tree) { return hattrie_weight(tree); }