mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-22 10:10:06 +00:00
Code Issues Releases Wiki Activity
bind/tests/isc/hashmap_test.c
Ondřej Surý f5c204ac3e
Move the library init and shutdown to executables 
Instead of relying on unreliable order of execution of the library
constructors and destructors, move them to individual binaries.  The
advantage is that the execution time and order will remain constant and
will not depend on the dynamic load dependency solver.

This requires more work, but that was mitigated by a simple requirement,
any executable using libisc and libdns, must include <isc/lib.h> and
<dns/lib.h> respectively (in this particular order).  In turn, these two
headers must not be included from within any library as they contain
inlined functions marked with constructor/destructor attributes.
2025-02-22 16:19:00 +01:00

519 lines
13 KiB
C
Raw Blame History

/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* SPDX-License-Identifier: MPL-2.0
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#include <inttypes.h>
#include <sched.h> /* IWYU pragma: keep */
#include <setjmp.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/hash.h>
#include <isc/hashmap.h>
#include <isc/lib.h>
#include <isc/mem.h>
#include <isc/string.h>
#include <isc/util.h>
#include <tests/isc.h>
/* INCLUDE LAST */
#define mctx __mctx
#include "hashmap.c"
#undef mctx
typedef struct test_node {
uint32_t hashval;
char key[64];
} test_node_t;
static bool
nodes_match(void *node0, const void *key) {
struct test_node *node = node0;
return memcmp(node->key, key, 16) == 0;
}
static bool
long_nodes_match(void *node0, const void *key) {
struct test_node *node = node0;
size_t len = strlen(key);
return memcmp(node->key, key, len) == 0;
}
static bool
upper_nodes_match(void *node0, const void *key) {
struct test_node *node = node0;
return isc_ascii_lowerequal((uint8_t *)node->key, key, 16);
}
static void
test_hashmap_full(uint8_t init_bits, uintptr_t count) {
isc_hashmap_t *hashmap = NULL;
isc_result_t result;
test_node_t *nodes, *long_nodes, *upper_nodes;
nodes = isc_mem_cget(mctx, count, sizeof(nodes[0]));
long_nodes = isc_mem_cget(mctx, count, sizeof(nodes[0]));
upper_nodes = isc_mem_cget(mctx, count, sizeof(nodes[0]));
isc_hashmap_create(mctx, init_bits, &hashmap);
assert_non_null(hashmap);
/*
* Note: snprintf() is followed with strlcat()
* to ensure we are always filling the 16 byte key.
*/
for (size_t i = 0; i < count; i++) {
/* short keys */
snprintf((char *)nodes[i].key, 16, "%u", (unsigned int)i);
strlcat((char *)nodes[i].key, " key of a raw hashmap!!", 16);
nodes[i].hashval = isc_hash32(nodes[i].key, 16, true);
/* long keys */
snprintf((char *)long_nodes[i].key, sizeof(long_nodes[i].key),
"%u", (unsigned int)i);
strlcat((char *)long_nodes[i].key, " key of a raw hashmap!!",
sizeof(long_nodes[i].key));
long_nodes[i].hashval = isc_hash32(
long_nodes[i].key,
strlen((const char *)long_nodes[i].key), true);
/* (some) uppercase keys */
snprintf((char *)upper_nodes[i].key, 16, "%u", (unsigned int)i);
strlcat((char *)upper_nodes[i].key, " KEY of a raw hashmap!!",
16);
upper_nodes[i].hashval = isc_hash32(upper_nodes[i].key, 16,
false);
}
/* insert short nodes */
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_add(hashmap, nodes[i].hashval, nodes_match,
nodes[i].key, &nodes[i], &f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(f, NULL);
}
/* check if the short nodes were insert */
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_find(hashmap, nodes[i].hashval,
nodes_match, nodes[i].key, &f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(&nodes[i], f);
}
/* check for double inserts */
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_add(hashmap, nodes[i].hashval, nodes_match,
nodes[i].key, &nodes[i], &f);
assert_int_equal(result, ISC_R_EXISTS);
assert_ptr_equal(f, &nodes[i]);
}
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_add(hashmap, long_nodes[i].hashval,
long_nodes_match, long_nodes[i].key,
&long_nodes[i], &f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(f, NULL);
}
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_find(hashmap, upper_nodes[i].hashval,
long_nodes_match, upper_nodes[i].key,
&f);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_null(f);
}
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_find(hashmap, long_nodes[i].hashval,
long_nodes_match, long_nodes[i].key,
&f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(f, &long_nodes[i]);
}
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_delete(hashmap, nodes[i].hashval,
nodes_match, nodes[i].key);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_hashmap_find(hashmap, nodes[i].hashval,
nodes_match, nodes[i].key, &f);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_null(f);
}
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_add(hashmap, upper_nodes[i].hashval,
upper_nodes_match, upper_nodes[i].key,
&upper_nodes[i], &f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(f, NULL);
}
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_delete(hashmap, long_nodes[i].hashval,
long_nodes_match,
long_nodes[i].key);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_hashmap_find(hashmap, long_nodes[i].hashval,
long_nodes_match, long_nodes[i].key,
&f);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_null(f);
}
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_find(hashmap, upper_nodes[i].hashval,
upper_nodes_match, upper_nodes[i].key,
&f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(f, &upper_nodes[i]);
}
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_find(hashmap, nodes[i].hashval,
nodes_match, nodes[i].key, &f);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_null(f);
}
isc_hashmap_destroy(&hashmap);
assert_null(hashmap);
isc_mem_cput(mctx, nodes, count, sizeof(nodes[0]));
isc_mem_cput(mctx, long_nodes, count, sizeof(nodes[0]));
isc_mem_cput(mctx, upper_nodes, count, sizeof(nodes[0]));
}
#include "hashmap_nodes.h"
static void
test_hashmap_iterator(bool random_data) {
isc_hashmap_t *hashmap = NULL;
isc_result_t result;
isc_hashmap_iter_t *iter = NULL;
size_t count = 7600;
test_node_t *nodes;
bool *seen;
nodes = isc_mem_cget(mctx, count, sizeof(nodes[0]));
seen = isc_mem_cget(mctx, count, sizeof(seen[0]));
isc_hashmap_create(mctx, HASHMAP_MIN_BITS, &hashmap);
assert_non_null(hashmap);
for (size_t i = 0; i < count; i++) {
/* short keys */
snprintf((char *)nodes[i].key, 16, "%u", (unsigned int)i);
strlcat((char *)nodes[i].key, " key of a raw hashmap!!", 16);
if (random_data) {
nodes[i].hashval = isc_hash32(nodes[i].key, 16, true);
} else {
nodes[i].hashval = test_hashvals[i];
}
}
for (size_t i = 0; i < count; i++) {
void *f = NULL;
result = isc_hashmap_add(hashmap, nodes[i].hashval, nodes_match,
nodes[i].key, &nodes[i], &f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(f, NULL);
}
/* We want to iterate while rehashing is in progress */
assert_true(rehashing_in_progress(hashmap));
memset(seen, 0, count * sizeof(seen[0]));
isc_hashmap_iter_create(hashmap, &iter);
for (result = isc_hashmap_iter_first(iter); result == ISC_R_SUCCESS;
result = isc_hashmap_iter_next(iter))
{
char key[16] = { 0 };
ptrdiff_t i;
const uint8_t *tkey = NULL;
test_node_t *v = NULL;
isc_hashmap_iter_current(iter, (void *)&v);
isc_hashmap_iter_currentkey(iter, &tkey);
i = v - &nodes[0];
snprintf(key, 16, "%u", (unsigned int)i);
strlcat(key, " key of a raw hashmap!!", 16);
assert_memory_equal(key, tkey, 16);
assert_false(seen[i]);
seen[i] = true;
}
assert_int_equal(result, ISC_R_NOMORE);
for (size_t i = 0; i < count; i++) {
assert_true(seen[i]);
}
/* erase odd */
memset(seen, 0, count * sizeof(seen[0]));
result = isc_hashmap_iter_first(iter);
while (result == ISC_R_SUCCESS) {
char key[16] = { 0 };
ptrdiff_t i;
const uint8_t *tkey = NULL;
test_node_t *v = NULL;
isc_hashmap_iter_current(iter, (void *)&v);
isc_hashmap_iter_currentkey(iter, &tkey);
i = v - nodes;
snprintf(key, 16, "%u", (unsigned int)i);
strlcat(key, " key of a raw hashmap!!", 16);
assert_memory_equal(key, tkey, 16);
if (i % 2 == 0) {
result = isc_hashmap_iter_delcurrent_next(iter);
} else {
result = isc_hashmap_iter_next(iter);
}
assert_false(seen[i]);
seen[i] = true;
}
assert_int_equal(result, ISC_R_NOMORE);
for (size_t i = 0; i < count; i++) {
assert_true(seen[i]);
}
/* erase even */
memset(seen, 0, count * sizeof(seen[0]));
result = isc_hashmap_iter_first(iter);
while (result == ISC_R_SUCCESS) {
char key[16] = { 0 };
ptrdiff_t i;
const uint8_t *tkey = NULL;
test_node_t *v = NULL;
isc_hashmap_iter_current(iter, (void *)&v);
isc_hashmap_iter_currentkey(iter, &tkey);
i = v - nodes;
snprintf(key, 16, "%u", (unsigned int)i);
strlcat(key, " key of a raw hashmap!!", 16);
assert_memory_equal(key, tkey, 16);
if (i % 2 == 1) {
result = isc_hashmap_iter_delcurrent_next(iter);
} else {
result = isc_hashmap_iter_next(iter);
}
}
assert_int_equal(result, ISC_R_NOMORE);
for (result = isc_hashmap_iter_first(iter); result == ISC_R_SUCCESS;
result = isc_hashmap_iter_next(iter))
{
assert_true(false);
}
assert_int_equal(result, ISC_R_NOMORE);
/* Iterator doesn't progress rehashing */
assert_true(rehashing_in_progress(hashmap));
isc_hashmap_iter_destroy(&iter);
assert_null(iter);
isc_hashmap_destroy(&hashmap);
assert_null(hashmap);
isc_mem_cput(mctx, seen, count, sizeof(seen[0]));
isc_mem_cput(mctx, nodes, count, sizeof(nodes[0]));
}
/* 1 bit, 120 elements test, full rehashing */
ISC_RUN_TEST_IMPL(isc_hashmap_1_120) {
test_hashmap_full(1, 120);
return;
}
/* 6 bit, 1000 elements test, full rehashing */
ISC_RUN_TEST_IMPL(isc_hashmap_6_1000) {
test_hashmap_full(6, 1000);
return;
}
/* 24 bit, 200K elements test, no rehashing */
ISC_RUN_TEST_IMPL(isc_hashmap_24_200000) {
test_hashmap_full(24, 200000);
return;
}
/* 15 bit, 45K elements test, full rehashing */
ISC_RUN_TEST_IMPL(isc_hashmap_1_48000) {
test_hashmap_full(1, 48000);
return;
}
/* 8 bit, 20k elements test, partial rehashing */
ISC_RUN_TEST_IMPL(isc_hashmap_8_20000) {
test_hashmap_full(8, 20000);
return;
}
/* test hashmap iterator */
ISC_RUN_TEST_IMPL(isc_hashmap_iterator) {
test_hashmap_iterator(true);
return;
}
ISC_RUN_TEST_IMPL(isc_hashmap_iterator_static) {
test_hashmap_iterator(false);
return;
}
ISC_RUN_TEST_IMPL(isc_hashmap_hash_zero_length) {
isc_hashmap_t *hashmap = NULL;
uint32_t hashval;
bool again = false;
again:
isc_hashmap_create(mctx, 1, &hashmap);
hashval = isc_hash32("", 0, true);
isc_hashmap_destroy(&hashmap);
if (hashval == 0 && !again) {
/*
* We could be extremely unlucky and the siphash could hash the
* zero length string to 0, so try one more time.
*/
again = true;
goto again;
}
assert_int_not_equal(hashval, 0);
}
static bool
case_match(void *node0, const void *key) {
struct test_node *node = node0;
size_t len = strlen(key);
return memcmp(node->key, key, len) == 0;
}
static bool
nocase_match(void *node0, const void *key) {
struct test_node *node = node0;
size_t len = strlen(key);
return isc_ascii_lowerequal((uint8_t *)node->key, key, len);
}
ISC_RUN_TEST_IMPL(isc_hashmap_case) {
isc_result_t result;
isc_hashmap_t *hashmap = NULL;
test_node_t lower = { .key = "isc_hashmap_case" };
test_node_t same = { .key = "isc_hashmap_case" };
test_node_t upper = { .key = "ISC_HASHMAP_CASE" };
test_node_t mixed = { .key = "IsC_hAsHmAp_CaSe" };
void *f = NULL;
isc_hashmap_create(mctx, 1, &hashmap);
result = isc_hashmap_add(hashmap,
isc_hash32(lower.key, strlen(lower.key), true),
case_match, lower.key, &lower, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_hashmap_add(hashmap,
isc_hash32(same.key, strlen(same.key), true),
case_match, same.key, &same, NULL);
assert_int_equal(result, ISC_R_EXISTS);
result = isc_hashmap_add(hashmap,
isc_hash32(upper.key, strlen(upper.key), true),
case_match, upper.key, &upper, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_hashmap_find(
hashmap, isc_hash32(mixed.key, strlen(mixed.key), true),
case_match, mixed.key, &f);
assert_int_equal(result, ISC_R_NOTFOUND);
assert_ptr_equal(f, NULL);
isc_hashmap_destroy(&hashmap);
isc_hashmap_create(mctx, 1, &hashmap);
result = isc_hashmap_add(
hashmap, isc_hash32(lower.key, strlen(lower.key), false),
nocase_match, lower.key, &lower, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_hashmap_add(hashmap,
isc_hash32(same.key, strlen(same.key), false),
nocase_match, same.key, &same, NULL);
assert_int_equal(result, ISC_R_EXISTS);
result = isc_hashmap_add(
hashmap, isc_hash32(upper.key, strlen(upper.key), false),
nocase_match, upper.key, &upper, NULL);
assert_int_equal(result, ISC_R_EXISTS);
result = isc_hashmap_find(
hashmap, isc_hash32(mixed.key, strlen(mixed.key), false),
nocase_match, mixed.key, &f);
assert_int_equal(result, ISC_R_SUCCESS);
assert_ptr_equal(f, &lower);
isc_hashmap_destroy(&hashmap);
}
ISC_TEST_LIST_START
ISC_TEST_ENTRY(isc_hashmap_hash_zero_length)
ISC_TEST_ENTRY(isc_hashmap_case)
ISC_TEST_ENTRY(isc_hashmap_1_120)
ISC_TEST_ENTRY(isc_hashmap_6_1000)
ISC_TEST_ENTRY(isc_hashmap_24_200000)
ISC_TEST_ENTRY(isc_hashmap_1_48000)
ISC_TEST_ENTRY(isc_hashmap_8_20000)
ISC_TEST_ENTRY(isc_hashmap_iterator)
ISC_TEST_ENTRY(isc_hashmap_iterator_static)
ISC_TEST_LIST_END
ISC_TEST_MAIN
Reference in New Issue View Git Blame Copy Permalink